Uses of Class
org.ddogleg.chainrule.CRMatrix

Packages that use CRMatrix
Package
Description
org.ddogleg.chainrule
 
org.ddogleg.chainrule.ops
 

  • Uses of CRMatrix in org.ddogleg.chainrule

    Methods in org.ddogleg.chainrule that return CRMatrix
    Modifier and Type
    Method
    Description
    CRMatrix<A>
    CRMatrix.copy()
    Creates a copy of the original array and this wrapper.
    static CRMatrix<double[]>
    CRMatrix.createD(int rows, int cols)
     
    CRMatrix<T>
    MathCRMatrix.createMatrix(int rows, int cols)
    Creates a new matrix with the specified shape
    CRMatrix<double[]>
    MathCRMatrixD.createMatrix(int rows, int cols)
     
    CRMatrix<T>
    MathCRMatrix.random(Random rand, double min, double max, int rows, int cols)
    Creates a matrix with random values
    CRMatrix<double[]>
    MathCRMatrixD.random(Random rand, double min, double max, int rows, int cols)
    Creates a new random matrix
    CRMatrix<A>
    CRMatrix.reserve(int length)
    Ensure that the array has at least this many elements in it
    CRMatrix<A>
    CRMatrix.reshape(int rows, int cols)
    Resizes the array and makes sure the data array is large enough
    CRMatrix<A>
    CRMatrix.setOffset(int offset)
    Assigns a new value to the offset and returns a reference to 'this' allowing operations to be chained.
    CRMatrix<A>
    CRMatrix.setTo(CRMatrix<A> src)
    Sets the value of this to be identical to 'src' and returns a refernece to 'this'
    Methods in org.ddogleg.chainrule with parameters of type CRMatrix
    Modifier and Type
    Method
    Description
    void
    JacobianSerialChain.AddToJacobian.addJacobian(int parameter, CRMatrix<T> jacobian)
     
    void
    MathCRMatrix.addTo(CRMatrix<T> dst, CRMatrix<T> src)
    Adds src into dst.
    void
    MathCRMatrixD.addTo(CRMatrix<double[]> dst, CRMatrix<double[]> src)
     
    void
    MathCRMatrix.diag(double value, CRMatrix<T> m)
    Fills the diagonal elements with the specified value
    void
    MathCRMatrixD.diag(double value, CRMatrix<double[]> m)
     
    void
    JacobianNumerical_F64.differentiate(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacInputs)
     
    void
    JacobianNumerical.differentiate(CRMatrix<T> dout, List<CRMatrix<T>> jacInputs)
    Performs numerical differentiation to compute the gradients of input and parameters.
    void
    MathCRMatrix.fill(CRMatrix<T> m, double value)
    Fills every element with the specified value
    void
    MathCRMatrixD.fill(CRMatrix<double[]> m, double value)
     
    void
    JacobianSerialChain.CaptureJacobian.handle(CRMatrix<T> jacobian)
     
    boolean
    CRMatrix.isEquals(CRMatrix<?> compare, double tol)
     
    boolean
    MathCRMatrix.isUncountable(CRMatrix<T> m)
    Returns true if the matrix contains at least one uncountable number
    boolean
    MathCRMatrixD.isUncountable(CRMatrix<double[]> m)
     
    void
    CROperatorBackwardsJac.jacobian(CRMatrix<T> dout, List<CRMatrix<T>> jacobianInputs)
    Computes the Jacobian of all the inputs and parameters to this function.
    void
    MathCRMatrix.mult(CRMatrix<T> a, CRMatrix<T> b, CRMatrix<T> out)
    Performs matrix multiplication.
    void
    MathCRMatrixD.mult(CRMatrix<double[]> a, CRMatrix<double[]> b, CRMatrix<double[]> out)
    Performs a matrix multiplication between a and b.
    void
    MathCRMatrix.random(Random rand, double min, double max, CRMatrix<T> output)
    Fills the matrix with uniformly distributed random values.
    void
    MathCRMatrixD.random(Random rand, double min, double max, CRMatrix<double[]> output)
    Fills the matrix with uniform random values.
    CRMatrix<A>
    CRMatrix.setTo(CRMatrix<A> src)
    Sets the value of this to be identical to 'src' and returns a refernece to 'this'
    default void
    MathCRMatrix.zero(CRMatrix<T> m)
    Fills all elements in the matrix with zero
    Method parameters in org.ddogleg.chainrule with type arguments of type CRMatrix
    Modifier and Type
    Method
    Description
    void
    JacobianNumerical_F64.differentiate(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacInputs)
     
    void
    JacobianNumerical.differentiate(CRMatrix<T> dout, List<CRMatrix<T>> jacInputs)
    Performs numerical differentiation to compute the gradients of input and parameters.
    void
    CROperatorBackwardsJac.jacobian(CRMatrix<T> dout, List<CRMatrix<T>> jacobianInputs)
    Computes the Jacobian of all the inputs and parameters to this function.

  • Uses of CRMatrix in org.ddogleg.chainrule.ops

    Fields in org.ddogleg.chainrule.ops declared as CRMatrix
    Modifier and Type
    Field
    Description
    protected final CRMatrix<double[]>
    CRErrorHuberNorm.workJac
     
    protected final CRMatrix<double[]>
    CRErrorVectorSW.workJac
     
    protected final CRMatrix<double[]>
    CRLossHuber.workJac
     
    protected final CRMatrix<double[]>
    CROperatorBilinearND.workJac
    Workspace for the jacobian
    Methods in org.ddogleg.chainrule.ops with parameters of type CRMatrix
    Modifier and Type
    Method
    Description
    void
    CRErrorHuberNorm.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
     
    void
    CRErrorVectorSW.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
     
    void
    CRLossHuber.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
     
    void
    CROperatorBilinearND.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
     
    void
    CROperatorClampLower.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    One where the value passed through, zero where the floor decided it
    void
    CROperatorConcat.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    Each input passes straight into its own run of the output, so its derivative is a selection matrix and the product is just that run's columns of dout
    void
    CROperatorDivide.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    The quotient rule, element by element: d(a/b)/da = 1/b and d(a/b)/db = -a/b^2
    void
    CROperatorDivideVS.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    The quotient rule: the vector's Jacobian is 1/b on the diagonal, and the scalar's is -a/b^2 as a single column
    void
    CROperatorDivideVSDamped.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    The quotient rule with the damping riding along in the denominator: the vector's Jacobian is 1/(beta + b) on the diagonal, and the scalar's is -a/(beta + b)^2 as a single column
    void
    CROperatorGridBilinearWeights.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    The cell is fixed, so a weight only moves through the fractions, and those are linear in the pixel
    void
    CROperatorMeanVector.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    Every strided element contributes equally, so the jacobian is 1/count at each of them
    void
    CROperatorMult.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    The product rule: each side's Jacobian is a diagonal holding the other side's values
    void
    CROperatorMultVS.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    The product rule: the vector's Jacobian is b on the diagonal, and the scalar's is the vector itself as a single column
    void
    CROperatorPlus.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    A sum has a derivative of one with respect to either side, so both inputs get the same Jacobian
    void
    CROperatorPlusAB.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    Each vector enters scaled by its own coefficient, and each coefficient enters as the vector it scales
    void
    CROperatorRemapParams.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
     
    void
    CRPenaltyL2.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
     
    protected void
    CROperatorBilinearND.jacobianKnot(CRMatrix<double[]> dout, CRMatrix<double[]> output, int knot)
    A coefficient enters linearly, so its derivative is its knot's weight times whatever the function makes of it.
    protected void
    CROperatorBilinearND.jacobianValue(CRMatrix<double[]> dout, CRMatrix<double[]> output)
    Each knot's polynomial moves with value, and the four of them are mixed by the same weights
    protected void
    CROperatorBilinearND.jacobianWeights(CRMatrix<double[]> dout, CRMatrix<double[]> output)
    A weight enters linearly, so its derivative is the polynomial it scales
    Method parameters in org.ddogleg.chainrule.ops with type arguments of type CRMatrix
    Modifier and Type
    Method
    Description
    void
    CRErrorHuberNorm.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
     
    void
    CRErrorVectorSW.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
     
    void
    CRLossHuber.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
     
    void
    CROperatorBilinearND.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
     
    void
    CROperatorClampLower.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    One where the value passed through, zero where the floor decided it
    void
    CROperatorConcat.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    Each input passes straight into its own run of the output, so its derivative is a selection matrix and the product is just that run's columns of dout
    void
    CROperatorDivide.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    The quotient rule, element by element: d(a/b)/da = 1/b and d(a/b)/db = -a/b^2
    void
    CROperatorDivideVS.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    The quotient rule: the vector's Jacobian is 1/b on the diagonal, and the scalar's is -a/b^2 as a single column
    void
    CROperatorDivideVSDamped.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    The quotient rule with the damping riding along in the denominator: the vector's Jacobian is 1/(beta + b) on the diagonal, and the scalar's is -a/(beta + b)^2 as a single column
    void
    CROperatorGridBilinearWeights.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    The cell is fixed, so a weight only moves through the fractions, and those are linear in the pixel
    void
    CROperatorMeanVector.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    Every strided element contributes equally, so the jacobian is 1/count at each of them
    void
    CROperatorMult.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    The product rule: each side's Jacobian is a diagonal holding the other side's values
    void
    CROperatorMultVS.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    The product rule: the vector's Jacobian is b on the diagonal, and the scalar's is the vector itself as a single column
    void
    CROperatorPlus.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    A sum has a derivative of one with respect to either side, so both inputs get the same Jacobian
    void
    CROperatorPlusAB.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
    Each vector enters scaled by its own coefficient, and each coefficient enters as the vector it scales
    void
    CROperatorRemapParams.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)
     
    void
    CRPenaltyL2.jacobian(CRMatrix<double[]> dout, List<CRMatrix<double[]>> jacobianInputs)