Public API

This page lists exported symbols of CTLie.

---

From CTLie

CTLie [Module]

CTLie Module

CTLie

Differential geometry operations on vector fields and Hamiltonians: Lie derivatives, Lie brackets, Poisson brackets, and partial time derivatives.

CTLie is a foundational package of the control-toolbox ecosystem. It provides:

• ad(X, Y) — Lie derivative and Lie bracket;

• Lift(f) — lift a function or vector field to a Hamiltonian;

• Poisson(H, G) — Poisson bracket;

• ∂ₜ(X) — partial time derivative;

• @Lie — macro for typed, intrinsic bracket/Poisson notation.

All operations support automatic differentiation via a global backend (dg_ad_backend/dg_ad_backend!). The actual differentiation is performed by the CTBaseDifferentiationInterface extension, which activates when DifferentiationInterface (and a concrete AD package such as ForwardDiff) is loaded.

@Lie [Macro]

CTLie.@Lie Macro

Macro for Lie brackets and Poisson brackets with compile-time typed dispatch.

Transforms bracket expressions into calls to CTLie.ad (Lie brackets) or CTLie.Poisson (Poisson brackets) with compile-time type dispatch based on keyword arguments.

Syntax

• Lie brackets: [X, Y] — computes the Lie bracket or Lie derivative

• Poisson brackets: {H, G} — computes the Poisson bracket

• Nested brackets: [[X, Y], Z] or { {H, G}, K } — supported

Arguments

• expr::Expr: Bracket expression using [...] for Lie or {...} for Poisson.

• args...: Optional keyword arguments:

  • is_autonomous::Bool: Override time dependence (default: from global config).

  • is_variable::Bool: Override variable dependence (default: from global config).

  • ad_backend::Expr: AD backend expression (default: global backend).

Returns

• Expanded code calling CTLie._lie_mac or CTLie._poisson_mac with typed dispatch.

Throws

• Exceptions.IncorrectArgument: If unknown keyword argument is provided.

• Exceptions.IncorrectArgument: If invalid argument format is used.

• Exceptions.IncorrectArgument: If Lie and Poisson brackets are mixed in the same expression.

• Exceptions.IncorrectArgument: If is_autonomous conflicts with operand trait.

• Exceptions.IncorrectArgument: If is_variable conflicts with operand trait.

Example

using CTLie

# Lie bracket with functions
X = x -> [x[2], -x[1]]
Y = x -> [-x[2], x[1]]
Z = @Lie [X, Y]

# Poisson bracket with functions
H = (x, p) -> p[1]^2 / 2 + x[1]^2
G = (x, p) -> x[1] * p[1]
B = @Lie {H, G}

# With explicit type override
Z = @Lie [X, Y] is_autonomous=true is_variable=false

Notes

• The macro uses compile-time typed dispatch via CTLie._lie_mac and CTLie._poisson_mac.

• Operands can be plain functions or typed objects (CTBase.Data.VectorField, CTBase.Data.Hamiltonian).

• Mixed types (function + typed object) are automatically normalized.

See also: CTLie.ad, CTLie.Poisson, CTLie.Lift

Lift [Function]

CTLie.Lift Function

Lift(
    f::Function;
    is_autonomous,
    is_variable
) -> LiftedHamiltonianFunction

Lift a function to a Hamiltonian via the canonical symplectic structure.

Returns a LiftedHamiltonianFunction representing H(x, p) = p' * f(x). This is an algebraic operation that does not use automatic differentiation.

Arguments

• f::Function: Vector field function (returns a vector).

• is_autonomous::Bool: Whether the function is time-independent (default: from global config).

• is_variable::Bool: Whether the function depends on a variable parameter (default: from global config).

Returns

• A LiftedHamiltonianFunction with signature depending on TD/VD:

  • Autonomous/Fixed: (x, p) -> p' * f(x)

  • NonAutonomous/Fixed: (t, x, p) -> p' * f(t, x)

  • Autonomous/NonFixed: (x, p, v) -> p' * f(x, v)

  • NonAutonomous/NonFixed: (t, x, p, v) -> p' * f(t, x, v)

Example

using CTLie

f = x -> [x[2], -x[1]]
H = Lift(f)

H([1.0, 2.0], [0.5, 1.0])  # Returns -1.5

See also: CTLie.Lift, CTLie.Poisson

