JetBundleXExpression JBΒΆ

jet.spad line 2820 [edit on github]

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.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

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 Field

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

from FunctionSpace2(Integer, Kernel %)

=: (%, %) -> Boolean

from BasicType

^: (%, %) -> %

from ElementaryFunctionCategory

^: (%, Fraction Integer) -> %

from RadicalCategory

^: (%, Integer) -> %

from DivisionRing

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

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

Beta: (%, %) -> %

from SpecialFunctionCategory

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

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

Chi: % -> %

from LiouvillianFunctionCategory

Ci: % -> %

from LiouvillianFunctionCategory

class: % -> NonNegativeInteger

from JetBundleFunctionCategory JB

coerce: % -> %

from Algebra %

coerce: % -> Expression Integer

coerce: % -> OutputForm

from CoercibleTo OutputForm

coerce: AlgebraicNumber -> %

from CoercibleFrom AlgebraicNumber

coerce: Expression Integer -> %

coerce: Fraction Integer -> %

from Algebra Fraction Integer

coerce: Fraction Polynomial Fraction Integer -> %

from FunctionSpace2(Integer, Kernel %)

coerce: Fraction Polynomial Integer -> %

from CoercibleFrom Fraction Polynomial Integer

coerce: Integer -> %

from NonAssociativeRing

coerce: JB -> %

from JetBundleFunctionCategory JB

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

commutator: (%, %) -> %

from NonAssociativeRng

conjugate: % -> %

from SpecialFunctionCategory

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

from Group

const?: % -> Boolean

from JetBundleFunctionCategory JB

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

convert: Factored % -> %

from FunctionSpace2(Integer, Kernel %)

cos: % -> %

from TrigonometricFunctionCategory

cosh: % -> %

from HyperbolicFunctionCategory

cot: % -> %

from TrigonometricFunctionCategory

coth: % -> %

from HyperbolicFunctionCategory

csc: % -> %

from TrigonometricFunctionCategory

csch: % -> %

from HyperbolicFunctionCategory

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

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

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

from JetBundleFunctionCategory JB

Ei: % -> %

from LiouvillianFunctionCategory

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

from ExpressionSpace2 Kernel %

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

from FunctionSpace2(Integer, Kernel %)

eval: (%, BasicOperator, 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(% -> %)) -> %

from ExpressionSpace2 Kernel %

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

from ExpressionSpace2 Kernel %

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

from Evalable %

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

from InnerEvalable(Kernel %, %)

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

from FunctionSpace2(Integer, Kernel %)

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

from FunctionSpace2(Integer, Kernel %)

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

from ExpressionSpace2 Kernel %

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

from ExpressionSpace2 Kernel %

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

from ExpressionSpace2 Kernel %

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

from ExpressionSpace2 Kernel %

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

from FunctionSpace2(Integer, Kernel %)

eval: (%, Symbol, NonNegativeInteger, 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

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

formalDiff: (%, List NonNegativeInteger) -> %

from JetBundleFunctionCategory JB

formalDiff: (%, PositiveInteger) -> %

from JetBundleFunctionCategory JB

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

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.

Gamma: % -> %

from SpecialFunctionCategory

Gamma: (%, %) -> %

from SpecialFunctionCategory

gcd: (%, %) -> %

from GcdDomain

gcd: List % -> %

from GcdDomain

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

from GcdDomain

getNotation: () -> Symbol

from JetBundleFunctionCategory JB

ground?: % -> Boolean

from FunctionSpace2(Integer, Kernel %)

ground: % -> Integer

from FunctionSpace2(Integer, Kernel %)

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

from SpecialFunctionCategory

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

from SpecialFunctionCategory

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

from SpecialFunctionCategory

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

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 DivisionRing

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 %, List List JB) -> SparseEchelonMatrix(JB, %)

from JetBundleFunctionCategory JB

