/** * For a set of N-1 "fit" parameters, produces N "model" parameters that sum to one. * @param n The number of "model" parameters, N */ public SumToOne(int n) { _set = getSet(n); _n = n; }
private void cal(double[] cum, double factor, int d, int n, int p1, double[] res) { if (n == 1) { return; } int n1 = n / 2; int n2 = n - n1; double s = (cum[p1 + n1] - cum[p1]) * factor; double c = 1 - s; res[d] = s; cal(cum, factor / s, d + 1, n1, p1, res); cal(cum, factor / c, d + n1, n2, p1 + n1, res); }
@Override protected NonLinearParameterTransforms getTransform(DoubleArray start, BitSet fixed) { return new UncoupledParameterTransforms(start, DEFAULT_TRANSFORMS, fixed); }
protected void assertRoundTrip(final ParameterLimitsTransform transform, final double modelParam) { final double fp = transform.transform(modelParam); final double mp = transform.inverseTransform(fp); assertEquals(modelParam, mp, 1e-8); }
protected void assertInverseGradient(final ParameterLimitsTransform transform, final double fitParam) { final double eps = 1e-5; final double g = transform.inverseTransformGradient(fitParam); double fdg; final double down = transform.inverseTransform(fitParam - eps); final double up = transform.inverseTransform(fitParam + eps); fdg = (up - down) / 2 / eps; assertEquals(g, fdg, 1e-6); }
@Override public DoubleArray apply(DoubleArray theta) { return trans.transform(theta); } };
@Test(expectedExceptions = IllegalArgumentException.class) public void testInputs() { getBracketer().checkInputs(F, 1., 1.); } }
@Override public DoubleMatrix apply(DoubleArray theta) { return trans.jacobian(theta); } };
@Test public void test() { super.assertInputs(MINIMIZER); super.assertMinimizer(MINIMIZER); } }
/** * Inverse transform from the N "model" parameters to the N-1 "fit" parameters. * Used mainly to find the start position of a optimisation routine. * * @param modelParms The N "model" parameters. <b>These must sum to one</b> * @return The N-1 "fit" parameters */ public DoubleArray inverseTransform(DoubleArray modelParms) { return DoubleArray.copyOf(inverseTransform(modelParms.toArray())); }
public void assertInputs(final ScalarMinimizer minimizer) { try { minimizer.minimize(null, 0.0, 2., 3.); Assert.fail(); } catch (final IllegalArgumentException e) { // Expected } }
@Override public double minimize(Function<Double, Double> f, double startPosition, double lower, double upper) { return minimize(f, lower, upper); }
@SuppressWarnings("synthetic-access") @Override public DoubleArray apply(DoubleArray yStar) { DoubleArray y = _transform.inverseTransform(yStar); return func.apply(y); } };
@Test public void testQuadratic() { assertFunction(QUADRATIC, -100, 100); assertFunction(QUADRATIC, 100, -100); assertFunction(QUADRATIC, 100, 50); assertFunction(QUADRATIC, -100, -50); }
protected void assertReverseRoundTrip(final ParameterLimitsTransform transform, final double fitParam) { final double mp = transform.inverseTransform(fitParam); final double fp = transform.transform(mp); assertEquals(fitParam, fp, 1e-8); }
@Override public DoubleArray apply(DoubleArray theta) { return trans.transform(theta); } };
@Test(expectedExceptions = IllegalArgumentException.class) public void testNullFunction() { getBracketer().checkInputs(null, 1., 2.); }
@Override protected NonLinearParameterTransforms getTransform(DoubleArray start) { final BitSet fixed = new BitSet(); return new UncoupledParameterTransforms(start, DEFAULT_TRANSFORMS, fixed); }
/** * Transform from the N-1 "fit" parameters to the N "model" parameters. * @param fitParms The N-1 "fit" parameters * @return The N "model" parameters */ public DoubleArray transform(DoubleArray fitParms) { return DoubleArray.copyOf(transform(fitParms.toArray())); }