Lift(
    f::Function,
    _::Type{TD},
    _::Type{VD}
) -> LiftedHamiltonianFunction{<:Function}

Lift a function to a Hamiltonian with explicit type parameters.

Returns a LiftedHamiltonianFunction representing H(x, p) = p' * f(x). This typed entry point is used by the @Lie macro for compile-time dispatch.

Arguments

• f::Function: Vector field function (returns a vector).

• ::Type{TD}: Time dependence type (Autonomous or NonAutonomous).

• ::Type{VD}: Variable dependence type (CTBase.Traits.Fixed or CTBase.Traits.NonFixed).

Returns

• A LiftedHamiltonianFunction{typeof(f), TD, VD}.

Example

using CTLie
using CTBase.Traits

f = x -> [x[2], -x[1]]
H = Lift(f, Traits.Autonomous, Traits.Fixed)

H([1.0, 2.0], [0.5, 1.0])  # Returns -1.5

See also: CTLie.Lift(f::Function), CTLie.@Lie

Lift(
    X::CTBase.Data.AbstractVectorField{TD, VD}
) -> CTBase.Data.Hamiltonian{LiftedHamiltonianFunction{F, TD, VD}, TD1, VD1} where {F, TD, VD, TD1<:CTBase.Traits.TimeDependence, VD1<:CTBase.Traits.VariableDependence}

Lift a vector field to a Hamiltonian via the canonical symplectic structure.

Returns a Data.Hamiltonian representing H(x, p) = p' * X(x). This overload allows lifting typed vector fields directly to Hamiltonians.

Arguments

• X::Data.AbstractVectorField{TD, VD}: Vector field to lift.

Returns

• Data.Hamiltonian{TD, VD}: The lifted Hamiltonian.

Throws

• Exceptions.NotImplemented: If the vector field is an AbstractHamiltonianVectorField.

Example

using CTLie
using CTBase.Data
using CTBase.Traits

X = VectorField(x -> [x[2], -x[1]], Traits.Autonomous, Traits.Fixed, Traits.OutOfPlace)
H = Lift(X)

H([1.0, 2.0], [0.5, 1.0])  # Returns -1.5

See also: CTLie.Lift(f::Function), CTLie.Poisson

LiftedHamiltonianFunction [Struct]

CTLie.LiftedHamiltonianFunction Type

struct LiftedHamiltonianFunction{F, TD, VD} <: Function

Callable struct representing the lifted Hamiltonian H(…) = p' * f(…).

Replaces the four argument-reordering closures previously returned by _Lift. TD and VD are compile-time trait parameters, so dispatch to the correct call method is resolved at compile time — no allocation per call.

Inherits from Function so that it satisfies the F<:Function constraint of Data.Hamiltonian and passes existing isa Function checks.

Poisson [Function]

CTLie.Poisson Function

Poisson(
    H::Function,
    G::Function;
    ad_backend,
    is_autonomous,
    is_variable
) -> CTLie.PoissonBracket

Compute the Poisson bracket of two Hamiltonian functions using keyword arguments.

Returns a function representing the Poisson bracket {H, G} = ∇ₚH' * ∇ₓG - ∇ₓH' * ∇ₚG. The time dependence and variable dependence are inferred from the is_autonomous and is_variable keyword arguments.

Arguments

• H::Function: First Hamiltonian function (returns a scalar).

• G::Function: Second Hamiltonian function (returns a scalar).

• ad_backend::Union{ADTypes.AbstractADType, CTBase.Core.NotProvidedType}: AD backend to use (default: global backend).

• is_autonomous::Bool: Whether the functions are time-independent (default: from global config).

• is_variable::Bool: Whether the functions depend on a variable parameter (default: from global config).

Returns

• A function with signature depending on TD/VD:

  • Autonomous/Fixed: (x, p) -> result

  • NonAutonomous/Fixed: (t, x, p) -> result

  • Autonomous/NonFixed: (x, p, v) -> result

  • NonAutonomous/NonFixed: (t, x, p, v) -> result

Example

using CTLie

H = (x, p) -> p[1]^2 / 2 + x[1]^2
G = (x, p) -> x[1] * p[1]

B = Poisson(H, G)
B([1.0, 2.0], [0.5, 1.0])  # Returns 1.0

