com.opengamma.analytics.math.util.wrapper.CommonsMathWrapper.java Source code

Introduction

Here is the source code for com.opengamma.analytics.math.util.wrapper.CommonsMathWrapper.java

Source

/**
 * 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());
            }
        };
    }
}