JetLazyFunction(JB, D)

jet.spad line 5448 [edit on github]

• JB : JetBundleCategory
• D : JetBundleFunctionCategory(JB)

JetLazyFunction takes as argument a domain in JetBundleFunctionCategory and returns another domain in the same category. This domain has basically the same properties as the argument domain, but there is a lazy evaluation mechanism for derivatives. This means that differentiations are not immediately performed. Instead a pointer is established to the function to be differentiated. Only when the exact value of the derivative is needed, the differentiation is executed. Special care is taken for leading derivatives and jet variables to avoid as much as possible the need to evaluate expressions. This entails that the result of jetVariables may contain spurious variables. Furthermore many functions in JetLazyFunction destructively change their arguments. This affects, however, only their internal representation, not the value obtained after full evaluation.

* : (%, %) -> %

from Magma

* : (D, %) -> %

d*exp is provided mainly for internal use, as basically all calculations should be performed within JetLazyFunction.

* : (Integer, %) -> %

from AbelianGroup

* : (NonNegativeInteger, %) -> %

from AbelianMonoid

* : (PositiveInteger, %) -> %

from AbelianSemiGroup

+ : (%, %) -> %

from AbelianSemiGroup

- : % -> %

from AbelianGroup

- : (%, %) -> %

from AbelianGroup

0 : () -> %

from AbelianMonoid

1 : () -> %

from MagmaWithUnit

= : (%, %) -> Boolean

from BasicType

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)

P : List(NonNegativeInteger) -> %

from JetBundleFunctionCategory(JB)

P : NonNegativeInteger -> %

from JetBundleFunctionCategory(JB)

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

from JetBundleFunctionCategory(JB)

P : (PositiveInteger, NonNegativeInteger) -> %

from JetBundleFunctionCategory(JB)

U : () -> %

from JetBundleFunctionCategory(JB)

U : PositiveInteger -> %

from JetBundleFunctionCategory(JB)

X : () -> %

from JetBundleFunctionCategory(JB)

X : PositiveInteger -> %

from JetBundleFunctionCategory(JB)

^ : (%, NonNegativeInteger) -> %

from MagmaWithUnit

^ : (%, PositiveInteger) -> %

from Magma

annihilate? : (%, %) -> Boolean

from Rng

antiCommutator : (%, %) -> %

from NonAssociativeSemiRng

associates? : (%, %) -> Boolean

from EntireRing

associator : (%, %, %) -> %

from NonAssociativeRng

autoReduce : List(%) -> List(%)

from JetBundleFunctionCategory(JB)

characteristic : () -> NonNegativeInteger

from NonAssociativeRing

class : % -> NonNegativeInteger

from JetBundleFunctionCategory(JB)

coerce : % -> %

from Algebra(%)

coerce : D -> %

coerce(d) coerces an element of D into the new domain. This includes the calculation of its leading derivative and its jet variables.

coerce : JB -> %

from JetBundleFunctionCategory(JB)

coerce : Integer -> %

from NonAssociativeRing

coerce : % -> D

coerce(exp) retracts an element to the base domain D. This looses all information about its leading derivative and its jet variables and requires complete evaluation of the expression.

coerce : % -> OutputForm

from CoercibleTo(OutputForm)

collect : % -> %

collect(exp) "collects" former lazy terms which have been meanwhile evaluated.

commutator : (%, %) -> %

from NonAssociativeRng

const? : % -> Boolean

from JetBundleFunctionCategory(JB)

dSubst : (%, JB, %) -> %

from JetBundleFunctionCategory(JB)

denominator : % -> %

from JetBundleFunctionCategory(JB)

differentiate : (%, JB) -> %

from JetBundleFunctionCategory(JB)

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

from JetBundleFunctionCategory(JB)

eqRep? : (%, %) -> Boolean

eqRep?(x, y) compares the representations of x and y without any evaluation. Thus it is much weaker than = and cannot decide equality of the evaluated expressions.

eval : % -> %

eval(exp) explicitly evaluates all terms in exp. exp is destructively altered.

eval1 : % -> %

eval1(exp) explicitly evaluates the next term in exp. exp is destructively altered.

exquo : (%, %) -> Union(%, "failed")

from EntireRing

extractSymbol : SparseEchelonMatrix(JB, %) -> SparseEchelonMatrix(JB, %)

from JetBundleFunctionCategory(JB)

formalDiff : (%, List(NonNegativeInteger)) -> %

from JetBundleFunctionCategory(JB)

formalDiff : (%, PositiveInteger) -> %

from JetBundleFunctionCategory(JB)

formalDiff : (List(%), PositiveInteger) -> List(%)

from JetBundleFunctionCategory(JB)

formalDiff2 : (%, PositiveInteger, SparseEchelonMatrix(JB, %)) -> Record(DPhi : %, JVars : List(JB))

from JetBundleFunctionCategory(JB)

formalDiff2 : (List(%), PositiveInteger, SparseEchelonMatrix(JB, %)) -> Record(DSys : List(%), JVars : List(List(JB)))

