/**
* Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.analytics.math.util.wrapper;
import org.apache.commons.lang.Validate;
import org.apache.commons.math.FunctionEvaluationException;
import org.apache.commons.math.analysis.DifferentiableUnivariateRealFunction;
import org.apache.commons.math.analysis.MultivariateRealFunction;
import org.apache.commons.math.analysis.UnivariateRealFunction;
import org.apache.commons.math.analysis.polynomials.PolynomialFunctionLagrangeForm;
import org.apache.commons.math.complex.Complex;
import org.apache.commons.math.linear.Array2DRowRealMatrix;
import org.apache.commons.math.linear.ArrayRealVector;
import org.apache.commons.math.linear.RealMatrix;
import org.apache.commons.math.linear.RealVector;
import org.apache.commons.math.optimization.RealPointValuePair;
import com.opengamma.analytics.math.MathException;
import com.opengamma.analytics.math.function.DoubleFunction1D;
import com.opengamma.analytics.math.function.Function1D;
import com.opengamma.analytics.math.function.FunctionND;
import com.opengamma.analytics.math.matrix.DoubleMatrix1D;
import com.opengamma.analytics.math.matrix.DoubleMatrix2D;
import com.opengamma.analytics.math.number.ComplexNumber;
/**
* Utility class for converting OpenGamma mathematical objects into <a href="http://commons.apache.org/math/api-2.1/index.html">Commons</a> objects and vice versa.
*/
public final class CommonsMathWrapper {
private CommonsMathWrapper() {
}
/**
* @param f An OG 1-D function mapping doubles onto doubles, not null
* @return A Commons univariate real function
*/
public static UnivariateRealFunction wrapUnivariate(final Function1D<Double, Double> f) {
Validate.notNull(f);
return new UnivariateRealFunction() {
@Override
public double value(final double x) {
return f.evaluate(x);
}
};
}
/**
* @param f An OG 1-D function mapping vectors of doubles onto doubles, not null
* @return A Commons multivariate real function
*/
public static MultivariateRealFunction wrapMultivariate(final Function1D<DoubleMatrix1D, Double> f) {
Validate.notNull(f);
return new MultivariateRealFunction() {
@Override
public double value(final double[] point) throws FunctionEvaluationException, IllegalArgumentException {
return f.evaluate(new DoubleMatrix1D(point));
}
};
}
/**
* @param f An OG n-D function mapping doubles onto doubles, not null
* @return A Commons multivariate real function
*/
public static MultivariateRealFunction wrap(final FunctionND<Double, Double> f) {
Validate.notNull(f);
return new MultivariateRealFunction() {
@Override
public double value(final double[] point) throws FunctionEvaluationException, IllegalArgumentException {
final int n = point.length;
final Double[] coordinate = new Double[n];
for (int i = 0; i < n; i++) {
coordinate[i] = point[i];
}
return f.evaluate(coordinate);
}
};
}
/**
* @param x An OG 2-D matrix of doubles, not null
* @return A Commons matrix
*/
public static RealMatrix wrap(final DoubleMatrix2D x) {
Validate.notNull(x);
return new Array2DRowRealMatrix(x.getData());
}
/**
* @param x An OG 1-D vector of doubles, not null
* @return A Commons matrix
*/
public static RealMatrix wrapAsMatrix(final DoubleMatrix1D x) {
Validate.notNull(x);
final int n = x.getNumberOfElements();
final double[][] y = new double[n][1];
for (int i = 0; i < n; i++) {
y[i][0] = x.getEntry(i);
}
return new Array2DRowRealMatrix(x.getData());
}
/**
* @param x A Commons matrix, not null
* @return An OG 2-D matrix of doubles
*/
public static DoubleMatrix2D unwrap(final RealMatrix x) {
Validate.notNull(x);
return new DoubleMatrix2D(x.getData());
}
/**
* @param x An OG vector of doubles, not null
* @return A Commons vector
*/
public static RealVector wrap(final DoubleMatrix1D x) {
Validate.notNull(x);
return new ArrayRealVector(x.getData());
}
/**
* @param x A Commons vector, not null
* @return An OG 1-D matrix of doubles
*/
public static DoubleMatrix1D unwrap(final RealVector x) {
Validate.notNull(x);
return new DoubleMatrix1D(x.getData());
}
/**
* @param z An OG complex number, not null
* @return A Commons complex number
*/
public static Complex wrap(final ComplexNumber z) {
Validate.notNull(z);
return new Complex(z.getReal(), z.getImaginary());
}
/**
* @param lagrange A Commons polynomial in Lagrange form, not null
* @return An OG 1-D function mapping doubles to doubles
*/
public static Function1D<Double, Double> unwrap(final PolynomialFunctionLagrangeForm lagrange) {
Validate.notNull(lagrange);
return new Function1D<Double, Double>() {
@Override
public Double evaluate(final Double x) {
try {
return lagrange.value(x);
} catch (final org.apache.commons.math.MathException e) {
throw new MathException(e);
}
}
};
}
/**
* @param x A Commons pair of <i>(x, f(x))</i>, not null
* @return A matrix of double with the <i>x</i> as the first element and <i>f(x)</i> the second
*/
public static double[] unwrap(final RealPointValuePair x) {
Validate.notNull(x);
return x.getPoint();
}
/**
* @param f An OG 1-D function mapping doubles to doubles, not null
* @return A Commons differentiable univariate real function
*/
public static DifferentiableUnivariateRealFunction wrapDifferentiable(final DoubleFunction1D f) {
Validate.notNull(f);
return new DifferentiableUnivariateRealFunction() {
@Override
public double value(final double x) throws FunctionEvaluationException {
return f.evaluate(x);
}
@Override
public UnivariateRealFunction derivative() {
return wrapUnivariate(f.derivative());
}
};
}
}