| Package | Description | 
|---|---|
| agi.foundation | 
 Contains commonly used types. 
 | 
| agi.foundation.coordinates | 
 Contains types for quantifying and converting between various coordinate representations. 
 | 
| agi.foundation.geometry | 
 Contains types for expressing the motion of fundamental geometric objects such as points, axes, and reference frames; 
 the manner in which they are related; and transformations between representations. 
 | 
| agi.foundation.geometry.shapes | 
 Contains types for representing geometric shapes such as curves, surfaces, and solids. 
 | 
| agi.foundation.infrastructure | 
 Contains types which support various aspects of the DME Component Libraries infrastructure. 
 | 
| agi.foundation.numericalmethods | 
 Contains general numerical algorithms. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
abstract Motion2<T,TDerivative> | 
MotionEvaluator2.evaluate(JulianDate date,
        int order)
Evaluates the function. 
 | 
abstract Motion2<TDependent,TDependentDerivative> | 
Function3.evaluate(TIndependent x,
        int order)
Evaluates the function. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
List<Motion2<T,TDerivative>> | 
ImmutableDateMotionCollection2.getMotions()
Gets the list of motion instances in this collection. 
 | 
List<Motion2<T,TDerivative>> | 
IDateMotionCollection2.getMotions()
Gets the list of motion instances in this collection. 
 | 
List<Motion2<T,TDerivative>> | 
DateMotionCollection2.getMotions()
Gets the list of motion instances in this collection. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
IDateMotionCollection2.add(JulianDate date,
   Motion2<T,TDerivative> motion)
Adds an item to the collection. 
 | 
void | 
DateMotionCollection2.add(JulianDate date,
   Motion2<T,TDerivative> motion)
Adds an item to the collection. 
 | 
static <T,TDerivative> | 
Motion2.equals(Motion2<T,TDerivative> left,
      Motion2<T,TDerivative> right)
Returns  
true if the two instances are exactly equal. | 
static <T,TDerivative> | 
Motion2.equals(Motion2<T,TDerivative> left,
      Motion2<T,TDerivative> right)
Returns  
true if the two instances are exactly equal. | 
boolean | 
Motion2.equalsType(Motion2<T,TDerivative> other)
Indicates whether another instance of this type is exactly equal to this instance. 
 | 
static <T,TDerivative> | 
Motion2.notEquals(Motion2<T,TDerivative> left,
         Motion2<T,TDerivative> right)
Returns  
true if the two instances are not exactly equal. | 
static <T,TDerivative> | 
Motion2.notEquals(Motion2<T,TDerivative> left,
         Motion2<T,TDerivative> right)
Returns  
true if the two instances are not exactly equal. | 
void | 
IDateMotionCollection2.setItem(int index,
       JulianDate date,
       Motion2<T,TDerivative> motion)
Sets an item at a particular index. 
 | 
void | 
DateMotionCollection2.setItem(int index,
       JulianDate date,
       Motion2<T,TDerivative> motion)
Sets an item at a particular index. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static Motion2<UnitQuaternion,Cartesian> | 
RotationalTransformation.compose(AngleAxisRotation first,
       Motion2<UnitQuaternion,Cartesian> second,
       int order)
Forms a new rotational transformation as the composition of two transformations. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
RotationalTransformation.compose(ElementaryRotation first,
       Motion2<UnitQuaternion,Cartesian> second,
       int order)
Forms a new rotational transformation as the composition of two transformations. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
RotationalTransformation.compose(Motion2<UnitQuaternion,Cartesian> first,
       AngleAxisRotation second,
       int order)
Forms a new rotational transformation as the composition of two transformations. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
RotationalTransformation.compose(Motion2<UnitQuaternion,Cartesian> first,
       ElementaryRotation second,
       int order)
Forms a new rotational transformation as the composition of two transformations. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
RotationalTransformation.compose(Motion2<UnitQuaternion,Cartesian> first,
       Motion2<UnitQuaternion,Cartesian> second,
       int order)
