JetBundleExpression(JB)

jet.spad line 2354 [edit on github]

• JB : JetBundleCategory

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.

* : (%, %) -> %

from Magma

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

from RightModule(Fraction(Integer))

* : (%, Integer) -> %

from RightModule(Integer)

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

from LeftModule(Fraction(Integer))

* : (Integer, %) -> %

from AbelianGroup

* : (NonNegativeInteger, %) -> %

from AbelianMonoid

* : (PositiveInteger, %) -> %

from AbelianSemiGroup

+ : (%, %) -> %

from AbelianSemiGroup

- : % -> %

from AbelianGroup

- : (%, %) -> %

from AbelianGroup

/ : (%, %) -> %

from Group

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

from FunctionSpace2(Integer, Kernel(%))

0 : () -> %

from AbelianMonoid

1 : () -> %

from MagmaWithUnit

= : (%, %) -> Boolean

from BasicType

Beta : (%, %) -> %

from SpecialFunctionCategory

Beta : (%, %, %) -> %

from SpecialFunctionCategory

Chi : % -> %

from LiouvillianFunctionCategory

Ci : % -> %

from LiouvillianFunctionCategory

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)

Ei : % -> %

from LiouvillianFunctionCategory

Gamma : % -> %

from SpecialFunctionCategory

Gamma : (%, %) -> %

from SpecialFunctionCategory

P : List(NonNegativeInteger) -> %

from JetBundleFunctionCategory(JB)

P : NonNegativeInteger -> %

from JetBundleFunctionCategory(JB)

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

from JetBundleFunctionCategory(JB)

P : (PositiveInteger, NonNegativeInteger) -> %

from JetBundleFunctionCategory(JB)

Shi : % -> %

from LiouvillianFunctionCategory

Si : % -> %

from LiouvillianFunctionCategory

U : () -> %

from JetBundleFunctionCategory(JB)

U : PositiveInteger -> %

from JetBundleFunctionCategory(JB)

X : () -> %

from JetBundleFunctionCategory(JB)

X : PositiveInteger -> %

from JetBundleFunctionCategory(JB)

^ : (%, %) -> %

from ElementaryFunctionCategory

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

from RadicalCategory

^ : (%, Integer) -> %

from Group

^ : (%, NonNegativeInteger) -> %

from MagmaWithUnit

^ : (%, PositiveInteger) -> %

from Magma

abs : % -> %

from SpecialFunctionCategory

acos : % -> %

from ArcTrigonometricFunctionCategory

acosh : % -> %

from ArcHyperbolicFunctionCategory

acot : % -> %

from ArcTrigonometricFunctionCategory

acoth : % -> %

from ArcHyperbolicFunctionCategory

acsc : % -> %

from ArcTrigonometricFunctionCategory

acsch : % -> %

from ArcHyperbolicFunctionCategory

airyAi : % -> %

from SpecialFunctionCategory

airyAiPrime : % -> %

from SpecialFunctionCategory

airyBi : % -> %

from SpecialFunctionCategory

airyBiPrime : % -> %

from SpecialFunctionCategory

algtower : % -> List(Kernel(%))

from FunctionSpace2(Integer, Kernel(%))

algtower : List(%) -> List(Kernel(%))

from FunctionSpace2(Integer, Kernel(%))

angerJ : (%, %) -> %

from SpecialFunctionCategory

annihilate? : (%, %) -> Boolean

from Rng

antiCommutator : (%, %) -> %

from NonAssociativeSemiRng

applyQuote : (Symbol, %) -> %

from FunctionSpace2(Integer, Kernel(%))

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

from FunctionSpace2(Integer, Kernel(%))

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

from FunctionSpace2(Integer, Kernel(%))

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

from FunctionSpace2(Integer, Kernel(%))

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

from FunctionSpace2(Integer, Kernel(%))

asec : % -> %

from ArcTrigonometricFunctionCategory

