JSMDUtils API

InterpAkima{T, N} <: AbstractInterpolationMethod

Type storing an Akima spline nodes and coefficient. T is the interpolation data type and N is the spline dimension (i.e., the number of interpolated functions).

Fields

• n – Number of node points.
• xn – Interpolated node points.
• yn – Node points function values
• c – Akima polynomial coefficients.

InterpAkima(x::AbstractVector, y::AbstractArray)

Construct an Akima spline interpolant from a set of data points x and their values y. Multi-dimensional splines can be constructed passing y as a subtype of AbstractMatrix such that each row contains a different set of values to be interpolated and the number of columns equals the number of data points.

References

• Akima, H. (1970), A New Method of Interpolation and Smooth Curve Fitting Based on Local Procedures, Journal of the ACM, DOI:

InterpCubicSplines(x::AbstractVector, y::AbstractArray, type::Symbol=:Natural)

Construct a cubic spline interpolant from a set of data points x and their values y. Multi-dimensional splines can be constructed by passing y as a subtype of AbstractMatrix, such that each row contains a different set of values to be interpolated and the number of columns equals the number of data points.

Different boundary conditions can be applied based on the specified type:

• :Natural: the second derivative of the first and the last polynomial are equal to zero at the boundary points.
• :NotAKnot: the third derivatives of the first and last two polynomials are equal in the points where they meet each other.
• :Periodic: the first and second derivatives at the initial and final points are equal.
• :Quadratic: the first and the last polynomial are quadratic.

InterpCubicSplines{T, N} <: AbstractInterpolationMethod

Type storing a cubic spline nodes and coefficients. T is the spline data type and N is the spline dimension (i.e., the number of interpolated functions).

Fields

• n – Number of node points.
• m – Size of the interpolated element.
• xn – Interpolated node points.
• yn – Node points function values.
• c – Spline polynomials coefficients.
• type – Boundary conditions type.

interpolate(ak::InterpAkima, x::Number, flat::Bool=true)

Interpolate the Akima spline ak at point x. If the spline has a single dimension (e.g., InterpAkima{T, 1}), a scalar value is returned. Otherwise, an SVector is computed.

If x is outside the boundary range of sp a flat extrapolation is used by default. If the flat argument is false, the first and last polynomials will be used to compute all the outside values.

interpolate(sp::InterpCubicSplines, x::Number, flat::Bool=true)

Interpolate the cubic spline sp at point x. If the spline has a single dimension (e.g., InterpCubicSpline{T, 1}), a scalar value is returned. Otherwise, an SVector is computed.

If x is outside the boundary range of sp a flat extrapolation is used by default. If the flat argument is false, the first and last polynomials will be used to compute all the outside values.

D²(f, x::Real)

Return d²f/dx² evaluated at x using ForwardDiff, assuming f is called as f(x).

This method assumes that isa(f(x), Union{Real, AbstractArray}).

D³(f, x::Real)

Return d³f/dx³ evaluated at x using ForwardDiff, assuming f is called as f(x).

This method assumes that isa(f(x), Union{Real, AbstractArray}).

D¹(f, x::Real)

Return df/dx evaluated at x using ForwardDiff, assuming f is called as f(x).

This method assumes that isa(f(x), Union{Real, AbstractArray}).

_3angles_to_δdcm(θ, rot_seq::Symbol)

Compute the time derivative of the DCM with all the angles stored in a single vector to optimise computations.

_3angles_to_δ²dcm(θ, rot_seq::Symbol)

Compute the 2nd time derivative of the DCM with all the angles stored in a single vector to optimise computations.

_3angles_to_δ³dcm(θ, rot_seq::Symbol)

Compute the 3rd order time derivative of the DCM with all the angles stored in a single vector to optimise computations.

angle_to_δdcm(θ[, ϕ[, γ]], rot_seq::Symbol = :ZYX)

Compute the derivative of the direction cosine matrix that perform a set of rotations (θ, ϕ, γ) about the coordinate axes in rot_seq. Each rotation input must be an indexable objected which includes the angle and its first time derivative.

The rotation sequence is defined by a Symbol specifing the rotation axes. The possible values depend on the number of rotations as follows:

