# JetBundleExpression JBΒΆ

JetBundleExpression defines expressions over a jet bundle based on Expression Integer. It allows all kind of algebraic operations. `simplify` is implemented using Groebner bases in polynomials over kernels. Thus it might not work correctly for general expressions. This also affects `dimension`.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from LeftModule %

*: (%, Fraction Integer) -> %
*: (%, Integer) -> %
*: (Fraction Integer, %) -> %
*: (Integer, %) -> %

from AbelianGroup

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

+: (%, %) -> %

from AbelianSemiGroup

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

/: (%, %) -> %

from Field

/: (SparseMultivariatePolynomial(Integer, Kernel %), SparseMultivariatePolynomial(Integer, Kernel %)) -> %
=: (%, %) -> Boolean

from BasicType

^: (%, %) -> %
^: (%, Fraction Integer) -> %

^: (%, Integer) -> %

from DivisionRing

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

abs: % -> %
acos: % -> %
acosh: % -> %
acot: % -> %
acoth: % -> %
acsc: % -> %
acsch: % -> %
airyAi: % -> %
airyAiPrime: % -> %
airyBi: % -> %
airyBiPrime: % -> %
algtower: % -> List Kernel %
algtower: List % -> List Kernel %
angerJ: (%, %) -> %
annihilate?: (%, %) -> Boolean

from Rng

antiCommutator: (%, %) -> %
applyQuote: (Symbol, %) -> %
applyQuote: (Symbol, %, %) -> %
applyQuote: (Symbol, %, %, %) -> %
applyQuote: (Symbol, %, %, %, %) -> %
applyQuote: (Symbol, List %) -> %
asec: % -> %
asech: % -> %
asin: % -> %
asinh: % -> %
associates?: (%, %) -> Boolean

from EntireRing

associator: (%, %, %) -> %
atan: % -> %
atanh: % -> %
autoReduce: List % -> List %
belong?: BasicOperator -> Boolean

from ExpressionSpace

besselI: (%, %) -> %
besselJ: (%, %) -> %
besselK: (%, %) -> %
besselY: (%, %) -> %
Beta: (%, %) -> %
Beta: (%, %, %) -> %
binomial: (%, %) -> %
box: % -> %

from ExpressionSpace

ceiling: % -> %
characteristic: () -> NonNegativeInteger
charlierC: (%, %, %) -> %
charthRoot: % -> Union(%, failed) if Integer has CharacteristicNonZero
Chi: % -> %
Ci: % -> %
class: % -> NonNegativeInteger
coerce: % -> %

from Algebra %

coerce: % -> Expression Integer

coerce: % -> OutputForm
coerce: AlgebraicNumber -> %

coerce: Expression Integer -> %

coerce: Fraction Integer -> %
coerce: Fraction Polynomial Fraction Integer -> %
coerce: Fraction Polynomial Integer -> %
coerce: Integer -> %
coerce: JB -> %
coerce: Kernel % -> %

from CoercibleFrom Kernel %

coerce: Polynomial Fraction Integer -> %
coerce: Polynomial Integer -> %

coerce: SparseMultivariatePolynomial(Expression Integer, JB) -> %

coerce: SparseMultivariatePolynomial(Integer, Kernel %) -> %

coerce: Symbol -> %
commutator: (%, %) -> %
conjugate: % -> %
conjugate: (%, %) -> % if Integer has Group

from Group

const?: % -> Boolean
convert: % -> InputForm
convert: % -> Pattern Float if Integer has ConvertibleTo Pattern Float
convert: % -> Pattern Integer
convert: Factored % -> %
cos: % -> %
cosh: % -> %
cot: % -> %
coth: % -> %
csc: % -> %
csch: % -> %
D: (%, List Symbol) -> %
D: (%, List Symbol, List NonNegativeInteger) -> %
D: (%, Symbol) -> %
D: (%, Symbol, NonNegativeInteger) -> %
definingPolynomial: % -> %

from ExpressionSpace

