com.opengamma.strata.math.impl.util.CommonsMathWrapper.java Source code

Introduction

Here is the source code for com.opengamma.strata.math.impl.util.CommonsMathWrapper.java

Source

/**
 * Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies
 * 
 * Please see distribution for license.
 */
package com.opengamma.strata.math.impl.util;

import java.util.function.Function;

import org.apache.commons.math3.analysis.MultivariateFunction;
import org.apache.commons.math3.analysis.UnivariateFunction;
import org.apache.commons.math3.analysis.differentiation.DerivativeStructure;
import org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction;
import org.apache.commons.math3.analysis.polynomials.PolynomialFunctionLagrangeForm;
import org.apache.commons.math3.complex.Complex;
import org.apache.commons.math3.exception.DimensionMismatchException;
import org.apache.commons.math3.exception.NonMonotonicSequenceException;
import org.apache.commons.math3.exception.NumberIsTooSmallException;
import org.apache.commons.math3.linear.Array2DRowRealMatrix;
import org.apache.commons.math3.linear.ArrayRealVector;
import org.apache.commons.math3.linear.RealMatrix;
import org.apache.commons.math3.linear.RealVector;
import org.apache.commons.math3.optim.PointValuePair;

import com.opengamma.strata.collect.ArgChecker;
import com.opengamma.strata.collect.array.DoubleArray;
import com.opengamma.strata.collect.array.DoubleMatrix;
import com.opengamma.strata.math.MathException;
import com.opengamma.strata.math.impl.ComplexNumber;
import com.opengamma.strata.math.impl.function.DoubleFunction1D;

/**
 * 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 {

    // restricted constructor
    private CommonsMathWrapper() {
    }

    //-------------------------------------------------------------------------
    /**
     * Wraps a function.
     * 
     * @param f  an OG 1-D function mapping doubles onto doubles
     * @return a Commons univariate real function
     */
    public static UnivariateFunction wrapUnivariate(Function<Double, Double> f) {
        ArgChecker.notNull(f, "f");
        return f::apply;
    }

    /**
     * Wraps a function.
     * 
     * @param f  an OG 1-D function mapping doubles onto doubles
     * @return a Commons univariate real function
     */
    public static MultivariateFunction wrapMultivariate(Function<Double, Double> f) {
        ArgChecker.notNull(f, "f");
        return point -> f.apply(point[0]);
    }

    /**
     * Wraps a function.
     * 
     * @param f  an OG 1-D function mapping vectors of doubles onto doubles
     * @return a Commons multivariate real function
     */
    public static MultivariateFunction wrapMultivariateVector(Function<DoubleArray, Double> f) {
        ArgChecker.notNull(f, "f");
        return point -> f.apply(DoubleArray.copyOf(point));
    }

    //-------------------------------------------------------------------------
    /**
     * Wraps a matrix.
     * 
     * @param x  an OG 2-D matrix of doubles
     * @return a Commons matrix
     */
    public static RealMatrix wrap(DoubleMatrix x) {
        ArgChecker.notNull(x, "x");
        return new Array2DRowRealMatrix(x.toArrayUnsafe());
    }

    /**
     * Wraps a matrix.
     * 
     * @param x  an OG 1-D vector of doubles
     * @return a Commons matrix 
     */
    public static RealMatrix wrapAsMatrix(DoubleArray x) {
        ArgChecker.notNull(x, "x");
        int n = x.size();
        double[][] y = new double[n][1];
        for (int i = 0; i < n; i++) {
            y[i][0] = x.get(i);
        }
        return new Array2DRowRealMatrix(x.toArrayUnsafe()); // cloned in Array2DRowRealMatrix constructor
    }

    /**
     * Unwraps a matrix.
     * 
     * @param x  a Commons matrix
     * @return an OG 2-D matrix of doubles
     */
    public static DoubleMatrix unwrap(RealMatrix x) {
        ArgChecker.notNull(x, "x");
        return DoubleMatrix.ofUnsafe(x.getData());
    }

    //-------------------------------------------------------------------------
    /**
     * Wraps a vector.
     * 
     * @param x  an OG vector of doubles
     * @return a Commons vector
     */
    public static RealVector wrap(DoubleArray x) {
        ArgChecker.notNull(x, "x");
        return new ArrayRealVector(x.toArrayUnsafe()); // cloned in ArrayRealVector constructor
    }

    /**
     * Unwraps a vector.
     * 
     * @param x  a Commons vector
     * @return an OG 1-D matrix of doubles
     */
    public static DoubleArray unwrap(RealVector x) {
        ArgChecker.notNull(x, "x");
        return DoubleArray.ofUnsafe(x.toArray());
    }

    //-------------------------------------------------------------------------
    /**
     * Wraps a complex number.
     * 
     * @param z An OG complex number
     * @return a Commons complex number
     */
    public static Complex wrap(ComplexNumber z) {
        ArgChecker.notNull(z, "z");
        return new Complex(z.getReal(), z.getImaginary());
    }

    //-------------------------------------------------------------------------
    /**
     * Unwraps a Lagrange.
     * 
     * @param lagrange  a Commons polynomial in Lagrange form
     * @return an OG 1-D function mapping doubles to doubles
     */
    public static Function<Double, Double> unwrap(PolynomialFunctionLagrangeForm lagrange) {
        ArgChecker.notNull(lagrange, "lagrange");
        return new Function<Double, Double>() {

            @Override
            public Double apply(Double x) {
                try {
                    return lagrange.value(x);
                } catch (DimensionMismatchException | NonMonotonicSequenceException | NumberIsTooSmallException e) {
                    throw new MathException(e);
                }
            }

        };
    }

    /**
     * Unwraps a pair.
     * 
     * @param x  a Commons pair of <i>(x, f(x))</i>
     * @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(PointValuePair x) {
        ArgChecker.notNull(x, "x");
        return x.getPoint();
    }

    /**
     * Wraps a differentiable univariate real function.
     * 
     * @param f  an OG 1-D function mapping doubles to doubles
     * @return a Commons differentiable univariate real function
     */
    public static UnivariateDifferentiableFunction wrapDifferentiable(DoubleFunction1D f) {
        ArgChecker.notNull(f, "f");
        return new UnivariateDifferentiableFunction() {
            @Override
            public double value(double x) {
                return f.applyAsDouble(x);
            }

            @Override
            public DerivativeStructure value(DerivativeStructure t) throws DimensionMismatchException {
                throw new IllegalArgumentException("Not implemented yet");
            }
        };
    }

}