Class Interpolator


  • public class Interpolator
    extends java.lang.Object
    • Nested Class Summary

      Nested Classes 
      Modifier and Type Class Description
      static class  Interpolator.Kind
      Kind of interpolation: for derivative, value or integral
    • Field Summary

      Fields 
      Modifier and Type Field Description
      protected static double dtMin  
    • Constructor Summary

      Constructors 
      Constructor Description
      Interpolator()  
    • Method Summary

      All Methods Static Methods Concrete Methods Deprecated Methods 
      Modifier and Type Method Description
      static int findLeftIndex​(long[] xa, int xaLength, long x)
      Deprecated.
      Mantis 14225, deprecated August 2, 2012.
      static int getLeft​(double ta, double[] t, int indx)
      Find left such that t[left] <= ta < t[left+1]
      static int getLeftVar​(double ta, double[] t, int indx)
      Find left such that t[left] <= ta < t[left+1] (but one less if ta == t[left+1])
      static double[] hermite3​(double x, double x0, double y0, double yp0, double x1, double y1, double yp1)
      Static method for cubic Hermite interpolation between two points, given their values and derivatives.
      protected static double[] interPolDer​(double x)
      For normalized argument x (between 0 and 1), calculate the derivatives ap0(x), ap1(x), bp0(x), bp1(x) of the four interpolating polynomials
      protected static double[] interPolInt​(double x)
      For normalized argument x (between 0 and 1), calculate the integrals A0(x), A1(x), B0(x), B1(x) of the interpolating polynomials A0(x) = int_0^x a0(y)*dy (etc)
      protected static double[] interPolVal​(double x)
      For normalized argument x (between 0 and 1), calculate the four interpolating polynomials a0(x), a1(x), b0(x), b1(x) [DRO-012, Eq.
      static double[] linear​(double x, double x0, double y0, double x1, double y1)  
      static Quaterniond qEval​(double tx, double[] t, Quaterniond[] q, Quaterniond[] qDot, int left, Interpolator.Kind kind)
      Evaluates the quaternion derivative, value or integral at point tx, using Hermite interpolation in t[], q[], qDot[].
      static Quaterniond[] qHermiteAverage​(double ta, double tb, double[] t, int indx, Quaterniond[] q, Quaterniond[] qDot)
      Static method for computing the average attitude quaternion over a finite time interval ta <= t <= tb, using cubic Hermite interpolation, as well as the average time derivative It is assumed that ta <= tb.
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • dtMin

        protected static double dtMin
    • Constructor Detail

      • Interpolator

        public Interpolator()
    • Method Detail

      • hermite3

        public static double[] hermite3​(double x,
                                        double x0,
                                        double y0,
                                        double yp0,
                                        double x1,
                                        double y1,
                                        double yp1)
        Static method for cubic Hermite interpolation between two points, given their values and derivatives.
        Parameters:
        x - desired abscissa (normally between x0 and x1)
        x0 - abscissa of first point
        y0 - function value at x0
        yp0 - first derivative at x0
        x1 - abscissa of second point
        y1 - function value at x1
        yp1 - derivative at x1
        Returns:
        array with interpolated function value at x and its derivative
      • linear

        public static double[] linear​(double x,
                                      double x0,
                                      double y0,
                                      double x1,
                                      double y1)
      • qHermiteAverage

        public static Quaterniond[] qHermiteAverage​(double ta,
                                                    double tb,
                                                    double[] t,
                                                    int indx,
                                                    Quaterniond[] q,
                                                    Quaterniond[] qDot)
        Static method for computing the average attitude quaternion over a finite time interval ta <= t <= tb, using cubic Hermite interpolation, as well as the average time derivative It is assumed that ta <= tb. If tb-ta is less than dtMin then no average is computed but the instantaneous (interpolated) values at the instant (ta+tb)/2 are returned instead. The times ta, tb, t[] are in [days] from some arbitrary but common origin. Time derivatives are in [1/day]. The lengths of the array arguments must be: t.length >= 2, q.length >= t.length, qDot-length >= t.length. No check is made of these conditions. The argument indx is such that t[indx] is not far from ta and tb. It must be in the range 0 <= indx <= t.length-2
        Parameters:
        ta - start time of the averaging interval
        tb - end time of the averaging interval
        t - array array of increasing times encompassing the averaging interval (i.e., t[0] <= ta and tb <= t[t.length-1])
        indx - an index in the array t[] that is a suitable starting point for locating ta and tb in the array
        q - array of attitude quaternions at times t[]
        qDot - array of attitude quaternion rates [1/timeUnit] at times t[]
        Returns:
        array containing the average attitude quaternion as the first element and the average attitude quaternion rate [1/timeUnit] as the second element
      • qEval

        public static Quaterniond qEval​(double tx,
                                        double[] t,
                                        Quaterniond[] q,
                                        Quaterniond[] qDot,
                                        int left,
                                        Interpolator.Kind kind)
        Evaluates the quaternion derivative, value or integral at point tx, using Hermite interpolation in t[], q[], qDot[]. left is such that t[left] <= tx < t[left+1]. Kind = DER returns the derivative at tx, VAL returns the value at tx, and INT returns the integral from t[left] to tx.
        Parameters:
        tx - time at which the derivative, value or integral is evaluated
        t - array of times (length >= 2)
        q - array of quaternions
        qDot - array of quaternion derivatives
        left - index in t, q and qDot susch that t[left] <= tx < t[left+1]
        kind - which kind of result is returned (derivative, value or integral)
        Returns:
        The quaternion
      • getLeft

        public static int getLeft​(double ta,
                                  double[] t,
                                  int indx)
        Find left such that t[left] <= ta < t[left+1]
        Parameters:
        ta -
        t -
        indx - starting index
        Returns:
        The left index
      • getLeftVar

        public static int getLeftVar​(double ta,
                                     double[] t,
                                     int indx)
        Find left such that t[left] <= ta < t[left+1] (but one less if ta == t[left+1])
        Parameters:
        ta -
        t -
        indx - starting index
        Returns:
        The left index
      • interPolVal

        protected static double[] interPolVal​(double x)
        For normalized argument x (between 0 and 1), calculate the four interpolating polynomials a0(x), a1(x), b0(x), b1(x) [DRO-012, Eq. (8)]
        Parameters:
        x -
        Returns:
        double array containing a0, a1, b0, b1 at x
      • interPolDer

        protected static double[] interPolDer​(double x)
        For normalized argument x (between 0 and 1), calculate the derivatives ap0(x), ap1(x), bp0(x), bp1(x) of the four interpolating polynomials
        Parameters:
        x - The value
        Returns:
        double array containing ap0, ap1, bp0, bp1 at x
      • interPolInt

        protected static double[] interPolInt​(double x)
        For normalized argument x (between 0 and 1), calculate the integrals A0(x), A1(x), B0(x), B1(x) of the interpolating polynomials A0(x) = int_0^x a0(y)*dy (etc)
        Parameters:
        x - The value
        Returns:
        double array containing A0, A1, B0, B1 at x
      • findLeftIndex

        @Deprecated
        public static int findLeftIndex​(long[] xa,
                                        int xaLength,
                                        long x)
        Deprecated.
        Mantis 14225, deprecated August 2, 2012. Use AttitudeUtils.findLeftIndex(long, long[], int). Remove by GT 18.0.
        In the non-decreasing sequence xa[0:n-1], finds the left index such that xa[left] <= x < xa[left+1] If x < xa[0] the method returns -1 if x >= xa[n-1], the last index to the array (n-1) is returned Uses a straight bisection method to locate the left index.
        Parameters:
        xa - - array of non-decreasing values
        xaLength - - ???
        x - - value to locate
        Returns:
        left index