See also: CTLie.Poisson, CTLie.ad, CTLie.Lift

Poisson(
    H::Function,
    G::Function,
    ::Type{TD},
    ::Type{VD};
    ad_backend
) -> CTLie.PoissonBracket{<:Function, <:Function}

Compute the Poisson bracket of two Hamiltonian functions with explicit type parameters.

Returns a function representing the Poisson bracket {H, G} = ∇ₚH' * ∇ₓG - ∇ₓH' * ∇ₚG. This typed entry point is used by the @Lie macro for compile-time dispatch.

Arguments

• H::Function: First Hamiltonian function (returns a scalar).

• G::Function: Second Hamiltonian function (returns a scalar).

• ::Type{TD}: Time dependence type (Autonomous or NonAutonomous).

• ::Type{VD}: Variable dependence type (CTBase.Traits.Fixed or CTBase.Traits.NonFixed).

• ad_backend::Union{ADTypes.AbstractADType, CTBase.Core.NotProvidedType}: AD backend to use (default: global backend).

Returns

• A function with signature depending on TD/VD.

Example

using CTLie
using CTBase.Traits

H = (x, p) -> p[1]^2 / 2 + x[1]^2
G = (x, p) -> x[1] * p[1]

B = Poisson(H, G, Traits.Autonomous, Traits.Fixed)
B([1.0, 2.0], [0.5, 1.0])  # Returns 1.0

See also: CTLie.Poisson(H::Function, G::Function), CTLie.@Lie, CTLie.ad

Poisson(
    H::CTBase.Data.AbstractHamiltonian{TD, VD},
    G::CTBase.Data.AbstractHamiltonian{TD, VD};
    ad_backend
) -> CTBase.Data.Hamiltonian{CTLie.PoissonBracket{FH, FG, B, TD, VD}, TD1, VD1} where {FH, FG, B<:CTBase.Differentiation.AbstractADBackend, TD, VD, TD1<:CTBase.Traits.TimeDependence, VD1<:CTBase.Traits.VariableDependence}

Compute the Poisson bracket of two typed Hamiltonians.

Returns a new Data.Hamiltonian representing the Poisson bracket {H, G}. Both Hamiltonians must share the same time dependence and variable dependence.

Arguments

• H::Data.AbstractHamiltonian{TD, VD}: First Hamiltonian.

• G::Data.AbstractHamiltonian{TD, VD}: Second Hamiltonian.

• ad_backend::Union{ADTypes.AbstractADType, CTBase.Core.NotProvidedType}: AD backend to use (default: global backend).

Returns

• Data.Hamiltonian{TD, VD}: The Poisson bracket as a Hamiltonian.

Example

using CTLie
using CTBase.Data
using CTBase.Traits

H = Hamiltonian((x, p) -> p[1]^2 / 2 + x[1]^2, Traits.Autonomous, Traits.Fixed)
G = Hamiltonian((x, p) -> x[1] * p[1], Traits.Autonomous, Traits.Fixed)

B = Poisson(H, G)
B([1.0, 2.0], [0.5, 1.0])  # Returns 1.0

See also: CTLie.Poisson(H::Function, G::Function), CTLie.ad

Poisson(
    H::CTBase.Data.AbstractHamiltonian{TD1, VD1},
    G::CTBase.Data.AbstractHamiltonian{TD2, VD2};
    ad_backend
) -> CTBase.Data.Hamiltonian{CTLie.PoissonBracket{FH, FG, B, TD, VD}, TD1, VD1} where {FH, FG, B<:CTBase.Differentiation.AbstractADBackend, TD, VD, TD1<:CTBase.Traits.TimeDependence, VD1<:CTBase.Traits.VariableDependence}

Error method for mismatched time/variable dependence in Hamiltonian Poisson bracket.

This method is called when two Hamiltonians have different time dependence or variable dependence types, which is not allowed for the Poisson bracket operation.

Arguments

• H::Data.AbstractHamiltonian{TD1, VD1}: First Hamiltonian.

• G::Data.AbstractHamiltonian{TD2, VD2}: Second Hamiltonian with mismatched TD/VD.

• ad_backend::Union{ADTypes.AbstractADType, CTBase.Core.NotProvidedType}: AD backend (unused).

Throws

• Exceptions.PreconditionError: Always thrown with details about the TD/VD mismatch.

Notes