denom: % -> SparseMultivariatePolynomial(Integer, Kernel %)
denominator: % -> %
differentiate: (%, JB) -> %
differentiate: (%, List Symbol) -> %
differentiate: (%, List Symbol, List NonNegativeInteger) -> %
differentiate: (%, Symbol) -> %
differentiate: (%, Symbol, NonNegativeInteger) -> %
digamma: % -> %
dilog: % -> %
dimension: (List %, SparseEchelonMatrix(JB, %), NonNegativeInteger) -> NonNegativeInteger
diracDelta: % -> %
distribute: % -> %

from ExpressionSpace

distribute: (%, %) -> %

from ExpressionSpace

divide: (%, %) -> Record(quotient: %, remainder: %)

from EuclideanDomain

dSubst: (%, JB, %) -> %
Ei: % -> %
ellipticE: % -> %
ellipticE: (%, %) -> %
ellipticF: (%, %) -> %
ellipticK: % -> %
ellipticPi: (%, %, %) -> %
elt: (BasicOperator, %) -> %

from ExpressionSpace

elt: (BasicOperator, %, %) -> %

from ExpressionSpace

elt: (BasicOperator, %, %, %) -> %

from ExpressionSpace

elt: (BasicOperator, %, %, %, %) -> %

from ExpressionSpace

elt: (BasicOperator, %, %, %, %, %) -> %

from ExpressionSpace

elt: (BasicOperator, %, %, %, %, %, %) -> %

from ExpressionSpace

elt: (BasicOperator, %, %, %, %, %, %, %) -> %

from ExpressionSpace

elt: (BasicOperator, %, %, %, %, %, %, %, %) -> %

from ExpressionSpace

elt: (BasicOperator, %, %, %, %, %, %, %, %, %) -> %

from ExpressionSpace

elt: (BasicOperator, List %) -> %

from ExpressionSpace

erf: % -> %
erfi: % -> %
euclideanSize: % -> NonNegativeInteger

from EuclideanDomain

eval: (%, %, %) -> %

from InnerEvalable(%, %)

eval: (%, BasicOperator, % -> %) -> %

from ExpressionSpace

eval: (%, BasicOperator, %, Symbol) -> %
eval: (%, BasicOperator, List % -> %) -> %

from ExpressionSpace

eval: (%, Equation %) -> %

from Evalable %

eval: (%, Kernel %, %) -> %

from InnerEvalable(Kernel %, %)

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

from InnerEvalable(%, %)

eval: (%, List BasicOperator, List %, Symbol) -> %
eval: (%, List BasicOperator, List(% -> %)) -> %

from ExpressionSpace

eval: (%, List BasicOperator, List(List % -> %)) -> %

from ExpressionSpace

eval: (%, List Equation %) -> %

from Evalable %

eval: (%, List Kernel %, List %) -> %

from InnerEvalable(Kernel %, %)

eval: (%, List Symbol, List NonNegativeInteger, List(% -> %)) -> %
eval: (%, List Symbol, List NonNegativeInteger, List(List % -> %)) -> %
eval: (%, List Symbol, List(% -> %)) -> %

from ExpressionSpace

eval: (%, List Symbol, List(List % -> %)) -> %

from ExpressionSpace

eval: (%, Symbol, % -> %) -> %

from ExpressionSpace

eval: (%, Symbol, List % -> %) -> %

from ExpressionSpace

eval: (%, Symbol, NonNegativeInteger, % -> %) -> %
eval: (%, Symbol, NonNegativeInteger, List % -> %) -> %
even?: % -> Boolean

from ExpressionSpace

exp: % -> %
expressIdealMember: (List %, %) -> Union(List %, failed)
exquo: (%, %) -> Union(%, failed)

from EntireRing

extendedEuclidean: (%, %) -> Record(coef1: %, coef2: %, generator: %)

from EuclideanDomain

extendedEuclidean: (%, %, %) -> Union(Record(coef1: %, coef2: %), failed)

from EuclideanDomain

