JetBundleXExpression(JB)

jet.spad line 2820 [edit on github]

• JB : JetBundleCategory

JetBundleXExpression implements arbitrary functions in a jet bundle which depend only on the independent variables x. Otherwise it is identical with JetBundleExpression. Such a domain is needed for JetLinearFunction.

* : (%, %) -> %

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(Integer, Kernel(%)) -> %

from FunctionSpace2(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(%)) -> %

function(f, arg) generates a function with name f and arguments arg.

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

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 the 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 : JetBundleExpression(JB) -> %

retract(p) is like retractIfCan(p) put yields a hard error, if p contains further jet variables.

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 : JetBundleExpression(JB) -> Union(%, "failed")

retractIfCan(p) checks whether p depends only on the independent variables. If yes, it is coerced.

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

JetBundleBaseFunctionCategory(JB)

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