This is a fallback error method that provides a clear error message when the types do not match. Use the matching TD/VD version for valid operations.

See also: CTLie.Poisson

Poisson(
    ::CTBase.Data.AbstractVectorField,
    ::CTBase.Data.AbstractVectorField;
    ad_backend
)

Disambiguator error method for two VectorField operands in Poisson bracket.

This overload resolves the ambiguity between the one-sided error methods when both arguments are AbstractVectorField. It is always an error; use ad(X, Y) instead.

Throws

• Exceptions.IncorrectArgument: Always thrown with suggestion to use Lie bracket.

See also: CTLie.ad

Poisson(::CTBase.Data.AbstractVectorField, ; ad_backend)

Error method for VectorField as first operand in Poisson bracket.

Throws

• Exceptions.IncorrectArgument: Always thrown with suggestion to use Lie bracket.

Poisson(, ::CTBase.Data.AbstractVectorField; ad_backend)

Error method for VectorField as second operand in Poisson bracket.

This is a symmetric companion to Poisson(::AbstractVectorField, ::Any), handling the case where the second argument is a VectorField and the first is some other type.

Arguments

• ::Any: First operand.

• ::Data.AbstractVectorField: VectorField second operand (not allowed in Poisson bracket).

• ad_backend::Union{ADTypes.AbstractADType, CTBase.Core.NotProvidedType}: AD backend (unused).

Throws

• Exceptions.IncorrectArgument: Always thrown with suggestion to use Lie bracket.

See also: CTLie.ad

ad [Function]

CTLie.ad Function

ad(
    X::Function,
    foo::Function;
    ad_backend,
    is_autonomous,
    is_variable
) -> CTLie.Ad

Compute the Lie derivative or Lie bracket of two functions using keyword arguments.

• If foo returns a scalar, returns the Lie derivative (directional derivative): ∇foo(x)'*X(x)

• If foo returns a vector, returns the Lie bracket: J_foo(x)*X(x) - J_X(x)*foo(x)

The time dependence and variable dependence are inferred from the is_autonomous and is_variable keyword arguments.

Arguments

• X::Function: Vector field function (returns a vector).

• foo::Function: Scalar or vector field function.

• ad_backend::Union{ADTypes.AbstractADType, CTBase.Core.NotProvidedType}: AD backend to use (default: global backend).

• is_autonomous::Bool: Whether the functions are time-independent (default: from global config).

• is_variable::Bool: Whether the functions depend on a variable parameter (default: from global config).

Returns

• A function with signature depending on TD/VD:

  • Autonomous/Fixed: (x) -> result

  • NonAutonomous/Fixed: (t, x) -> result

  • Autonomous/NonFixed: (x, v) -> result

  • NonAutonomous/NonFixed: (t, x, v) -> result

Example

using CTLie

X = x -> [x[2], -x[1]]
f = x -> x[1]^2 + x[2]^2

# Lie derivative (scalar output)
L = ad(X, f)
L([1.0, 2.0])  # Returns 0.0

See also: CTLie.ad, CTLie.Poisson, CTLie.Lift

ad(
    X::Function,
    foo::Function,
    ::Type{TD<:CTBase.Traits.TimeDependence},
    ::Type{VD<:CTBase.Traits.VariableDependence};
    ad_backend
) -> CTLie.Ad{var"#s179", var"#s1791", var"#s1792", TD, VD} where {var"#s179"<:Function, var"#s1791"<:Function, var"#s1792"<:CTBase.Differentiation.AbstractADBackend, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence}

Compute the Lie derivative or Lie bracket of two functions with explicit type parameters.

• If foo returns a scalar, returns the Lie derivative (directional derivative): ∇foo(x)'*X(x)

• If foo returns a vector, returns the Lie bracket: J_foo(x)*X(x) - J_X(x)*foo(x)

This typed entry point is used by the @Lie macro for compile-time dispatch.

Arguments

• X::Function: Vector field function (returns a vector).

• foo::Function: Scalar or vector field function.

• ::Type{TD}: Time dependence type (Autonomous or NonAutonomous).

• ::Type{VD}: Variable dependence type (CTBase.Traits.Fixed or CTBase.Traits.NonFixed).

• ad_backend::Union{ADTypes.AbstractADType, CTBase.Core.NotProvidedType}: AD backend to use (default: global backend).

