org.apache.commons.math3.analysis.MultivariateMatrixFunction Java Examples

@Test(expected=TestException.class)
public void testNoOptimum() {
    DifferentiableMultivariateVectorOptimizer underlyingOptimizer =
        new GaussNewtonOptimizer(true,
                                 new SimpleVectorValueChecker(1.0e-6, 1.0e-6));
    JDKRandomGenerator g = new JDKRandomGenerator();
    g.setSeed(12373523445l);
    RandomVectorGenerator generator =
        new UncorrelatedRandomVectorGenerator(1, new GaussianRandomGenerator(g));
    DifferentiableMultivariateVectorMultiStartOptimizer optimizer =
        new DifferentiableMultivariateVectorMultiStartOptimizer(underlyingOptimizer,
                                                                   10, generator);
    optimizer.optimize(100, new DifferentiableMultivariateVectorFunction() {
            public MultivariateMatrixFunction jacobian() {
                return null;
            }
            public double[] value(double[] point) {
                throw new TestException();
            }
        }, new double[] { 2 }, new double[] { 1 }, new double[] { 0 });
}
 

public MultivariateMatrixFunction getModelFunctionJacobian() {
    return new MultivariateMatrixFunction() {
        public double[][] value(double[] params) {
            double[][] jacobian = new double[time.size()][5];

            for (int i = 0; i < jacobian.length; ++i) {
                final double t = time.get(i);
                jacobian[i][0] = 1;

                final double p3 =  params[3];
                final double p4 =  params[4];
                final double tOp3 = t / p3;
                final double tOp4 = t / p4;
                jacobian[i][1] = FastMath.exp(-tOp3);
                jacobian[i][2] = FastMath.exp(-tOp4);
                jacobian[i][3] = params[1] * FastMath.exp(-tOp3) * tOp3 / p3;
                jacobian[i][4] = params[2] * FastMath.exp(-tOp4) * tOp4 / p4;
            }
            return jacobian;
        }
    };
}
 

public MultivariateMatrixFunction getModelFunctionJacobian() {
    return new MultivariateMatrixFunction() {
        public double[][] value(double[] params) {
            double[][] jacobian = new double[time.size()][5];

            for (int i = 0; i < jacobian.length; ++i) {
                final double t = time.get(i);
                jacobian[i][0] = 1;

                final double p3 =  params[3];
                final double p4 =  params[4];
                final double tOp3 = t / p3;
                final double tOp4 = t / p4;
                jacobian[i][1] = Math.exp(-tOp3);
                jacobian[i][2] = Math.exp(-tOp4);
                jacobian[i][3] = params[1] * Math.exp(-tOp3) * tOp3 / p3;
                jacobian[i][4] = params[2] * Math.exp(-tOp4) * tOp4 / p4;
            }
            return jacobian;
        }
    };
}
 

public ModelFunctionJacobian getModelFunctionJacobian() {
    return new ModelFunctionJacobian(new MultivariateMatrixFunction() {
            public double[][] value(double[] params) {
                double[][] jacobian = new double[time.size()][5];

                for (int i = 0; i < jacobian.length; ++i) {
                    final double t = time.get(i);
                    jacobian[i][0] = 1;

                    final double p3 =  params[3];
                    final double p4 =  params[4];
                    final double tOp3 = t / p3;
                    final double tOp4 = t / p4;
                    jacobian[i][1] = Math.exp(-tOp3);
                    jacobian[i][2] = Math.exp(-tOp4);
                    jacobian[i][3] = params[1] * Math.exp(-tOp3) * tOp3 / p3;
                    jacobian[i][4] = params[2] * Math.exp(-tOp4) * tOp4 / p4;
                }
                return jacobian;
            }
        });
}
 

