Orbit (patrius 4.0 API)

java.lang.Object
- fr.cnes.sirius.patrius.orbits.Orbit

All Implemented Interfaces:

PVCoordinatesProvider, TimeInterpolable<Orbit>, TimeShiftable<Orbit>, TimeStamped, Serializable

Direct Known Subclasses:

ApsisOrbit, CartesianOrbit, CircularOrbit, EquatorialOrbit, EquinoctialOrbit, KeplerianOrbit, StelaEquinoctialOrbit
```
public abstract class Orbit
extends Object
implements TimeStamped, TimeShiftable<Orbit>, TimeInterpolable<Orbit>, Serializable, PVCoordinatesProvider
```
This class handles orbital parameters.
For user convenience, both the Cartesian and the equinoctial elements are provided by this class, regardless of the canonical representation implemented in the derived class (which may be classical keplerian elements for example).

The parameters are defined in a frame specified by the user. It is important to make sure this frame is consistent: it probably is inertial and centered on the central body. This information is used for example by some force models.

The object OrbitalParameters is guaranteed to be immutable.

Author:

Luc Maisonobe, Guylaine Prat, Fabien Maussion, Véronique Pommier-Maurussane

See Also:
Serialized Form

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`Orbit(Frame frameIn, AbsoluteDate dateIn, double muIn)` Default constructor.
`protected`	`Orbit(PVCoordinates pvCoordinatesIn, Frame frameIn, AbsoluteDate dateIn, double muIn)` Set the orbit from Cartesian parameters.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addKeplerContribution(PositionAngle type, double gm, double[] pDot)` Call the method `orbitAddKeplerContribution(PositionAngle, double, double[])` implemented in inherited classes of Orbit.
`protected abstract double[][]`	`computeJacobianEccentricWrtCartesian()` Compute the Jacobian of the orbital parameters with eccentric angle with respect to the Cartesian parameters.
`protected abstract double[][]`	`computeJacobianMeanWrtCartesian()` Compute the Jacobian of the orbital parameters with mean angle with respect to the Cartesian parameters.
`protected abstract double[][]`	`computeJacobianTrueWrtCartesian()` Compute the Jacobian of the orbital parameters with true angle with respect to the Cartesian parameters.
`protected double[][]`	`createInverseJacobian(PositionAngle type)` Create an inverse Jacobian.
`protected static void`	`fillHalfRow(double a, Vector3D v, double[] row, int j)` Fill a Jacobian half row with a single vector.
`protected static void`	`fillHalfRow(double a1, Vector3D v1, double a2, Vector3D v2, double[] row, int j)` Fill a Jacobian half row with a linear combination of vectors.
`protected static void`	`fillHalfRow(double a1, Vector3D v1, double a2, Vector3D v2, double a3, Vector3D v3, double[] row, int j)` Fill a Jacobian half row with a linear combination of vectors.
`protected static void`	`fillHalfRow(double a1, Vector3D v1, double a2, Vector3D v2, double a3, Vector3D v3, double a4, Vector3D v4, double[] row, int j)` Fill a Jacobian half row with a linear combination of vectors.
`protected static void`	`fillHalfRow(double a1, Vector3D v1, double a2, Vector3D v2, double a3, Vector3D v3, double a4, Vector3D v4, double a5, Vector3D v5, double[] row, int j)` Fill a Jacobian half row with a linear combination of vectors.
`protected static void`	`fillHalfRow(double a1, Vector3D v1, double a2, Vector3D v2, double a3, Vector3D v3, double a4, Vector3D v4, double a5, Vector3D v5, double a6, Vector3D v6, double[] row, int j)` Fill a Jacobian half row with a linear combination of vectors.
`abstract double`	`getA()` Get the semi-major axis.
`AbsoluteDate`	`getDate()` Get the date of orbital parameters.
`abstract double`	`getE()` Get the eccentricity.
`abstract double`	`getEquinoctialEx()` Get the first component of the equinoctial eccentricity vector.
`abstract double`	`getEquinoctialEy()` Get the second component of the equinoctial eccentricity vector.
`Frame`	`getFrame()` Get the frame in which the orbital parameters are defined.
`abstract double`	`getHx()` Get hx = ix / (2 * cos(i/2)), where ix is the first component of the inclination vector.
`abstract double`	`getHy()` Get hy = iy / (2 * cos(i/2)), where iy is the second component of the inclination vector.
`abstract double`	`getI()` Get the inclination.
`RealMatrix`	`getJacobian(OrbitType numerator, OrbitType denominator)` Get coordinate conversion jacobian.
`void`	`getJacobianWrtCartesian(PositionAngle type, double[][] jacobian)` Compute the Jacobian of the orbital parameters with respect to the Cartesian parameters.
`void`	`getJacobianWrtParameters(PositionAngle type, double[][] jacobian)` Compute the Jacobian of the Cartesian parameters with respect to the orbital parameters.
`protected double[][]`	`getJacobianWrtParametersEccentric()`
`protected double[][]`	`getJacobianWrtParametersMean()`
`protected double[][]`	`getJacobianWrtParametersTrue()`
`double`	`getKeplerianMeanMotion()` Get the keplerian mean motion.
`double`	`getKeplerianPeriod()` Get the keplerian period.
`RealMatrix`	`getKeplerianTransitionMatrix(double dt)` Get keplerian transition matrix.
`abstract double`	`getLE()` Get the eccentric longitude argument.
`abstract double`	`getLM()` Get the mean longitude argument.
`abstract double`	`getLv()` Get the true longitude argument.
`double`	`getMu()` Get the central acceleration constant.
`abstract IOrbitalParameters`	`getParameters()` Get underlying orbital parameters.
`PVCoordinates`	`getPVCoordinates()` Get the `PVCoordinates` in definition frame.
`PVCoordinates`	`getPVCoordinates(AbsoluteDate otherDate, Frame otherFrame)` Get the `PVCoordinates` of the body in the selected frame.
`PVCoordinates`	`getPVCoordinates(Frame outputFrame)` Get the `PVCoordinates` in a specified frame.
`abstract OrbitType`	`getType()` Get the orbit type.
`protected abstract PVCoordinates`	`initPVCoordinates()` Compute the position/velocity coordinates from the canonical parameters.
`static boolean`	`isPositiveDefinite(RealMatrix matrix, double small)` Test the positivity of a matrix.
`protected abstract void`	`orbitAddKeplerContribution(PositionAngle type, double gm, double[] pDot)` Add the contribution of the Keplerian motion to parameters derivatives
`protected abstract Orbit`	`orbitShiftedBy(double dt)` Get a time-shifted orbit.
`protected void`	`setJacobianWrtParametersEccentric(double[][] jacobianWrtParametersEccentricIn)`
`protected void`	`setJacobianWrtParametersMean(double[][] jacobianWrtParametersMeanIn)`
`protected void`	`setJacobianWrtParametersTrue(double[][] jacobianWrtParametersTrueIn)`
`Orbit`	`shiftedBy(double dt)` Call the method `orbitShiftedBy(double)` implemented in inherited classes of Orbit.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface fr.cnes.sirius.patrius.time.TimeInterpolable
interpolate

- Constructor Detail
  - Orbit
```
protected Orbit(Frame frameIn,
     AbsoluteDate dateIn,
     double muIn)