Returns

• A function with signature depending on TD/VD:

  • Autonomous/Fixed: (x) -> result

  • NonAutonomous/Fixed: (t, x) -> result

  • Autonomous/NonFixed: (x, v) -> result

  • NonAutonomous/NonFixed: (t, x, v) -> result

Example

using CTLie
using CTBase.Traits

X = x -> [x[2], -x[1]]
f = x -> x[1]^2 + x[2]^2

# Lie derivative with explicit types
L = ad(X, f, Traits.Autonomous, Traits.Fixed)
L([1.0, 2.0])  # Returns 0.0

See also: CTLie.ad(X::Function, foo::Function), CTLie.@Lie, CTLie.Poisson

ad(
    X::CTBase.Data.AbstractVectorField{TD, VD, MDX},
    Y::CTBase.Data.AbstractVectorField{TD, VD, MDY};
    ad_backend
) -> CTBase.Data.VectorField{CTLie.Ad{TX, TF, B, TD, VD}, TD1, VD1, CTBase.Traits.OutOfPlace} where {TX, TF, B<:CTBase.Differentiation.AbstractADBackend, TD, VD, TD1<:CTBase.Traits.TimeDependence, VD1<:CTBase.Traits.VariableDependence}

Compute the Lie bracket of two vector fields.

Returns a new Data.VectorField representing the Lie bracket [X, Y] = J_Y(x)*X(x) - J_X(x)*Y(x). Both vector fields must share the same time dependence and variable dependence.

Arguments

• X::Data.AbstractVectorField{TD, VD, MDX}: First vector field.

• Y::Data.AbstractVectorField{TD, VD, MDY}: Second vector field.

• ad_backend::Union{ADTypes.AbstractADType, CTBase.Core.NotProvidedType}: AD backend to use (default: global backend).

Returns

• Data.VectorField{TD, VD, Traits.OutOfPlace}: The Lie bracket as a vector field.

Throws

• Exceptions.NotImplemented: If either vector field is an AbstractHamiltonianVectorField.

• Exceptions.NotImplemented: If either vector field has InPlace mutability.

Example

using CTLie
using CTBase.Data
using CTBase.Traits

X = VectorField(x -> [x[2], -x[1]], Traits.Autonomous, Traits.Fixed, Traits.OutOfPlace)
Y = VectorField(x -> [-x[2], x[1]], Traits.Autonomous, Traits.Fixed, Traits.OutOfPlace)

Z = ad(X, Y)
Z([1.0, 2.0])  # Returns [0.0, 0.0]

See also: CTLie.ad

ad(
    X::CTBase.Data.AbstractVectorField{TD, VD, MDX},
    f::Function;
    ad_backend
) -> CTLie.Ad{_A, <:Function} where _A

Compute the Lie derivative of a scalar function along a vector field.

Returns a plain function representing the directional derivative ∇f(x)'*X(x).

Arguments

• X::Data.AbstractVectorField{TD, VD, MDX}: Vector field.

• f::Function: Scalar function.

• ad_backend::Union{ADTypes.AbstractADType, CTBase.Core.NotProvidedType}: AD backend to use (default: global backend).

Returns

• A function with signature depending on TD/VD that returns a scalar.

Throws

• Exceptions.NotImplemented: If the vector field is an AbstractHamiltonianVectorField.

• Exceptions.NotImplemented: If the vector field has InPlace mutability.

Example

using CTLie
using CTBase.Data
using CTBase.Traits

X = VectorField(x -> [x[2], -x[1]], Traits.Autonomous, Traits.Fixed, Traits.OutOfPlace)
f = x -> x[1]^2 + x[2]^2

L = ad(X, f)
L([1.0, 2.0])  # Returns 0.0

See also: CTLie.ad

ad(
    X::CTBase.Data.AbstractVectorField{TD1, VD1, MDX},
    Y::CTBase.Data.AbstractVectorField{TD2, VD2, MDY};
    ad_backend
) -> CTBase.Data.VectorField{CTLie.Ad{TX, TF, B, TD, VD}, TD1, VD1, CTBase.Traits.OutOfPlace} where {TX, TF, B<:CTBase.Differentiation.AbstractADBackend, TD, VD, TD1<:CTBase.Traits.TimeDependence, VD1<:CTBase.Traits.VariableDependence}