private MultivariateMatrixFunction getNumericJacobianFunction(final double[] xgrid1, final double[] ygrid1, final double[] xgrid2, final double[] ygrid2) {
    final MultivariateVectorFunction valueFunction = getValueFunction(xgrid1, ygrid1, xgrid2, ygrid2);
    return new MultivariateMatrixFunction() {
        static final double step = 0.01;

        @Override
        public double[][] value(double[] point) throws IllegalArgumentException {
            double[][] retVal = new double[xgrid1.length + xgrid2.length][point.length];

            for(int i = 0; i < point.length; i++) {
                double[] newPoint = point.clone();
                newPoint[i] = newPoint[i] + step;
                double[] f1 = valueFunction.value(newPoint);
                double[] f2 = valueFunction.value(point);
                for(int j = 0; j < f1.length; j++) {
                    retVal[j][i] = (f1[j] - f2[j]) / step;
                }
            }
            return retVal;
        }
    };
}
 

public MultivariateMatrixFunction getNumericJacobianFunction(final double[] xgrid, final double[] ygrid) {
    final MultivariateVectorFunction valueFunction = getValueFunction(xgrid, ygrid);
    return new MultivariateMatrixFunction() {
        static final double step = 0.01;

        @Override
        public double[][] value(double[] point) throws IllegalArgumentException {
            double[][] retVal = new double[xgrid.length][point.length];

            for(int i = 0; i < point.length; i++) {
                double[] newPoint = point.clone();
                newPoint[i] = newPoint[i] + step;
                double[] f1 = valueFunction.value(newPoint);
                double[] f2 = valueFunction.value(point);
                for(int j = 0; j < f1.length; j++) {
                    retVal[j][i] = (f1[j] - f2[j]) / step;
                }
            }
            return retVal;
        }
    };
}
 

@Override
public MultivariateMatrixFunction getJacobianFunction(final double[] xgrid, final double[] ygrid) {
    return new MultivariateMatrixFunction() {
        @Override
        public double[][] value(double[] point) throws IllegalArgumentException {
            fixParams(point);
            //
            double[][] retVal = new double[xgrid.length][point.length];
            for(int i = 0; i < nmol; i++) {
                double [] tmp = Arrays.copyOfRange(point, i*Params.PARAMS_LENGTH, (i+1)*Params.PARAMS_LENGTH);
                double [][] J = psf.getNumericJacobianFunction(xgrid, ygrid).value(tmp);
                for(int j = 0; j < J.length; j++) {
                    for(int k = 0, l = i*Params.PARAMS_LENGTH; k < J[j].length; k++, l++) {
                        retVal[j][l] = J[j][k];
                    }
                }
            }
            return retVal;
        }
    };
}
 

@Test(expected=TestException.class)
public void testNoOptimum() {
    DifferentiableMultivariateVectorOptimizer underlyingOptimizer =
        new GaussNewtonOptimizer(true,
                                 new SimpleVectorValueChecker(1.0e-6, 1.0e-6));
    JDKRandomGenerator g = new JDKRandomGenerator();
    g.setSeed(12373523445l);
    RandomVectorGenerator generator =
        new UncorrelatedRandomVectorGenerator(1, new GaussianRandomGenerator(g));
    DifferentiableMultivariateVectorMultiStartOptimizer optimizer =
        new DifferentiableMultivariateVectorMultiStartOptimizer(underlyingOptimizer,
                                                                   10, generator);
    optimizer.optimize(100, new DifferentiableMultivariateVectorFunction() {
            public MultivariateMatrixFunction jacobian() {
                return null;
            }
            public double[] value(double[] point) {
                throw new TestException();
            }
        }, new double[] { 2 }, new double[] { 1 }, new double[] { 0 });
}
 