```
    Default constructor. Build a new instance with arbitrary default elements.
    
    Parameters:
    frameIn - the frame in which the parameters are defined (must be a pseudo-inertial frame)
    dateIn - date of the orbital parameters
    muIn - central attraction coefficient (m^3/s^2)
  - Orbit
```
protected Orbit(PVCoordinates pvCoordinatesIn,
     Frame frameIn,
     AbsoluteDate dateIn,
     double muIn)
```
    Set the orbit from Cartesian parameters.
    
    Parameters:
    pvCoordinatesIn - the position and velocity in the inertial frame
    frameIn - the frame in which the PVCoordinates are defined
    dateIn - date of the orbital parameters
    muIn - central attraction coefficient (m^3/s^2)
- Method Detail
  - getParameters
```
public abstract IOrbitalParameters getParameters()
```
    Get underlying orbital parameters.
    
    Returns:
    orbital parameters
  - getType
```
public abstract OrbitType getType()
```
    Get the orbit type.
    
    Returns:
    orbit type
  - getFrame
```
public Frame getFrame()
```
    Get the frame in which the orbital parameters are defined.
    
    Returns:
    frame in which the orbital parameters are defined
  - getA
```
public abstract double getA()
```
    Get the semi-major axis.
    Note that the semi-major axis is considered negative for hyperbolic orbits.
    
    Returns:
    semi-major axis (m)
  - getEquinoctialEx
```
public abstract double getEquinoctialEx()
```
    Get the first component of the equinoctial eccentricity vector.
    
    Returns:
    first component of the equinoctial eccentricity vector
  - getEquinoctialEy
```
public abstract double getEquinoctialEy()
```
    Get the second component of the equinoctial eccentricity vector.
    
    Returns:
    second component of the equinoctial eccentricity vector
  - getHx
```
public abstract double getHx()
```
    Get hx = ix / (2 * cos(i/2)), where ix is the first component of the inclination vector. Another formulation is hx = tan(i/2) cos(Ω)
    
    Returns:
    first component of the inclination vector
  - getHy
```
public abstract double getHy()
```
    Get hy = iy / (2 * cos(i/2)), where iy is the second component of the inclination vector. Another formulation is hy = tan(i/2) sin(Ω)
    
    Returns:
    second component of the inclination vector
  - getLE
```
public abstract double getLE()
```
    Get the eccentric longitude argument.
    
    Returns:
    eccentric longitude argument (rad)
  - getLv
```
public abstract double getLv()
```
    Get the true longitude argument.
    
    Returns:
    true longitude argument (rad)
  - getLM
```
public abstract double getLM()
```
    Get the mean longitude argument.
    
    Returns:
    mean longitude argument (rad)
  - getE
```
public abstract double getE()
```
    Get the eccentricity.
    
    Returns:
    eccentricity
  - getI
```
public abstract double getI()
```
    Get the inclination.
    
    Returns:
    inclination (rad)
  - getMu
```
public double getMu()
```
    Get the central acceleration constant.
    
    Returns:
    central acceleration constant
  - getKeplerianPeriod
```
public double getKeplerianPeriod()
```
    Get the keplerian period.
    The keplerian period is computed directly from semi major axis and central acceleration constant.
    
    Returns:
    keplerian period in seconds, or positive infinity for hyperbolic orbits
  - getKeplerianMeanMotion
```
public double getKeplerianMeanMotion()
```
    Get the keplerian mean motion.
    The keplerian mean motion is computed directly from semi major axis and central acceleration constant.
    
    Returns:
    keplerian mean motion in radians per second
  - getDate
```
public AbsoluteDate getDate()
```
    Get the date of orbital parameters.
    
    Specified by:
    
    getDate in interface TimeStamped
    
    Returns:
    date of the orbital parameters
  - getPVCoordinates
```
public PVCoordinates getPVCoordinates(Frame outputFrame)
                               throws PatriusException
