Java BivariateFunction类代码示例

import org.apache.commons.math3.analysis.BivariateFunction; //导入依赖的package包/类
/**
 * Compute all partial derivatives.
 */
private void computePartialDerivatives() {
    final int lastI = xval.length - 1;
    final int lastJ = yval.length - 1;
    partialDerivatives = new BivariateFunction[5][lastI][lastJ];

    for (int i = 0; i < lastI; i++) {
        for (int j = 0; j < lastJ; j++) {
            final BicubicSplineFunction f = splines[i][j];
            partialDerivatives[0][i][j] = f.partialDerivativeX();
            partialDerivatives[1][i][j] = f.partialDerivativeY();
            partialDerivatives[2][i][j] = f.partialDerivativeXX();
            partialDerivatives[3][i][j] = f.partialDerivativeYY();
            partialDerivatives[4][i][j] = f.partialDerivativeXY();
        }
    }
}
 

import org.apache.commons.math3.analysis.BivariateFunction; //导入依赖的package包/类
/**
 * Interpolating a plane.
 * <p>
 * z = 2 x - 3 y + 5
 */
@Test
public void testPlane() {
    final int numberOfElements = 10;
    final double minimumX = -10;
    final double maximumX = 10;
    final double minimumY = -10;
    final double maximumY = 10;
    final int numberOfSamples = 100;

    final double interpolationTolerance = 7e-15;
    final double maxTolerance = 6e-14;

    // Function values
    BivariateFunction f = new BivariateFunction() {
            public double value(double x, double y) {
                return 2 * x - 3 * y + 5;
            }
        };

    testInterpolation(minimumX,
                      maximumX,
                      minimumY,
                      maximumY,
                      numberOfElements,
                      numberOfSamples,
                      f,
                      interpolationTolerance,
                      maxTolerance);
}
 

import org.apache.commons.math3.analysis.BivariateFunction; //导入依赖的package包/类
/**
 * Interpolating a paraboloid.
 * <p>
 * z = 2 x<sup>2</sup> - 3 y<sup>2</sup> + 4 x y - 5
 */
@Test
public void testParabaloid() {
    final int numberOfElements = 10;
    final double minimumX = -10;
    final double maximumX = 10;
    final double minimumY = -10;
    final double maximumY = 10;
    final int numberOfSamples = 100;

    final double interpolationTolerance = 2e-14;
    final double maxTolerance = 6e-14;

    // Function values
    BivariateFunction f = new BivariateFunction() {
            public double value(double x, double y) {
                return 2 * x * x - 3 * y * y + 4 * x * y - 5;
            }
        };

    testInterpolation(minimumX,
                      maximumX,
                      minimumY,
                      maximumY,
                      numberOfElements,
                      numberOfSamples,
                      f,
                      interpolationTolerance,
                      maxTolerance);
}
 

import org.apache.commons.math3.analysis.BivariateFunction; //导入依赖的package包/类
/**
 * Interpolating a plane.
 * <p>
 * z = 2 x - 3 y + 5
 */
@Test
public void testPlane() {
    BivariateFunction f = new BivariateFunction() {
            public double value(double x, double y) {
                return 2 * x - 3 * y + 5;
            }
        };

    testInterpolation(3000,
                      1e-13,
                      f,
                      false);
}
 

import org.apache.commons.math3.analysis.BivariateFunction; //导入依赖的package包/类
/**
 * Interpolating a paraboloid.
 * <p>
 * z = 2 x<sup>2</sup> - 3 y<sup>2</sup> + 4 x y - 5
 */
@Test
public void testParaboloid() {
    BivariateFunction f = new BivariateFunction() {
            public double value(double x, double y) {
                return 2 * x * x - 3 * y * y + 4 * x * y - 5;
            }
        };

    testInterpolation(3000,
                      1e-12,
                      f,
                      false);
}
 

import org.apache.commons.math3.analysis.BivariateFunction; //导入依赖的package包/类
/**
 * Make interpolation function for grid data
 * @param x X data
 * @param y Y data
 * @param z Z data
 * @return Interpolation function
 */
public static BivariateFunction getBiInterpFunc(Array x, Array y, Array z) {
    double[] xd = (double[]) ArrayUtil.copyToNDJavaArray(x);
    double[] yd = (double[]) ArrayUtil.copyToNDJavaArray(y);
    double[][] zd = (double[][]) ArrayUtil.copyToNDJavaArray(z);
    BivariateGridInterpolator li = new BicubicInterpolator();
    BivariateFunction func = li.interpolate(xd, yd, zd);

    return func;
}
 

