Java FastMath.rint方法代码示例

import org.apache.commons.math3.util.FastMath; //导入方法依赖的package包/类
/** Perform remainder of two derivative structures.
 * @param lhs array holding left hand side of remainder
 * @param lhsOffset offset of the left hand side in its array
 * @param rhs array right hand side of remainder
 * @param rhsOffset offset of the right hand side in its array
 * @param result array where result must be stored (it may be
 * one of the input arrays)
 * @param resultOffset offset of the result in its array
 */
public void remainder(final double[] lhs, final int lhsOffset,
                      final double[] rhs, final int rhsOffset,
                      final double[] result, final int resultOffset) {

    // compute k such that lhs % rhs = lhs - k rhs
    final double rem = FastMath.IEEEremainder(lhs[lhsOffset], rhs[rhsOffset]);
    final double k   = FastMath.rint((lhs[lhsOffset] - rem) / rhs[rhsOffset]);

    // set up value
    result[resultOffset] = rem;

    // set up partial derivatives
    for (int i = 1; i < getSize(); ++i) {
        result[resultOffset + i] = lhs[lhsOffset + i] - k * rhs[rhsOffset + i];
    }

}
 

import org.apache.commons.math3.util.FastMath; //导入方法依赖的package包/类
@Override
protected double index(final double p, final int length) {
    final double minLimit = 1d/2 / length;
    return Double.compare(p, minLimit) <= 0 ?
            0 : FastMath.rint(length * p);
}
 

import org.apache.commons.math3.util.FastMath; //导入方法依赖的package包/类
/** {@inheritDoc} */
public double value(double x) {
    return FastMath.rint(x);
}
 

import org.apache.commons.math3.util.FastMath; //导入方法依赖的package包/类
/** {@inheritDoc}
 * @since 3.2
 */
public DerivativeStructure rint() {
    return new DerivativeStructure(compiler.getFreeParameters(),
                                   compiler.getOrder(),
                                   FastMath.rint(data[0]));
}
 

import org.apache.commons.math3.util.FastMath; //导入方法依赖的package包/类
/**
 * Creates an exponential decay {@link NeighbourhoodSizeFunction function}.
 * It will compute <code>a e<sup>-x / b</sup></code>,
 * where {@code x} is the (integer) independent variable and
 * <ul>
 *  <li><code>a = initValue</code>
 *  <li><code>b = -numCall / ln(valueAtNumCall / initValue)</code>
 * </ul>
 *
 * @param initValue Initial value, i.e.
 * {@link NeighbourhoodSizeFunction#value(long) value(0)}.
 * @param valueAtNumCall Value of the function at {@code numCall}.
 * @param numCall Argument for which the function returns
 * {@code valueAtNumCall}.
 * @return the neighbourhood size function.
 * @throws org.apache.commons.math3.exception.NotStrictlyPositiveException
 * if {@code initValue <= 0}.
 * @throws org.apache.commons.math3.exception.NotStrictlyPositiveException
 * if {@code valueAtNumCall <= 0}.
 * @throws org.apache.commons.math3.exception.NumberIsTooLargeException
 * if {@code valueAtNumCall >= initValue}.
 * @throws org.apache.commons.math3.exception.NotStrictlyPositiveException
 * if {@code numCall <= 0}.
 */
public static NeighbourhoodSizeFunction exponentialDecay(final double initValue,
                                                         final double valueAtNumCall,
                                                         final long numCall) {
    return new NeighbourhoodSizeFunction() {
        /** DecayFunction. */
        private final ExponentialDecayFunction decay
            = new ExponentialDecayFunction(initValue, valueAtNumCall, numCall);

        /** {@inheritDoc} */
        public int value(long n) {
            return (int) FastMath.rint(decay.value(n));
        }
    };
}
 

import org.apache.commons.math3.util.FastMath; //导入方法依赖的package包/类
/**
 * Creates an sigmoid-like {@code NeighbourhoodSizeFunction function}.
 * The function {@code f} will have the following properties:
 * <ul>
 *  <li>{@code f(0) = initValue}</li>
 *  <li>{@code numCall} is the inflexion point</li>
 *  <li>{@code slope = f'(numCall)}</li>
 * </ul>
 *
 * @param initValue Initial value, i.e.
 * {@link NeighbourhoodSizeFunction#value(long) value(0)}.
 * @param slope Value of the function derivative at {@code numCall}.
 * @param numCall Inflexion point.
 * @return the neighbourhood size function.
 * @throws org.apache.commons.math3.exception.NotStrictlyPositiveException
 * if {@code initValue <= 0}.
 * @throws org.apache.commons.math3.exception.NumberIsTooLargeException
 * if {@code slope >= 0}.
 * @throws org.apache.commons.math3.exception.NotStrictlyPositiveException
 * if {@code numCall <= 0}.
 */
public static NeighbourhoodSizeFunction quasiSigmoidDecay(final double initValue,
                                                          final double slope,
                                                          final long numCall) {
    return new NeighbourhoodSizeFunction() {
        /** DecayFunction. */
        private final QuasiSigmoidDecayFunction decay
            = new QuasiSigmoidDecayFunction(initValue, slope, numCall);

        /** {@inheritDoc} */
        public int value(long n) {
            return (int) FastMath.rint(decay.value(n));
        }
    };
}
 

import org.apache.commons.math3.util.FastMath; //导入方法依赖的package包/类
/** {@inheritDoc} */
public SparseGradient remainder(final SparseGradient a) {

    // compute k such that lhs % rhs = lhs - k rhs
    final double rem = FastMath.IEEEremainder(value, a.value);
    final double k   = FastMath.rint((value - rem) / a.value);

    return subtract(a.multiply(k));

}