asech : % -> %

from ArcHyperbolicFunctionCategory

asin : % -> %

from ArcTrigonometricFunctionCategory

asinh : % -> %

from ArcHyperbolicFunctionCategory

associates? : (%, %) -> Boolean

from EntireRing

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

from NonAssociativeRng

atan : % -> %

from ArcTrigonometricFunctionCategory

atanh : % -> %

from ArcHyperbolicFunctionCategory

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

from JetBundleFunctionCategory(JB)

belong? : BasicOperator -> Boolean

from ExpressionSpace2(Kernel(%))

besselI : (%, %) -> %

from SpecialFunctionCategory

besselJ : (%, %) -> %

from SpecialFunctionCategory

besselK : (%, %) -> %

from SpecialFunctionCategory

besselY : (%, %) -> %

from SpecialFunctionCategory

binomial : (%, %) -> %

from CombinatorialFunctionCategory

box : % -> %

from ExpressionSpace2(Kernel(%))

ceiling : % -> %

from SpecialFunctionCategory

characteristic : () -> NonNegativeInteger

from NonAssociativeRing

charlierC : (%, %, %) -> %

from SpecialFunctionCategory

charthRoot : % -> Union(%, "failed") if Integer has CharacteristicNonZero

from CharacteristicNonZero

class : % -> NonNegativeInteger

from JetBundleFunctionCategory(JB)

coerce : % -> %

from Algebra(%)

coerce : JB -> %

from JetBundleFunctionCategory(JB)

coerce : AlgebraicNumber -> %

from CoercibleFrom(AlgebraicNumber)

coerce : Expression(Integer) -> %

coerce : Fraction(Integer) -> %

from FunctionSpace2(Integer, Kernel(%))

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

from FunctionSpace2(Integer, Kernel(%))

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

from CoercibleFrom(Fraction(Polynomial(Integer)))

coerce : Integer -> %

from NonAssociativeRing

coerce : Kernel(%) -> %

from CoercibleFrom(Kernel(%))

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

from FunctionSpace2(Integer, Kernel(%))

coerce : Polynomial(Integer) -> %

from CoercibleFrom(Polynomial(Integer))

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

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

coerce : Symbol -> %

from CoercibleFrom(Symbol)

coerce : % -> Expression(Integer)

coerce : % -> OutputForm

from CoercibleTo(OutputForm)

commutator : (%, %) -> %

from NonAssociativeRng

conjugate : % -> %

from SpecialFunctionCategory

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

from Group

const? : % -> Boolean

from JetBundleFunctionCategory(JB)

convert : Factored(%) -> %

from FunctionSpace2(Integer, Kernel(%))

convert : % -> InputForm

from ConvertibleTo(InputForm)

convert : % -> Pattern(Float) if Integer has ConvertibleTo(Pattern(Float))

from ConvertibleTo(Pattern(Float))

convert : % -> Pattern(Integer)

from ConvertibleTo(Pattern(Integer))

cos : % -> %

from TrigonometricFunctionCategory

cosh : % -> %

from HyperbolicFunctionCategory

cot : % -> %

from TrigonometricFunctionCategory

coth : % -> %

from HyperbolicFunctionCategory

csc : % -> %

from TrigonometricFunctionCategory

csch : % -> %

from HyperbolicFunctionCategory

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

from JetBundleFunctionCategory(JB)

definingPolynomial : % -> %

from ExpressionSpace2(Kernel(%))

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

from FunctionSpace2(Integer, Kernel(%))

denominator : % -> %

from FunctionSpace2(Integer, Kernel(%))

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)

digamma : % -> %

from SpecialFunctionCategory

dilog : % -> %

from LiouvillianFunctionCategory

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

from JetBundleFunctionCategory(JB)

diracDelta : % -> %

from SpecialFunctionCategory

distribute : % -> %

from ExpressionSpace2(Kernel(%))

distribute : (%, %) -> %

