JetBundleFunctionCategory JBΒΆ

jet.spad line 494

JetBundleFunctionCategory defines the category of functions (local sections) over a jet bundle. The formal derivative is defined already here. It uses the Jacobi matrix of the functions. The columns of the matrices are enumerated by jet variables. Thus they are represented as a Record of the matrix and a list of the jet variables. Several simplification routines are implemented already here.

0: %
from AbelianMonoid
1: %
from MagmaWithUnit
*: (%, %) -> %
from Magma
*: (Integer, %) -> %
from AbelianGroup
*: (NonNegativeInteger, %) -> %
from AbelianMonoid
*: (PositiveInteger, %) -> %
from AbelianSemiGroup
+: (%, %) -> %
from AbelianSemiGroup
-: % -> %
from AbelianGroup
-: (%, %) -> %
from AbelianGroup
=: (%, %) -> Boolean
from BasicType
^: (%, NonNegativeInteger) -> %
from MagmaWithUnit
^: (%, PositiveInteger) -> %
from Magma
~=: (%, %) -> Boolean
from BasicType
annihilate?: (%, %) -> Boolean
from Rng
antiCommutator: (%, %) -> %
from NonAssociativeSemiRng
associates?: (%, %) -> Boolean
from EntireRing
associator: (%, %, %) -> %
from NonAssociativeRng
autoReduce: List % -> List %
autoReduce(sys) tries to simplify a system by solving each equation for its leading term and substituting it into the other equations.
characteristic: () -> NonNegativeInteger
from NonAssociativeRing
class: % -> NonNegativeInteger
class(f) is defined as the highest class of the jet variables effectively occurring in f.
coerce: % -> %
from Algebra %
coerce: % -> OutputForm
from CoercibleTo OutputForm
coerce: Integer -> %
from NonAssociativeRing
coerce: JB -> %
coerce(jv) coerces the jet variable jv into a local section.
commutator: (%, %) -> %
from NonAssociativeRng
const?: % -> Boolean
const?(f) checks whether f depends of jet variables.
D: (%, List Symbol) -> %
from PartialDifferentialRing Symbol
D: (%, List Symbol, List NonNegativeInteger) -> %
from PartialDifferentialRing Symbol
D: (%, Symbol) -> %
from PartialDifferentialRing Symbol
D: (%, Symbol, NonNegativeInteger) -> %
from PartialDifferentialRing Symbol
denominator: % -> %
denominator(f) yields the denominator of f.
differentiate: (%, JB) -> %
differentiate(f, jv) differentiates the function f wrt the jet variable jv.
differentiate: (%, List Symbol) -> %
from PartialDifferentialRing Symbol
differentiate: (%, List Symbol, List NonNegativeInteger) -> %
from PartialDifferentialRing Symbol
differentiate: (%, Symbol) -> %
from PartialDifferentialRing Symbol
differentiate: (%, Symbol, NonNegativeInteger) -> %
from PartialDifferentialRing Symbol
dimension: (List %, SparseEchelonMatrix(JB, %), NonNegativeInteger) -> NonNegativeInteger
dimension(sys, jm, q) computes the dimension of the manifold described by the system sys with Jacobi matrix jm in the jet bundle of order q.
dSubst: (%, JB, %) -> %
dSubst(f, jv, exp) is like subst(f, jv, exp). But additionally for all derivatives of jv the corresponding substitutions are performed.
exquo: (%, %) -> Union(%, failed)
from EntireRing
extractSymbol: SparseEchelonMatrix(JB, %) -> SparseEchelonMatrix(JB, %)
extractSymbol(jm) extracts the highest order part of the Jacobi matrix.
formalDiff2: (%, PositiveInteger, SparseEchelonMatrix(JB, %)) -> Record(DPhi: %, JVars: List JB)
formalDiff2(f, i, jm) formally differentiates the function f with the Jacobi matrix jm wrt the i-th independent variable. JVars is a list of the jet variables effectively in the result DPhi (might be too large).
formalDiff2: (List %, PositiveInteger, SparseEchelonMatrix(JB, %)) -> Record(DSys: List %, JVars: List List JB)
formalDiff2(sys, i, jm) is like the other ``formalDiff2`` but for systems.
formalDiff: (%, List NonNegativeInteger) -> %
formalDiff(f, mu) formally differentiates f as indicated by the multi-index mu.
formalDiff: (%, PositiveInteger) -> %
formalDiff(f, i) formally (totally) differentiates f wrt the i-th independent variable.
formalDiff: (List %, PositiveInteger) -> List %
formalDiff(sys, i) formally differentiates a family sys of functions wrt the i-th independent variable.
freeOf?: (%, JB) -> Boolean
freeOf?(fun, jv) checks whether fun contains the jet variable jv.
gcd: (%, %) -> %
from GcdDomain
gcd: List % -> %
from GcdDomain
gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial %
from GcdDomain