extractSymbol: SparseEchelonMatrix(JB, %) -> SparseEchelonMatrix(JB, %)
factor: % -> Factored %
factorial: % -> %
factorials: % -> %
factorials: (%, Symbol) -> %
floor: % -> %
formalDiff2: (%, PositiveInteger, SparseEchelonMatrix(JB, %)) -> Record(DPhi: %, JVars: List JB)
formalDiff2: (List %, PositiveInteger, SparseEchelonMatrix(JB, %)) -> Record(DSys: List %, JVars: List List JB)
formalDiff: (%, List NonNegativeInteger) -> %
formalDiff: (%, PositiveInteger) -> %
formalDiff: (List %, PositiveInteger) -> List %
fractionPart: % -> %
freeOf?: (%, %) -> Boolean

from ExpressionSpace

freeOf?: (%, JB) -> Boolean
freeOf?: (%, Symbol) -> Boolean

from ExpressionSpace

fresnelC: % -> %
fresnelS: % -> %
function: (Symbol, List %, NonNegativeInteger) -> %

`function(f, arg, show)` generates a function with name `f` and arguments `arg`. In the output only the first `show` arguments are shown.

Gamma: % -> %
Gamma: (%, %) -> %
gcd: (%, %) -> %

from GcdDomain

gcd: List % -> %

from GcdDomain

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

from GcdDomain

getNotation: () -> Symbol
ground?: % -> Boolean
ground: % -> Integer
hankelH1: (%, %) -> %
hankelH2: (%, %) -> %
height: % -> NonNegativeInteger

from ExpressionSpace

hermiteH: (%, %) -> %
hypergeometricF: (List %, List %, %) -> %
integral: (%, SegmentBinding %) -> %
integral: (%, Symbol) -> %
inv: % -> %

from DivisionRing

is?: (%, BasicOperator) -> Boolean

from ExpressionSpace

is?: (%, Symbol) -> Boolean

from ExpressionSpace

isExpt: % -> Union(Record(var: Kernel %, exponent: Integer), failed)
isExpt: (%, BasicOperator) -> Union(Record(var: Kernel %, exponent: Integer), failed)
isExpt: (%, Symbol) -> Union(Record(var: Kernel %, exponent: Integer), failed)
isMult: % -> Union(Record(coef: Integer, var: Kernel %), failed)
isPlus: % -> Union(List %, failed)
isPower: % -> Union(Record(val: %, exponent: Integer), failed)
isTimes: % -> Union(List %, failed)
jacobiCn: (%, %) -> %
jacobiDn: (%, %) -> %
jacobiMatrix: (List %, List List JB) -> SparseEchelonMatrix(JB, %)
jacobiMatrix: List % -> SparseEchelonMatrix(JB, %)
jacobiP: (%, %, %, %) -> %
jacobiSn: (%, %) -> %
jacobiTheta: (%, %) -> %
jacobiZeta: (%, %) -> %
jetVariables: % -> List JB
kelvinBei: (%, %) -> %
kelvinBer: (%, %) -> %
kelvinKei: (%, %) -> %
kelvinKer: (%, %) -> %
kernel: (BasicOperator, %) -> %

from ExpressionSpace

kernel: (BasicOperator, List %) -> %

from ExpressionSpace

kernels: % -> List Kernel %

from ExpressionSpace

kernels: List % -> List Kernel %

from ExpressionSpace

kummerM: (%, %, %) -> %
kummerU: (%, %, %) -> %
laguerreL: (%, %, %) -> %
lambertW: % -> %
latex: % -> String

from SetCategory

lcm: (%, %) -> %

from GcdDomain

lcm: List % -> %

from GcdDomain

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

from LeftOreRing

leftPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower: (%, PositiveInteger) -> %

from Magma

leftRecip: % -> Union(%, failed)

from MagmaWithUnit

legendreP: (%, %, %) -> %
legendreQ: (%, %, %) -> %
lerchPhi: (%, %, %) -> %
li: % -> %
log: % -> %
lommelS1: (%, %, %) -> %
lommelS2: (%, %, %) -> %
mainKernel: % -> Union(Kernel %, failed)

