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

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

>= : (%, %) -> Boolean

from PartialOrder

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.

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.

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.

U : () -> %

U() generates the only dependent variable.

U : PositiveInteger -> %

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

X : () -> %

X() generates the only independent variable.

X : PositiveInteger -> %

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

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).

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.

variables : NonNegativeInteger -> List(%)

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

variables : (NonNegativeInteger, PositiveInteger) -> List(%)

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

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.

~= : (%, %) -> Boolean

from BasicType

CoercibleTo(OutputForm)

SetCategory

OrderedSet

Comparable

PartialOrder

BasicType

CoercibleTo(Expression(Integer))