Error method for mismatched time/variable dependence in vector field Lie bracket.

This method is called when two vector fields have different time dependence or variable dependence types, which is not allowed for the Lie bracket operation.

Arguments

• X::Data.AbstractVectorField{TD1, VD1, MDX}: First vector field.

• Y::Data.AbstractVectorField{TD2, VD2, MDY}: Second vector field with mismatched TD/VD.

• ad_backend::Union{ADTypes.AbstractADType, CTBase.Core.NotProvidedType}: AD backend (unused).

Throws

• Exceptions.PreconditionError: Always thrown with details about the TD/VD mismatch.

Notes

This is a fallback error method that provides a clear error message when the types do not match. Use the matching TD/VD version for valid operations.

See also: CTLie.ad

ad(
    ::CTBase.Data.AbstractHamiltonian,
    ::CTBase.Data.AbstractHamiltonian;
    ad_backend
)

Disambiguator error method for two Hamiltonian operands in Lie bracket.

This overload resolves the ambiguity between the one-sided error methods when both arguments are AbstractHamiltonian. It is always an error; use Poisson(H, G) instead.

Throws

• Exceptions.IncorrectArgument: Always thrown with suggestion to use Poisson bracket.

See also: CTLie.Poisson

ad(::CTBase.Data.AbstractHamiltonian, ; ad_backend)

Error method for Hamiltonian as first operand in Lie bracket.

Throws

• Exceptions.IncorrectArgument: Always thrown with suggestion to use Poisson bracket.

ad(, ::CTBase.Data.AbstractHamiltonian; ad_backend)

Error method for Hamiltonian as second operand in Lie bracket.

This is a symmetric companion to ad(::AbstractHamiltonian, ::Any), handling the case where the second argument is a Hamiltonian and the first is some other type.

Arguments

• ::Any: First operand.

• ::Data.AbstractHamiltonian: Hamiltonian second operand (not allowed in Lie bracket).

• ad_backend::Union{ADTypes.AbstractADType, CTBase.Core.NotProvidedType}: AD backend (unused).

Throws

• Exceptions.IncorrectArgument: Always thrown with suggestion to use Poisson bracket.

See also: CTLie.Poisson

dg_ad_backend [Function]

CTLie.dg_ad_backend Function

dg_ad_backend() -> CTBase.Differentiation.AbstractADBackend

Return the current global automatic differentiation backend used by CTLie operations.

The backend is used by CTLie.ad, CTLie.Poisson, and CTLie.∂ₜ when no explicit ad_backend keyword argument is provided.

Returns

• Differentiation.AbstractADBackend: The current AD backend.

Example

using CTLie

backend = dg_ad_backend()

See also: CTLie.dg_ad_backend!, CTLie.ad, CTLie.Poisson, CTLie.∂ₜ

dg_ad_backend! [Function]

CTLie.dg_ad_backend! Function

dg_ad_backend!(ad_backend::ADTypes.AbstractADType)

Set the global automatic differentiation backend used by CTLie operations.

This function rebuilds the backend from an ADTypes backend type. The new backend will be used by CTLie.ad, CTLie.Poisson, and CTLie.∂ₜ when no explicit ad_backend keyword argument is provided.

Arguments

• ad_backend::ADTypes.AbstractADType: The ADTypes backend type to use (e.g., AutoForwardDiff()).

Returns

• nothing

Example

using CTLie
using ADTypes

dg_ad_backend!(AutoForwardDiff())

See also: CTLie.dg_ad_backend, CTLie.ad, CTLie.Poisson, CTLie.∂ₜ

∂ₜ [Function]

CTLie.∂ₜ Function

∂ₜ(f::Function; ad_backend) -> CTLie.TimeDeriv_F{<:Function}

Compute the time derivative of a function.

Returns a TimeDeriv_F callable representing the partial derivative with respect to time. The input function must accept time as its first argument.

Arguments

• f::Function: Function that takes time as the first argument.

• ad_backend::Union{ADTypes.AbstractADType, CTBase.Core.NotProvidedType}: AD backend to use (default: global backend).

Returns

• A TimeDeriv_F callable (t, args...) -> ∂f/∂t(t, args...).

Example

using CTLie

f = (t, x) -> t * x[1] + x[2]^2
df_dt = ∂ₜ(f)

df_dt(2.0, [1.0, 3.0])  # Returns 1.0

