Package gaia.cu9.ari.gaiaorbit.util.gaia.utils

Class Interpolator

java.lang.Object

gaia.cu9.ari.gaiaorbit.util.gaia.utils.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

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