• 1 rotation (θ₁): :X, :Y, or :Z.
• 2 rotations (θ₁, θ₂): :XY, :XZ, :YX, :YZ, :ZX, or :ZY.
• 3 rotations (θ₁, θ₂, θ₃): :XYX, XYZ, :XZX, :XZY, :YXY, :YXZ, :YZX, :YZY, :ZXY, :ZXZ, :ZYX, or :ZYZ

See also

See also angle_to_δ²dcm

angle_to_δ²dcm(θ[, ϕ[, γ]], rot_seq::Symbol = :ZYX)

Compute the second order time derivative of the direction cosine matrix that perform a set of rotations (θ, ϕ, γ) about the coordinate axes in rot_seq. Each rotation input must be an indexable objected which includes the angle and its first and second order time derivatives.

The rotation sequence is defined by a Symbol specifing the rotation axes. The possible values depend on the number of rotations as follows:

• 1 rotation (θ₁): :X, :Y, or :Z.
• 2 rotations (θ₁, θ₂): :XY, :XZ, :YX, :YZ, :ZX, or :ZY.
• 3 rotations (θ₁, θ₂, θ₃): :XYX, XYZ, :XZX, :XZY, :YXY, :YXZ, :YZX, :YZY, :ZXY, :ZXZ, :ZYX, or :ZYZ

See also

See also angle_to_δdcm

angle_to_δ³dcm(θ::Number[, ϕ::Number[, γ::Number]], rot_seq::Symbol = :Z)

Compute the second order time derivative of the direction cosine matrix that perform a set of rotations (θ, ϕ, γ) about the coordinate axes in rot_seq. Each rotation input must be an indexable objected which includes the angle and its time derivatives up to order 3 (jerk).

The rotation sequence is defined by a Symbol specifing the rotation axes. The possible values depend on the number of rotations as follows:

• 1 rotation (θ₁): :X, :Y, or :Z.
• 2 rotations (θ₁, θ₂): :XY, :XZ, :YX, :YZ, :ZX, or :ZY.
• 3 rotations (θ₁, θ₂, θ₃): :XYX, XYZ, :XZX, :XZY, :YXY, :YXZ, :YZX, :YZY, :ZXY, :ZXZ, :ZYX, or :ZYZ

See also

See also angle_to_δdcm

angleplane(v1::AbstractArray, n::AbstractArray)

Compute the angle between a vector v1 and (its projection on) a plane with normal n, in rad.

angleplaned(v1::AbstractArray, n::AbstractArray)

Compute the angle between a vector v1 and (its projection on) a plane with normal n, in deg.

anglevec(v1::AbstractArray, v2::AbstractArray)

Compute the angle between two vectors v1 and v2, in rad.

anglevecd(v1::AbstractArray, v2::AbstractArray)

Compute the angle between two vectors v1 and v2, in deg.

cross12(x::AbstractVector, y::AbstractVector)

Compute the cross product between x and y and its 1st, 2nd and 3rd order time derivatives.

cross3(x::AbstractVector, y::AbstractVector)

Compute the cross product between x and y, considering only their first 3 elements.

cross6(x::AbstractVector, y::AbstractVector)

Compute the cross product between x and y and its time derivative.

cross9(x::AbstractVector, y::AbstractVector)

Compute the cross product between x and y and its 1st and 2nd-order time derivatives.

projplane(v1::AbstractArray, n::AbstractArray)

Compute the orthogonal projection of a vector v1 on a plane with normal n.

projvec(v1::AbstractArray, v2::AbstractArray)

Compute the orthogonal projection of a vector v1 on a vector v2.

skew(a)

Create a skew matrix from the vector v.

unitcross(v1::AbstractArray, v2::AbstractArray)

Compute the normalized cross product of v1 and v2.

unitvec(v::AbstractVector)

Normalise the vector v.

δunitvec(v::AbstractVector)

Compute the time derivative of a unit vector v.

δ²unitvec(v::AbstractVector)

Compute the 2nd-order time derivative of a unit vector v.

δ³unitvec(v::AbstractVector)

Compute the 3rd-order time derivative of a unit vector v.

AutoHessianConfig

Wrapper object around a ForwardDiff.HessianConfig type.

AutoHessianConfig(x)