import org.apache.commons.math3.analysis.BivariateFunction; //导入依赖的package包/类
/**
 * Compute the value of the function
 * @param func The function
 * @param x Input x data
 * @param y Input y data
 * @return Function value
 */
public static Array evaluate(BivariateFunction func, Array x, Array y) {
    Array r = Array.factory(DataType.DOUBLE, x.getShape());
    for (int i = 0; i < r.getSize(); i++)
        r.setDouble(i, func.value(x.getDouble(i), y.getDouble(i)));
    
    return r;
}
 

import org.apache.commons.math3.analysis.BivariateFunction; //导入依赖的package包/类
/**
 * @return the partial derivative wrt {@code x}.
 */
public BivariateFunction partialDerivativeX() {
    if (partialDerivativeX == null) {
        computePartialDerivatives();
    }

    return partialDerivativeX;
}
 

import org.apache.commons.math3.analysis.BivariateFunction; //导入依赖的package包/类
/**
 * @return the partial derivative wrt {@code y}.
 */
public BivariateFunction partialDerivativeY() {
    if (partialDerivativeY == null) {
        computePartialDerivatives();
    }

    return partialDerivativeY;
}
 

import org.apache.commons.math3.analysis.BivariateFunction; //导入依赖的package包/类
/**
 * @return the second partial derivative wrt {@code x}.
 */
public BivariateFunction partialDerivativeXX() {
    if (partialDerivativeXX == null) {
        computePartialDerivatives();
    }

    return partialDerivativeXX;
}
 

import org.apache.commons.math3.analysis.BivariateFunction; //导入依赖的package包/类
/**
 * @return the second partial derivative wrt {@code y}.
 */
public BivariateFunction partialDerivativeYY() {
    if (partialDerivativeYY == null) {
        computePartialDerivatives();
    }

    return partialDerivativeYY;
}
 

import org.apache.commons.math3.analysis.BivariateFunction; //导入依赖的package包/类
/**
 * @return the second partial cross-derivative.
 */
public BivariateFunction partialDerivativeXY() {
    if (partialDerivativeXY == null) {
        computePartialDerivatives();
    }

    return partialDerivativeXY;
}
 

import org.apache.commons.math3.analysis.BivariateFunction; //导入依赖的package包/类
@Override
public BivariateFunction interpolate(double[] xval, double[] yval, double[][] fval) throws NoDataException, DimensionMismatchException, NonMonotonicSequenceException, NumberIsTooSmallException {
    if (xval.length == 0 || yval.length == 0 || fval.length == 0)
        throw new NoDataException();
    if (xval.length != fval.length)
        throw new DimensionMismatchException(xval.length, fval.length);
    if (yval.length != fval[0].length)
        throw new DimensionMismatchException(yval.length, fval[0].length);
    MathArrays.checkOrder(xval);
    MathArrays.checkOrder(yval);
    return new BilinearInterpolatingFunction(xval, yval, fval);
}
 

import org.apache.commons.math3.analysis.BivariateFunction; //导入依赖的package包/类
private static double[][] calculateNewValues(
	double[][] data, int interpolationLevel
) {
	final int initialRows = data.length;
	final int initialColumns = data[0].length;
	
	final BivariateGridInterpolator interpolator = new BilinearInterpolator();
	final BivariateFunction function = interpolator.interpolate(
		IntStream.range(0, initialRows).asDoubleStream().toArray(),
		IntStream.range(0, initialColumns).asDoubleStream().toArray(),
		data
	);
	
	final int newNumRows = CALCULATE_SIZE.applyAsInt(
		initialRows, interpolationLevel);
	final int newNumColumns = CALCULATE_SIZE.applyAsInt(
		initialColumns, interpolationLevel);
	
	final double[][] newValues = new double[newNumRows][newNumColumns];
	
	final double xFactor = ((double) initialRows - 1d) / ((double) newNumRows - 1d);
	final double yFactor = ((double) initialColumns - 1d) / ((double) newNumColumns - 1d);
	for (int i = 0; i < newValues.length; i++) {
		for (int j = 0; j < newValues[i].length; j++) {
			newValues[i][j] = function.value(
				(double) i * xFactor, (double) j * yFactor
			);
		}
	}
	
	return newValues;
}