Forms a new rotational transformation as the composition of two transformations. 
 | 
static Motion2<UnitCartesian,Cartesian> | 
UnitCartesian.convertMotion(Motion1<Cartesian> motion,
             int order)
Converts the motion given in terms of a set of  
Cartesian coordinates to motion
    of the corresponding set of UnitCartesian coordinates. | 
static Motion2<UnitQuaternion,Cartesian> | 
AlignedConstrained.getMotion(Motion1<Cartesian> principal,
         Motion1<Cartesian> reference,
         int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
    will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
AlignedConstrained.getMotion(Motion2<UnitCartesian,Cartesian> principal,
         Motion2<UnitCartesian,Cartesian> reference,
         int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
    will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes. 
 | 
Motion2<UnitQuaternion,Cartesian> | 
KinematicTransformation.getRotationalMotion()
Gets the rotational portion of this transformation. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
RotationalTransformation.invert(Motion2<UnitQuaternion,Cartesian> motion,
      int order)
Forms the inverse rotational transformation. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
RotationVectorAngularVelocity.toMotionUnitQuaternionCartesian(Motion1<RotationVectorAngularVelocity> motionRotationVectorAngularVelocity,
                               int order)
 | 
static Motion2<UnitQuaternion,Cartesian> | 
RotationVectorAngularVelocity.toMotionUnitQuaternionCartesian(RotationVectorAngularVelocity rotationVectorAngularVelocity,
                               int order)
 | 
| Modifier and Type | Method and Description | 
|---|---|
static Motion2<UnitQuaternion,Cartesian> | 
RotationalTransformation.compose(AngleAxisRotation first,
       Motion2<UnitQuaternion,Cartesian> second,
       int order)
Forms a new rotational transformation as the composition of two transformations. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
RotationalTransformation.compose(ElementaryRotation first,
       Motion2<UnitQuaternion,Cartesian> second,
       int order)
Forms a new rotational transformation as the composition of two transformations. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
RotationalTransformation.compose(Motion2<UnitQuaternion,Cartesian> first,
       AngleAxisRotation second,
       int order)
Forms a new rotational transformation as the composition of two transformations. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
RotationalTransformation.compose(Motion2<UnitQuaternion,Cartesian> first,
       ElementaryRotation second,
       int order)
Forms a new rotational transformation as the composition of two transformations. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
RotationalTransformation.compose(Motion2<UnitQuaternion,Cartesian> first,
       Motion2<UnitQuaternion,Cartesian> second,
       int order)
Forms a new rotational transformation as the composition of two transformations. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
RotationalTransformation.compose(Motion2<UnitQuaternion,Cartesian> first,
       Motion2<UnitQuaternion,Cartesian> second,
       int order)
Forms a new rotational transformation as the composition of two transformations. 
 | 
static Motion1<Double> | 
UnitCartesian.dihedralAngle(Motion2<UnitCartesian,Cartesian> motFrom,
             Motion2<UnitCartesian,Cartesian> motTo,
             Motion2<UnitCartesian,Cartesian> motAxis,
             int order)
Calculates the scalar dihedral angle (and derivatives) of the three given values with
    Cartesian derivative information. 
 | 
static Motion1<Double> | 
UnitCartesian.dihedralAngle(Motion2<UnitCartesian,Cartesian> motFrom,
             Motion2<UnitCartesian,Cartesian> motTo,
             Motion2<UnitCartesian,Cartesian> motAxis,
             int order)
Calculates the scalar dihedral angle (and derivatives) of the three given values with
    Cartesian derivative information. 
 | 
static Motion1<Double> | 
UnitCartesian.dihedralAngle(Motion2<UnitCartesian,Cartesian> motFrom,
             Motion2<UnitCartesian,Cartesian> motTo,
             Motion2<UnitCartesian,Cartesian> motAxis,
             int order)
Calculates the scalar dihedral angle (and derivatives) of the three given values with
    Cartesian derivative information. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
AlignedConstrained.getMotion(Motion2<UnitCartesian,Cartesian> principal,
         Motion2<UnitCartesian,Cartesian> reference,
         int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
    will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
AlignedConstrained.getMotion(Motion2<UnitCartesian,Cartesian> principal,
         Motion2<UnitCartesian,Cartesian> reference,
         int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
    will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
RotationalTransformation.invert(Motion2<UnitQuaternion,Cartesian> motion,
      int order)
Forms the inverse rotational transformation. 
 | 
static Motion1<RotationVectorAngularVelocity> | 
RotationVectorAngularVelocity.toMotionRotationVectorAngularVelocity(Motion2<UnitQuaternion,Cartesian> motionUnitQuaternionCartesian,
                                     int order)
 | 
static RotationVectorAngularVelocity | 
RotationVectorAngularVelocity.toRotationVectorAngularVelocity(Motion2<UnitQuaternion,Cartesian> motionUnitQuaternionCartesian)
 | 
static Motion1<Cartesian> | 
RotationalTransformation.transform(Motion2<UnitQuaternion,Cartesian> rotationalTransformation,
         Motion1<Cartesian> motion,
         int order)
Transforms the vector observed in the A axes to the B axes. 
 | 
| Constructor and Description | 
|---|
KinematicTransformation(Cartesian translation,
                       Cartesian translationalVelocity,
                       Cartesian translationalAcceleration,
                       Motion2<UnitQuaternion,Cartesian> rotationalTransformation)
Initializes a new instance with the specified translational parameters and  
RotationalMotion (get). | 
KinematicTransformation(Motion1<Cartesian> translationalMotion,
                       Motion2<UnitQuaternion,Cartesian> rotationalMotion)
Initializes a new instance from the specified translational and rotational motion. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static Motion2<UnitQuaternion,Cartesian> | 
AxesEastNorthUp.computeFixedToEastNorthUpRotation(Ellipsoid shape,
                                 Motion1<Cartesian> fixedReferencePoint,
                                 int order)
Computes the rotation from the central body's fixed axes to a set of east-north-up axes based on
    a specified reference point. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
AxesNorthEastDown.computeFixedToNorthEastDownRotation(Ellipsoid shape,
                                   Motion1<Cartesian> fixedReferencePoint,
                                   int order)
Computes the rotation from the central body's fixed axes to a set of north-east-down axes based on
    a specified reference point. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
AxesAlignedConstrained.computeTransformation(Motion1<Cartesian> principal,
                     AxisIndicator principalAxis,
                     Motion1<Cartesian> reference,
                     AxisIndicator referenceAxis,
                     int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
    will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
AxesAlignedConstrained.computeTransformation(Motion1<Cartesian> principal,
                     Motion1<Cartesian> reference,
                     int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
    will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
AxesAlignedConstrained.computeTransformation(Motion2<UnitCartesian,Cartesian> principal,
                     AxisIndicator principalAxis,
                     Motion2<UnitCartesian,Cartesian> reference,
                     AxisIndicator referenceAxis,
                     int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
    will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
AxesAlignedConstrained.computeTransformation(Motion2<UnitCartesian,Cartesian> principal,
                     Motion2<UnitCartesian,Cartesian> reference,
                     int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
    will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes. 
 | 
Motion2<UnitCartesian,Cartesian> | 
NormalizedVectorEvaluator.evaluate(JulianDate date,
        int order)
Evaluates the function. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static Motion2<UnitQuaternion,Cartesian> | 
AxesAlignedConstrained.computeTransformation(Motion2<UnitCartesian,Cartesian> principal,
                     AxisIndicator principalAxis,
                     Motion2<UnitCartesian,Cartesian> reference,
                     AxisIndicator referenceAxis,
                     int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
    will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
AxesAlignedConstrained.computeTransformation(Motion2<UnitCartesian,Cartesian> principal,
                     AxisIndicator principalAxis,
                     Motion2<UnitCartesian,Cartesian> reference,
                     AxisIndicator referenceAxis,
                     int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
    will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
AxesAlignedConstrained.computeTransformation(Motion2<UnitCartesian,Cartesian> principal,
                     Motion2<UnitCartesian,Cartesian> reference,
                     int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
    will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes. 
 | 
static Motion2<UnitQuaternion,Cartesian> | 
AxesAlignedConstrained.computeTransformation(Motion2<UnitCartesian,Cartesian> principal,
                     Motion2<UnitCartesian,Cartesian> reference,
                     int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
    will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
Motion2<UnitCartesian,Cartesian> | 
Ellipsoid.surfaceNormalMotion(Motion1<Cartesian> surfaceMotion,
                   int order)
Converts the motion given in terms of a surface point to motion of the surface normal vector. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
Motion2<TResult,TResultDerivative> | 
ParameterizedMotionEvaluatorWithDerivativeType.evaluate(JulianDate date,
        int order)
Evaluates this parameterized evaluator. 
 | 
Motion2<TResult,TResultDerivative> | 
ParameterizedMotionEvaluatorWithDerivativeType1.evaluate(JulianDate date,
        int order,
        TParameter1 parameter1)
Evaluates this parameterized evaluator. 
 | 
Motion2<TResult,TResultDerivative> | 
ParameterizedMotionEvaluatorWithDerivativeType2.evaluate(JulianDate date,
        int order,
        TParameter1 parameter1,
        TParameter2 parameter2)
Evaluates this parameterized evaluator. 
 | 
Motion2<TResult,TResultDerivative> | 
ParameterizedMotionEvaluatorWithDerivativeType3.evaluate(JulianDate date,
        int order,
        TParameter1 parameter1,
        TParameter2 parameter2,
        TParameter3 parameter3)
Evaluates this parameterized evaluator. 
 | 
Motion2<TResult,TResultDerivative> | 
ParameterizedMotionEvaluatorWithDerivativeType4.evaluate(JulianDate date,
        int order,
        TParameter1 parameter1,
        TParameter2 parameter2,
        TParameter3 parameter3,
        TParameter4 parameter4)
Evaluates this parameterized evaluator. 
 | 
Motion2<TResult,TResultDerivative> | 
ParameterizedMotionEvaluatorWithDerivativeType5.evaluate(JulianDate date,
        int order,
        TParameter1 parameter1,
        TParameter2 parameter2,
        TParameter3 parameter3,
        TParameter4 parameter4,
        TParameter5 parameter5)
Evaluates this parameterized evaluator. 
 | 
Motion2<TResult,TResultDerivative> | 
ParameterizedMotionEvaluatorWithDerivativeType6.evaluate(JulianDate date,
        int order,
        TParameter1 parameter1,
        TParameter2 parameter2,
        TParameter3 parameter3,
        TParameter4 parameter4,
        TParameter5 parameter5,
        TParameter6 parameter6)
Evaluates this parameterized evaluator. 
 | 
Motion2<TResult,TResultDerivative> | 
ParameterizedMotionEvaluatorWithDerivativeType7.evaluate(JulianDate date,
        int order,
        TParameter1 parameter1,
        TParameter2 parameter2,
        TParameter3 parameter3,
        TParameter4 parameter4,
        TParameter5 parameter5,
        TParameter6 parameter6,
        TParameter7 parameter7)
Evaluates this parameterized evaluator. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static Matrix | 
Covariance6By6TwoBodyBlender.transformCovariance(Matrix originalCovariance,
                   Motion2<UnitQuaternion,Cartesian> axesTransformation)
Transforms a 6x6 covariance matrix into new axes. 
 |