cern.jet.math.tfloat.FloatFunctions Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of parallelcolt Show documentation
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!
/*
Copyright (C) 1999 CERN - European Organization for Nuclear Research.
Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose
is hereby granted without fee, provided that the above copyright notice appear in all copies and
that both that copyright notice and this permission notice appear in supporting documentation.
CERN makes no representations about the suitability of this software for any purpose.
It is provided "as is" without expressed or implied warranty.
*/
package cern.jet.math.tfloat;
import cern.colt.function.tfloat.FloatFloatFunction;
import cern.colt.function.tfloat.FloatFloatProcedure;
import cern.colt.function.tfloat.FloatFunction;
import cern.colt.function.tfloat.FloatProcedure;
// import com.imsl.math.Sfun;
/**
* Function objects to be passed to generic methods. Contains the functions of
* {@link java.lang.Math} as function objects, as well as a few more basic
* functions.
*
* Function objects conveniently allow to express arbitrary functions in a
* generic manner. Essentially, a function object is an object that can perform
* a function on some arguments. It has a minimal interface: a method
* apply that takes the arguments, computes something and returns some
* result value. Function objects are comparable to function pointers in C used
* for call-backs.
*
* Unary functions are of type {@link cern.colt.function.tfloat.FloatFunction} ,
* binary functions of type {@link cern.colt.function.tfloat.FloatFloatFunction}
* . All can be retrieved via public
static final variables named after the function. Unary predicates are of
* type {@link cern.colt.function.tfloat.FloatProcedure}, binary predicates of
* type {@link cern.colt.function.tfloat.FloatFloatProcedure}. All can be
* retrieved via public
static final variables named isXXX.
*
*
* Binary functions and predicates also exist as unary functions with the second
* argument being fixed to a constant. These are generated and retrieved via
* factory methods (again with the same name as the function). Example:
*
* - Functions.pow gives the function ab.
*
- Functions.pow.apply(2,3)==8.
*
- Functions.pow(3) gives the function a3.
*
- Functions.pow(3).apply(2)==8.
*
* More general, any binary function can be made an unary functions by fixing
* either the first or the second argument. See methods
* {@link #bindArg1(FloatFloatFunction,float)} and
* {@link #bindArg2(FloatFloatFunction,float)}. The order of arguments can be
* swapped so that the first argument becomes the second and vice-versa. See
* method {@link #swapArgs(FloatFloatFunction)}. Example:
*
* - Functions.pow gives the function ab.
*
- Functions.bindArg2(Functions.pow,3) gives the function
* x3.
*
- Functions.bindArg1(Functions.pow,3) gives the function
* 3x.
*
- Functions.swapArgs(Functions.pow) gives the function
* ba.
*
*
* Even more general, functions can be chained (composed, assembled). Assume we
* have two unary functions g and h. The unary function
* g(h(a)) applying both in sequence can be generated via
* {@link #chain(FloatFunction,FloatFunction)}:
*
* - Functions.chain(g,h);
*
* Assume further we have a binary function f. The binary function
* g(f(a,b)) can be generated via
* {@link #chain(FloatFunction,FloatFloatFunction)}:
*
* - Functions.chain(g,f);
*
* The binary function f(g(a),h(b)) can be generated via
* {@link #chain(FloatFloatFunction,FloatFunction,FloatFunction)}:
*
* - Functions.chain(f,g,h);
*
* Arbitrarily complex functions can be composed from these building blocks. For
* example sin(a) + cos2(b) can be specified as follows:
*
* - chain(plus,sin,chain(square,cos));
*
* or, of course, as
*
*
* new FloatFloatFunction() {
* public final float apply(float a, float b) {
* return Math.sin(a) + Math.pow(Math.cos(b), 2);
* }
* }
*
*
*
* For aliasing see {@link #functions}. Try this
*
*
*
*
* // should yield 1.4399560356056456 in all cases
* float a = 0.5;
* float b = 0.2;
* float v = Math.sin(a) + Math.pow(Math.cos(b), 2);
* System.out.println(v);
* Functions F = Functions.functions;
* FloatFloatFunction f = F.chain(F.plus, F.sin, F.chain(F.square, F.cos));
* System.out.println(f.apply(a, b));
* FloatFloatFunction g = new FloatFloatFunction() {
* public float apply(float a, float b) {
* return Math.sin(a) + Math.pow(Math.cos(b), 2);
* }
* };
* System.out.println(g.apply(a, b));
*
*
*
*
*
*
*
Performance
*
* Surprise. Using modern non-adaptive JITs such as SunJDK 1.2.2 (java -classic)
* there seems to be no or only moderate performance penalty in using function
* objects in a loop over traditional code in a loop. For complex nested
* function objects (e.g.
* F.chain(F.abs,F.chain(F.plus,F.sin,F.chain(F.square,F.cos)))) the
* penalty is zero, for trivial functions (e.g. F.plus) the penalty is
* often acceptable.
*
*
* Iteration Performance [million
* function evaluations per second]
* Pentium Pro 200 Mhz, SunJDK 1.2.2, NT, java -classic,
*
*
*
*
*
*
* 30000000 iterations
*
*
* 3000000 iterations (10 times less)
*
*
*
* F.plus
* a+b
*
* F.chain(F.abs,F.chain(F.plus,F.sin,F.chain(F.square,F.cos)))
*
* Math.abs(Math.sin(a) + Math.pow(Math.cos(b),2))
*
*
*
*
*
* 10.8
* 29.6
* 0.43
* 0.35
*
*
*
*
*
*
*
* @author [email protected]
* @version 1.0, 09/24/99
*/
public class FloatFunctions extends Object {
/**
* Little trick to allow for "aliasing", that is, renaming this class.
* Writing code like
*
* Functions.chain(Functions.plus,Functions.sin,Functions.chain(Functions.square,Functions.cos));
*
* is a bit awkward, to say the least. Using the aliasing you can instead
* write
*
* Functions F = Functions.functions;
F.chain(F.plus,F.sin,F.chain(F.square,F.cos));
*/
public static final FloatFunctions functions = new FloatFunctions();
/***************************************************************************
*
Unary functions
**************************************************************************/
/**
* Function that returns Math.abs(a).
*/
public static final FloatFunction abs = new FloatFunction() {
public final float apply(float a) {
return Math.abs(a);
}
};
/**
* Function that returns Math.acos(a).
*/
public static final FloatFunction acos = new FloatFunction() {
public final float apply(float a) {
return (float) Math.acos(a);
}
};
/**
* Function that returns com.imsl.math.Sfun.acosh(a).
*/
/*
* public static final FloatFunction acosh = new FloatFunction() { public
* final float apply(float a) { return Sfun.acosh(a); } };
*/
/**
* Function that returns Math.asin(a).
*/
public static final FloatFunction asin = new FloatFunction() {
public final float apply(float a) {
return (float) Math.asin(a);
}
};
/**
* Function that returns com.imsl.math.Sfun.asinh(a).
*/
/*
* public static final FloatFunction asinh = new FloatFunction() { public
* final float apply(float a) { return Sfun.asinh(a); } };
*/
/**
* Function that returns Math.atan(a).
*/
public static final FloatFunction atan = new FloatFunction() {
public final float apply(float a) {
return (float) Math.atan(a);
}
};
/**
* Function that returns com.imsl.math.Sfun.atanh(a).
*/
/*
* public static final FloatFunction atanh = new FloatFunction() { public
* final float apply(float a) { return Sfun.atanh(a); } };
*/
/**
* Function that returns Math.ceil(a).
*/
public static final FloatFunction ceil = new FloatFunction() {
public final float apply(float a) {
return (float) Math.ceil(a);
}
};
/**
* Function that returns Math.cos(a).
*/
public static final FloatFunction cos = new FloatFunction() {
public final float apply(float a) {
return (float) Math.cos(a);
}
};
/**
* Function that returns com.imsl.math.Sfun.cosh(a).
*/
/*
* public static final FloatFunction cosh = new FloatFunction() { public
* final float apply(float a) { return Sfun.cosh(a); } };
*/
/**
* Function that returns com.imsl.math.Sfun.cot(a).
*/
/*
* public static final FloatFunction cot = new FloatFunction() { public
* final float apply(float a) { return Sfun.cot(a); } };
*/
/**
* Function that returns com.imsl.math.Sfun.erf(a).
*/
/*
* public static final FloatFunction erf = new FloatFunction() { public
* final float apply(float a) { return Sfun.erf(a); } };
*/
/**
* Function that returns com.imsl.math.Sfun.erfc(a).
*/
/*
* public static final FloatFunction erfc = new FloatFunction() { public
* final float apply(float a) { return Sfun.erfc(a); } };
*/
/**
* Function that returns Math.exp(a).
*/
public static final FloatFunction exp = new FloatFunction() {
public final float apply(float a) {
return (float) Math.exp(a);
}
};
/**
* Function that returns Math.floor(a).
*/
public static final FloatFunction floor = new FloatFunction() {
public final float apply(float a) {
return (float) Math.floor(a);
}
};
/**
* Function that returns com.imsl.math.Sfun.gamma(a).
*/
/*
* public static final FloatFunction gamma = new FloatFunction() { public
* final float apply(float a) { return Sfun.gamma(a); } };
*/
/**
* Function that returns its argument.
*/
public static final FloatFunction identity = new FloatFunction() {
public final float apply(float a) {
return a;
}
};
/**
* Function that returns 1.0 / a.
*/
public static final FloatFunction inv = new FloatFunction() {
public final float apply(float a) {
return (float) (1.0 / a);
}
};
/**
* Function that returns Math.log(a).
*/
public static final FloatFunction log = new FloatFunction() {
public final float apply(float a) {
return (float) Math.log(a);
}
};
/**
* Function that returns com.imsl.math.Sfun.log10(a).
*/
/*
* public static final FloatFunction log10 = new FloatFunction() { public
* final float apply(float a) { return Sfun.log10(a); } };
*/
/**
* Function that returns Math.log(a) / Math.log(2).
*/
public static final FloatFunction log2 = new FloatFunction() {
// 1.0 / Math.log(2) == 1.4426950408889634
public final float apply(float a) {
return (float) (Math.log(a) * 1.4426950408889634);
}
};
/**
* Function that returns com.imsl.math.Sfun.logGamma(a).
*/
/*
* public static final FloatFunction logGamma = new FloatFunction() {
* public final float apply(float a) { return Sfun.logGamma(a); } };
*/
/**
* Function that returns -a.
*/
public static final FloatFunction neg = new FloatFunction() {
public final float apply(float a) {
return -a;
}
};
/**
* Function that returns Math.rint(a).
*/
public static final FloatFunction rint = new FloatFunction() {
public final float apply(float a) {
return (float) Math.rint(a);
}
};
/**
* Function that returns a < 0 ? -1 : a > 0 ? 1 : 0.
*/
public static final FloatFunction sign = new FloatFunction() {
public final float apply(float a) {
return a < 0 ? -1 : a > 0 ? 1 : 0;
}
};
/**
* Function that returns Math.sin(a).
*/
public static final FloatFunction sin = new FloatFunction() {
public final float apply(float a) {
return (float) Math.sin(a);
}
};
/**
* Function that returns com.imsl.math.Sfun.sinh(a).
*/
/*
* public static final FloatFunction sinh = new FloatFunction() { public
* final float apply(float a) { return Sfun.sinh(a); } };
*/
/**
* Function that returns Math.sqrt(a).
*/
public static final FloatFunction sqrt = new FloatFunction() {
public final float apply(float a) {
return (float) Math.sqrt(a);
}
};
/**
* Function that returns a * a.
*/
public static final FloatFunction square = new FloatFunction() {
public final float apply(float a) {
return a * a;
}
};
/**
* Function that returns Math.tan(a).
*/
public static final FloatFunction tan = new FloatFunction() {
public final float apply(float a) {
return (float) Math.tan(a);
}
};
/**
* Function that returns com.imsl.math.Sfun.tanh(a).
*/
/*
* public static final FloatFunction tanh = new FloatFunction() { public
* final float apply(float a) { return Sfun.tanh(a); } };
*/
/**
* Function that returns Math.toDegrees(a).
*/
/*
* public static final FloatFunction toDegrees = new FloatFunction() {
* public final float apply(float a) { return Math.toDegrees(a); } };
*/
/**
* Function that returns Math.toRadians(a).
*/
/*
* public static final FloatFunction toRadians = new FloatFunction() {
* public final float apply(float a) { return Math.toRadians(a); } };
*/
/***************************************************************************
* Binary functions
**************************************************************************/
/**
* Function that returns Math.atan2(a,b).
*/
public static final FloatFloatFunction atan2 = new FloatFloatFunction() {
public final float apply(float a, float b) {
return (float) Math.atan2(a, b);
}
};
/**
* Function that returns com.imsl.math.Sfun.logBeta(a,b).
*/
/*
* public static final FloatFloatFunction logBeta = new
* FloatFloatFunction() { public final float apply(float a, float b) {
* return Sfun.logBeta(a,b); } };
*/
/**
* Function that returns a < b ? -1 : a > b ? 1 : 0.
*/
public static final FloatFloatFunction compare = new FloatFloatFunction() {
public final float apply(float a, float b) {
return a < b ? -1 : a > b ? 1 : 0;
}
};
/**
* Function that returns a / b.
*/
public static final FloatFloatFunction div = new FloatFloatFunction() {
public final float apply(float a, float b) {
return a / b;
}
};
/**
* Function that returns -(a / b).
*/
public static final FloatFloatFunction divNeg = new FloatFloatFunction() {
public final float apply(float a, float b) {
return -(a / b);
}
};
/**
* Function that returns a == b ? 1 : 0.
*/
public static final FloatFloatFunction equals = new FloatFloatFunction() {
public final float apply(float a, float b) {
return a == b ? 1 : 0;
}
};
/**
* Function that returns a > b ? 1 : 0.
*/
public static final FloatFloatFunction greater = new FloatFloatFunction() {
public final float apply(float a, float b) {
return a > b ? 1 : 0;
}
};
/**
* Function that returns Math.IEEEremainder(a,b).
*/
public static final FloatFloatFunction IEEEremainder = new FloatFloatFunction() {
public final float apply(float a, float b) {
return (float) Math.IEEEremainder(a, b);
}
};
/**
* Function that returns a == b.
*/
public static final FloatFloatProcedure isEqual = new FloatFloatProcedure() {
public final boolean apply(float a, float b) {
return a == b;
}
};
/**
* Function that returns a < b.
*/
public static final FloatFloatProcedure isLess = new FloatFloatProcedure() {
public final boolean apply(float a, float b) {
return a < b;
}
};
/**
* Function that returns a > b.
*/
public static final FloatFloatProcedure isGreater = new FloatFloatProcedure() {
public final boolean apply(float a, float b) {
return a > b;
}
};
/**
* Function that returns a < b ? 1 : 0.
*/
public static final FloatFloatFunction less = new FloatFloatFunction() {
public final float apply(float a, float b) {
return a < b ? 1 : 0;
}
};
/**
* Function that returns Math.log(a) / Math.log(b).
*/
public static final FloatFloatFunction lg = new FloatFloatFunction() {
public final float apply(float a, float b) {
return (float) (Math.log(a) / Math.log(b));
}
};
/**
* Function that returns Math.max(a,b).
*/
public static final FloatFloatFunction max = new FloatFloatFunction() {
public final float apply(float a, float b) {
return Math.max(a, b);
}
};
/**
* Function that returns Math.min(a,b).
*/
public static final FloatFloatFunction min = new FloatFloatFunction() {
public final float apply(float a, float b) {
return Math.min(a, b);
}
};
/**
* Function that returns a - b.
*/
public static final FloatFloatFunction minus = plusMultSecond(-1);
/*
* new FloatFloatFunction() { public final float apply(float a, float
* b) { return a - b; } };
*/
/**
* Function that returns a % b.
*/
public static final FloatFloatFunction mod = new FloatFloatFunction() {
public final float apply(float a, float b) {
return a % b;
}
};
/**
* Function that returns a * b.
*/
public static final FloatFloatFunction mult = new FloatFloatFunction() {
public final float apply(float a, float b) {
return a * b;
}
};
/**
* Function that returns -(a * b).
*/
public static final FloatFloatFunction multNeg = new FloatFloatFunction() {
public final float apply(float a, float b) {
return -(a * b);
}
};
/**
* Function that returns a * b^2.
*/
public static final FloatFloatFunction multSquare = new FloatFloatFunction() {
public final float apply(float a, float b) {
return a * b * b;
}
};
/**
* Function that returns a + b.
*/
public static final FloatFloatFunction plus = plusMultSecond(1);
// new FloatFloatFunction() {
// public final float apply(float a, float b) {
// return a + b;
// }
// };
/**
* Function that returns Math.abs(a) + Math.abs(b).
*/
public static final FloatFloatFunction plusAbs = new FloatFloatFunction() {
public final float apply(float a, float b) {
return Math.abs(a) + Math.abs(b);
}
};
/**
* Function that returns Math.pow(a,b).
*/
public static final FloatFloatFunction pow = new FloatFloatFunction() {
public final float apply(float a, float b) {
return (float) Math.pow(a, b);
}
};
/**
* Makes this class non instantiable, but still let's others inherit from
* it.
*/
protected FloatFunctions() {
}
/**
* Constructs a function that returns (from<=a && a<=to) ? 1 : 0.
* a is a variable, from and to are fixed.
*/
public static FloatFunction between(final float from, final float to) {
return new FloatFunction() {
public final float apply(float a) {
return (from <= a && a <= to) ? 1 : 0;
}
};
}
/**
* Constructs a unary function from a binary function with the first operand
* (argument) fixed to the given constant c. The second operand is
* variable (free).
*
* @param function
* a binary function taking operands in the form
* function.apply(c,var).
* @return the unary function function(c,var).
*/
public static FloatFunction bindArg1(final FloatFloatFunction function, final float c) {
return new FloatFunction() {
public final float apply(float var) {
return function.apply(c, var);
}
};
}
/**
* Constructs a unary function from a binary function with the second
* operand (argument) fixed to the given constant c. The first
* operand is variable (free).
*
* @param function
* a binary function taking operands in the form
* function.apply(var,c).
* @return the unary function function(var,c).
*/
public static FloatFunction bindArg2(final FloatFloatFunction function, final float c) {
return new FloatFunction() {
public final float apply(float var) {
return function.apply(var, c);
}
};
}
/**
* Constructs the function f( g(a), h(b) ).
*
* @param f
* a binary function.
* @param g
* a unary function.
* @param h
* a unary function.
* @return the binary function f( g(a), h(b) ).
*/
public static FloatFloatFunction chain(final FloatFloatFunction f, final FloatFunction g, final FloatFunction h) {
return new FloatFloatFunction() {
public final float apply(float a, float b) {
return f.apply(g.apply(a), h.apply(b));
}
};
}
/**
* Constructs the function g( h(a,b) ).
*
* @param g
* a unary function.
* @param h
* a binary function.
* @return the unary function g( h(a,b) ).
*/
public static FloatFloatFunction chain(final FloatFunction g, final FloatFloatFunction h) {
return new FloatFloatFunction() {
public final float apply(float a, float b) {
return g.apply(h.apply(a, b));
}
};
}
/**
* Constructs the function g( h(a) ).
*
* @param g
* a unary function.
* @param h
* a unary function.
* @return the unary function g( h(a) ).
*/
public static FloatFunction chain(final FloatFunction g, final FloatFunction h) {
return new FloatFunction() {
public final float apply(float a) {
return g.apply(h.apply(a));
}
};
}
/**
* Constructs a function that returns a < b ? -1 : a > b ? 1 : 0.
* a is a variable, b is fixed.
*/
public static FloatFunction compare(final float b) {
return new FloatFunction() {
public final float apply(float a) {
return a < b ? -1 : a > b ? 1 : 0;
}
};
}
/**
* Constructs a function that returns the constant c.
*/
public static FloatFunction constant(final float c) {
return new FloatFunction() {
public final float apply(float a) {
return c;
}
};
}
/**
* Demonstrates usage of this class.
*/
public static void demo1() {
cern.jet.math.tfloat.FloatFunctions F = cern.jet.math.tfloat.FloatFunctions.functions;
float a = 0.5f;
float b = 0.2f;
float v = (float) (Math.sin(a) + Math.pow(Math.cos(b), 2));
System.out.println(v);
FloatFloatFunction f = FloatFunctions.chain(FloatFunctions.plus, FloatFunctions.sin, FloatFunctions.chain(
FloatFunctions.square, FloatFunctions.cos));
// FloatFloatFunction f = F.chain(plus,sin,F.chain(square,cos));
System.out.println(f.apply(a, b));
FloatFloatFunction g = new FloatFloatFunction() {
public final float apply(float x, float y) {
return (float) (Math.sin(x) + Math.pow(Math.cos(y), 2));
}
};
System.out.println(g.apply(a, b));
FloatFunction m = FloatFunctions.plus(3);
FloatFunction n = FloatFunctions.plus(4);
System.out.println(m.apply(0));
System.out.println(n.apply(0));
}
/**
* Benchmarks and demonstrates usage of trivial and complex functions.
*/
public static void demo2(int size) {
cern.jet.math.tfloat.FloatFunctions F = cern.jet.math.tfloat.FloatFunctions.functions;
System.out.println("\n\n");
float a = 0.0f;
float b = 0.0f;
float v = (float) Math.abs(Math.sin(a) + Math.pow(Math.cos(b), 2));
// float v = Math.sin(a) + Math.pow(Math.cos(b),2);
// float v = a + b;
System.out.println(v);
// FloatFloatFunction f = F.chain(F.plus,F.identity,F.identity);
FloatFloatFunction f = FloatFunctions.chain(FloatFunctions.abs, FloatFunctions.chain(FloatFunctions.plus,
FloatFunctions.sin, FloatFunctions.chain(FloatFunctions.square, FloatFunctions.cos)));
// FloatFloatFunction f =
// F.chain(F.plus,F.sin,F.chain(F.square,F.cos));
// FloatFloatFunction f = F.plus;
System.out.println(f.apply(a, b));
FloatFloatFunction g = new FloatFloatFunction() {
public final float apply(float x, float y) {
return (float) Math.abs(Math.sin(x) + Math.pow(Math.cos(y), 2));
}
// public final float apply(float x, float y) { return x+y; }
};
System.out.println(g.apply(a, b));
// emptyLoop
cern.colt.Timer emptyLoop = new cern.colt.Timer().start();
a = 0;
b = 0;
float sum = 0;
for (int i = size; --i >= 0;) {
sum += a;
a++;
b++;
}
emptyLoop.stop().display();
System.out.println("empty sum=" + sum);
cern.colt.Timer timer = new cern.colt.Timer().start();
a = 0;
b = 0;
sum = 0;
for (int i = size; --i >= 0;) {
sum += Math.abs(Math.sin(a) + Math.pow(Math.cos(b), 2));
// sum += a + b;
a++;
b++;
}
timer.stop().display();
System.out.println("evals / sec = " + size / timer.minus(emptyLoop).seconds());
System.out.println("sum=" + sum);
timer.reset().start();
a = 0;
b = 0;
sum = 0;
for (int i = size; --i >= 0;) {
sum += f.apply(a, b);
a++;
b++;
}
timer.stop().display();
System.out.println("evals / sec = " + size / timer.minus(emptyLoop).seconds());
System.out.println("sum=" + sum);
timer.reset().start();
a = 0;
b = 0;
sum = 0;
for (int i = size; --i >= 0;) {
sum += g.apply(a, b);
a++;
b++;
}
timer.stop().display();
System.out.println("evals / sec = " + size / timer.minus(emptyLoop).seconds());
System.out.println("sum=" + sum);
}
/**
* Constructs a function that returns a / b. a is a
* variable, b is fixed.
*/
public static FloatFunction div(final float b) {
return mult(1 / b);
}
/**
* Constructs a function that returns a == b ? 1 : 0. a is
* a variable, b is fixed.
*/
public static FloatFunction equals(final float b) {
return new FloatFunction() {
public final float apply(float a) {
return a == b ? 1 : 0;
}
};
}
/**
* Constructs a function that returns a > b ? 1 : 0. a is
* a variable, b is fixed.
*/
public static FloatFunction greater(final float b) {
return new FloatFunction() {
public final float apply(float a) {
return a > b ? 1 : 0;
}
};
}
/**
* Constructs a function that returns Math.IEEEremainder(a,b).
* a is a variable, b is fixed.
*/
public static FloatFunction IEEEremainder(final float b) {
return new FloatFunction() {
public final float apply(float a) {
return (float) Math.IEEEremainder(a, b);
}
};
}
/**
* Constructs a function that returns from<=a && a<=to. a
* is a variable, from and to are fixed.
*/
public static FloatProcedure isBetween(final float from, final float to) {
return new FloatProcedure() {
public final boolean apply(float a) {
return from <= a && a <= to;
}
};
}
/**
* Constructs a function that returns a == b. a is a
* variable, b is fixed.
*/
public static FloatProcedure isEqual(final float b) {
return new FloatProcedure() {
public final boolean apply(float a) {
return a == b;
}
};
}
/**
* Constructs a function that returns a > b. a is a
* variable, b is fixed.
*/
public static FloatProcedure isGreater(final float b) {
return new FloatProcedure() {
public final boolean apply(float a) {
return a > b;
}
};
}
/**
* Constructs a function that returns a < b. a is a
* variable, b is fixed.
*/
public static FloatProcedure isLess(final float b) {
return new FloatProcedure() {
public final boolean apply(float a) {
return a < b;
}
};
}
/**
* Constructs a function that returns a < b ? 1 : 0. a is
* a variable, b is fixed.
*/
public static FloatFunction less(final float b) {
return new FloatFunction() {
public final float apply(float a) {
return a < b ? 1 : 0;
}
};
}
/**
* Constructs a function that returns Math.log(a) / Math.log(b)
* . a is a variable, b is fixed.
*/
public static FloatFunction lg(final float b) {
return new FloatFunction() {
private final double logInv = 1 / Math.log(b); // cached for speed
public final float apply(float a) {
return (float) (Math.log(a) * logInv);
}
};
}
/**
* Tests various methods of this class.
*/
protected static void main(String args[]) {
int size = Integer.parseInt(args[0]);
demo2(size);
// demo1();
}
/**
* Constructs a function that returns Math.max(a,b). a is
* a variable, b is fixed.
*/
public static FloatFunction max(final float b) {
return new FloatFunction() {
public final float apply(float a) {
return Math.max(a, b);
}
};
}
/**
* Constructs a function that returns Math.min(a,b). a is
* a variable, b is fixed.
*/
public static FloatFunction min(final float b) {
return new FloatFunction() {
public final float apply(float a) {
return Math.min(a, b);
}
};
}
/**
* Constructs a function that returns a - b. a is a
* variable, b is fixed.
*/
public static FloatFunction minus(final float b) {
return plus(-b);
}
/**
* Constructs a function that returns a - b*constant. a
* and b are variables, constant is fixed.
*/
public static FloatFloatFunction minusMult(final float constant) {
return plusMultSecond(-constant);
}
/**
* Constructs a function that returns a % b. a is a
* variable, b is fixed.
*/
public static FloatFunction mod(final float b) {
return new FloatFunction() {
public final float apply(float a) {
return a % b;
}
};
}
/**
* Constructs a function that returns a * b. a is a
* variable, b is fixed.
*/
public static FloatFunction mult(final float b) {
return new FloatMult(b);
/*
* return new FloatFunction() { public final float apply(float a) {
* return a * b; } };
*/
}
/**
* Constructs a function that returns a + b. a is a
* variable, b is fixed.
*/
public static FloatFunction plus(final float b) {
return new FloatFunction() {
public final float apply(float a) {
return a + b;
}
};
}
public static FloatFloatFunction multSecond(final float constant) {
return new FloatFloatFunction() {
public final float apply(float a, float b) {
return b * constant;
}
};
}
/**
* Constructs a function that returns a + b*constant. a
* and b are variables, constant is fixed.
*/
public static FloatFloatFunction plusMultSecond(final float constant) {
return new FloatPlusMultSecond(constant);
}
/**
* Constructs a function that returns a * constant + b. a
* and b are variables, constant is fixed.
*/
public static FloatFloatFunction plusMultFirst(final float constant) {
return new FloatPlusMultFirst(constant);
}
/**
* Constructs a function that returns Math.pow(a,b). a is
* a variable, b is fixed.
*/
public static FloatFunction pow(final float b) {
return new FloatFunction() {
public final float apply(float a) {
return (float) Math.pow(a, b);
}
};
}
/**
* Constructs a function that returns a new uniform random number in the
* open unit interval (0.0,1.0) (excluding 0.0 and 1.0).
* Currently the engine is
* {@link cern.jet.random.tfloat.engine.FloatMersenneTwister} and is seeded
* with the current time.
*
* Note that any random engine derived from
* {@link cern.jet.random.tfloat.engine.FloatRandomEngine} and any random
* distribution derived from
* {@link cern.jet.random.tfloat.AbstractFloatDistribution} are function
* objects, because they implement the proper interfaces. Thus, if you are
* not happy with the default, just pass your favourite random generator to
* function evaluating methods.
*/
public static FloatFunction random() {
return new RandomFloatFunction();
}
// TODO
private static class RandomFloatFunction implements FloatFunction {
public float apply(float argument) {
return (float) Math.random();
}
}
/**
* Constructs a function that returns the number rounded to the given
* precision; Math.rint(a/precision)*precision. Examples:
*
*
* precision = 0.01 rounds 0.012 --> 0.01, 0.018 --> 0.02
* precision = 10 rounds 123 --> 120 , 127 --> 130
*
*/
public static FloatFunction round(final float precision) {
return new FloatFunction() {
public final float apply(float a) {
return (float) (Math.rint(a / precision) * precision);
}
};
}
/**
* Constructs a function that returns function.apply(b,a), i.e.
* applies the function with the first operand as second operand and the
* second operand as first operand.
*
* @param function
* a function taking operands in the form
* function.apply(a,b).
* @return the binary function function(b,a).
*/
public static FloatFloatFunction swapArgs(final FloatFloatFunction function) {
return new FloatFloatFunction() {
public final float apply(float a, float b) {
return function.apply(b, a);
}
};
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy