JetBundleCategoryΒΆ

jet.spad line 37

JetBundleCategory provides basic data structures and procedures for jet bundles. Nearly all necessary functions are implemented already here. Only the representation and functions which direct access to 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
~=: (%, %) -> 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.
hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
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

Comparable

OrderedSet

PartialOrder

SetCategory