# JetBundleCategory¶

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.