from JetBundleFunctionCategory(JB)

freeOf? : (%, JB) -> Boolean

from JetBundleFunctionCategory(JB)

gcd : (%, %) -> %

from GcdDomain

gcd : List(%) -> %

from GcdDomain

gcdPolynomial : (SparseUnivariatePolynomial(%), SparseUnivariatePolynomial(%)) -> SparseUnivariatePolynomial(%)

from GcdDomain

getNotation : () -> Symbol

from JetBundleFunctionCategory(JB)

ground? : % -> Boolean

ground(exp) is true, if exp contains only fully evaluated parts.

jacobiMatrix : List(%) -> SparseEchelonMatrix(JB, %)

from JetBundleFunctionCategory(JB)

jacobiMatrix : (List(%), List(List(JB))) -> SparseEchelonMatrix(JB, %)

from JetBundleFunctionCategory(JB)

jetVariables : % -> List(JB)

from JetBundleFunctionCategory(JB)

latex : % -> String

from SetCategory

lcm : (%, %) -> %

from GcdDomain

lcm : List(%) -> %

from GcdDomain

lcmCoef : (%, %) -> Record(llcm_res : %, coeff1 : %, coeff2 : %)

from LeftOreRing

leadingDer : % -> JB

from JetBundleFunctionCategory(JB)

leftPower : (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower : (%, PositiveInteger) -> %

from Magma

leftRecip : % -> Union(%, "failed")

from MagmaWithUnit

numDepVar : () -> PositiveInteger

from JetBundleFunctionCategory(JB)

numIndVar : () -> PositiveInteger

from JetBundleFunctionCategory(JB)

numerator : % -> %

from JetBundleFunctionCategory(JB)

one? : % -> Boolean

from MagmaWithUnit

opposite? : (%, %) -> Boolean

from AbelianMonoid

order : % -> NonNegativeInteger

from JetBundleFunctionCategory(JB)

orderDim : (List(%), SparseEchelonMatrix(JB, %), NonNegativeInteger) -> NonNegativeInteger

from JetBundleFunctionCategory(JB)

plenaryPower : (%, PositiveInteger) -> %

from NonAssociativeAlgebra(%)

recip : % -> Union(%, "failed")

from MagmaWithUnit

reduceMod : (List(%), List(%)) -> List(%)

from JetBundleFunctionCategory(JB)

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

from JetBundleFunctionCategory(JB)

simpMod : (List(%), List(%)) -> List(%)

from JetBundleFunctionCategory(JB)

simpMod : (List(%), SparseEchelonMatrix(JB, %), List(%)) -> Record(Sys : List(%), JM : SparseEchelonMatrix(JB, %), Depend : Union("failed", List(List(NonNegativeInteger))))

from JetBundleFunctionCategory(JB)

simpOne : % -> %

from JetBundleFunctionCategory(JB)

simplify : (List(%), SparseEchelonMatrix(JB, %)) -> Record(Sys : List(%), JM : SparseEchelonMatrix(JB, %), Depend : Union("failed", List(List(NonNegativeInteger))))

from JetBundleFunctionCategory(JB)

solveFor : (%, JB) -> Union(%, "failed")

from JetBundleFunctionCategory(JB)

sortLD : List(%) -> List(%)

from JetBundleFunctionCategory(JB)

statistics : () -> Void

statistics() prints a statistic on the use of the lazy evaluation mechanism. It displays the number of lazy differentiations performed and how many of them had to be executed explicitly later on.

subst : (%, JB, %) -> %

from JetBundleFunctionCategory(JB)

subtractIfCan : (%, %) -> Union(%, "failed")

from CancellationAbelianMonoid

symbol : List(%) -> SparseEchelonMatrix(JB, %)

from JetBundleFunctionCategory(JB)

unit? : % -> Boolean

from EntireRing

unitCanonical : % -> %

from EntireRing

unitNormal : % -> Record(unit : %, canonical : %, associate : %)

from EntireRing

zero? : % -> Boolean

from AbelianMonoid

~= : (%, %) -> Boolean

from BasicType

IntegralDomain

noZeroDivisors

SetCategory

RightModule(%)

RetractableTo(JB)

Monoid

GcdDomain

AbelianMonoid

Algebra(%)

CancellationAbelianMonoid

MagmaWithUnit

Module(%)

BasicType

LeftModule(%)

JetBundleFunctionCategory(JB)

LeftOreRing

PartialDifferentialRing(Symbol)

CommutativeRing

Magma

NonAssociativeRing

SemiGroup

NonAssociativeRng

BiModule(%, %)

CoercibleFrom(JB)

AbelianGroup

AbelianSemiGroup

CommutativeStar

NonAssociativeSemiRing

Rng

NonAssociativeAlgebra(%)

unitsKnown

Ring

SemiRng

EntireRing

NonAssociativeSemiRng

lazyRepresentation

CoercibleTo(OutputForm)

SemiRing

TwoSidedRecip