```
    Get the PVCoordinates in a specified frame.
    
    Parameters:
    outputFrame - frame in which the position/velocity coordinates shall be computed
    
    Returns:
    pvCoordinates in the specified output frame
    
    Throws:
    
    PatriusException - if transformation between frames cannot be computed
    See Also:
    getPVCoordinates()
  - getPVCoordinates
```
public PVCoordinates getPVCoordinates(AbsoluteDate otherDate,
                             Frame otherFrame)
                               throws PatriusException
```
    Get the PVCoordinates of the body in the selected frame.
    
    Specified by:
    
    getPVCoordinates in interface PVCoordinatesProvider
    
    Parameters:
    otherDate - current date
    otherFrame - the frame where to define the position
    
    Returns:
    position/velocity of the body (m and m/s)
    
    Throws:
    
    PatriusException - if position cannot be computed in given frame
  - getPVCoordinates
```
public PVCoordinates getPVCoordinates()
```
    Get the PVCoordinates in definition frame.
    
    Returns:
    pvCoordinates in the definition frame
    See Also:
    getPVCoordinates(Frame)
  - initPVCoordinates
```
protected abstract PVCoordinates initPVCoordinates()
```
    Compute the position/velocity coordinates from the canonical parameters.
    
    Returns:
    computed position/velocity coordinates
  - orbitShiftedBy
```
protected abstract Orbit orbitShiftedBy(double dt)
```
    Get a time-shifted orbit.
    The orbit can be slightly shifted to close dates. This shift is based on a simple keplerian model. It is not intended as a replacement for proper orbit and attitude propagation but should be sufficient for small time shifts or coarse accuracy.
    
    Parameters:
    dt - time shift in seconds
    
    Returns:
    a new orbit, shifted with respect to the instance (which is immutable)
  - shiftedBy
```
public Orbit shiftedBy(double dt)
```
    Call the method orbitShiftedBy(double) implemented in inherited classes of Orbit.
    
    Specified by:
    
    shiftedBy in interface TimeShiftable<Orbit>
    
    Parameters:
    dt - time shift in seconds
    
    Returns:
    a new orbit, shifted with respect to the instance (which is immutable)
  - getJacobianWrtCartesian
```
public void getJacobianWrtCartesian(PositionAngle type,
                           double[][] jacobian)