from ExpressionSpace

map: (% -> %, Kernel %) -> %

from ExpressionSpace

meijerG: (List %, List %, List %, List %, %) -> %
meixnerM: (%, %, %, %) -> %
minPoly: Kernel % -> SparseUnivariatePolynomial %

from ExpressionSpace

multiEuclidean: (List %, %) -> Union(List %, failed)

from EuclideanDomain

nthRoot: (%, Integer) -> %

numDepVar: () -> PositiveInteger
numer: % -> SparseMultivariatePolynomial(Integer, Kernel %)
numerator: % -> %
numerJP: % -> SparseMultivariatePolynomial(Expression Integer, JB)

`numerJP(f)` writes `f` as polynomial over `JB`.

numIndVar: () -> PositiveInteger
odd?: % -> Boolean

from ExpressionSpace

one?: % -> Boolean

from MagmaWithUnit

operator: BasicOperator -> BasicOperator

from ExpressionSpace

operators: % -> List BasicOperator

from ExpressionSpace

opposite?: (%, %) -> Boolean

from AbelianMonoid

order: % -> NonNegativeInteger
orderDim: (List %, SparseEchelonMatrix(JB, %), NonNegativeInteger) -> NonNegativeInteger
P: (PositiveInteger, List NonNegativeInteger) -> %
P: (PositiveInteger, NonNegativeInteger) -> %
P: List NonNegativeInteger -> %
P: NonNegativeInteger -> %
paren: % -> %

from ExpressionSpace

patternMatch: (%, Pattern Float, PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if Integer has PatternMatchable Float
patternMatch: (%, Pattern Integer, PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %)
permutation: (%, %) -> %
pi: () -> %
plenaryPower: (%, PositiveInteger) -> %
polygamma: (%, %) -> %
polylog: (%, %) -> %
prime?: % -> Boolean
principalIdeal: List % -> Record(coef: List %, generator: %)
product: (%, SegmentBinding %) -> %
product: (%, Symbol) -> %
quo: (%, %) -> %

from EuclideanDomain

recip: % -> Union(%, failed)

from MagmaWithUnit

reduce: % -> %

`reduce(x)` reduces algebraics in `x`.

reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer)
reducedSystem: Matrix % -> Matrix Integer
reduceMod: (List %, List %) -> List %
rem: (%, %) -> %

from EuclideanDomain

retract: % -> AlgebraicNumber
retract: % -> Fraction Integer
retract: % -> Fraction Polynomial Integer
retract: % -> Integer
retract: % -> JB

from RetractableTo JB

retract: % -> Kernel %

from RetractableTo Kernel %

retract: % -> Polynomial Integer
retract: % -> Symbol
retractIfCan: % -> Union(AlgebraicNumber, failed)
retractIfCan: % -> Union(Fraction Integer, failed)
retractIfCan: % -> Union(Fraction Polynomial Integer, failed)
retractIfCan: % -> Union(Integer, failed)
retractIfCan: % -> Union(JB, failed)

from RetractableTo JB

retractIfCan: % -> Union(Kernel %, failed)

from RetractableTo Kernel %

retractIfCan: % -> Union(Polynomial Integer, failed)
retractIfCan: % -> Union(Symbol, failed)
riemannZeta: % -> %
rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

rootOf: % -> %
rootOf: (%, Symbol) -> %
rootOf: (SparseUnivariatePolynomial %, Symbol) -> %
rootOf: Polynomial % -> %
rootOf: SparseUnivariatePolynomial % -> %
rootsOf: % -> List %
rootsOf: (%, Symbol) -> List %
rootsOf: (SparseUnivariatePolynomial %, Symbol) -> List %
rootsOf: Polynomial % -> List %
rootsOf: SparseUnivariatePolynomial % -> List %
rootSum: (%, SparseUnivariatePolynomial %, Symbol) -> %
sample: %

from AbelianMonoid