getNotation: () -> Symbol

hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
jacobiMatrix: (List %, List List JB) -> SparseEchelonMatrix(JB, %)
jacobiMatrix(sys, jvars) constructs the Jacobi matrix of the family sys of functions. jvars contains for each function the effectively occurring jet variables. The columns of the matrix are ordered.
jacobiMatrix: List % -> SparseEchelonMatrix(JB, %)
jacobiMatrix(sys) constructs the Jacobi matrix of the family sys of functions.
jetVariables: % -> List JB
jetVariables(f) yields all jet variables effectively occurring in f in an ordered list.
latex: % -> String
from SetCategory
lcm: (%, %) -> %
from GcdDomain
lcm: List % -> %
from GcdDomain
lcmCoef: (%, %) -> Record(llcm_res: %, coeff1: %, coeff2: %)
from LeftOreRing
leadingDer: % -> JB
leadingDer(fun) yields the leading derivative of fun. If fun contains no derivatives 1 is returned.
leftPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit
leftPower: (%, PositiveInteger) -> %
from Magma
leftRecip: % -> Union(%, failed)
from MagmaWithUnit

numDepVar: () -> PositiveInteger

numerator: % -> %
numerator(f) yields the numerator of f.

numIndVar: () -> PositiveInteger

one?: % -> Boolean
from MagmaWithUnit
opposite?: (%, %) -> Boolean
from AbelianMonoid
order: % -> NonNegativeInteger
order(f) gives highest order of the jet variables effectively occurring in f.
orderDim: (List %, SparseEchelonMatrix(JB, %), NonNegativeInteger) -> NonNegativeInteger
orderDim(sys, jm, q) computes the dimension of the manifold described by the system sys with Jacobi matrix jm in the jet bundle of order q over the jet bundle of order q-1.

P: (PositiveInteger, List NonNegativeInteger) -> %

P: (PositiveInteger, NonNegativeInteger) -> %

P: List NonNegativeInteger -> %

P: NonNegativeInteger -> %

recip: % -> Union(%, failed)
from MagmaWithUnit
reduceMod: (List %, List %) -> List %
reduceMod(sys1, sys2) reduces the system sys1 modulo the system sys2.
retract: % -> JB
from RetractableTo JB
retractIfCan: % -> Union(JB, failed)
from RetractableTo JB
rightPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit
rightPower: (%, PositiveInteger) -> %
from Magma
rightRecip: % -> Union(%, failed)
from MagmaWithUnit
sample: %
from AbelianMonoid

setNotation: Symbol -> Void

simplify: (List %, SparseEchelonMatrix(JB, %)) -> Record(Sys: List %, JM: SparseEchelonMatrix(JB, %), Depend: Union(failed, List List NonNegativeInteger))
simplify(sys, jm) simplifies a system with given Jacobi matrix. The Jacobi matrix of the simplified system is returned, too. Depend contains for each equation of the simplified system the numbers of the equations of the original system out of which it is build, if it is possible to obtain this information. If one can generate equations of lower order by purely algebraic operations, then simplify should do this.
simpMod: (List %, List %) -> List %
simpMod(sys1, sys2) simplifies the system sys1 modulo the system sys2.
simpMod: (List %, SparseEchelonMatrix(JB, %), List %) -> Record(Sys: List %, JM: SparseEchelonMatrix(JB, %), Depend: Union(failed, List List NonNegativeInteger))
simpMod(sys1, sys2) simplifies the system sys1 modulo the system sys2. Returns the same information as simplify.
simpOne: % -> %
simpOne(f) removes unnecessary coefficients and exponents, denominators etc.
solveFor: (%, JB) -> Union(%, failed)
solveFor(fun, jv) tries to solve fun for the jet variable jv.
sortLD: List % -> List %
sortLD(sys) sorts the functions in sys according to their leading derivatives.
subst: (%, JB, %) -> %
subst(f, jv, exp) substitutes exp for the jet variable jv in the function f.
subtractIfCan: (%, %) -> Union(%, failed)
from CancellationAbelianMonoid
symbol: List % -> SparseEchelonMatrix(JB, %)
symbol(sys) computes directly the symbol of the family sys of functions.

U: () -> %

U: PositiveInteger -> %

unit?: % -> Boolean
from EntireRing
unitCanonical: % -> %
from EntireRing
unitNormal: % -> Record(unit: %, canonical: %, associate: %)
from EntireRing

X: () -> %

X: PositiveInteger -> %

zero?: % -> Boolean
from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra %

BasicType

BiModule(%, %)

CancellationAbelianMonoid

CoercibleTo OutputForm

CommutativeRing

CommutativeStar

EntireRing

GcdDomain

IntegralDomain

LeftModule %

LeftOreRing

Magma

MagmaWithUnit

Module %

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

PartialDifferentialRing Symbol

RetractableTo JB

RightModule %

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

unitsKnown