```
    Compute the Jacobian of the orbital parameters with respect to the Cartesian parameters.
    Element jacobian[i][j] is the derivative of parameter i of the orbit with respect to Cartesian coordinate j. This means each row correspond to one orbital parameter whereas columns 0 to 5 correspond to the Cartesian coordinates x, y, z, xDot, yDot and zDot.
    
    Parameters:
    type - type of the position angle to use
    jacobian - placeholder 6x6 (or larger) matrix to be filled with the Jacobian, if matrix is larger than 6x6, only the 6x6 upper left corner will be modified
  - getJacobianWrtParameters
```
public void getJacobianWrtParameters(PositionAngle type,
                            double[][] jacobian)
```
    Compute the Jacobian of the Cartesian parameters with respect to the orbital parameters.
    Element jacobian[i][j] is the derivative of parameter i of the orbit with respect to Cartesian coordinate j. This means each row correspond to one orbital parameter whereas columns 0 to 5 correspond to the Cartesian coordinates x, y, z, xDot, yDot and zDot.
    
    Parameters:
    type - type of the position angle to use
    jacobian - placeholder 6x6 (or larger) matrix to be filled with the Jacobian, if matrix is larger than 6x6, only the 6x6 upper left corner will be modified
  - createInverseJacobian
```
protected double[][] createInverseJacobian(PositionAngle type)
```
    Create an inverse Jacobian.
    
    Parameters:
    type - type of the position angle to use
    
    Returns:
    inverse Jacobian
  - computeJacobianMeanWrtCartesian
```
protected abstract double[][] computeJacobianMeanWrtCartesian()
```
    Compute the Jacobian of the orbital parameters with mean angle with respect to the Cartesian parameters.
    Element jacobian[i][j] is the derivative of parameter i of the orbit with respect to Cartesian coordinate j. This means each row correspond to one orbital parameter whereas columns 0 to 5 correspond to the Cartesian coordinates x, y, z, xDot, yDot and zDot.
    
    Returns:
    6x6 Jacobian matrix
    See Also:
    computeJacobianEccentricWrtCartesian(), computeJacobianTrueWrtCartesian()
  - computeJacobianEccentricWrtCartesian
```
protected abstract double[][] computeJacobianEccentricWrtCartesian()
```
    Compute the Jacobian of the orbital parameters with eccentric angle with respect to the Cartesian parameters.
    Element jacobian[i][j] is the derivative of parameter i of the orbit with respect to Cartesian coordinate j. This means each row correspond to one orbital parameter whereas columns 0 to 5 correspond to the Cartesian coordinates x, y, z, xDot, yDot and zDot.
    
    Returns:
    6x6 Jacobian matrix
    See Also:
    computeJacobianMeanWrtCartesian(), computeJacobianTrueWrtCartesian()
  - computeJacobianTrueWrtCartesian
```
protected abstract double[][] computeJacobianTrueWrtCartesian()
```
    Compute the Jacobian of the orbital parameters with true angle with respect to the Cartesian parameters.
    Element jacobian[i][j] is the derivative of parameter i of the orbit with respect to Cartesian coordinate j. This means each row correspond to one orbital parameter whereas columns 0 to 5 correspond to the Cartesian coordinates x, y, z, xDot, yDot and zDot.
    
    Returns:
    6x6 Jacobian matrix
    See Also:
    computeJacobianMeanWrtCartesian(), computeJacobianEccentricWrtCartesian()
  - orbitAddKeplerContribution
```
protected abstract void orbitAddKeplerContribution(PositionAngle type,
                              double gm,
                              double[] pDot)