sec: % -> %
sech: % -> %
setNotation: Symbol -> Void
Shi: % -> %
Si: % -> %
sign: % -> %
simplify: (List %, SparseEchelonMatrix(JB, %)) -> Record(Sys: List %, JM: SparseEchelonMatrix(JB, %), Depend: Union(failed, List List NonNegativeInteger))
simpMod: (List %, List %) -> List %
simpMod: (List %, SparseEchelonMatrix(JB, %), List %) -> Record(Sys: List %, JM: SparseEchelonMatrix(JB, %), Depend: Union(failed, List List NonNegativeInteger))
simpOne: % -> %
sin: % -> %
sinh: % -> %
sizeLess?: (%, %) -> Boolean

from EuclideanDomain

smaller?: (%, %) -> Boolean

from Comparable

solveFor: (%, JB) -> Union(%, failed)
sortLD: List % -> List %
sqrt: % -> %

squareFree: % -> Factored %
squareFreePart: % -> %
struveH: (%, %) -> %
struveL: (%, %) -> %
subst: (%, Equation %) -> %

from ExpressionSpace

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

from ExpressionSpace

subst: (%, List Kernel %, List %) -> %

from ExpressionSpace

subtractIfCan: (%, %) -> Union(%, failed)
summation: (%, SegmentBinding %) -> %
summation: (%, Symbol) -> %
symbol: List % -> SparseEchelonMatrix(JB, %)
tan: % -> %
tanh: % -> %
tower: % -> List Kernel %

from ExpressionSpace

tower: List % -> List Kernel %

from ExpressionSpace

U: () -> %
U: PositiveInteger -> %
unit?: % -> Boolean

from EntireRing

unitCanonical: % -> %

from EntireRing

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

from EntireRing

unitStep: % -> %
univariate: (%, Kernel %) -> Fraction SparseUnivariatePolynomial %
variables: % -> List Symbol
variables: List % -> List Symbol
weberE: (%, %) -> %
weierstrassP: (%, %, %) -> %
weierstrassPInverse: (%, %, %) -> %
weierstrassPPrime: (%, %, %) -> %
weierstrassSigma: (%, %, %) -> %
weierstrassZeta: (%, %, %) -> %
whittakerM: (%, %, %) -> %
whittakerW: (%, %, %) -> %
X: () -> %
X: PositiveInteger -> %
zero?: % -> Boolean

from AbelianMonoid

zeroOf: % -> %
zeroOf: (%, Symbol) -> %
zeroOf: (SparseUnivariatePolynomial %, Symbol) -> %
zeroOf: Polynomial % -> %
zeroOf: SparseUnivariatePolynomial % -> %
zerosOf: % -> List %
zerosOf: (%, Symbol) -> List %
zerosOf: (SparseUnivariatePolynomial %, Symbol) -> List %
zerosOf: Polynomial % -> List %
zerosOf: SparseUnivariatePolynomial % -> List %

AbelianGroup

AbelianMonoid

AbelianSemiGroup

AlgebraicallyClosedField

ArcHyperbolicFunctionCategory

ArcTrigonometricFunctionCategory

BasicType

BiModule(%, %)

CancellationAbelianMonoid

canonicalsClosed

canonicalUnitNormal

CharacteristicZero

CombinatorialFunctionCategory

CombinatorialOpsCategory

CommutativeRing

CommutativeStar

Comparable

DivisionRing

ElementaryFunctionCategory

EntireRing

EuclideanDomain

ExpressionSpace

Field

GcdDomain

Group if Integer has Group

HyperbolicFunctionCategory

InnerEvalable(%, %)

InnerEvalable(Kernel %, %)

IntegralDomain

LeftOreRing

LiouvillianFunctionCategory

Magma

MagmaWithUnit

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

PrimitiveFunctionCategory

PrincipalIdealDomain

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

SpecialFunctionCategory

TranscendentalFunctionCategory

TrigonometricFunctionCategory

TwoSidedRecip

UniqueFactorizationDomain

unitsKnown