SELECT <Multiplication function>(Note) as Mult_Note 
   FROM  --here I have a bunch of sub query
 ( SELECT .... FROM ... ORDER BY Note )

SQL> CREATE OR REPLACE TYPE multiply_type AS OBJECT
  2  (
  3     total NUMBER,
  4  
  5     static function
  6          ODCIAggregateInitialize(sctx IN OUT multiply_type )
  7          return number,
  8  
  9     member function
 10          ODCIAggregateIterate(self IN OUT multiply_type ,
 11                               value IN number )
 12          return number,
 13  
 14     member function
 15          ODCIAggregateTerminate(self IN multiply_type,
 16                                 returnValue OUT  number,
 17                                 flags IN number)
 18          return number,
 19  
 20     member function
 21          ODCIAggregateMerge(self IN OUT multiply_type,
 22                             ctx2 IN multiply_type)
 23          return number
 24  );
 25  /

Type created.

SQL> CREATE OR REPLACE TYPE BODY multiply_type
  2  is
  3  
  4  static function ODCIAggregateInitialize(sctx IN OUT multiply_type)
  5  return number
  6  is
  7  begin
  8      sctx := multiply_type( null );
  9      return ODCIConst.Success;
 10  end;
 11  
 12  member function ODCIAggregateIterate(self IN OUT multiply_type,
 13                                       value IN number )
 14  return number
 15  is
 16  begin
 17      self.total := nvl(self.total, 1) * value;
 18      return ODCIConst.Success;
 19  end;
 20  
 21  member function ODCIAggregateTerminate(self IN multiply_type,
 22                                         returnValue OUT number,
 23                                         flags IN number)
 24  return number
 25  is
 26  begin
 27      returnValue := self.total;
 28      return ODCIConst.Success;
 29  end;
 30  
 31  member function ODCIAggregateMerge(self IN OUT multiply_type,
 32                                     ctx2 IN multiply_type)
 33  return number
 34  is
 35  begin
 36      self.total := ctx2.total;
 37      return ODCIConst.Success;
 38  end;
 39  
 40  END;
 41  /

Type body created.

SQL> 
SQL> CREATE OR REPLACE FUNCTION multiply_func(input number)
  2    RETURN number
  3  PARALLEL_ENABLE AGGREGATE USING multiply_type;
  4  /

Function created.

SQL> SELECT multiply_func(x.sum_value)
  2    FROM ( SELECT SUM(1) sum_value FROM dual
  3            UNION ALL
  4           SELECT SUM(3) FROM dual
  5            UNION ALL
  6           SELECT SUM(5) FROM dual ) x
  7  /

MULTIPLY_FUNC(X.SUM_VALUE)
--------------------------
                        15

SQL> CREATE TABLE t (id NUMBER, factor NUMBER)
  2  /
 
Table created.
 
SQL> INSERT INTO t VALUES (1,10);
SQL> INSERT INTO t VALUES (2,2);
SQL> INSERT INTO t VALUES (2,3);
SQL> INSERT INTO t VALUES (2,4);
SQL> INSERT INTO t VALUES (3,3.16);
SQL> INSERT INTO t VALUES (3,1.25);
SQL> INSERT INTO t VALUES (3,1.50);
SQL> INSERT INTO t VALUES (3,1.20);
 
SQL> SELECT   t.id
  2  ,        EXP(SUM(LN(t.factor))) product
  3  FROM     t
  4  GROUP BY t.id
  5  ORDER BY t.id
  6  /
 
        ID    PRODUCT
---------- ----------
         1         10
         2         24
         3       7.11
 
SQL>