```
    Add the contribution of the Keplerian motion to parameters derivatives
    This method is used by numerical propagators to evaluate the part of Keplerrian motion to evolution of the orbital state.
    
    Parameters:
    type - type of the position angle in the state
    gm - attraction coefficient to use
    pDot - array containing orbital state derivatives to update (the Keplerian part must be added to the array components, as the array may already contain some non-zero elements corresponding to non-Keplerian parts)
  - addKeplerContribution
```
public void addKeplerContribution(PositionAngle type,
                         double gm,
                         double[] pDot)
```
    Call the method orbitAddKeplerContribution(PositionAngle, double, double[]) implemented in inherited classes of Orbit.
    
    Parameters:
    type - type of the position angle in the state
    gm - attraction coefficient to use
    pDot - array containing orbital state derivatives to update (the Keplerian part must be added to the array components, as the array may already contain some non-zero elements corresponding to non-Keplerian parts)
  - fillHalfRow
```
protected static void fillHalfRow(double a,
               Vector3D v,
               double[] row,
               int j)
```
    Fill a Jacobian half row with a single vector.
    
    Parameters:
    a - coefficient of the vector
    v - vector
    row - Jacobian matrix row
    j - index of the first element to set (row[j], row[j+1] and row[j+2] will all be set)
  - fillHalfRow
```
protected static void fillHalfRow(double a1,
               Vector3D v1,
               double a2,
               Vector3D v2,
               double[] row,
               int j)
```
    Fill a Jacobian half row with a linear combination of vectors.
    
    Parameters:
    a1 - coefficient of the first vector
    v1 - first vector
    a2 - coefficient of the second vector
    v2 - second vector
    row - Jacobian matrix row
    j - index of the first element to set (row[j], row[j+1] and row[j+2] will all be set)
  - fillHalfRow
```
protected static void fillHalfRow(double a1,
               Vector3D v1,
               double a2,
               Vector3D v2,
               double a3,
               Vector3D v3,
               double[] row,
               int j)
```
    Fill a Jacobian half row with a linear combination of vectors.
    
    Parameters:
    a1 - coefficient of the first vector
    v1 - first vector
    a2 - coefficient of the second vector
    v2 - second vector
    a3 - coefficient of the third vector
    v3 - third vector
    row - Jacobian matrix row
    j - index of the first element to set (row[j], row[j+1] and row[j+2] will all be set)
  - fillHalfRow
```
protected static void fillHalfRow(double a1,
               Vector3D v1,
               double a2,
               Vector3D v2,
               double a3,
               Vector3D v3,
               double a4,
               Vector3D v4,
               double[] row,
               int j)
```
    Fill a Jacobian half row with a linear combination of vectors.
    
    Parameters:
    a1 - coefficient of the first vector
    v1 - first vector
    a2 - coefficient of the second vector
    v2 - second vector
    a3 - coefficient of the third vector
    v3 - third vector
    a4 - coefficient of the fourth vector
    v4 - fourth vector
    row - Jacobian matrix row
    j - index of the first element to set (row[j], row[j+1] and row[j+2] will all be set)
  - fillHalfRow
```
protected static void fillHalfRow(double a1,
               Vector3D v1,
               double a2,
               Vector3D v2,
               double a3,
               Vector3D v3,
               double a4,
               Vector3D v4,
               double a5,
               Vector3D v5,
               double[] row,
               int j)
```
    Fill a Jacobian half row with a linear combination of vectors.
    
    Parameters:
    a1 - coefficient of the first vector
    v1 - first vector
    a2 - coefficient of the second vector
    v2 - second vector
    a3 - coefficient of the third vector
    v3 - third vector
    a4 - coefficient of the fourth vector
    v4 - fourth vector
    a5 - coefficient of the fifth vector
    v5 - fifth vector
    row - Jacobian matrix row
    j - index of the first element to set (row[j], row[j+1] and row[j+2] will all be set)
  - fillHalfRow
```
protected static void fillHalfRow(double a1,
               Vector3D v1,
               double a2,
               Vector3D v2,
               double a3,
               Vector3D v3,
               double a4,
               Vector3D v4,
               double a5,
               Vector3D v5,
               double a6,
               Vector3D v6,
               double[] row,
               int j)
