Java tutorial
/** * Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies * * Please see distribution for license. */ package com.opengamma.analytics.math.minimization; import java.util.Arrays; import java.util.BitSet; import org.apache.commons.lang.ObjectUtils; import com.opengamma.analytics.math.matrix.DoubleMatrix1D; import com.opengamma.analytics.math.matrix.DoubleMatrix2D; import com.opengamma.util.ArgumentChecker; /** * For a set of <i>n</i> function parameters, this takes <i>n</i> ParameterLimitsTransform (which can be the NullTransform which does NOT transform the parameter) which transform * a constrained function parameter (e.g. must be between -1 and 1) to a unconstrained fit parameter. It also takes a BitSet (of length <i>n</i>) with an element set to <b>true</b> if * that parameter is fixed - a set of <i>n</i> startValues must also be provided, with only those corresponding to fixed parameters being used (i.e. the parameter is fixed at the startValue). * The purpose is to allow an optimiser to work with unconstrained parameters without modifying the function that one wishes to optimise. */ // TODO not tested public class UncoupledParameterTransforms implements NonLinearParameterTransforms { private final DoubleMatrix1D _startValues; private final ParameterLimitsTransform[] _transforms; private final boolean[] _freeParameters; private final int _nMP; private final int _nFP; /** * * @param startValues fixed parameter values (if no parameters are fixed this is completely ignored) * @param transforms Array of ParameterLimitsTransform (which can be the NullTransform which does NOT transform the parameter) which transform * a constrained function parameter (e.g. must be between -1 and 1) to a unconstrained fit parameter. * @param fixed BitSet with an element set to <b>true</b> if that parameter is fixed */ public UncoupledParameterTransforms(final DoubleMatrix1D startValues, final ParameterLimitsTransform[] transforms, final BitSet fixed) { ArgumentChecker.notNull(startValues, "null start values"); ArgumentChecker.notEmpty(transforms, "must specify transforms"); ArgumentChecker.notNull(fixed, "must specify what is fixed (even if none)"); _nMP = startValues.getNumberOfElements(); ArgumentChecker.isTrue(_nMP == transforms.length, "Have {}-dimensional start value but {} transforms", _nMP, transforms.length); _freeParameters = new boolean[_nMP]; for (int i = 0; i < _nMP; i++) { if (i < fixed.size()) { _freeParameters[i] = !fixed.get(i); } else { _freeParameters[i] = true; } } final int count = fixed.cardinality(); ArgumentChecker.isTrue(count < _nMP, "all parameters are fixed"); _nFP = _nMP - count; _startValues = startValues; _transforms = transforms; } /** * * @return The number of function parameters */ @Override public int getNumberOfModelParameters() { return _nMP; } /** * * @return The number of fitting parameters (equals the number of model parameters minus the number of fixed parameters) */ @Override public int getNumberOfFittingParameters() { return _nFP; } /** * Transforms from a set of function parameters (some of which may have constrained range and/or be fixed) to a (possibly smaller) set of unconstrained fitting parameters * <b>Note:</b> If a parameter is fixed, it is its value as provided by <i>startValues<\i> not the value given here that will be returned by inverseTransform (and thus used in the function) * @param functionParameters The function parameters * @return The fitting parameters */ @Override public DoubleMatrix1D transform(final DoubleMatrix1D functionParameters) { ArgumentChecker.notNull(functionParameters, "function parameters"); ArgumentChecker.isTrue(functionParameters.getNumberOfElements() == _nMP, "functionParameters wrong dimension"); final double[] fittingParameter = new double[_nFP]; for (int i = 0, j = 0; i < _nMP; i++) { if (_freeParameters[i]) { fittingParameter[j] = _transforms[i].transform(functionParameters.getEntry(i)); j++; } } return new DoubleMatrix1D(fittingParameter); } /** * Transforms from a set of unconstrained fitting parameters to a (possibly larger) set of function parameters (some of which may have constrained range and/or be fixed). * @param fittingParameters The fitting parameters * @return The function parameters */ @Override public DoubleMatrix1D inverseTransform(final DoubleMatrix1D fittingParameters) { ArgumentChecker.notNull(fittingParameters, "fitting parameters"); ArgumentChecker.isTrue(fittingParameters.getNumberOfElements() == _nFP, "fittingParameter wrong dimension"); final double[] modelParameter = new double[_nMP]; for (int i = 0, j = 0; i < _nMP; i++) { if (_freeParameters[i]) { modelParameter[i] = _transforms[i].inverseTransform(fittingParameters.getEntry(j)); j++; } else { modelParameter[i] = _startValues.getEntry(i); } } return new DoubleMatrix1D(modelParameter); } /** * Calculates the Jacobian of the transform from function parameters to fitting parameters - the i,j element will be the partial derivative of i^th fitting parameter with respect * to the j^th function parameter * @param functionParameters The function parameters * @return matrix of partial derivative of fitting parameter with respect to function parameters */ // TODO not tested @Override public DoubleMatrix2D jacobian(final DoubleMatrix1D functionParameters) { ArgumentChecker.notNull(functionParameters, "function parameters"); ArgumentChecker.isTrue(functionParameters.getNumberOfElements() == _nMP, "functionParameters wrong dimension"); final double[][] jac = new double[_nFP][_nMP]; for (int i = 0, j = 0; i < _nMP; i++) { if (_freeParameters[i]) { jac[j][i] = _transforms[i].transformGradient(functionParameters.getEntry(i)); j++; } } return new DoubleMatrix2D(jac); } /** * Calculates the Jacobian of the transform from fitting parameters to function parameters - the i,j element will be the partial derivative of i^th function parameter with respect * to the j^th fitting parameter * @param fittingParameters The fitting parameters * @return matrix of partial derivative of function parameter with respect to fitting parameters */ // TODO not tested // @Override // public DoubleMatrix2D inverseJacobian(final DoubleMatrix1D fittingParameters) { // ArgumentChecker.notNull(fittingParameters, "fitting parameters"); // ArgumentChecker.isTrue(fittingParameters.getNumberOfElements() == _nFP, "fitting parameters wrong dimension"); // final double[][] jac = new double[_nMP][_nFP]; // for (int i = 0, j = 0; i < _nMP; i++) { // if (_fixed[i]) { // jac[i][j] = _transforms[i].inverseTransformGradient(fittingParameters.getEntry(j)); // j++; // } // } // return DoubleMatrix2D.noCopy(jac); // } @SuppressWarnings("deprecation") @Override public DoubleMatrix2D inverseJacobian(final DoubleMatrix1D fittingParameters) { ArgumentChecker.notNull(fittingParameters, "fitting parameters"); ArgumentChecker.isTrue(fittingParameters.getNumberOfElements() == _nFP, "fitting parameters wrong dimension"); final double[][] jac = new double[_nMP][_nFP]; final int[] p = new int[_nMP]; final int[] q = new int[_nMP]; int t = 0; for (int i = 0; i < _nMP; i++) { if (_freeParameters[i]) { p[t] = i; q[t] = t; t++; } } int pderef, qderef; for (int i = 0; i < t; i++) { pderef = p[i]; qderef = q[i]; jac[pderef][qderef] = _transforms[pderef].inverseTransformGradient(fittingParameters.getEntry(qderef)); } return DoubleMatrix2D.noCopy(jac); } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + Arrays.hashCode(_freeParameters); result = prime * result + _startValues.hashCode(); result = prime * result + Arrays.hashCode(_transforms); return result; } @Override public boolean equals(final Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } final UncoupledParameterTransforms other = (UncoupledParameterTransforms) obj; if (!Arrays.equals(_freeParameters, other._freeParameters)) { return false; } if (!ObjectUtils.equals(_startValues, other._startValues)) { return false; } return Arrays.equals(_transforms, other._transforms); } }