JetBundleCategory¶

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.

BasicType

CoercibleTo Expression Integer

CoercibleTo OutputForm