public MultivariateMatrixFunction getModelFunctionJacobian() {
    return new MultivariateMatrixFunction() {
        public double[][] value(double[] params) {
            double[][] jacobian = new double[time.size()][5];

            for (int i = 0; i < jacobian.length; ++i) {
                final double t = time.get(i);
                jacobian[i][0] = 1;

                final double p3 =  params[3];
                final double p4 =  params[4];
                final double tOp3 = t / p3;
                final double tOp4 = t / p4;
                jacobian[i][1] = FastMath.exp(-tOp3);
                jacobian[i][2] = FastMath.exp(-tOp4);
                jacobian[i][3] = params[1] * FastMath.exp(-tOp3) * tOp3 / p3;
                jacobian[i][4] = params[2] * FastMath.exp(-tOp4) * tOp4 / p4;
            }
            return jacobian;
        }
    };
}
 

public MultivariateMatrixFunction jacobian() {
    return new MultivariateMatrixFunction() {
        public double[][] value(double[] point) {
            return jacobian(point);
        }
    };
}
 

public ModelFunctionJacobian getModelFunctionJacobian() {
    return new ModelFunctionJacobian(new MultivariateMatrixFunction() {
            public double[][] value(double[] params) {
                return factors.getData();
            }
        });
}
 

public MultivariateMatrixFunction getModelFunctionJacobian() {
    return new MultivariateMatrixFunction() {
        public double[][] value(double[] params) {                    
            double[][] jacobian = new double[x.size()][3];
            for (int i = 0; i < jacobian.length; ++i) {
                jacobian[i][0] = x.get(i) * x.get(i);
                jacobian[i][1] = x.get(i);
                jacobian[i][2] = 1.0;
            }
            return jacobian;
        }
    };
}
 

public MultivariateMatrixFunction jacobian() {
    return new MultivariateMatrixFunction() {
        public double[][] value(double[] point) {
            return jacobian(point);
        }
    };
}
 

public ModelFunctionJacobian getModelFunctionJacobian() {
    return new ModelFunctionJacobian(new MultivariateMatrixFunction() {
            public double[][] value(final double[] a)
                throws IllegalArgumentException {
                final int n = getNumObservations();
                final double[][] j = new double[n][];
                for (int i = 0; i < n; i++) {
                    j[i] = getModelDerivatives(getX(i), a);
                }
                return j;
            }
        });
}
 

public ModelFunctionJacobian getModelFunctionJacobian() {
    return new ModelFunctionJacobian(new MultivariateMatrixFunction() {
            public double[][] value(double[] params) {
                final int n = points.size();
                final Vector2D center = new Vector2D(params[0], params[1]);

                double dRdX = 0;
                double dRdY = 0;
                for (Vector2D pk : points) {
                    double dk = pk.distance(center);
                    dRdX += (center.getX() - pk.getX()) / dk;
                    dRdY += (center.getY() - pk.getY()) / dk;
                }
                dRdX /= n;
                dRdY /= n;

                // Jacobian of the radius residuals.
                double[][] jacobian = new double[n][2];
                for (int i = 0; i < n; i++) {
                    final Vector2D pi = points.get(i);
                    final double di = pi.distance(center);
                    jacobian[i][0] = (center.getX() - pi.getX()) / di - dRdX;
                    jacobian[i][1] = (center.getY() - pi.getY()) / di - dRdY;
                }

                return jacobian;
            }
    });
}
 

public MultivariateMatrixFunction getModelFunctionJacobian() {
    return new MultivariateMatrixFunction() {
        public double[][] value(double[] point) {
            return jacobian(point);
        }
    };
}
 

public MultivariateMatrixFunction getModelFunctionJacobian() {
    return new MultivariateMatrixFunction() {
        public double[][] value(final double[] a)
            throws IllegalArgumentException {
            final int n = getNumObservations();
            final double[][] j = new double[n][];
            for (int i = 0; i < n; i++) {
                j[i] = getModelDerivatives(getX(i), a);
            }
            return j;
        }
    };
}
 

public MultivariateMatrixFunction getModelFunctionJacobian() {
    return new MultivariateMatrixFunction() {
        public double[][] value(double[] point) {
            return jacobian(point);
        }
    };
}
 