```
    Fill a Jacobian half row with a linear combination of vectors.
    
    Parameters:
    a1 - coefficient of the first vector
    v1 - first vector
    a2 - coefficient of the second vector
    v2 - second vector
    a3 - coefficient of the third vector
    v3 - third vector
    a4 - coefficient of the fourth vector
    v4 - fourth vector
    a5 - coefficient of the fifth vector
    v5 - fifth vector
    a6 - coefficient of the sixth vector
    v6 - sixth vector
    row - Jacobian matrix row
    j - index of the first element to set (row[j], row[j+1] and row[j+2] will all be set)
  - setJacobianWrtParametersMean
```
protected void setJacobianWrtParametersMean(double[][] jacobianWrtParametersMeanIn)
```
    Parameters:
    jacobianWrtParametersMeanIn - the jacobianWrtParametersMean to set
  - getJacobianWrtParametersMean
```
protected double[][] getJacobianWrtParametersMean()
```
    Returns:
    the jacobianWrtParametersMean
  - setJacobianWrtParametersEccentric
```
protected void setJacobianWrtParametersEccentric(double[][] jacobianWrtParametersEccentricIn)
```
    Parameters:
    jacobianWrtParametersEccentricIn - the jacobianWrtParametersEccentric to set
  - getJacobianWrtParametersEccentric
```
protected double[][] getJacobianWrtParametersEccentric()
```
    Returns:
    the jacobianWrtParametersEccentric
  - setJacobianWrtParametersTrue
```
protected void setJacobianWrtParametersTrue(double[][] jacobianWrtParametersTrueIn)
```
    Parameters:
    jacobianWrtParametersTrueIn - the jacobianWrtParametersTrue to set
  - getJacobianWrtParametersTrue
```
protected double[][] getJacobianWrtParametersTrue()
```
    Returns:
    the jacobianWrtParametersTrue
  - getJacobian
```
public RealMatrix getJacobian(OrbitType numerator,
                     OrbitType denominator)
```
    Get coordinate conversion jacobian.
    
    Parameters:
    numerator - Numerator parameters.
    denominator - Denominator parameters.
    
    Returns:
    Jacobian matrix numerator / denominator.
  - getKeplerianTransitionMatrix
```
public RealMatrix getKeplerianTransitionMatrix(double dt)
```
    Get keplerian transition matrix.
    
    Parameters:
    dt - Propagation interval.
    
    Returns:
    Transition matrix given in the coordinates type of the input orbit.
  - isPositiveDefinite
```
public static boolean isPositiveDefinite(RealMatrix matrix,
                         double small)
```
    Test the positivity of a matrix.
    
    Parameters:
    matrix - Symmetric positive semidefinite matrix
    small - Diagonal elements threshold under which columns are considered to be dependent on previous ones and are discarded
    
    Returns:
    true if the matrix is positive definite false otherwise

Class Orbit

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface fr.cnes.sirius.patrius.time.TimeInterpolable

Constructor Detail

Orbit

Orbit

Method Detail

getParameters

getType

getFrame

getA

getEquinoctialEx

getEquinoctialEy

getHx

getHy

getLE

getLv

getLM

getE

getI

getMu

getKeplerianPeriod

getKeplerianMeanMotion

getDate

getPVCoordinates

getPVCoordinates

getPVCoordinates

initPVCoordinates

orbitShiftedBy

shiftedBy

getJacobianWrtCartesian

getJacobianWrtParameters

createInverseJacobian

computeJacobianMeanWrtCartesian

computeJacobianEccentricWrtCartesian

computeJacobianTrueWrtCartesian

orbitAddKeplerContribution

addKeplerContribution

fillHalfRow

fillHalfRow

fillHalfRow

fillHalfRow

fillHalfRow

fillHalfRow

setJacobianWrtParametersMean

getJacobianWrtParametersMean

setJacobianWrtParametersEccentric

getJacobianWrtParametersEccentric

setJacobianWrtParametersTrue

getJacobianWrtParametersTrue

getJacobian

getKeplerianTransitionMatrix

isPositiveDefinite