Java ArithmeticUtils.isPowerOfTwo方法代码示例

import org.apache.commons.math3.util.ArithmeticUtils; //导入方法依赖的package包/类
/**
 *Devuelve la energía de fourier de los acelerómetros
 * importante el orden del df
 * 1ºGyro
 * 2ºAcell
 * @param df
 * @return
 */
private List giveMeFFT(DataFrame df){
    List retList = new ArrayList();
    //http://commons.apache.org/proper/commons-math/javadocs/api-3.6/org/apache/commons/math3/transform/FastFourierTransformer.html
    //http://commons.apache.org/proper/commons-math/javadocs/api-3.6/org/apache/commons/math3/transform/DftNormalization.html
    //http://jakevdp.github.io/blog/2013/08/28/understanding-the-fft/

    double[][] miMatrix = (double[][]) df.toArray(double[][].class);
    RealMatrix rm = new Array2DRowRealMatrix(miMatrix);

    double logaritmo;
    double[] x = rm.getColumn(3);// accel-x
    double[] y = rm.getColumn(4);// accel-y
    double[] z = rm.getColumn(5);// accel-z

    if(!ArithmeticUtils.isPowerOfTwo(df.length())){
        logaritmo = Math.log(x.length)/Math.log(2);
        x = Arrays.copyOf(x, (int) Math.pow(2, Math.ceil(logaritmo)));
        y = Arrays.copyOf(y, (int) Math.pow(2, Math.ceil(logaritmo)));
        z = Arrays.copyOf(z, (int) Math.pow(2, Math.ceil(logaritmo)));
    }


    FastFourierTransformer fft = new FastFourierTransformer(DftNormalization.STANDARD);

    Complex[] X = fft.transform(x, TransformType.FORWARD);
    Complex[] Y = fft.transform(y, TransformType.FORWARD);
    Complex[] Z = fft.transform(z, TransformType.FORWARD);

    double sumX = 0;
    double sumY = 0;
    double sumZ = 0;

    for (int i = 0; i < df.length(); i++) {
        sumX += Math.pow(X[i].abs(), 2);
        sumY += Math.pow(Y[i].abs(), 2);
        sumZ += Math.pow(Z[i].abs(), 2);
    }

    retList.add(sumX/df.length());
    retList.add(sumY/df.length());
    retList.add(sumZ/df.length());



    return retList;
}
 

import org.apache.commons.math3.util.ArithmeticUtils; //导入方法依赖的package包/类
/**
 * Perform the FST algorithm (including inverse). The first element of the
 * data set is required to be {@code 0}.
 *
 * @param f the real data array to be transformed
 * @return the real transformed array
 * @throws MathIllegalArgumentException if the length of the data array is
 *   not a power of two, or the first element of the data array is not zero
 */
protected double[] fst(double[] f) throws MathIllegalArgumentException {

    final double[] transformed = new double[f.length];

    if (!ArithmeticUtils.isPowerOfTwo(f.length)) {
        throw new MathIllegalArgumentException(
                LocalizedFormats.NOT_POWER_OF_TWO_CONSIDER_PADDING,
                Integer.valueOf(f.length));
    }
    if (f[0] != 0.0) {
        throw new MathIllegalArgumentException(
                LocalizedFormats.FIRST_ELEMENT_NOT_ZERO,
                Double.valueOf(f[0]));
    }
    final int n = f.length;
    if (n == 1) {       // trivial case
        transformed[0] = 0.0;
        return transformed;
    }

    // construct a new array and perform FFT on it
    final double[] x = new double[n];
    x[0] = 0.0;
    x[n >> 1] = 2.0 * f[n >> 1];
    for (int i = 1; i < (n >> 1); i++) {
        final double a = FastMath.sin(i * FastMath.PI / n) * (f[i] + f[n - i]);
        final double b = 0.5 * (f[i] - f[n - i]);
        x[i]     = a + b;
        x[n - i] = a - b;
    }
    FastFourierTransformer transformer;
    transformer = new FastFourierTransformer(DftNormalization.STANDARD);
    Complex[] y = transformer.transform(x, TransformType.FORWARD);

    // reconstruct the FST result for the original array
    transformed[0] = 0.0;
    transformed[1] = 0.5 * y[0].getReal();
    for (int i = 1; i < (n >> 1); i++) {
        transformed[2 * i]     = -y[i].getImaginary();
        transformed[2 * i + 1] = y[i].getReal() + transformed[2 * i - 1];
    }

    return transformed;
}
 

import org.apache.commons.math3.util.ArithmeticUtils; //导入方法依赖的package包/类
/**
 * Perform the FCT algorithm (including inverse).
 *
 * @param f the real data array to be transformed
 * @return the real transformed array
 * @throws MathIllegalArgumentException if the length of the data array is
 * not a power of two plus one
 */
protected double[] fct(double[] f)
    throws MathIllegalArgumentException {

    final double[] transformed = new double[f.length];

    final int n = f.length - 1;
    if (!ArithmeticUtils.isPowerOfTwo(n)) {
        throw new MathIllegalArgumentException(
            LocalizedFormats.NOT_POWER_OF_TWO_PLUS_ONE,
            Integer.valueOf(f.length));
    }
    if (n == 1) {       // trivial case
        transformed[0] = 0.5 * (f[0] + f[1]);
        transformed[1] = 0.5 * (f[0] - f[1]);
        return transformed;
    }

    // construct a new array and perform FFT on it
    final double[] x = new double[n];
    x[0] = 0.5 * (f[0] + f[n]);
    x[n >> 1] = f[n >> 1];
    // temporary variable for transformed[1]
    double t1 = 0.5 * (f[0] - f[n]);
    for (int i = 1; i < (n >> 1); i++) {
        final double a = 0.5 * (f[i] + f[n - i]);
        final double b = FastMath.sin(i * FastMath.PI / n) * (f[i] - f[n - i]);
        final double c = FastMath.cos(i * FastMath.PI / n) * (f[i] - f[n - i]);
        x[i] = a - b;
        x[n - i] = a + b;
        t1 += c;
    }
    FastFourierTransformer transformer;
    transformer = new FastFourierTransformer(DftNormalization.STANDARD);
    Complex[] y = transformer.transform(x, TransformType.FORWARD);

    // reconstruct the FCT result for the original array
    transformed[0] = y[0].getReal();
    transformed[1] = t1;
    for (int i = 1; i < (n >> 1); i++) {
        transformed[2 * i]     = y[i].getReal();
        transformed[2 * i + 1] = transformed[2 * i - 1] - y[i].getImaginary();
    }
    transformed[n] = y[n >> 1].getReal();

    return transformed;
}