cern.colt.matrix.doc-files.function2.html Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of parallelcolt Show documentation

Parallel Colt is a multithreaded version of Colt - a library for high performance scientific computing in Java. It contains efficient algorithms for data analysis, linear algebra, multi-dimensional arrays, Fourier transforms, statistics and histogramming.

The newest version!

Function Objects

Example 2: Aggregation
Aggregation is a generalized form of summation or integration. Aggregation 
  functions visit all cells of a matrix and derive a single number as "summary 
  information". Number of elements, mean, maximum, minimum, variance, root-mean-square 
  are classic aggregation functions, but there are many more. Floods of data are 
  too difficult to understand - a single number sells better to management. More 
  seriously, the scientific process takes observations and tries to find patterns, 
  the essentials of knowledge, which are more compact and easier to internalize 
  than the observations itself. The most compact representation of knowledge is, 
  of course, a single number. 
We will use the prefabricated plus and square function objects 
  to compute the sum of squares of a 1-d matrix, but first, let's get prepared. 
double[] v1 = {0, 1, 2, 3}; 
DoubleMatrix1D matrix = new DenseDoubleMatrix1D(v1);

// the naming shortcut (alias) saves some keystrokes:
cern.jet.math.Functions F = cern.jet.math.Functions.functions;


Aggregation over one matrix 
// Sum( x[i]*x[i] ) 
System.out.println(matrix.aggregate(F.plus,F.square));
// --> 14

// Sum( x[i]*x[i]*x[i] ) 
System.out.println(matrix.aggregate(F.plus,F.pow(3)));
// --> 36

// Sum( x[i] ) 
System.out.println(matrix.aggregate(F.plus,F.identity));
// or the specialized version
System.out.println(matrix.zSum());
// --> 6

// Min( x[i] ) 
System.out.println(matrix.aggregate(F.min,F.identity));
// --> 0

// Max( Sqrt(x[i]) / 2 ) 
System.out.println(matrix.aggregate(F.max,F.chain(F.div(2),F.sqrt)));
// --> 0.8660254037844386

// Number of all cells with 0 <= value <= 2
System.out.println(matrix.aggregate(F.plus,F.between(0,2)));
// --> 3

// Number of all cells with 0.8 <= Log2(value) <= 1.2
System.out.println(matrix.aggregate(F.plus,F.chain(F.between(0.8,1.2),F.log2)));
// --> 1

// Product( x[i] )
System.out.println(matrix.aggregate(F.mult,F.identity));
// --> 0

// Product( x[i] ) of all x[i] > limit
final double limit = 1;
DoubleFunction f = new DoubleFunction() {
	public final double apply(double a) { return a>limit ? a : 1; }
};
System.out.println(matrix.aggregate(F.mult,f));
// --> 6

// RMS (Root-Mean-Square) is a measure of the average "size" of the elements of a data sequence.
double rms = Math.sqrt(matrix.aggregate(F.plus,F.square) / matrix.size());

Aggregation over two matrices 
DoubleMatrix1D x = matrix.copy();
DoubleMatrix1D y = matrix.copy();
// x is 0 1 2 3 
// y is 0 1 2 3 

// Sum( x[i]*y[i] )
System.out.println(x.aggregate(y, F.plus, F.mult));
// --> 14

// Sum( (x[i]+y[i])^2 )
System.out.println(x.aggregate(y, F.plus, F.chain(F.square,F.plus)));
// --> 56


// Sum(Math.PI * Math.log(y[i] / x[i]))
x.aggregate(y, F.plus, F.chain(F.mult(Math.PI),F.chain(F.log,F.swapArgs(F.div))));

// equivalent, but perhaps less error prone and more readable: 
x.aggregate(y, F.plus,
   new DoubleDoubleFunction() {
      public double apply(double a, double b) { return Math.PI*Math.log(b/a); }
   }
);

Try the examples on 2-d or 3-d matrices. They work without changes (except, 
  of course, that construction of the source matrix need to be modified).