public ModelFunctionJacobian getModelFunctionJacobian() {
    return new ModelFunctionJacobian(new MultivariateMatrixFunction() {
            public double[][] value(double[] point) {
                return jacobian(point);
            }
    });
}
 

public ModelFunctionJacobian getModelFunctionJacobian() {
    return new ModelFunctionJacobian(new MultivariateMatrixFunction() {
            public double[][] value(double[] point) {
                return factors.getData();
            }
        });
}
 

public MultivariateMatrixFunction getModelFunctionJacobian() {
    return new MultivariateMatrixFunction() {
        public double[][] value(double[] params) {
            return factors.getData();
        }
    };
}
 

public ModelFunctionJacobian getModelFunctionJacobian() {
    return new ModelFunctionJacobian(new MultivariateMatrixFunction() {
            public double[][] value(double[] point) {
                return computeJacobian(point);
            }
        });
}
 

public MultivariateMatrixFunction getModelFunctionJacobian() {
    return new MultivariateMatrixFunction() {
        public double[][] value(double[] params) {                    
            double[][] jacobian = new double[x.size()][3];
            for (int i = 0; i < jacobian.length; ++i) {
                jacobian[i][0] = x.get(i) * x.get(i);
                jacobian[i][1] = x.get(i);
                jacobian[i][2] = 1.0;
            }
            return jacobian;
        }
    };
}
 

public ModelFunctionJacobian getModelFunctionJacobian() {
    return new ModelFunctionJacobian(new MultivariateMatrixFunction() {
            public double[][] value(double[] point) {
                return jacobian(point);
            }
        });
}
 

/**
 * @return the model function Jacobian.
 */
public ModelFunctionJacobian getModelFunctionJacobian() {
    return new ModelFunctionJacobian(new MultivariateMatrixFunction() {
            public double[][] value(double[] point) {
                final double[][] jacobian = new double[observations.size()][];
                int i = 0;
                for (WeightedObservedPoint observed : observations) {
                    jacobian[i++] = f.gradient(observed.getX(), point);
                }
                return jacobian;
            }
        });
}
 

public MultivariateMatrixFunction jacobian() {
    return new MultivariateMatrixFunction() {
        public double[][] value(double[] point) {
            return factors.getData();
        }
    };
}
 

public ModelFunctionJacobian getModelFunctionJacobian() {
    return new ModelFunctionJacobian(new MultivariateMatrixFunction() {
            public double[][] value(double[] point) {
                return factors.getData();
            }
        });
}
 

public MultivariateMatrixFunction jacobian() {
    return new MultivariateMatrixFunction() {
        public double[][] value(double[] point) {
            return jacobian(point);
        }
    };
}
 

public MultivariateMatrixFunction jacobian() {
    return new MultivariateMatrixFunction() {
        public double[][] value(double[] point) {
            return jacobian(point);
        }
    };
}
 

public ModelFunctionJacobian getModelFunctionJacobian() {
    return new ModelFunctionJacobian(new MultivariateMatrixFunction() {
            public double[][] value(double[] params) {
                final int n = points.size();
                final Vector2D center = new Vector2D(params[0], params[1]);

                double dRdX = 0;
                double dRdY = 0;
                for (Vector2D pk : points) {
                    double dk = pk.distance(center);
                    dRdX += (center.getX() - pk.getX()) / dk;
                    dRdY += (center.getY() - pk.getY()) / dk;
                }
                dRdX /= n;
                dRdY /= n;

                // Jacobian of the radius residuals.
                double[][] jacobian = new double[n][2];
                for (int i = 0; i < n; i++) {
                    final Vector2D pi = points.get(i);
                    final double di = pi.distance(center);
                    jacobian[i][0] = (center.getX() - pi.getX()) / di - dRdX;
                    jacobian[i][1] = (center.getY() - pi.getY()) / di - dRdY;
                }

                return jacobian;
            }
    });
}