from ExpressionSpace2(Kernel(%))

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

from EuclideanDomain

ellipticE : % -> %

from SpecialFunctionCategory

ellipticE : (%, %) -> %

from SpecialFunctionCategory

ellipticF : (%, %) -> %

from SpecialFunctionCategory

ellipticK : % -> %

from SpecialFunctionCategory

ellipticPi : (%, %, %) -> %

from SpecialFunctionCategory

elt : (BasicOperator, %) -> %

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

erf : % -> %

from LiouvillianFunctionCategory

erfi : % -> %

from LiouvillianFunctionCategory

euclideanSize : % -> NonNegativeInteger

from EuclideanDomain

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

from InnerEvalable(%, %)

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

from FunctionSpace2(Integer, Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from Evalable(%)

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

from InnerEvalable(Kernel(%), %)

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

from InnerEvalable(%, %)

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

from FunctionSpace2(Integer, Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from Evalable(%)

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

from InnerEvalable(Kernel(%), %)

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

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from FunctionSpace2(Integer, Kernel(%))

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

from FunctionSpace2(Integer, Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from FunctionSpace2(Integer, Kernel(%))

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

from FunctionSpace2(Integer, Kernel(%))

even? : % -> Boolean

from ExpressionSpace2(Kernel(%))

exp : % -> %

from ElementaryFunctionCategory

expressIdealMember : (List(%), %) -> Union(List(%), "failed")

from PrincipalIdealDomain

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, %)

from JetBundleFunctionCategory(JB)

factor : % -> Factored(%)

from UniqueFactorizationDomain

factorial : % -> %

from CombinatorialFunctionCategory

factorials : % -> %

from CombinatorialOpsCategory

factorials : (%, Symbol) -> %

from CombinatorialOpsCategory

floor : % -> %

from SpecialFunctionCategory

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)

fractionPart : % -> %

from SpecialFunctionCategory

freeOf? : (%, %) -> Boolean

from ExpressionSpace2(Kernel(%))

freeOf? : (%, JB) -> Boolean

from JetBundleFunctionCategory(JB)

freeOf? : (%, Symbol) -> Boolean

from ExpressionSpace2(Kernel(%))

fresnelC : % -> %

from LiouvillianFunctionCategory

fresnelS : % -> %

from LiouvillianFunctionCategory

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.

gcd : (%, %) -> %

from GcdDomain

gcd : List(%) -> %

from GcdDomain

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

from GcdDomain

getNotation : () -> Symbol

from JetBundleFunctionCategory(JB)

ground : % -> Integer

from FunctionSpace2(Integer, Kernel(%))

ground? : % -> Boolean

from FunctionSpace2(Integer, Kernel(%))

hahnQ : (%, %, %, %, %) -> %

from SpecialFunctionCategory

hahnR : (%, %, %, %, %) -> %

from SpecialFunctionCategory

hahnS : (%, %, %, %, %) -> %

from SpecialFunctionCategory

hahn_p : (%, %, %, %, %) -> %

from SpecialFunctionCategory

hankelH1 : (%, %) -> %

from SpecialFunctionCategory

hankelH2 : (%, %) -> %

from SpecialFunctionCategory

height : % -> NonNegativeInteger

from ExpressionSpace2(Kernel(%))

hermiteH : (%, %) -> %

from SpecialFunctionCategory

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

from SpecialFunctionCategory

integral : (%, SegmentBinding(%)) -> %

from PrimitiveFunctionCategory

integral : (%, Symbol) -> %

from PrimitiveFunctionCategory

inv : % -> %

from Group

is? : (%, BasicOperator) -> Boolean

from ExpressionSpace2(Kernel(%))

is? : (%, Symbol) -> Boolean

from ExpressionSpace2(Kernel(%))

isExpt : % -> Union(Record(var : Kernel(%), exponent : Integer), "failed")

from FunctionSpace2(Integer, Kernel(%))

isExpt : (%, BasicOperator) -> Union(Record(var : Kernel(%), exponent : Integer), "failed")

from FunctionSpace2(Integer, Kernel(%))

isExpt : (%, Symbol) -> Union(Record(var : Kernel(%), exponent : Integer), "failed")

from FunctionSpace2(Integer, Kernel(%))

isMult : % -> Union(Record(coef : Integer, var : Kernel(%)), "failed")

from FunctionSpace2(Integer, Kernel(%))

isPlus : % -> Union(List(%), "failed")

from FunctionSpace2(Integer, Kernel(%))

isPower : % -> Union(Record(val : %, exponent : Integer), "failed")

from FunctionSpace2(Integer, Kernel(%))

isTimes : % -> Union(List(%), "failed")

from FunctionSpace2(Integer, Kernel(%))

jacobiCn : (%, %) -> %

from SpecialFunctionCategory

jacobiDn : (%, %) -> %

from SpecialFunctionCategory

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

from JetBundleFunctionCategory(JB)

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

from JetBundleFunctionCategory(JB)

jacobiP : (%, %, %, %) -> %

from SpecialFunctionCategory

jacobiSn : (%, %) -> %

from SpecialFunctionCategory

jacobiTheta : (%, %) -> %

from SpecialFunctionCategory

jacobiZeta : (%, %) -> %

from SpecialFunctionCategory

jetVariables : % -> List(JB)

from JetBundleFunctionCategory(JB)

kelvinBei : (%, %) -> %

from SpecialFunctionCategory

kelvinBer : (%, %) -> %

from SpecialFunctionCategory

kelvinKei : (%, %) -> %

from SpecialFunctionCategory

kelvinKer : (%, %) -> %

from SpecialFunctionCategory

kernel : (BasicOperator, %) -> %

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

kernels : % -> List(Kernel(%))

from ExpressionSpace2(Kernel(%))

kernels : List(%) -> List(Kernel(%))

from ExpressionSpace2(Kernel(%))

krawtchoukK : (%, %, %, %) -> %

from SpecialFunctionCategory

kummerM : (%, %, %) -> %

from SpecialFunctionCategory

kummerU : (%, %, %) -> %

from SpecialFunctionCategory

laguerreL : (%, %, %) -> %

from SpecialFunctionCategory

lambertW : % -> %

from SpecialFunctionCategory

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

legendreP : (%, %, %) -> %

from SpecialFunctionCategory

legendreQ : (%, %, %) -> %

from SpecialFunctionCategory

lerchPhi : (%, %, %) -> %

from SpecialFunctionCategory

li : % -> %

from LiouvillianFunctionCategory

log : % -> %

from ElementaryFunctionCategory

lommelS1 : (%, %, %) -> %

from SpecialFunctionCategory

lommelS2 : (%, %, %) -> %

from SpecialFunctionCategory

mainKernel : % -> Union(Kernel(%), "failed")

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from SpecialFunctionCategory

meixnerM : (%, %, %, %) -> %

from SpecialFunctionCategory

meixnerP : (%, %, %, %) -> %

from SpecialFunctionCategory

minPoly : Kernel(%) -> SparseUnivariatePolynomial(%)

from ExpressionSpace2(Kernel(%))

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

from EuclideanDomain

nthRoot : (%, Integer) -> %

from RadicalCategory

numDepVar : () -> PositiveInteger

from JetBundleFunctionCategory(JB)

numIndVar : () -> PositiveInteger

from JetBundleFunctionCategory(JB)

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

from FunctionSpace2(Integer, Kernel(%))

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

numerJP(f) writes f as polynomial over JB.

numerator : % -> %

from FunctionSpace2(Integer, Kernel(%))

odd? : % -> Boolean

from ExpressionSpace2(Kernel(%))

one? : % -> Boolean

from MagmaWithUnit

operator : BasicOperator -> BasicOperator

from ExpressionSpace2(Kernel(%))

operators : % -> List(BasicOperator)

from ExpressionSpace2(Kernel(%))

opposite? : (%, %) -> Boolean

from AbelianMonoid

order : % -> NonNegativeInteger

from JetBundleFunctionCategory(JB)

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

from JetBundleFunctionCategory(JB)

paren : % -> %

from ExpressionSpace2(Kernel(%))

patternMatch : (%, Pattern(Float), PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if Integer has PatternMatchable(Float)

from PatternMatchable(Float)

patternMatch : (%, Pattern(Integer), PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %)

from PatternMatchable(Integer)

permutation : (%, %) -> %

from CombinatorialFunctionCategory

pi : () -> %

from TranscendentalFunctionCategory

plenaryPower : (%, PositiveInteger) -> %

from NonAssociativeAlgebra(Integer)

polygamma : (%, %) -> %

from SpecialFunctionCategory

polylog : (%, %) -> %

from SpecialFunctionCategory

prime? : % -> Boolean

from UniqueFactorizationDomain

principalIdeal : List(%) -> Record(coef : List(%), generator : %)

from PrincipalIdealDomain

product : (%, SegmentBinding(%)) -> %

from CombinatorialOpsCategory

product : (%, Symbol) -> %

from CombinatorialOpsCategory

quo : (%, %) -> %

from EuclideanDomain

racahR : (%, %, %, %, %, %) -> %

from SpecialFunctionCategory

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

from MagmaWithUnit

reduce : % -> %

reduce(x) reduces algebraics in x.

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

from JetBundleFunctionCategory(JB)

reducedSystem : Matrix(%) -> Matrix(Integer)

from LinearlyExplicitOver(Integer)

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

from LinearlyExplicitOver(Integer)

rem : (%, %) -> %

from EuclideanDomain

retract : % -> JB

from RetractableTo(JB)

retract : % -> AlgebraicNumber

from RetractableTo(AlgebraicNumber)

retract : % -> Fraction(Integer)

from RetractableTo(Fraction(Integer))

retract : % -> Fraction(Polynomial(Integer))

from RetractableTo(Fraction(Polynomial(Integer)))

retract : % -> Integer

from RetractableTo(Integer)

retract : % -> Kernel(%)

from RetractableTo(Kernel(%))

retract : % -> Polynomial(Integer)

from RetractableTo(Polynomial(Integer))

retract : % -> Symbol

from RetractableTo(Symbol)

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

from RetractableTo(JB)

retractIfCan : % -> Union(AlgebraicNumber, "failed")

from RetractableTo(AlgebraicNumber)

retractIfCan : % -> Union(Fraction(Integer), "failed")

from RetractableTo(Fraction(Integer))

retractIfCan : % -> Union(Fraction(Polynomial(Integer)), "failed")

from RetractableTo(Fraction(Polynomial(Integer)))

retractIfCan : % -> Union(Integer, "failed")

from RetractableTo(Integer)

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

from RetractableTo(Kernel(%))

retractIfCan : % -> Union(Polynomial(Integer), "failed")

from RetractableTo(Polynomial(Integer))

retractIfCan : % -> Union(Symbol, "failed")

from RetractableTo(Symbol)

riemannZeta : % -> %

from SpecialFunctionCategory

rightPower : (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower : (%, PositiveInteger) -> %

from Magma

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

from MagmaWithUnit

rootOf : % -> %

from AlgebraicallyClosedFunctionSpace(Integer)

rootOf : (%, Symbol) -> %

from AlgebraicallyClosedFunctionSpace(Integer)

rootOf : Polynomial(%) -> %

from AlgebraicallyClosedField

rootOf : SparseUnivariatePolynomial(%) -> %

from AlgebraicallyClosedField

rootOf : (SparseUnivariatePolynomial(%), Symbol) -> %

from AlgebraicallyClosedField

rootSum : (%, SparseUnivariatePolynomial(%), Symbol) -> %

from AlgebraicallyClosedFunctionSpace(Integer)

rootsOf : % -> List(%)

from AlgebraicallyClosedFunctionSpace(Integer)

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

from AlgebraicallyClosedFunctionSpace(Integer)

rootsOf : Polynomial(%) -> List(%)

from AlgebraicallyClosedField

rootsOf : SparseUnivariatePolynomial(%) -> List(%)

from AlgebraicallyClosedField

rootsOf : (SparseUnivariatePolynomial(%), Symbol) -> List(%)

from AlgebraicallyClosedField

sample : () -> %

from AbelianMonoid

sec : % -> %

from TrigonometricFunctionCategory

sech : % -> %

from HyperbolicFunctionCategory

setNotation : Symbol -> Void

from JetBundleFunctionCategory(JB)

sign : % -> %

from SpecialFunctionCategory

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)

sin : % -> %

from TrigonometricFunctionCategory

sinh : % -> %

from HyperbolicFunctionCategory

sizeLess? : (%, %) -> Boolean

from EuclideanDomain

smaller? : (%, %) -> Boolean

from Comparable

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

from JetBundleFunctionCategory(JB)

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

from JetBundleFunctionCategory(JB)

sqrt : % -> %

from RadicalCategory

squareFree : % -> Factored(%)

from UniqueFactorizationDomain

squareFreePart : % -> %

from UniqueFactorizationDomain

struveH : (%, %) -> %

from SpecialFunctionCategory

struveL : (%, %) -> %

from SpecialFunctionCategory

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

from JetBundleFunctionCategory(JB)

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

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from ExpressionSpace2(Kernel(%))

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

from CancellationAbelianMonoid

summation : (%, SegmentBinding(%)) -> %

from CombinatorialOpsCategory

summation : (%, Symbol) -> %

from CombinatorialOpsCategory

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

from JetBundleFunctionCategory(JB)

tan : % -> %

from TrigonometricFunctionCategory

tanh : % -> %

from HyperbolicFunctionCategory

tower : % -> List(Kernel(%))

from ExpressionSpace2(Kernel(%))

tower : List(%) -> List(Kernel(%))

from ExpressionSpace2(Kernel(%))

unit? : % -> Boolean

from EntireRing

unitCanonical : % -> %

from EntireRing

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

from EntireRing

unitStep : % -> %

from SpecialFunctionCategory

univariate : (%, Kernel(%)) -> Fraction(SparseUnivariatePolynomial(%))

from FunctionSpace2(Integer, Kernel(%))

variables : % -> List(Symbol)

from FunctionSpace2(Integer, Kernel(%))

variables : List(%) -> List(Symbol)

from FunctionSpace2(Integer, Kernel(%))

weberE : (%, %) -> %

from SpecialFunctionCategory

weierstrassP : (%, %, %) -> %

from SpecialFunctionCategory

weierstrassPInverse : (%, %, %) -> %

from SpecialFunctionCategory

weierstrassPPrime : (%, %, %) -> %

from SpecialFunctionCategory

weierstrassSigma : (%, %, %) -> %

from SpecialFunctionCategory

weierstrassZeta : (%, %, %) -> %

from SpecialFunctionCategory

whittakerM : (%, %, %) -> %

from SpecialFunctionCategory

whittakerW : (%, %, %) -> %

from SpecialFunctionCategory

wilsonW : (%, %, %, %, %, %) -> %

from SpecialFunctionCategory

zero? : % -> Boolean

from AbelianMonoid

zeroOf : % -> %

from AlgebraicallyClosedFunctionSpace(Integer)

zeroOf : (%, Symbol) -> %

from AlgebraicallyClosedFunctionSpace(Integer)

zeroOf : Polynomial(%) -> %

from AlgebraicallyClosedField

zeroOf : SparseUnivariatePolynomial(%) -> %

from AlgebraicallyClosedField

zeroOf : (SparseUnivariatePolynomial(%), Symbol) -> %

from AlgebraicallyClosedField

zerosOf : % -> List(%)

from AlgebraicallyClosedFunctionSpace(Integer)

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

from AlgebraicallyClosedFunctionSpace(Integer)

zerosOf : Polynomial(%) -> List(%)

from AlgebraicallyClosedField

zerosOf : SparseUnivariatePolynomial(%) -> List(%)

from AlgebraicallyClosedField

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

from AlgebraicallyClosedField

~= : (%, %) -> Boolean

from BasicType

EntireRing

Ring

CoercibleFrom(AlgebraicNumber)

BiModule(Integer, Integer)

Algebra(%)

CoercibleFrom(Kernel(%))

CancellationAbelianMonoid

CommutativeStar

LiouvillianFunctionCategory

ConvertibleTo(Pattern(Float))

Patternable(Integer)

LinearlyExplicitOver(Integer)

SemiGroup

RetractableTo(Kernel(%))

LeftModule(Integer)

AlgebraicallyClosedFunctionSpace(Integer)

Monoid

InnerEvalable(Kernel(%), %)

CombinatorialFunctionCategory

FunctionSpace(Integer)

LeftModule(%)

BiModule(Fraction(Integer), Fraction(Integer))

SpecialFunctionCategory

TrigonometricFunctionCategory

Module(%)

BasicType

JetBundleFunctionCategory(JB)

LeftOreRing

CoercibleFrom(Fraction(Integer))

noZeroDivisors

ExpressionSpace2(Kernel(%))

SemiRing

NonAssociativeAlgebra(%)

CharacteristicNonZero

RetractableTo(AlgebraicNumber)

RetractableTo(Polynomial(Integer))

EuclideanDomain

CoercibleFrom(Fraction(Polynomial(Integer)))

CombinatorialOpsCategory

NonAssociativeRing

CoercibleFrom(Symbol)

NonAssociativeSemiRing

NonAssociativeRng

Field

CoercibleFrom(Polynomial(Integer))

FunctionSpace2(Integer, Kernel(%))

PrincipalIdealDomain

canonicalsClosed

DivisionRing

SetCategory

ArcTrigonometricFunctionCategory

CommutativeRing

ArcHyperbolicFunctionCategory

unitsKnown

AbelianSemiGroup

RetractableTo(JB)

Rng

canonicalUnitNormal

LeftModule(Fraction(Integer))

FullyPatternMatchable(Integer)

FullyLinearlyExplicitOver(Integer)

IntegralDomain

ExpressionSpace

RightModule(Integer)

Evalable(%)

NonAssociativeAlgebra(Fraction(Integer))

AlgebraicallyClosedField

FullyRetractableTo(Integer)

RadicalCategory

Group

NonAssociativeSemiRng

GcdDomain

CharacteristicZero

PatternMatchable(Float)

PartialDifferentialRing(Symbol)

Algebra(Fraction(Integer))

HyperbolicFunctionCategory

AbelianGroup

Module(Integer)

RetractableTo(Fraction(Polynomial(Integer)))

TwoSidedRecip

MagmaWithUnit

PrimitiveFunctionCategory

Comparable

CoercibleFrom(Integer)

AbelianMonoid

PatternMatchable(Integer)

CoercibleTo(OutputForm)

BiModule(%, %)

RetractableTo(Fraction(Integer))

CoercibleFrom(JB)

SemiRng

ConvertibleTo(InputForm)

RetractableTo(Symbol)

RightModule(Fraction(Integer))

NonAssociativeAlgebra(Integer)

InnerEvalable(%, %)

UniqueFactorizationDomain

ElementaryFunctionCategory

TranscendentalFunctionCategory

ConvertibleTo(Pattern(Integer))

Module(Fraction(Integer))

Algebra(Integer)

RightModule(%)

RetractableTo(Integer)

Magma