See also: CTLie.∂ₜ

∂ₜ(
    X::CTBase.Data.AbstractHamiltonianVectorField{TD, VD, MD};
    ad_backend
) -> CTBase.Data.HamiltonianVectorField{CTLie.TimeDeriv_HVF{FX, B, TD, VD}, CTBase.Traits.NonAutonomous, VD1, CTBase.Traits.OutOfPlace} where {FX, B<:CTBase.Differentiation.AbstractADBackend, TD, VD, VD1<:CTBase.Traits.VariableDependence}

Compute the time derivative of a Hamiltonian vector field.

Returns a new Data.HamiltonianVectorField with NonAutonomous time dependence. For autonomous vector fields, the derivative is zero.

Arguments

• X::Data.AbstractHamiltonianVectorField{TD, VD, MD}: Hamiltonian vector field.

• ad_backend::Union{ADTypes.AbstractADType, CTBase.Core.NotProvidedType}: AD backend to use (default: global backend).

Returns

• Data.HamiltonianVectorField{Traits.NonAutonomous, VD, Traits.OutOfPlace}: Time derivative.

Throws

• Exceptions.NotImplemented: If the vector field has InPlace mutability.

Example

using CTLie
using CTBase.Data
using CTBase.Traits

X = HamiltonianVectorField((t, x, p) -> t * p, Traits.NonAutonomous, Traits.Fixed, Traits.OutOfPlace)
dX_dt = ∂ₜ(X)

dX_dt(2.0, [1.0], [0.5])  # Returns 0.5

See also: CTLie.∂ₜ

∂ₜ(
    X::CTBase.Data.AbstractVectorField{TD, VD, MD};
    ad_backend
) -> CTBase.Data.HamiltonianVectorField{CTLie.TimeDeriv_HVF{FX, B, TD, VD}, CTBase.Traits.NonAutonomous, VD1, CTBase.Traits.OutOfPlace} where {FX, B<:CTBase.Differentiation.AbstractADBackend, TD, VD, VD1<:CTBase.Traits.VariableDependence}

Compute the time derivative of a vector field.

Returns a new Data.VectorField with NonAutonomous time dependence. For autonomous vector fields, the derivative is zero.

Arguments

• X::Data.AbstractVectorField{TD, VD, MD}: Vector field.

• ad_backend::Union{ADTypes.AbstractADType, CTBase.Core.NotProvidedType}: AD backend to use (default: global backend).

Returns

• Data.VectorField{Traits.NonAutonomous, VD, Traits.OutOfPlace}: Time derivative.

Throws

• Exceptions.NotImplemented: If the vector field has InPlace mutability.

Example

using CTLie
using CTBase.Data
using CTBase.Traits

X = VectorField((t, x) -> t * x, Traits.NonAutonomous, Traits.Fixed, Traits.OutOfPlace)
dX_dt = ∂ₜ(X)

dX_dt(2.0, [1.0, 2.0])  # Returns [1.0, 2.0]

See also: CTLie.∂ₜ

∂ₜ(
    H::CTBase.Data.AbstractHamiltonian{TD, VD};
    ad_backend
) -> CTBase.Data.Hamiltonian{CTLie.TimeDeriv_Ham{FH, B, TD, VD}, CTBase.Traits.NonAutonomous, VD1} where {FH, B<:CTBase.Differentiation.AbstractADBackend, TD, VD, VD1<:CTBase.Traits.VariableDependence}

Compute the time derivative of a Hamiltonian.

Returns a new Data.Hamiltonian with NonAutonomous time dependence. For autonomous Hamiltonians, the derivative is zero.

Arguments

• H::Data.AbstractHamiltonian{TD, VD}: Hamiltonian.

• ad_backend::Union{ADTypes.AbstractADType, CTBase.Core.NotProvidedType}: AD backend to use (default: global backend).

Returns

• Data.Hamiltonian{Traits.NonAutonomous, VD}: Time derivative.

Example

using CTLie
using CTBase.Data
using CTBase.Traits

H = Hamiltonian((t, x, p) -> t * p[1] + x[1]^2, Traits.NonAutonomous, Traits.Fixed)
dH_dt = ∂ₜ(H)

dH_dt(2.0, [1.0], [0.5])  # Returns 0.5

See also: CTLie.∂ₜ