jet.spad line 37 [edit on github]

JetBundleCategory provides basic data structures and procedures for jet bundles. Nearly all necessary functions are implemented already here. Only the representation and functions which directly access it must be implemented in a domain. Two notations of derivatives are supported. Default is multi-index notation, where the i-th entry of the index denotes the number of differentiations taken with respect to x^i. In repeated index notation each entry i in the index denotes a differentiation with respect to x^i. The choice affects, however, only in- and output. Internally, multi-index notation is used throughout.

1: %

1 generates the special “jet variable” 1, which is needed for the representation of linear functions.

<=: (%, %) -> Boolean

from PartialOrder

<: (%, %) -> Boolean

from PartialOrder

=: (%, %) -> Boolean

from BasicType

>=: (%, %) -> Boolean

from PartialOrder

>: (%, %) -> Boolean

jv1 > jv2 checks whether jv1 is greater than jv2 in the internal ordering.

~=: (%, %) -> Boolean

from BasicType

allRepeated: List NonNegativeInteger -> List List PositiveInteger

allRepeated(ind) returns a list of all possible realizations of a given multi-index as repeated index.

class: % -> NonNegativeInteger

class(jv) yields the class of the jet variable jv (Class of multi-index for derivative, 0 else).

class: List NonNegativeInteger -> NonNegativeInteger

class(ind) yields the class of the multi-index ind (Position for first non-vanishing entry).

coerce: % -> Expression Integer

from CoercibleTo Expression Integer

coerce: % -> OutputForm

from CoercibleTo OutputForm

derivativeOf?: (%, %) -> List NonNegativeInteger

derivativeOf?(jv1, jv2) checks whether jv1 is a derivative of jv2. In this case, the difference of their multi-indices is returned. Otherwise, an empty list is returned.

differentiate: (%, PositiveInteger) -> Union(%, 0)

differentiate(jv, i) differentiates jv wrt the i-th independent variable.

dimJ: NonNegativeInteger -> NonNegativeInteger

dimJ(q) computes the (fibre) dimension of the q-th order jet bundle.

dimS: NonNegativeInteger -> NonNegativeInteger

dimS(q) computes dimension of SqT x VE (= number of derivatives of order q).

getNotation: () -> Symbol

getNotation() shows the currently used notation.

index: % -> PositiveInteger

index(jv) yields number of the jet variable jv.

integrate: (%, PositiveInteger) -> %

integrate(jv, i) is like integrateIfCan(jv, i) but yields an error, if the integration is not possible.

integrateIfCan: (%, PositiveInteger) -> Union(%, failed)

integrate(jv, i) integrated jv wrt the i-th independent variable, if possible.

latex: % -> String

from SetCategory

m2r: List NonNegativeInteger -> List PositiveInteger

m2r(ind) transforms a multi-index into a repeated index.

max: (%, %) -> %

from OrderedSet

min: (%, %) -> %

from OrderedSet

multiIndex: % -> List NonNegativeInteger

multiIndex(jv) returns the multi-index of the jet variable jv.

name: % -> Symbol

name(jv) yields the name of the jet variable jv.

numDepVar: () -> PositiveInteger

numDepVar returns the number of dependent variables.

numIndVar: () -> PositiveInteger

numIndVar returns the number of independent variables.

one?: % -> Boolean

one?(jv) checks whether the jet variables jv is the special variable 1.

order: % -> NonNegativeInteger

order(jv) yields the order of the jet variable jv (Order as derivative).

P: (PositiveInteger, List NonNegativeInteger) -> %

P(i, ind) generates the derivative of the i-th dependent variable wrt the index ind. Whether ind is interpreted as multi-index or as repeated index depends on the chosen notation.

P: (PositiveInteger, NonNegativeInteger) -> %

P(i, j) generates the j-th derivative of the i-th independent variable wrt the only independent variable.

P: List NonNegativeInteger -> %

P(ind) generates the derivative of the only dependent variable wrt the index ind.

P: NonNegativeInteger -> %

P(i) generates the i-th derivative of the only dependent variable wrt the only independent variable.

Pm: (PositiveInteger, List NonNegativeInteger) -> %

Pm(i, ind) is like P(i, ind) but ind is always a multi-index.

Pr: (PositiveInteger, List PositiveInteger) -> %

Pr(i, ind) is like P(i, ind) but ind is always a repeated index.

r2m: List PositiveInteger -> List NonNegativeInteger

r2m(ind) transforms a repeated index into a multi-index.

repeatedIndex: % -> List PositiveInteger

repeatedIndex(jv) returns the multi-index of the jet variable jv in repeated index notation.

setNotation: Symbol -> Symbol

setNotation(s) chooses the notation used for derivatives. Returns the old value.

smaller?: (%, %) -> Boolean

from Comparable

type: % -> Symbol

type(jv) yields the type (Const, Indep, Dep, Deriv) of the jet variable jv.

U: () -> %

U() generates the only dependent variable.

U: PositiveInteger -> %

U(i) generates the i-th dependent variable.

variables: (NonNegativeInteger, PositiveInteger) -> List %

variables(q, c) computes all jet variables of order q whose class is greater than or equal to c.

variables: NonNegativeInteger -> List %

variables(q) computes the list of all jet variables up to order q.

weight: % -> NonNegativeInteger

weight(jv) assigns each jet variable a unique integer reflecting its position in the internal ordering. The variable with the greater weight is also greater in this ordering.

X: () -> %

X() generates the only independent variable.

X: PositiveInteger -> %

X(i) generates the i-th independent variable.


CoercibleTo Expression Integer

CoercibleTo OutputForm