http://git-wip-us.apache.org/repos/asf/mahout/blob/545648f6/core/src/main/java/org/apache/mahout/math/function/Functions.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/mahout/math/function/Functions.java b/core/src/main/java/org/apache/mahout/math/function/Functions.java new file mode 100644 index 0000000..f08c328 --- /dev/null +++ b/core/src/main/java/org/apache/mahout/math/function/Functions.java @@ -0,0 +1,1730 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* +Copyright 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 org.apache.mahout.math.function; + + +import com.google.common.base.Preconditions; +import org.apache.mahout.math.jet.random.engine.MersenneTwister; + +import java.util.Date; + + +/** + * 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. <p>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 <tt>apply</tt> that takes the arguments, computes something and returns some result + * value. Function objects are comparable to function pointers in C used for call-backs. <p>Unary functions are of type + * {@link org.apache.mahout.math.function.DoubleFunction}, binary functions of type {@link + * org.apache.mahout.math.function.DoubleDoubleFunction}. All can be retrieved via <tt>public static final</tt> + * variables named after the function. Unary predicates are of type + * {@link DoubleProcedure}, + * binary predicates of type {@link org.apache.mahout.math.function.DoubleDoubleProcedure}. All can be retrieved via + * <tt>public static final</tt> variables named <tt>isXXX</tt>. + * + * <p> 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: <ul> + * <li><tt>Functions.pow</tt> gives the function <tt>a<sup>b</sup></tt>. <li><tt>Functions.pow.apply(2,3)==8</tt>. + * <li><tt>Functions.pow(3)</tt> gives the function <tt>a<sup>3</sup></tt>. <li><tt>Functions.pow(3).apply(2)==8</tt>. + * </ul> More general, any binary function can be made an unary functions by fixing either the first or the second + * argument. See methods {@link #bindArg1(org.apache.mahout.math.function.DoubleDoubleFunction ,double)} and {@link + * #bindArg2(org.apache.mahout.math.function.DoubleDoubleFunction ,double)}. The order of arguments can + * be swapped so that the first argument becomes the + * second and vice-versa. See method {@link #swapArgs(org.apache.mahout.math.function.DoubleDoubleFunction)}. + * Example: <ul> <li><tt>Functions.pow</tt> + * gives the function <tt>a<sup>b</sup></tt>. <li><tt>Functions.bindArg2(Functions.pow,3)</tt> gives the function + * <tt>x<sup>3</sup></tt>. <li><tt>Functions.bindArg1(Functions.pow,3)</tt> gives the function <tt>3<sup>x</sup></tt>. + * <li><tt>Functions.swapArgs(Functions.pow)</tt> gives the function <tt>b<sup>a</sup></tt>. </ul> <p> Even more + * general, functions can be chained (composed, assembled). Assume we have two unary functions <tt>g</tt> and + * <tt>h</tt>. The unary function <tt>g(h(a))</tt> applying both in sequence can be generated via {@link + * #chain(org.apache.mahout.math.function.DoubleFunction , org.apache.mahout.math.function.DoubleFunction)}: + * <ul> <li><tt>Functions.chain(g,h);</tt> </ul> Assume further we have a binary + * function <tt>f</tt>. The binary function <tt>g(f(a,b))</tt> can be generated via {@link + * #chain(org.apache.mahout.math.function.DoubleFunction , org.apache.mahout.math.function.DoubleDoubleFunction)}: + * <ul> <li><tt>Functions.chain(g,f);</tt> </ul> The binary function + * <tt>f(g(a),h(b))</tt> can be generated via + * {@link #chain(org.apache.mahout.math.function.DoubleDoubleFunction , org.apache.mahout.math.function.DoubleFunction , + * org.apache.mahout.math.function.DoubleFunction)}: <ul> + * <li><tt>Functions.chain(f,g,h);</tt> </ul> Arbitrarily complex functions can be composed from these building blocks. + * For example <tt>sin(a) + cos<sup>2</sup>(b)</tt> can be specified as follows: <ul> + * <li><tt>chain(plus,sin,chain(square,cos));</tt> </ul> or, of course, as + * <pre> + * new DoubleDoubleFunction() { + * public final double apply(double a, double b) { return Math.sin(a) + Math.pow(Math.cos(b),2); } + * } + * </pre> + * <p> For aliasing see functions. Try this <table> <tr><td class="PRE"> + * <pre> + * // should yield 1.4399560356056456 in all cases + * double a = 0.5; + * double b = 0.2; + * double v = Math.sin(a) + Math.pow(Math.cos(b),2); + * log.info(v); + * Functions F = Functions.functions; + * DoubleDoubleFunction f = F.chain(F.plus,F.sin,F.chain(F.square,F.cos)); + * log.info(f.apply(a,b)); + * DoubleDoubleFunction g = new DoubleDoubleFunction() { + * public double apply(double a, double b) { return Math.sin(a) + Math.pow(Math.cos(b),2); } + * }; + * log.info(g.apply(a,b)); + * </pre> + * </td></tr></table> + * + * <p> <H3>Performance</H3> + * + * 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. <tt>F.chain(F.abs,F.chain(F.plus,F.sin,F.chain(F.square,F.cos)))</tt>) the penalty is zero, for trivial + * functions (e.g. <tt>F.plus</tt>) the penalty is often acceptable. <center> <table border cellpadding="3" + * cellspacing="0" align="center"> + * <tr valign="middle" bgcolor="#33CC66" align="center"> <td nowrap colspan="7"> + * <font size="+2">Iteration Performance [million function evaluations per second]</font><br> <font size="-1">Pentium + * Pro 200 Mhz, SunJDK 1.2.2, NT, java -classic, </font></td> </tr> + * <tr valign="middle" bgcolor="#66CCFF" align="center"> <td nowrap bgcolor="#FF9966" rowspan="2"> </td> <td bgcolor="#FF9966" colspan="2"> <p> 30000000 + * iterations</p> </td> <td bgcolor="#FF9966" colspan="2"> 3000000 iterations (10 times less)</td> <td bgcolor="#FF9966" + * colspan="2"> </td> </tr> + * <tr valign="middle" bgcolor="#66CCFF" align="center"> <td nowrap bgcolor="#FF9966"> + * <tt>F.plus</tt></td> <td bgcolor="#FF9966"><tt>a+b</tt></td> <td bgcolor="#FF9966"> + * <tt>F.chain(F.abs,F.chain(F.plus,F.sin,F.chain(F.square,F.cos)))</tt></td> <td bgcolor="#FF9966"> + * <tt>Math.abs(Math.sin(a) + Math.pow(Math.cos(b),2))</tt></td> <td bgcolor="#FF9966"> </td> <td + * bgcolor="#FF9966"> </td> </tr> + * <tr valign="middle" bgcolor="#66CCFF" align="center"> <td nowrap + * bgcolor="#FF9966"> </td> <td nowrap>10.8</td> <td nowrap>29.6</td> <td nowrap>0.43</td> <td nowrap>0.35</td> <td + * nowrap> </td> <td nowrap> </td> </tr> + * </table></center> + */ +public final class Functions { + + /* + * <H3>Unary functions</H3> + */ + /** Function that returns <tt>Math.abs(a)</tt>. */ + public static final DoubleFunction ABS = new DoubleFunction() { + @Override + public double apply(double a) { + return Math.abs(a); + } + }; + + /** Function that returns <tt>Math.acos(a)</tt>. */ + public static final DoubleFunction ACOS = new DoubleFunction() { + @Override + public double apply(double a) { + return Math.acos(a); + } + }; + + /** Function that returns <tt>Math.asin(a)</tt>. */ + public static final DoubleFunction ASIN = new DoubleFunction() { + @Override + public double apply(double a) { + return Math.asin(a); + } + }; + + /** Function that returns <tt>Math.atan(a)</tt>. */ + public static final DoubleFunction ATAN = new DoubleFunction() { + @Override + public double apply(double a) { + return Math.atan(a); + } + }; + + /** Function that returns <tt>Math.ceil(a)</tt>. */ + public static final DoubleFunction CEIL = new DoubleFunction() { + + @Override + public double apply(double a) { + return Math.ceil(a); + } + }; + + /** Function that returns <tt>Math.cos(a)</tt>. */ + public static final DoubleFunction COS = new DoubleFunction() { + + @Override + public double apply(double a) { + return Math.cos(a); + } + }; + + /** Function that returns <tt>Math.exp(a)</tt>. */ + public static final DoubleFunction EXP = new DoubleFunction() { + + @Override + public double apply(double a) { + return Math.exp(a); + } + }; + + /** Function that returns <tt>Math.floor(a)</tt>. */ + public static final DoubleFunction FLOOR = new DoubleFunction() { + + @Override + public double apply(double a) { + return Math.floor(a); + } + }; + + /** Function that returns its argument. */ + public static final DoubleFunction IDENTITY = new DoubleFunction() { + + @Override + public double apply(double a) { + return a; + } + }; + + /** Function that returns <tt>1.0 / a</tt>. */ + public static final DoubleFunction INV = new DoubleFunction() { + + @Override + public double apply(double a) { + return 1.0 / a; + } + }; + + /** Function that returns <tt>Math.log(a)</tt>. */ + public static final DoubleFunction LOGARITHM = new DoubleFunction() { + + @Override + public double apply(double a) { + return Math.log(a); + } + }; + + /** Function that returns <tt>Math.log(a) / Math.log(2)</tt>. */ + public static final DoubleFunction LOG2 = new DoubleFunction() { + + @Override + public double apply(double a) { + return Math.log(a) * 1.4426950408889634; + } + }; + + /** Function that returns <tt>-a</tt>. */ + public static final DoubleFunction NEGATE = new DoubleFunction() { + + @Override + public double apply(double a) { + return -a; + } + }; + + /** Function that returns <tt>Math.rint(a)</tt>. */ + public static final DoubleFunction RINT = new DoubleFunction() { + + @Override + public double apply(double a) { + return Math.rint(a); + } + }; + + /** + * Function that returns {@code a < 0 ? -1 : a > 0 ? 1 : 0}. + */ + public static final DoubleFunction SIGN = new DoubleFunction() { + + @Override + public double apply(double a) { + return a < 0 ? -1 : a > 0 ? 1 : 0; + } + }; + + /** Function that returns <tt>Math.sin(a)</tt>. */ + public static final DoubleFunction SIN = new DoubleFunction() { + + @Override + public double apply(double a) { + return Math.sin(a); + } + }; + + /** Function that returns <tt>Math.sqrt(a)</tt>. */ + public static final DoubleFunction SQRT = new DoubleFunction() { + + @Override + public double apply(double a) { + return Math.sqrt(a); + } + }; + + /** Function that returns <tt>a * a</tt>. */ + public static final DoubleFunction SQUARE = new DoubleFunction() { + + @Override + public double apply(double a) { + return a * a; + } + }; + + /** Function that returns <tt> 1 / (1 + exp(-a) </tt> */ + public static final DoubleFunction SIGMOID = new DoubleFunction() { + @Override + public double apply(double a) { + return 1.0 / (1.0 + Math.exp(-a)); + } + }; + + /** Function that returns <tt> a * (1-a) </tt> */ + public static final DoubleFunction SIGMOIDGRADIENT = new DoubleFunction() { + @Override + public double apply(double a) { + return a * (1.0 - a); + } + }; + + /** Function that returns <tt>Math.tan(a)</tt>. */ + public static final DoubleFunction TAN = new DoubleFunction() { + + @Override + public double apply(double a) { + return Math.tan(a); + } + }; + + /* + * <H3>Binary functions</H3> + */ + + /** Function that returns <tt>Math.atan2(a,b)</tt>. */ + public static final DoubleDoubleFunction ATAN2 = new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return Math.atan2(a, b); + } + }; + + /** + * Function that returns <tt>a < b ? -1 : a > b ? 1 : 0</tt>. + */ + public static final DoubleDoubleFunction COMPARE = new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return a < b ? -1 : a > b ? 1 : 0; + } + }; + + /** Function that returns <tt>a / b</tt>. */ + public static final DoubleDoubleFunction DIV = new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return a / b; + } + + /** + * x / 0 = infinity or undefined depending on x + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return false; + } + + /** + * 0 / y = 0 unless y = 0 + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return false; + } + + /** + * x / 0 = infinity or undefined depending on x + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return false; + } + + /** + * x / y != y / x + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return false; + } + + /** + * x / (y / z) = x * z / y + * (x / y) / z = x / (y * z) + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return false; + } + + }; + + /** Function that returns <tt>a == b ? 1 : 0</tt>. */ + public static final DoubleDoubleFunction EQUALS = new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return a == b ? 1 : 0; + } + + /** + * x = y iff y = x + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return true; + } + }; + + /** + * Function that returns <tt>a > b ? 1 : 0</tt>. + */ + public static final DoubleDoubleFunction GREATER = new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return a > b ? 1 : 0; + } + }; + + /** Function that returns <tt>Math.IEEEremainder(a,b)</tt>. */ + public static final DoubleDoubleFunction IEEE_REMAINDER = new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return Math.IEEEremainder(a, b); + } + }; + + /** Function that returns <tt>a == b</tt>. */ + public static final DoubleDoubleProcedure IS_EQUAL = new DoubleDoubleProcedure() { + + @Override + public boolean apply(double a, double b) { + return a == b; + } + }; + + /** + * Function that returns {@code a < b}. + */ + public static final DoubleDoubleProcedure IS_LESS = new DoubleDoubleProcedure() { + + @Override + public boolean apply(double a, double b) { + return a < b; + } + }; + + /** + * Function that returns {@code a > b}. + */ + public static final DoubleDoubleProcedure IS_GREATER = new DoubleDoubleProcedure() { + + @Override + public boolean apply(double a, double b) { + return a > b; + } + }; + + /** + * Function that returns <tt>a < b ? 1 : 0</tt>. + */ + public static final DoubleDoubleFunction LESS = new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return a < b ? 1 : 0; + } + }; + + /** Function that returns <tt>Math.log(a) / Math.log(b)</tt>. */ + public static final DoubleDoubleFunction LG = new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return Math.log(a) / Math.log(b); + } + }; + + /** Function that returns <tt>Math.max(a,b)</tt>. */ + public static final DoubleDoubleFunction MAX = new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return Math.max(a, b); + } + + /** + * max(x, 0) = x or 0 depending on the sign of x + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return false; + } + + /** + * max(0, y) = y or 0 depending on the sign of y + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return false; + } + + /** + * max(x, 0) = x or 0 depending on the sign of x + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return false; + } + + /** + * max(x, max(y, z)) = max(max(x, y), z) + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return true; + } + + /** + * max(x, y) = max(y, x) + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return true; + } + }; + + public static final DoubleDoubleFunction MAX_ABS = new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return Math.max(Math.abs(a), Math.abs(b)); + } + + /** + * max(|x|, 0) = |x| + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return true; + } + + /** + * max(0, |y|) = |y| + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return false; + } + + /** + * max(|x|, 0) = |x| + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return false; + } + + /** + * max(|x|, max(|y|, |z|)) = max(max(|x|, |y|), |z|) + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return true; + } + + /** + * max(|x|, |y|) = max(|y\, |x\) + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return true; + } + }; + + /** Function that returns <tt>Math.min(a,b)</tt>. */ + public static final DoubleDoubleFunction MIN = new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return Math.min(a, b); + } + + /** + * min(x, 0) = x or 0 depending on the sign of x + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return false; + } + + /** + * min(0, y) = y or 0 depending on the sign of y + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return false; + } + + /** + * min(x, 0) = x or 0 depending on the sign of x + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return false; + } + + /** + * min(x, min(y, z)) = min(min(x, y), z) + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return true; + } + + /** + * min(x, y) = min(y, x) + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return true; + } + }; + + /** Function that returns <tt>a - b</tt>. */ + public static final DoubleDoubleFunction MINUS = plusMult(-1); + + public static final DoubleDoubleFunction MINUS_SQUARED = new DoubleDoubleFunction() { + @Override + public double apply(double x, double y) { + return (x - y) * (x - y); + } + + /** + * (x - 0)^2 = x^2 != x + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return false; + } + + /** + * (0 - y)^2 != 0 + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return false; + } + + /** + * (x - 0)^2 != x + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return false; + } + + /** + * (x - y)^2 = (y - x)^2 + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return true; + } + + /** + * (x - (y - z)^2)^2 != ((x - y)^2 - z)^2 + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return false; + } + }; + + /** Function that returns <tt>a % b</tt>. */ + public static final DoubleDoubleFunction MOD = new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return a % b; + } + }; + + /** Function that returns <tt>a * b</tt>. */ + public static final DoubleDoubleFunction MULT = new TimesFunction(); + + /** Function that returns <tt>a + b</tt>. */ + public static final DoubleDoubleFunction PLUS = plusMult(1); + + /** Function that returns <tt>Math.abs(a) + Math.abs(b)</tt>. */ + public static final DoubleDoubleFunction PLUS_ABS = new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return Math.abs(a) + Math.abs(b); + } + + /** + * abs(x) + abs(0) = abs(x) != x + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return false; + } + + /** + * abs(0) + abs(y) = abs(y) != 0 unless y = 0 + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return false; + } + + /** + * abs(x) + abs(0) = abs(x) != 0 unless x = 0 + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return false; + } + + /** + * abs(x) + abs(abs(y) + abs(z)) = abs(x) + abs(y) + abs(z) + * abs(abs(x) + abs(y)) + abs(z) = abs(x) + abs(y) + abs(z) + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return true; + } + + /** + * abs(x) + abs(y) = abs(y) + abs(x) + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return true; + } + }; + + public static final DoubleDoubleFunction MINUS_ABS = new DoubleDoubleFunction() { + @Override + public double apply(double x, double y) { + return Math.abs(x - y); + } + + /** + * |x - 0| = |x| + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return false; + } + + /** + * |0 - y| = |y| + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return false; + } + + /** + * |x - 0| = |x| + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return false; + } + + /** + * |x - y| = |y - x| + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return true; + } + + /** + * |x - |y - z|| != ||x - y| - z| (|5 - |4 - 3|| = 1; ||5 - 4| - 3| = |1 - 3| = 2) + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return false; + } + }; + + /** Function that returns <tt>Math.pow(a,b)</tt>. */ + public static final DoubleDoubleFunction POW = new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return Math.pow(a, b); + } + + /** + * x^0 = 1 for any x unless x = 0 (undefined) + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return false; + } + + /** + * 0^y = 0 for any y unless y = 0 (undefined, but Math.pow(0, 0) = 1) + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return false; + } + + /** + * x^0 = 1 for any x (even x = 0) + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return false; + } + + /** + * x^y != y^x (2^3 != 3^2) + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return false; + } + + /** + * x^(y^z) != (x^y)^z ((2^3)^4 = 8^4 = 2^12 != 2^(3^4) = 2^81) + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return false; + } + }; + + public static final DoubleDoubleFunction SECOND = new DoubleDoubleFunction() { + @Override + public double apply(double x, double y) { + return y; + } + + /** + * f(x, 0) = x for any x + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return false; + } + + /** + * f(0, y) = y for any y + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return false; + } + + /** + * f(x, 0) = 0 for any x + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return true; + } + + /** + * f(x, y) = x != y = f(y, x) for any x, y unless x = y + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return false; + } + + /** + * f(x, f(y, z)) = f(x, z) = z + * f(f(x, y), z) = z + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return true; + } + }; + + /** + * This function is specifically designed to be used when assigning a vector to one that is all zeros (created + * by like()). It enables iteration only through the nonzeros of the right hand side by declaring isLikeRightPlus + * to be true. This is NOT generally true for SECOND (hence the other function above). + */ + public static final DoubleDoubleFunction SECOND_LEFT_ZERO = new DoubleDoubleFunction() { + @Override + public double apply(double x, double y) { + Preconditions.checkArgument(x == 0, "This special version of SECOND needs x == 0"); + return y; + } + + /** + * f(x, 0) = 0 for any x; we're only assigning to left hand sides that are strictly 0 + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return true; + } + + /** + * f(0, y) = y for any y + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return false; + } + + /** + * f(x, 0) = 0 for any x + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return true; + } + + /** + * f(x, y) = x != y = f(y, x) for any x, y unless x = y + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return false; + } + + /** + * f(x, f(y, z)) = f(x, z) = z + * f(f(x, y), z) = z + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return true; + } + }; + public static final DoubleDoubleFunction MULT_SQUARE_LEFT = new DoubleDoubleFunction() { + @Override + public double apply(double x, double y) { + return x * x * y; + } + + /** + * x * x * 0 = 0 + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return false; + } + + /** + * 0 * 0 * y = 0 + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return true; + } + + /** + * x * x * 0 = 0 + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return true; + } + + /** + * x * x * y != y * y * x + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return false; + } + + /** + * x * x * y * y * z != x * x * y * x * x * y * z + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return false; + } + }; + + public static final DoubleDoubleFunction MULT_RIGHT_PLUS1 = new DoubleDoubleFunction() { + + /** + * Apply the function to the arguments and return the result + * + * @param x a double for the first argument + * @param y a double for the second argument + * @return the result of applying the function + */ + @Override + public double apply(double x, double y) { + return x * (y + 1); + } + + /** + * x * 1 = x + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return true; + } + + /** + * 0 * y = 0 + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return true; + } + + /** + * x * 1 = x != 0 + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return false; + } + + /** + * x * (y + 1) != y * (x + 1) + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return false; + } + + /** + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return false; + } + }; + + public static DoubleDoubleFunction reweigh(final double wx, final double wy) { + final double tw = wx + wy; + return new DoubleDoubleFunction() { + @Override + public double apply(double x, double y) { + return (wx * x + wy * y) / tw; + } + + /** + * f(x, 0) = wx * x / tw = x iff wx = tw (practically, impossible, as tw = wx + wy and wy > 0) + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return wx == tw; + } + + /** + * f(0, y) = wy * y / tw = 0 iff y = 0 + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return false; + } + + /** + * f(x, 0) = wx * x / tw = 0 iff x = 0 + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return false; + } + + /** + * wx * x + wy * y = wx * y + wy * x iff wx = wy + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return wx == wy; + } + + /** + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return false; + } + }; + } + + private Functions() { + } + + /** + * Constructs a function that returns {@code (from<=a && a<=to) ? 1 : 0}. + * <tt>a</tt> is a variable, <tt>from</tt> and <tt>to</tt> are fixed. + */ + public static DoubleFunction between(final double from, final double to) { + return new DoubleFunction() { + + @Override + public double apply(double 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 + * <tt>c</tt>. The second operand is variable (free). + * + * @param function a binary function taking operands in the form <tt>function.apply(c,var)</tt>. + * @return the unary function <tt>function(c,var)</tt>. + */ + public static DoubleFunction bindArg1(final DoubleDoubleFunction function, final double c) { + return new DoubleFunction() { + + @Override + public double apply(double var) { + return function.apply(c, var); + } + }; + } + + /** + * Constructs a unary function from a binary function with the second operand (argument) fixed to the given constant + * <tt>c</tt>. The first operand is variable (free). + * + * @param function a binary function taking operands in the form <tt>function.apply(var,c)</tt>. + * @return the unary function <tt>function(var,c)</tt>. + */ + public static DoubleFunction bindArg2(final DoubleDoubleFunction function, final double c) { + return new DoubleFunction() { + + @Override + public double apply(double var) { + return function.apply(var, c); + } + }; + } + + /** + * Constructs the function <tt>f( g(a), h(b) )</tt>. + * + * @param f a binary function. + * @param g a unary function. + * @param h a unary function. + * @return the binary function <tt>f( g(a), h(b) )</tt>. + */ + public static DoubleDoubleFunction chain(final DoubleDoubleFunction f, final DoubleFunction g, + final DoubleFunction h) { + return new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return f.apply(g.apply(a), h.apply(b)); + } + + /** + * fx(c, 0) = f(g(x), h(0)) = f(g(x), 0) = g(x) = x if h(0) = 0 and f isLikeRightPlus and g(x) = x + * Impossible to check whether g(x) = x for any x, so we return false. + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return false; + } + + /** + * fc(0, y) = f(g(0), h(y)) = f(0, h(y)) = 0 if g(0) = 0 and f isLikeLeftMult + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return g.apply(0) == 0 && f.isLikeLeftMult(); + } + + /** + * fc(x, 0) = f(g(x), h(0)) = f(g(x), 0) = 0 if h(0) = 0 and f isLikeRightMult + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return h.apply(0) == 0 && f.isLikeRightMult(); + } + + /** + * fc(x, y) = f(g(x), h(y)) = f(h(y), g(x)) + * fc(y, x) = f(g(y), h(x)) = f(h(x), g(y)) + * Either g(x) = g(y) for any x, y and h(x) = h(y) for any x, y or g = h and f isCommutative. + * Can only check if g = h (reference equality, assuming they're both the same static function in + * this file) and f isCommutative. There are however other scenarios when this might happen that are NOT + * covered by this definition. + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return g.equals(h) && f.isCommutative(); + } + + /** + * fc(x, fc(y, z)) = f(g(x), h(f(g(y), h(z)))) + * fc(fc(x, y), z) = f(g(f(g(x), h(y))), h(z)) + * Impossible to check. + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return false; + } + }; + } + + /** + * Constructs the function <tt>g( h(a,b) )</tt>. + * + * @param g a unary function. + * @param h a binary function. + * @return the binary function <tt>g( h(a,b) )</tt>. + */ + public static DoubleDoubleFunction chain(final DoubleFunction g, final DoubleDoubleFunction h) { + return new DoubleDoubleFunction() { + + @Override + public double apply(double a, double b) { + return g.apply(h.apply(a, b)); + } + + /** + * g(h(x, 0)) = g(x) = x for any x iff g(x) = x and h isLikeRightPlus + * Impossible to check. + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return false; + } + + /** + * g(h(0, y)) = g(0) = 0 for any y iff g(0) = 0 and h isLikeLeftMult + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return !g.isDensifying() && h.isLikeLeftMult(); + } + + /** + * g(h(x, 0)) = g(0) = 0 for any x iff g(0) = 0 and h isLikeRightMult + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return !g.isDensifying() && h.isLikeRightMult(); + } + + /** + * fc(x, y) = g(h(x, y)) = g(h(y, x)) = fc(y, x) iff h isCommutative + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return h.isCommutative(); + } + + /** + * fc(x, fc(y, z)) = g(h(x, g(h(y, z))) + * fc(fc(x, y), z) = g(h(g(h(x, y)), z)) + * Impossible to check. + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return false; + } + }; + } + + /** + * Constructs the function <tt>g( h(a) )</tt>. + * + * @param g a unary function. + * @param h a unary function. + * @return the unary function <tt>g( h(a) )</tt>. + */ + public static DoubleFunction chain(final DoubleFunction g, final DoubleFunction h) { + return new DoubleFunction() { + + @Override + public double apply(double a) { + return g.apply(h.apply(a)); + } + }; + } + + /** + * Constructs the function <tt>g( h(a) )</tt>. + * + * @param g a unary function. + * @param h an {@link IntIntFunction} function. + * @return the unary function <tt>g( h(a) )</tt>. + */ + public static IntIntFunction chain(final DoubleFunction g, final IntIntFunction h) { + return new IntIntFunction() { + + @Override + public double apply(int first, int second) { + return g.apply(h.apply(first, second)); + } + }; + } + + + /** + * Constructs a function that returns {@code a < b ? -1 : a > b ? 1 : 0}. <tt>a</tt> is a variable, <tt>b</tt> is + * fixed. + */ + public static DoubleFunction compare(final double b) { + return new DoubleFunction() { + + @Override + public double apply(double a) { + return a < b ? -1 : a > b ? 1 : 0; + } + }; + } + + /** Constructs a function that returns the constant <tt>c</tt>. */ + public static DoubleFunction constant(final double c) { + return new DoubleFunction() { + + @Override + public double apply(double a) { + return c; + } + }; + } + + + /** Constructs a function that returns <tt>a / b</tt>. <tt>a</tt> is a variable, <tt>b</tt> is fixed. */ + public static DoubleFunction div(double b) { + return mult(1 / b); + } + + /** Constructs a function that returns <tt>a == b ? 1 : 0</tt>. <tt>a</tt> is a variable, <tt>b</tt> is fixed. */ + public static DoubleFunction equals(final double b) { + return new DoubleFunction() { + + @Override + public double apply(double a) { + return a == b ? 1 : 0; + } + }; + } + + /** Constructs a function that returns <tt>a != b ? 1 : 0</tt>. <tt>a</tt> is a variable, <tt>b</tt> is fixed. */ + public static DoubleFunction notEqual(final double b) { + return new DoubleFunction() { + + @Override + public double apply(double a) { + return a != b ? 1 : 0; + } + }; + } + + /** + * Constructs a function that returns <tt>a > b ? 1 : 0</tt>. <tt>a</tt> + * is a variable, <tt>b</tt> is fixed. + */ + public static DoubleFunction greater(final double b) { + return new DoubleFunction() { + + @Override + public double apply(double a) { + return a > b ? 1 : 0; + } + }; + } + + /** + * Constructs a function that returns <tt>Math.IEEEremainder(a,b)</tt>. <tt>a</tt> is a variable, <tt>b</tt> is + * fixed. + */ + public static DoubleFunction mathIEEEremainder(final double b) { + return new DoubleFunction() { + + @Override + public double apply(double a) { + return Math.IEEEremainder(a, b); + } + }; + } + + /** + * Constructs a function that returns {@code from<=a && a<=to}. <tt>a</tt> + * is a variable, <tt>from</tt> and + * <tt>to</tt> are fixed. + * + * Note that DoubleProcedure is generated code and thus looks like an invalid reference unless you can see + * the generated stuff. + */ + public static DoubleProcedure isBetween(final double from, final double to) { + return new DoubleProcedure() { + + @Override + public boolean apply(double a) { + return from <= a && a <= to; + } + }; + } + + /** + * Constructs a function that returns <tt>a == b</tt>. <tt>a</tt> is a + * variable, <tt>b</tt> is fixed. + */ + public static DoubleProcedure isEqual(final double b) { + return new DoubleProcedure() { + + @Override + public boolean apply(double a) { + return a == b; + } + }; + } + + /** + * Constructs a function that returns <tt>a > b</tt>. <tt>a</tt> is a + * variable, <tt>b</tt> is fixed. + */ + public static DoubleProcedure isGreater(final double b) { + return new DoubleProcedure() { + + @Override + public boolean apply(double a) { + return a > b; + } + }; + } + + /** + * Constructs a function that returns {@code a < b}. <tt>a</tt> is a + * variable, <tt>b</tt> is fixed. + */ + public static DoubleProcedure isLess(final double b) { + return new DoubleProcedure() { + + @Override + public boolean apply(double a) { + return a < b; + } + }; + } + + /** + * Constructs a function that returns <tt>a < b ? 1 : 0</tt>. <tt>a</tt> is a + * variable, <tt>b</tt> is fixed. + */ + public static DoubleFunction less(final double b) { + return new DoubleFunction() { + + @Override + public double apply(double a) { + return a < b ? 1 : 0; + } + }; + } + + /** + * Constructs a function that returns <tt>Math.log(a) / Math.log(b)</tt>. + * <tt>a</tt> is a variable, <tt>b</tt> is fixed. + */ + public static DoubleFunction lg(final double b) { + return new DoubleFunction() { + private final double logInv = 1 / Math.log(b); // cached for speed + + + @Override + public double apply(double a) { + return Math.log(a) * logInv; + } + }; + } + + /** Constructs a function that returns <tt>Math.max(a,b)</tt>. <tt>a</tt> is a variable, <tt>b</tt> is fixed. */ + public static DoubleFunction max(final double b) { + return new DoubleFunction() { + + @Override + public double apply(double a) { + return Math.max(a, b); + } + }; + } + + /** Constructs a function that returns <tt>Math.min(a,b)</tt>. <tt>a</tt> is a variable, <tt>b</tt> is fixed. */ + public static DoubleFunction min(final double b) { + return new DoubleFunction() { + + @Override + public double apply(double a) { + return Math.min(a, b); + } + }; + } + + /** Constructs a function that returns <tt>a - b</tt>. <tt>a</tt> is a variable, <tt>b</tt> is fixed. */ + public static DoubleFunction minus(double b) { + return plus(-b); + } + + /** + * Constructs a function that returns <tt>a - b*constant</tt>. <tt>a</tt> and <tt>b</tt> are variables, + * <tt>constant</tt> is fixed. + */ + public static DoubleDoubleFunction minusMult(double constant) { + return plusMult(-constant); + } + + /** Constructs a function that returns <tt>a % b</tt>. <tt>a</tt> is a variable, <tt>b</tt> is fixed. */ + public static DoubleFunction mod(final double b) { + return new DoubleFunction() { + + @Override + public double apply(double a) { + return a % b; + } + }; + } + + /** Constructs a function that returns <tt>a * b</tt>. <tt>a</tt> is a variable, <tt>b</tt> is fixed. */ + public static DoubleFunction mult(double b) { + return new Mult(b); + /* + return new DoubleFunction() { + public final double apply(double a) { return a * b; } + }; + */ + } + + /** Constructs a function that returns <tt>a + b</tt>. <tt>a</tt> is a variable, <tt>b</tt> is fixed. */ + public static DoubleFunction plus(final double b) { + return new DoubleFunction() { + + @Override + public double apply(double a) { + return a + b; + } + }; + } + + /** + * Constructs a function that returns <tt>a + b*constant</tt>. <tt>a</tt> and <tt>b</tt> are variables, + * <tt>constant</tt> is fixed. + */ + public static DoubleDoubleFunction plusMult(double constant) { + return new PlusMult(constant); + } + + /** Constructs a function that returns <tt>Math.pow(a,b)</tt>. <tt>a</tt> is a variable, <tt>b</tt> is fixed. */ + public static DoubleFunction pow(final double b) { + return new DoubleFunction() { + + @Override + public double apply(double a) { + if (b == 2) { + return a * a; + } else { + return Math.pow(a, b); + } + } + }; + } + + /** + * Constructs a function that returns a new uniform random number in the open unit interval {@code (0.0,1.0)} + * (excluding 0.0 and 1.0). Currently the engine is {@link MersenneTwister} and is + * seeded with the current time. <p> Note that any random engine derived from {@link + * org.apache.mahout.math.jet.random.engine.RandomEngine} and any random distribution derived from {@link + * org.apache.mahout.math.jet.random.AbstractDistribution} 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 DoubleFunction random() { + return new MersenneTwister(new Date()); + } + + /** + * Constructs a function that returns the number rounded to the given precision; + * <tt>Math.rint(a/precision)*precision</tt>. Examples: + * {@code + * precision = 0.01 rounds 0.012 --> 0.01, 0.018 --> 0.02 + * precision = 10 rounds 123 --> 120 , 127 --> 130 + * } + */ + public static DoubleFunction round(final double precision) { + return new DoubleFunction() { + @Override + public double apply(double a) { + return Math.rint(a / precision) * precision; + } + }; + } + + /** + * Constructs a function that returns <tt>function.apply(b,a)</tt>, 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 <tt>function.apply(a,b)</tt>. + * @return the binary function <tt>function(b,a)</tt>. + */ + public static DoubleDoubleFunction swapArgs(final DoubleDoubleFunction function) { + return new DoubleDoubleFunction() { + @Override + public double apply(double a, double b) { + return function.apply(b, a); + } + }; + } + + public static DoubleDoubleFunction minusAbsPow(final double exponent) { + return new DoubleDoubleFunction() { + @Override + public double apply(double x, double y) { + return Math.pow(Math.abs(x - y), exponent); + } + + /** + * |x - 0|^p = |x|^p != x unless x > 0 and p = 1 + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return false; + } + + /** + * |0 - y|^p = |y|^p + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return false; + } + + /** + * |x - 0|^p = |x|^p + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return false; + } + + /** + * |x - y|^p = |y - x|^p + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return true; + } + + /** + * |x - |y - z|^p|^p != ||x - y|^p - z|^p + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return false; + } + }; + } +}
http://git-wip-us.apache.org/repos/asf/mahout/blob/545648f6/core/src/main/java/org/apache/mahout/math/function/IntFunction.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/mahout/math/function/IntFunction.java b/core/src/main/java/org/apache/mahout/math/function/IntFunction.java new file mode 100644 index 0000000..b91fe18 --- /dev/null +++ b/core/src/main/java/org/apache/mahout/math/function/IntFunction.java @@ -0,0 +1,41 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* +Copyright 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 org.apache.mahout.math.function; + +/** + * Interface that represents a function object: a function that takes a single argument and returns a single value. + */ +public interface IntFunction { + + /** + * Applies a function to an argument. + * + * @param argument argument passed to the function. + * @return the result of the function. + */ + int apply(int argument); +} http://git-wip-us.apache.org/repos/asf/mahout/blob/545648f6/core/src/main/java/org/apache/mahout/math/function/IntIntDoubleFunction.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/mahout/math/function/IntIntDoubleFunction.java b/core/src/main/java/org/apache/mahout/math/function/IntIntDoubleFunction.java new file mode 100644 index 0000000..b08f08b --- /dev/null +++ b/core/src/main/java/org/apache/mahout/math/function/IntIntDoubleFunction.java @@ -0,0 +1,43 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* +Copyright 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 org.apache.mahout.math.function; + +/** + * Interface that represents a function object: a function that takes three arguments. + */ +public interface IntIntDoubleFunction { + + /** + * Applies a function to three arguments. + * + * @param first first argument passed to the function. + * @param second second argument passed to the function. + * @param third third argument passed to the function. + * @return the result of the function. + */ + double apply(int first, int second, double third); +} http://git-wip-us.apache.org/repos/asf/mahout/blob/545648f6/core/src/main/java/org/apache/mahout/math/function/IntIntFunction.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/mahout/math/function/IntIntFunction.java b/core/src/main/java/org/apache/mahout/math/function/IntIntFunction.java new file mode 100644 index 0000000..f08bb28 --- /dev/null +++ b/core/src/main/java/org/apache/mahout/math/function/IntIntFunction.java @@ -0,0 +1,25 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.mahout.math.function; + +/** + * A function that takes to integer arguments and returns Double. + */ +public interface IntIntFunction { + double apply(int first, int second); +} http://git-wip-us.apache.org/repos/asf/mahout/blob/545648f6/core/src/main/java/org/apache/mahout/math/function/Mult.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/mahout/math/function/Mult.java b/core/src/main/java/org/apache/mahout/math/function/Mult.java new file mode 100644 index 0000000..9bbc5ec --- /dev/null +++ b/core/src/main/java/org/apache/mahout/math/function/Mult.java @@ -0,0 +1,71 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* +Copyright 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 org.apache.mahout.math.function; + +/** + * Only for performance tuning of compute intensive linear algebraic computations. + * Constructs functions that return one of + * <ul> + * <li><tt>a * constant</tt> + * <li><tt>a / constant</tt> + * </ul> + * <tt>a</tt> is variable, <tt>constant</tt> is fixed, but for performance reasons publicly accessible. + * Intended to be passed to <tt>matrix.assign(function)</tt> methods. + */ + +public final class Mult extends DoubleFunction { + + private double multiplicator; + + Mult(double multiplicator) { + this.multiplicator = multiplicator; + } + + /** Returns the result of the function evaluation. */ + @Override + public double apply(double a) { + return a * multiplicator; + } + + /** <tt>a / constant</tt>. */ + public static Mult div(double constant) { + return mult(1 / constant); + } + + /** <tt>a * constant</tt>. */ + public static Mult mult(double constant) { + return new Mult(constant); + } + + public double getMultiplicator() { + return multiplicator; + } + + public void setMultiplicator(double multiplicator) { + this.multiplicator = multiplicator; + } +} http://git-wip-us.apache.org/repos/asf/mahout/blob/545648f6/core/src/main/java/org/apache/mahout/math/function/ObjectObjectProcedure.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/mahout/math/function/ObjectObjectProcedure.java b/core/src/main/java/org/apache/mahout/math/function/ObjectObjectProcedure.java new file mode 100644 index 0000000..46ad8d0 --- /dev/null +++ b/core/src/main/java/org/apache/mahout/math/function/ObjectObjectProcedure.java @@ -0,0 +1,40 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.mahout.math.function; + +/** + * Interface that represents a procedure object: + * a procedure that takes two arguments and returns a 'continue' flag. + */ +public interface ObjectObjectProcedure<K,V> { + + /** + * Applies a procedure to an argument. Optionally can return a boolean flag to inform the object calling the + * procedure. + * + * <p>Example: forEach() methods often use procedure objects. To signal to a forEach() method whether iteration should + * continue normally or terminate (because for example a matching element has been found), a procedure can return + * <tt>false</tt> to indicate termination and <tt>true</tt> to indicate continuation. + * + * @param key key value passed to the procedure + * @param value value value passed to the procedure. + * @return a flag to inform the object calling the procedure. + */ + boolean apply(K key, V value); +} http://git-wip-us.apache.org/repos/asf/mahout/blob/545648f6/core/src/main/java/org/apache/mahout/math/function/ObjectProcedure.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/mahout/math/function/ObjectProcedure.java b/core/src/main/java/org/apache/mahout/math/function/ObjectProcedure.java new file mode 100644 index 0000000..8c1b1c8 --- /dev/null +++ b/core/src/main/java/org/apache/mahout/math/function/ObjectProcedure.java @@ -0,0 +1,47 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* +Copyright 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 org.apache.mahout.math.function; + +/** + * Interface that represents a procedure object: a procedure that takes a single argument and does not return a value. + */ +public interface ObjectProcedure<T> { + + /** + * Applies a procedure to an argument. Optionally can return a boolean flag to inform the object calling the + * procedure. + * + * <p>Example: forEach() methods often use procedure objects. To signal to a forEach() method whether iteration should + * continue normally or terminate (because for example a matching element has been found), a procedure can return + * <tt>false</tt> to indicate termination and <tt>true</tt> to indicate continuation. + * + * @param element element passed to the procedure. + * @return a flag to inform the object calling the procedure. + */ + boolean apply(T element); +} http://git-wip-us.apache.org/repos/asf/mahout/blob/545648f6/core/src/main/java/org/apache/mahout/math/function/PlusMult.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/mahout/math/function/PlusMult.java b/core/src/main/java/org/apache/mahout/math/function/PlusMult.java new file mode 100644 index 0000000..ff99a70 --- /dev/null +++ b/core/src/main/java/org/apache/mahout/math/function/PlusMult.java @@ -0,0 +1,123 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* +Copyright 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 org.apache.mahout.math.function; + +import org.apache.mahout.math.jet.math.Constants; + +/** + * Only for performance tuning of compute intensive linear algebraic computations. + * Constructs functions that return one of + * <ul> + * <li><tt>a + b*constant</tt> + * <li><tt>a - b*constant</tt> + * <li><tt>a + b/constant</tt> + * <li><tt>a - b/constant</tt> + * </ul> + * <tt>a</tt> and <tt>b</tt> are variables, <tt>constant</tt> is fixed, but for performance reasons publicly accessible. + * Intended to be passed to <tt>matrix.assign(otherMatrix,function)</tt> methods. + */ + +public final class PlusMult extends DoubleDoubleFunction { + + private double multiplicator; + + public PlusMult(double multiplicator) { + this.multiplicator = multiplicator; + } + + /** Returns the result of the function evaluation. */ + @Override + public double apply(double a, double b) { + return a + b * multiplicator; + } + + /** <tt>a - b*constant</tt>. */ + public static PlusMult minusMult(double constant) { + return new PlusMult(-constant); + } + + /** <tt>a + b*constant</tt>. */ + public static PlusMult plusMult(double constant) { + return new PlusMult(constant); + } + + public double getMultiplicator() { + return multiplicator; + } + + /** + * x + 0 * c = x + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return true; + } + + /** + * 0 + y * c = y * c != 0 + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return false; + } + + /** + * x + 0 * c = x != 0 + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return false; + } + + /** + * x + y * c = y + x * c iff c = 1 + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return Math.abs(multiplicator - 1.0) < Constants.EPSILON; + } + + /** + * f(x, f(y, z)) = x + c * (y + c * z) = x + c * y + c^2 * z + * f(f(x, y), z) = (x + c * y) + c * z = x + c * y + c * z + * true only for c = 0 or c = 1 + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return Math.abs(multiplicator - 0.0) < Constants.EPSILON + || Math.abs(multiplicator - 1.0) < Constants.EPSILON; + } + + public void setMultiplicator(double multiplicator) { + this.multiplicator = multiplicator; + } +} http://git-wip-us.apache.org/repos/asf/mahout/blob/545648f6/core/src/main/java/org/apache/mahout/math/function/SquareRootFunction.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/mahout/math/function/SquareRootFunction.java b/core/src/main/java/org/apache/mahout/math/function/SquareRootFunction.java new file mode 100644 index 0000000..5eebea0 --- /dev/null +++ b/core/src/main/java/org/apache/mahout/math/function/SquareRootFunction.java @@ -0,0 +1,26 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.mahout.math.function; + +public final class SquareRootFunction extends DoubleFunction { + + @Override + public double apply(double arg1) { + return Math.sqrt(arg1); + } +} http://git-wip-us.apache.org/repos/asf/mahout/blob/545648f6/core/src/main/java/org/apache/mahout/math/function/TimesFunction.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/mahout/math/function/TimesFunction.java b/core/src/main/java/org/apache/mahout/math/function/TimesFunction.java new file mode 100644 index 0000000..e4e27b4 --- /dev/null +++ b/core/src/main/java/org/apache/mahout/math/function/TimesFunction.java @@ -0,0 +1,77 @@ +/* Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.mahout.math.function; + +public final class TimesFunction extends DoubleDoubleFunction { + + /** + * Computes the product of two numbers. + * + * @param x first argument + * @param y second argument + * @return the product + */ + @Override + public double apply(double x, double y) { + return x * y; + } + + /** + * x * 0 = y only if y = 0 + * @return true iff f(x, 0) = x for any x + */ + @Override + public boolean isLikeRightPlus() { + return false; + } + + /** + * 0 * y = 0 for any y + * @return true iff f(0, y) = 0 for any y + */ + @Override + public boolean isLikeLeftMult() { + return true; + } + + /** + * x * 0 = 0 for any x + * @return true iff f(x, 0) = 0 for any x + */ + @Override + public boolean isLikeRightMult() { + return true; + } + + /** + * x * y = y * x for any x, y + * @return true iff f(x, y) = f(y, x) for any x, y + */ + @Override + public boolean isCommutative() { + return true; + } + + /** + * x * (y * z) = (x * y) * z for any x, y, z + * @return true iff f(x, f(y, z)) = f(f(x, y), z) for any x, y, z + */ + @Override + public boolean isAssociative() { + return true; + } +} http://git-wip-us.apache.org/repos/asf/mahout/blob/545648f6/core/src/main/java/org/apache/mahout/math/function/VectorFunction.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/mahout/math/function/VectorFunction.java b/core/src/main/java/org/apache/mahout/math/function/VectorFunction.java new file mode 100644 index 0000000..3b5af77 --- /dev/null +++ b/core/src/main/java/org/apache/mahout/math/function/VectorFunction.java @@ -0,0 +1,27 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.mahout.math.function; + +import org.apache.mahout.math.Vector; + +/** + * Defines a function of a vector that returns a double. + */ +public interface VectorFunction { + double apply(Vector f); +} http://git-wip-us.apache.org/repos/asf/mahout/blob/545648f6/core/src/main/java/org/apache/mahout/math/function/package-info.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/mahout/math/function/package-info.java b/core/src/main/java/org/apache/mahout/math/function/package-info.java new file mode 100644 index 0000000..47ceace --- /dev/null +++ b/core/src/main/java/org/apache/mahout/math/function/package-info.java @@ -0,0 +1,4 @@ +/** + * Core interfaces for functions, comparisons and procedures on objects and primitive data types. + */ +package org.apache.mahout.math.function; http://git-wip-us.apache.org/repos/asf/mahout/blob/545648f6/core/src/main/java/org/apache/mahout/math/jet/math/Arithmetic.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/mahout/math/jet/math/Arithmetic.java b/core/src/main/java/org/apache/mahout/math/jet/math/Arithmetic.java new file mode 100644 index 0000000..83d512b --- /dev/null +++ b/core/src/main/java/org/apache/mahout/math/jet/math/Arithmetic.java @@ -0,0 +1,328 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +/* +Copyright 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 org.apache.mahout.math.jet.math; + +/** + * Arithmetic functions. + */ +public final class Arithmetic { + + // for method logFactorial(...) + // log(k!) for k = 0, ..., 29 + private static final double[] LOG_FACTORIAL_TABLE = { + 0.00000000000000000, 0.00000000000000000, 0.69314718055994531, + 1.79175946922805500, 3.17805383034794562, 4.78749174278204599, + 6.57925121201010100, 8.52516136106541430, 10.60460290274525023, + 12.80182748008146961, 15.10441257307551530, 17.50230784587388584, + 19.98721449566188615, 22.55216385312342289, 25.19122118273868150, + 27.89927138384089157, 30.67186010608067280, 33.50507345013688888, + 36.39544520803305358, 39.33988418719949404, 42.33561646075348503, + 45.38013889847690803, 48.47118135183522388, 51.60667556776437357, + 54.78472939811231919, 58.00360522298051994, 61.26170176100200198, + 64.55753862700633106, 67.88974313718153498, 71.25703896716800901 + }; + + // k! for k = 0, ..., 20 + private static final long[] FACTORIAL_TABLE = { + 1L, + 1L, + 2L, + 6L, + 24L, + 120L, + 720L, + 5040L, + 40320L, + 362880L, + 3628800L, + 39916800L, + 479001600L, + 6227020800L, + 87178291200L, + 1307674368000L, + 20922789888000L, + 355687428096000L, + 6402373705728000L, + 121645100408832000L, + 2432902008176640000L + }; + + // k! for k = 21, ..., 170 + private static final double[] LARGE_FACTORIAL_TABLE = { + 5.109094217170944E19, + 1.1240007277776077E21, + 2.585201673888498E22, + 6.204484017332394E23, + 1.5511210043330984E25, + 4.032914611266057E26, + 1.0888869450418352E28, + 3.048883446117138E29, + 8.841761993739701E30, + 2.652528598121911E32, + 8.222838654177924E33, + 2.6313083693369355E35, + 8.68331761881189E36, + 2.952327990396041E38, + 1.0333147966386144E40, + 3.719933267899013E41, + 1.3763753091226346E43, + 5.23022617466601E44, + 2.0397882081197447E46, + 8.15915283247898E47, + 3.34525266131638E49, + 1.4050061177528801E51, + 6.041526306337384E52, + 2.6582715747884495E54, + 1.196222208654802E56, + 5.502622159812089E57, + 2.5862324151116827E59, + 1.2413915592536068E61, + 6.082818640342679E62, + 3.0414093201713376E64, + 1.5511187532873816E66, + 8.06581751709439E67, + 4.274883284060024E69, + 2.308436973392413E71, + 1.2696403353658264E73, + 7.109985878048632E74, + 4.052691950487723E76, + 2.350561331282879E78, + 1.386831185456898E80, + 8.32098711274139E81, + 5.075802138772246E83, + 3.146997326038794E85, + 1.9826083154044396E87, + 1.2688693218588414E89, + 8.247650592082472E90, + 5.443449390774432E92, + 3.6471110918188705E94, + 2.48003554243683E96, + 1.7112245242814127E98, + 1.1978571669969892E100, + 8.504785885678624E101, + 6.123445837688612E103, + 4.470115461512686E105, + 3.307885441519387E107, + 2.4809140811395404E109, + 1.8854947016660506E111, + 1.451830920282859E113, + 1.1324281178206295E115, + 8.94618213078298E116, + 7.15694570462638E118, + 5.797126020747369E120, + 4.7536433370128435E122, + 3.94552396972066E124, + 3.314240134565354E126, + 2.8171041143805494E128, + 2.4227095383672744E130, + 2.107757298379527E132, + 1.854826422573984E134, + 1.6507955160908465E136, + 1.4857159644817605E138, + 1.3520015276784033E140, + 1.2438414054641305E142, + 1.156772507081641E144, + 1.0873661566567426E146, + 1.0329978488239061E148, + 9.916779348709491E149, + 9.619275968248216E151, + 9.426890448883248E153, + 9.332621544394415E155, + 9.332621544394418E157, + 9.42594775983836E159, + 9.614466715035125E161, + 9.902900716486178E163, + 1.0299016745145631E166, + 1.0813967582402912E168, + 1.1462805637347086E170, + 1.2265202031961373E172, + 1.324641819451829E174, + 1.4438595832024942E176, + 1.5882455415227423E178, + 1.7629525510902457E180, + 1.974506857221075E182, + 2.2311927486598138E184, + 2.543559733472186E186, + 2.925093693493014E188, + 3.393108684451899E190, + 3.96993716080872E192, + 4.6845258497542896E194, + 5.574585761207606E196, + 6.689502913449135E198, + 8.094298525273444E200, + 9.875044200833601E202, + 1.2146304367025332E205, + 1.506141741511141E207, + 1.882677176888926E209, + 2.3721732428800483E211, + 3.0126600184576624E213, + 3.856204823625808E215, + 4.974504222477287E217, + 6.466855489220473E219, + 8.471580690878813E221, + 1.1182486511960037E224, + 1.4872707060906847E226, + 1.99294274616152E228, + 2.690472707318049E230, + 3.6590428819525483E232, + 5.0128887482749884E234, + 6.917786472619482E236, + 9.615723196941089E238, + 1.3462012475717523E241, + 1.8981437590761713E243, + 2.6953641378881633E245, + 3.8543707171800694E247, + 5.550293832739308E249, + 8.047926057471989E251, + 1.1749972043909107E254, + 1.72724589045464E256, + 2.5563239178728637E258, + 3.8089226376305687E260, + 5.7133839564458575E262, + 8.627209774233244E264, + 1.3113358856834527E267, + 2.0063439050956838E269, + 3.0897696138473515E271, + 4.789142901463393E273, + 7.471062926282892E275, + 1.1729568794264134E278, + 1.8532718694937346E280, + 2.946702272495036E282, + 4.714723635992061E284, + 7.590705053947223E286, + 1.2296942187394494E289, + 2.0044015765453032E291, + 3.287218585534299E293, + 5.423910666131583E295, + 9.003691705778434E297, + 1.5036165148649983E300, + 2.5260757449731988E302, + 4.2690680090047056E304, + 7.257415615308004E306 + }; + + private Arithmetic() { + } + + /** + * Efficiently returns the binomial coefficient, often also referred to as "n over k" or "n choose k". The binomial + * coefficient is defined as <ul> + * <li><tt>k<0</tt>: <tt>0</tt>.</li> + * <li><tt>k==0 || k==n</tt>: <tt>1</tt>.</li> + * <li><tt>k==1 || k==n-1</tt>: <tt>n</tt>.</li> + * <li>else: <tt>(n * n-1 * ... * n-k+1 ) / ( 1 * 2 * ... * k )</tt>.</li> + * </ul> + * + * @return the binomial coefficient. + */ + public static double binomial(long n, long k) { + if (k < 0) { + return 0; + } + if (k == 0 || k == n) { + return 1; + } + if (k == 1 || k == n - 1) { + return n; + } + + // try quick version and see whether we get numeric overflows. + // factorial(..) is O(1); requires no loop; only a table lookup. + if (n > k) { + int max = FACTORIAL_TABLE.length + LARGE_FACTORIAL_TABLE.length; + if (n < max) { // if (n! < inf && k! < inf) + double nFactorial = factorial((int) n); + double kFactorial = factorial((int) k); + double nMinusKFactorial = factorial((int) (n - k)); + double nk = nMinusKFactorial * kFactorial; + if (nk != Double.POSITIVE_INFINITY) { // no numeric overflow? + // now this is completely safe and accurate + return nFactorial / nk; + } + } + if (k > n / 2) { + k = n - k; + } // quicker + } + + // binomial(n,k) = (n * n-1 * ... * n-k+1 ) / ( 1 * 2 * ... * k ) + long a = n - k + 1; + long b = 1; + double binomial = 1; + for (long i = k; i-- > 0;) { + binomial *= (double) a++ / b++; + } + return binomial; + } + + /** + * Instantly returns the factorial <tt>k!</tt>. + * + * @param k must hold <tt>k >= 0</tt>. + */ + private static double factorial(int k) { + if (k < 0) { + throw new IllegalArgumentException(); + } + + int length1 = FACTORIAL_TABLE.length; + if (k < length1) { + return FACTORIAL_TABLE[k]; + } + + int length2 = LARGE_FACTORIAL_TABLE.length; + if (k < length1 + length2) { + return LARGE_FACTORIAL_TABLE[k - length1]; + } else { + return Double.POSITIVE_INFINITY; + } + } + + /** + * Returns <tt>log(k!)</tt>. Tries to avoid overflows. For {@code k<30} simply + * looks up a table in <tt>O(1)</tt>. For {@code k>=30} uses stirlings + * approximation. + * + * @param k must hold <tt>k >= 0</tt>. + */ + public static double logFactorial(int k) { + if (k >= 30) { + + double r = 1.0 / k; + double rr = r * r; + double c7 = -5.95238095238095238e-04; + double c5 = 7.93650793650793651e-04; + double c3 = -2.77777777777777778e-03; + double c1 = 8.33333333333333333e-02; + double c0 = 9.18938533204672742e-01; + return (k + 0.5) * Math.log(k) - k + c0 + r * (c1 + rr * (c3 + rr * (c5 + rr * c7))); + } else { + return LOG_FACTORIAL_TABLE[k]; + } + } + +} http://git-wip-us.apache.org/repos/asf/mahout/blob/545648f6/core/src/main/java/org/apache/mahout/math/jet/math/Constants.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/mahout/math/jet/math/Constants.java b/core/src/main/java/org/apache/mahout/math/jet/math/Constants.java new file mode 100644 index 0000000..b99340d --- /dev/null +++ b/core/src/main/java/org/apache/mahout/math/jet/math/Constants.java @@ -0,0 +1,49 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +/* +Copyright 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 org.apache.mahout.math.jet.math; + +/** + * Defines some useful constants. + */ +public final class Constants { + + public static final double MACHEP = 1.11022302462515654042E-16; + public static final double MAXLOG = 7.09782712893383996732E2; + public static final double MINLOG = -7.451332191019412076235E2; + public static final double MAXGAM = 171.624376956302725; + public static final double SQTPI = 2.50662827463100050242E0; + public static final double LOGPI = 1.14472988584940017414; + + public static final double BIG = 4.503599627370496e15; + public static final double BIG_INVERSE = 2.22044604925031308085e-16; + + public static final double EPSILON = 1.0E-6; + + private Constants() { + } +}