jacobiMatrix: List % -> 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: (% -> %, 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

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

from FunctionSpace2(Integer, Kernel %)

numerator: % -> %

from FunctionSpace2(Integer, Kernel %)

numIndVar: () -> PositiveInteger

from JetBundleFunctionCategory JB

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

P: (PositiveInteger, List NonNegativeInteger) -> %

from JetBundleFunctionCategory JB

P: (PositiveInteger, NonNegativeInteger) -> %

from JetBundleFunctionCategory JB

P: List NonNegativeInteger -> %

from JetBundleFunctionCategory JB

P: 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 Fraction 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.

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

from LinearlyExplicitOver Integer

reducedSystem: Matrix % -> Matrix Integer

from LinearlyExplicitOver Integer

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

from JetBundleFunctionCategory JB

rem: (%, %) -> %

from EuclideanDomain

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: % -> JB

from RetractableTo JB

retract: % -> Kernel %

from RetractableTo Kernel %

retract: % -> Polynomial Integer

from RetractableTo Polynomial Integer

retract: % -> Symbol

from RetractableTo Symbol

retract: JetBundleExpression JB -> %

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

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(JB, failed)

from RetractableTo JB

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

from RetractableTo Kernel %

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

from RetractableTo Polynomial Integer

retractIfCan: % -> Union(Symbol, failed)

from RetractableTo Symbol

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

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

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: (SparseUnivariatePolynomial %, Symbol) -> %

from AlgebraicallyClosedField

rootOf: Polynomial % -> %

from AlgebraicallyClosedField

rootOf: SparseUnivariatePolynomial % -> %

from AlgebraicallyClosedField

rootsOf: % -> List %

from AlgebraicallyClosedFunctionSpace Integer

rootsOf: (%, Symbol) -> List %

from AlgebraicallyClosedFunctionSpace Integer

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

from AlgebraicallyClosedField

rootsOf: Polynomial % -> List %

from AlgebraicallyClosedField

rootsOf: SparseUnivariatePolynomial % -> List %

from AlgebraicallyClosedField

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

from AlgebraicallyClosedFunctionSpace Integer

sample: %

from AbelianMonoid

sec: % -> %

from TrigonometricFunctionCategory

sech: % -> %

from HyperbolicFunctionCategory

setNotation: Symbol -> Void

from JetBundleFunctionCategory JB

Shi: % -> %

from LiouvillianFunctionCategory

Si: % -> %

from LiouvillianFunctionCategory

sign: % -> %

from SpecialFunctionCategory

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

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

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: (%, Equation %) -> %

from ExpressionSpace2 Kernel %

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

from JetBundleFunctionCategory JB

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 %

U: () -> %

from JetBundleFunctionCategory JB

U: PositiveInteger -> %

from JetBundleFunctionCategory JB

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

X: () -> %

from JetBundleFunctionCategory JB

X: PositiveInteger -> %

from JetBundleFunctionCategory JB

zero?: % -> Boolean

from AbelianMonoid

zeroOf: % -> %

from AlgebraicallyClosedFunctionSpace Integer

zeroOf: (%, Symbol) -> %

from AlgebraicallyClosedFunctionSpace Integer

zeroOf: (SparseUnivariatePolynomial %, Symbol) -> %

from AlgebraicallyClosedField

zeroOf: Polynomial % -> %

from AlgebraicallyClosedField

zeroOf: SparseUnivariatePolynomial % -> %

from AlgebraicallyClosedField

zerosOf: % -> List %

from AlgebraicallyClosedFunctionSpace Integer

zerosOf: (%, Symbol) -> List %

from AlgebraicallyClosedFunctionSpace Integer

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

from AlgebraicallyClosedField

zerosOf: Polynomial % -> List %

from AlgebraicallyClosedField

zerosOf: SparseUnivariatePolynomial % -> List %

from AlgebraicallyClosedField

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra %

Algebra Fraction Integer

Algebra Integer

AlgebraicallyClosedField

AlgebraicallyClosedFunctionSpace Integer

ArcHyperbolicFunctionCategory

ArcTrigonometricFunctionCategory

BasicType

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer)

BiModule(Integer, Integer)

CancellationAbelianMonoid

canonicalsClosed

canonicalUnitNormal

CharacteristicNonZero if Integer has CharacteristicNonZero

CharacteristicZero

CoercibleFrom AlgebraicNumber

CoercibleFrom Fraction Integer

CoercibleFrom Fraction Polynomial Integer

CoercibleFrom Integer

CoercibleFrom JB

CoercibleFrom Kernel %

CoercibleFrom Polynomial Integer

CoercibleFrom Symbol

CoercibleTo OutputForm

CombinatorialFunctionCategory

CombinatorialOpsCategory

CommutativeRing

CommutativeStar

Comparable

ConvertibleTo InputForm

ConvertibleTo Pattern Float if Integer has ConvertibleTo Pattern Float

ConvertibleTo Pattern Integer

DivisionRing

ElementaryFunctionCategory

EntireRing

EuclideanDomain

Evalable %

ExpressionSpace

ExpressionSpace2 Kernel %

Field

FullyLinearlyExplicitOver Integer

FullyPatternMatchable Integer

FullyRetractableTo Integer

FunctionSpace Integer

FunctionSpace2(Integer, Kernel %)

GcdDomain

Group if Integer has Group

HyperbolicFunctionCategory

InnerEvalable(%, %)

InnerEvalable(Kernel %, %)

IntegralDomain

JetBundleBaseFunctionCategory JB

JetBundleFunctionCategory JB

LeftModule %

LeftModule Fraction Integer

LeftModule Integer

LeftOreRing

LinearlyExplicitOver Integer

LiouvillianFunctionCategory

Magma

MagmaWithUnit

Module %

Module Fraction Integer

Module Integer

Monoid

NonAssociativeAlgebra %

NonAssociativeAlgebra Fraction Integer

NonAssociativeAlgebra Integer

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

PartialDifferentialRing Symbol

Patternable Integer

PatternMatchable Float if Integer has PatternMatchable Float

PatternMatchable Integer

PrimitiveFunctionCategory

PrincipalIdealDomain

RadicalCategory

RetractableTo AlgebraicNumber

RetractableTo Fraction Integer

RetractableTo Fraction Polynomial Integer

RetractableTo Integer

RetractableTo JB

RetractableTo Kernel %

RetractableTo Polynomial Integer

RetractableTo Symbol

RightModule %

RightModule Fraction Integer

RightModule Integer

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

SpecialFunctionCategory

TranscendentalFunctionCategory

TrigonometricFunctionCategory

TwoSidedRecip

UniqueFactorizationDomain

unitsKnown