Generate a Autodiff.AutoHessianConfig instance based on the type and shape of the input vector x.

The returned AutoHessianConfig instance contains all the work buffers required by Autodiff.hessian! when the target function takes the form f(x). The chunk size is automatically set to 1 since it is part of the type. Having a larger chunk-size improves performance but would require a greater number of dispatches for the function wrappers.

See Also

See also Autodiff.hessian!.

JSMDDiffTag

Singleton to be used as a ForwardDiff tag for the JSMD ecosystem.

AutoGradientConfig(x)

Generate a ForwardDiff.GradientConfig instance based on the type and shape of the input x.

The returned GradientConfig instance contains all the work buffers required by Autodiff.gradient!. The chunk size is automatically set to 1 since it is part of the type. Having a larger chunk-size improves performance but would require a greater number of dispatches for the function wrappers.

See also

See also Autodiff.gradient!

AutoJacobianConfig(x)

Generate a ForwardDiff.JacobianConfig instance based on the type and shape of the input vector x.

The returned JacobianConfig instance contains all the work buffers required by Autodiff.jacobian! when the target function takes the form f(x). The chunk size is automatically set to 1 since it is part of the type. Having a larger chunk-size improves performance but would require a greater number of dispatches for the function wrappers.

AutoJacobianConfig(y, x)

Generate a ForwardDiff.JacobianConfig instance based on the type and shape of the input vector x and the output vector y.

The returned JacobianConfig instance contains all the work buffers required by Autodiff.jacobian! when the target function takes the in-place form f!(y, x).

See Also

See also Autodiff.jacobian!.

derivative(f, x::Number)

Return df/dx evaluated at x, assuming f is called as f(x).

See also

See also Autodiff.gradient! and Autodiff.hessian!

gentag(x)

Generate a dual tag for the element type of x.

gradient!(res, f, x)
gradient!(res, f, x, cfg::GradientConfig)

Compute ∇f evaluated at x and store the output in res, assuming f is called as f(x). To avoid runtime allocations, a GradientConfig instance must be provided.

See Also

See also Autodiff.AutoGradientConfig

hessian!(res, f, x)
hessian!(res, f, x, ahc::AutoHessianConfig)

Compute H(f) (i.e., J(∇(f))) evaluated at x and store the output in res, assuming f is called as f(x). To avoid runtime allocations, an Autodiff.AutoHessianConfig instance must be provided.

See Also

See also Autodiff.AutoHessianConfig.

jacobian!(res, f, x)
jacobian!(res, f, x, cfg::JacobianConfig)

Compute J(f) evaluated at the input vector x and store the result in res, assuming f is called as f(x). To avoid runtime allocations, a JacobianConfig instance must be provided.

jacobian!(res, f!, y, x) jacobian!(res, f!, y, x, cfg::JacobianConfig)

Compute J(f) evaluated at the input vector x and store the result in res, assuming f is called as f!(y, x), where the result is stored in y. To avoid runtime allocations, a JacobianConfig instance must be provided.

See Also

See also Autodiff.AutoJacobianConfig

JSMDUtils.FileUtils.JSON <: JSMDInterfaces.FilesIO.AbstractFile

A type representing JSMDUtils.FileUtils.JSON files.

JSMDUtils.FileUtils.TXT <: JSMDInterfaces.FilesIO.AbstractFile

A type representing JSMDUtils.FileUtils.TXT files.

JSMDUtils.FileUtils.YAML <: JSMDInterfaces.FilesIO.AbstractFile

A type representing JSMDUtils.FileUtils.YAML files.

load(file::JSON{1})

Open a JSON file and parse its data in a dictionary.

load(file::TXT{1})

Open a TEXT file and parse its data in a list of strings.

load(file::YAML{1})

Open a YAML file and parse its data in a dictionary.

EmptyEphemerisProvider <: AbstractEphemerisProvider

Empty provider to initialise the frame system without loading ephemeris files.

format_camelcase(str::AbstractString)

Format str in CamelCase, such that the first letter of each word in the sentence is capitalized and spaces are removed.

format_snakecase(str::AbstractString)

Format str in SnakeCase, such that all the letters are in lower case and spaces are replaced with underscores.