AlgebraicallyClosedFunctionSpace RΒΆ

algfunc.spad line 143

Model for algebraically closed function spaces.

0: %
from AbelianMonoid
1: %
from MagmaWithUnit
*: (%, %) -> %
from Magma
*: (%, Fraction Integer) -> %
from RightModule Fraction Integer
*: (%, R) -> %
from RightModule R
*: (Fraction Integer, %) -> %
from LeftModule Fraction Integer
*: (Integer, %) -> %
from AbelianGroup
*: (NonNegativeInteger, %) -> %
from AbelianMonoid
*: (PositiveInteger, %) -> %
from AbelianSemiGroup
*: (R, %) -> %
from LeftModule R
+: (%, %) -> %
from AbelianSemiGroup
-: % -> %
from AbelianGroup
-: (%, %) -> %
from AbelianGroup
/: (%, %) -> %
from Group
/: (SparseMultivariatePolynomial(R, Kernel %), SparseMultivariatePolynomial(R, Kernel %)) -> %
from FunctionSpace R
=: (%, %) -> Boolean
from BasicType
^: (%, Fraction Integer) -> %
from RadicalCategory
^: (%, Integer) -> %
from Group
^: (%, NonNegativeInteger) -> %
from MagmaWithUnit
^: (%, PositiveInteger) -> %
from Magma
~=: (%, %) -> Boolean
from BasicType
algtower: % -> List Kernel %
from FunctionSpace R
algtower: List % -> List Kernel %
from FunctionSpace R
annihilate?: (%, %) -> Boolean
from Rng
antiCommutator: (%, %) -> %
from NonAssociativeSemiRng
applyQuote: (Symbol, %) -> %
from FunctionSpace R
applyQuote: (Symbol, %, %) -> %
from FunctionSpace R
applyQuote: (Symbol, %, %, %) -> %
from FunctionSpace R
applyQuote: (Symbol, %, %, %, %) -> %
from FunctionSpace R
applyQuote: (Symbol, List %) -> %
from FunctionSpace R
associates?: (%, %) -> Boolean
from EntireRing
associator: (%, %, %) -> %
from NonAssociativeRng
belong?: BasicOperator -> Boolean
from ExpressionSpace
box: % -> %
from ExpressionSpace
characteristic: () -> NonNegativeInteger
from NonAssociativeRing
charthRoot: % -> Union(%, failed) if R has CharacteristicNonZero
from CharacteristicNonZero
coerce: % -> %
from Algebra %
coerce: % -> OutputForm
from CoercibleTo OutputForm
coerce: AlgebraicNumber -> % if R has RetractableTo Integer
from RetractableTo AlgebraicNumber
coerce: Fraction Integer -> %
from Algebra Fraction Integer
coerce: Fraction Polynomial Fraction R -> %
from FunctionSpace R
coerce: Fraction Polynomial R -> %
from RetractableTo Fraction Polynomial R
coerce: Fraction R -> %
from FunctionSpace R
coerce: Integer -> %
from NonAssociativeRing
coerce: Kernel % -> %
from RetractableTo Kernel %
coerce: Polynomial Fraction R -> %
from FunctionSpace R
coerce: Polynomial R -> %
from RetractableTo Polynomial R
coerce: R -> %
from RetractableTo R
coerce: SparseMultivariatePolynomial(R, Kernel %) -> %
from FunctionSpace R
coerce: Symbol -> %
from RetractableTo Symbol
commutator: (%, %) -> %
from NonAssociativeRng
conjugate: (%, %) -> % if R has Group
from Group
convert: % -> InputForm if R has ConvertibleTo InputForm
from ConvertibleTo InputForm
convert: % -> Pattern Float if R has ConvertibleTo Pattern Float
from ConvertibleTo Pattern Float
convert: % -> Pattern Integer if R has ConvertibleTo Pattern Integer
from ConvertibleTo Pattern Integer
convert: Factored % -> %
from FunctionSpace R
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 ExpressionSpace
denom: % -> SparseMultivariatePolynomial(R, Kernel %)
from FunctionSpace R
denominator: % -> %
from FunctionSpace R
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
distribute: % -> %
from ExpressionSpace
distribute: (%, %) -> %
from ExpressionSpace
divide: (%, %) -> Record(quotient: %, remainder: %)
from EuclideanDomain
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
euclideanSize: % -> NonNegativeInteger
from EuclideanDomain
eval: % -> % if R has ConvertibleTo InputForm
from FunctionSpace R
eval: (%, %, %) -> %
from InnerEvalable(%, %)
eval: (%, BasicOperator, % -> %) -> %
from ExpressionSpace
eval: (%, BasicOperator, %, Symbol) -> % if R has ConvertibleTo InputForm
from FunctionSpace R
eval: (%, BasicOperator, List % -> %) -> %
from ExpressionSpace
eval: (%, Equation %) -> %
from Evalable %
eval: (%, Kernel %, %) -> %
from InnerEvalable(Kernel %, %)
eval: (%, List %, List %) -> %
from InnerEvalable(%, %)
eval: (%, List BasicOperator, List % -> %) -> %
from ExpressionSpace
eval: (%, List BasicOperator, List %, Symbol) -> % if R has ConvertibleTo InputForm
from FunctionSpace R
eval: (%, List BasicOperator, List List % -> %) -> %
from ExpressionSpace
eval: (%, List Equation %) -> %
from Evalable %
eval: (%, List Kernel %, List %) -> %
from InnerEvalable(Kernel %, %)
eval: (%, List Symbol) -> % if R has ConvertibleTo InputForm
from FunctionSpace R
eval: (%, List Symbol, List % -> %) -> %
from ExpressionSpace
eval: (%, List Symbol, List List % -> %) -> %
from ExpressionSpace
eval: (%, List Symbol, List NonNegativeInteger, List % -> %) -> %
from FunctionSpace R
eval: (%, List Symbol, List NonNegativeInteger, List List % -> %) -> %
from FunctionSpace R
eval: (%, Symbol) -> % if R has ConvertibleTo InputForm
from FunctionSpace R
eval: (%, Symbol, % -> %) -> %
from ExpressionSpace
eval: (%, Symbol, List % -> %) -> %
from ExpressionSpace
eval: (%, Symbol, NonNegativeInteger, % -> %) -> %
from FunctionSpace R
eval: (%, Symbol, NonNegativeInteger, List % -> %) -> %
from FunctionSpace R
even?: % -> Boolean if % has RetractableTo Integer
from ExpressionSpace
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
factor: % -> Factored %
from UniqueFactorizationDomain
freeOf?: (%, %) -> Boolean
from ExpressionSpace
freeOf?: (%, Symbol) -> Boolean
from ExpressionSpace
gcd: (%, %) -> %
from GcdDomain
gcd: List % -> %
from GcdDomain
gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial %
from GcdDomain
ground: % -> R
from FunctionSpace R
ground?: % -> Boolean
from FunctionSpace R
hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
height: % -> NonNegativeInteger
from ExpressionSpace
inv: % -> %
from Group
is?: (%, BasicOperator) -> Boolean
from ExpressionSpace
is?: (%, Symbol) -> Boolean
from ExpressionSpace
isExpt: % -> Union(Record(var: Kernel %, exponent: Integer), failed)
from FunctionSpace R
isExpt: (%, BasicOperator) -> Union(Record(var: Kernel %, exponent: Integer), failed)
from FunctionSpace R
isExpt: (%, Symbol) -> Union(Record(var: Kernel %, exponent: Integer), failed)
from FunctionSpace R
isMult: % -> Union(Record(coef: Integer, var: Kernel %), failed)
from FunctionSpace R
isPlus: % -> Union(List %, failed)
from FunctionSpace R
isPower: % -> Union(Record(val: %, exponent: Integer), failed)
from FunctionSpace R
isTimes: % -> Union(List %, failed)
from FunctionSpace R
kernel: (BasicOperator, %) -> %
from ExpressionSpace
kernel: (BasicOperator, List %) -> %
from ExpressionSpace
kernels: % -> List Kernel %
from ExpressionSpace
kernels: List % -> List Kernel %
from ExpressionSpace
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
mainKernel: % -> Union(Kernel %, failed)
from ExpressionSpace
map: (% -> %, Kernel %) -> %
from ExpressionSpace
minPoly: Kernel % -> SparseUnivariatePolynomial %
from ExpressionSpace
multiEuclidean: (List %, %) -> Union(List %, failed)
from EuclideanDomain
nthRoot: (%, Integer) -> %
from RadicalCategory
numer: % -> SparseMultivariatePolynomial(R, Kernel %)
from FunctionSpace R
numerator: % -> %
from FunctionSpace R
odd?: % -> Boolean if % has RetractableTo Integer
from ExpressionSpace
one?: % -> Boolean
from MagmaWithUnit
operator: BasicOperator -> BasicOperator
from ExpressionSpace
operators: % -> List BasicOperator
from ExpressionSpace
opposite?: (%, %) -> Boolean
from AbelianMonoid
paren: % -> %
from ExpressionSpace
patternMatch: (%, Pattern Float, PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if R has PatternMatchable Float
from PatternMatchable Float
patternMatch: (%, Pattern Integer, PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if R has PatternMatchable Integer
from PatternMatchable Integer
prime?: % -> Boolean
from UniqueFactorizationDomain
principalIdeal: List % -> Record(coef: List %, generator: %)
from PrincipalIdealDomain
quo: (%, %) -> %
from EuclideanDomain
recip: % -> Union(%, failed)
from MagmaWithUnit
reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if R has LinearlyExplicitOver Integer
from LinearlyExplicitOver Integer
reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix R, vec: Vector R)
from LinearlyExplicitOver R
reducedSystem: Matrix % -> Matrix Integer if R has LinearlyExplicitOver Integer
from LinearlyExplicitOver Integer
reducedSystem: Matrix % -> Matrix R
from LinearlyExplicitOver R
rem: (%, %) -> %
from EuclideanDomain
retract: % -> AlgebraicNumber if R has RetractableTo Integer
from RetractableTo AlgebraicNumber
retract: % -> Fraction Integer if R has RetractableTo Fraction Integer or R has RetractableTo Integer
from RetractableTo Fraction Integer
retract: % -> Fraction Polynomial R
from RetractableTo Fraction Polynomial R
retract: % -> Integer if R has RetractableTo Integer
from RetractableTo Integer
retract: % -> Kernel %
from RetractableTo Kernel %
retract: % -> Polynomial R
from RetractableTo Polynomial R
retract: % -> R
from RetractableTo R
retract: % -> Symbol
from RetractableTo Symbol
retractIfCan: % -> Union(AlgebraicNumber, failed) if R has RetractableTo Integer
from RetractableTo AlgebraicNumber
retractIfCan: % -> Union(Fraction Integer, failed) if R has RetractableTo Fraction Integer or R has RetractableTo Integer
from RetractableTo Fraction Integer
retractIfCan: % -> Union(Fraction Polynomial R, failed)
from RetractableTo Fraction Polynomial R
retractIfCan: % -> Union(Integer, failed) if R has RetractableTo Integer
from RetractableTo Integer
retractIfCan: % -> Union(Kernel %, failed)
from RetractableTo Kernel %
retractIfCan: % -> Union(Polynomial R, failed)
from RetractableTo Polynomial R
retractIfCan: % -> Union(R, failed)
from RetractableTo R
retractIfCan: % -> Union(Symbol, failed)
from RetractableTo Symbol
rightPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit
rightPower: (%, PositiveInteger) -> %
from Magma
rightRecip: % -> Union(%, failed)
from MagmaWithUnit
rootOf: % -> %
rootOf(p) returns y such that p(y) = 0. Error: if p has more than one variable y.
rootOf: (%, Symbol) -> %
rootOf(p, y) returns y such that p(y) = 0. The object returned displays as 'y.
rootOf: (SparseUnivariatePolynomial %, Symbol) -> %
from AlgebraicallyClosedField
rootOf: Polynomial % -> %
from AlgebraicallyClosedField
rootOf: SparseUnivariatePolynomial % -> %
from AlgebraicallyClosedField
rootsOf: % -> List %
rootsOf(p, y) returns [y1, ..., yn] such that p(yi) = 0; Note: the returned values y1, ..., yn contain new symbols which are bound in the interpreter to the respective values. Error: if p has more than one variable y.
rootsOf: (%, Symbol) -> List %
rootsOf(p, y) returns [y1, ..., yn] such that p(yi) = 0; The returned roots contain new symbols '\%z0, '\%z1 ...; Note: the new symbols are bound in the interpreter to the respective values.
rootsOf: (SparseUnivariatePolynomial %, Symbol) -> List %
from AlgebraicallyClosedField
rootsOf: Polynomial % -> List %
from AlgebraicallyClosedField
rootsOf: SparseUnivariatePolynomial % -> List %
from AlgebraicallyClosedField

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

sample: %
from MagmaWithUnit
sizeLess?: (%, %) -> Boolean
from EuclideanDomain
smaller?: (%, %) -> Boolean
from Comparable
sqrt: % -> %
from RadicalCategory
squareFree: % -> Factored %
from UniqueFactorizationDomain
squareFreePart: % -> %
from UniqueFactorizationDomain
subst: (%, Equation %) -> %
from ExpressionSpace
subst: (%, List Equation %) -> %
from ExpressionSpace
subst: (%, List Kernel %, List %) -> %
from ExpressionSpace
subtractIfCan: (%, %) -> Union(%, failed)
from CancellationAbelianMonoid
tower: % -> List Kernel %
from ExpressionSpace
tower: List % -> List Kernel %
from ExpressionSpace
unit?: % -> Boolean
from EntireRing
unitCanonical: % -> %
from EntireRing
unitNormal: % -> Record(unit: %, canonical: %, associate: %)
from EntireRing
univariate: (%, Kernel %) -> Fraction SparseUnivariatePolynomial %
from FunctionSpace R
variables: % -> List Symbol
from FunctionSpace R
variables: List % -> List Symbol
from FunctionSpace R
zero?: % -> Boolean
from AbelianMonoid
zeroOf: % -> %
zeroOf(p) returns y such that p(y) = 0. The value y is expressed in terms of radicals if possible, and otherwise as an implicit algebraic quantity. Error: if p has more than one variable.
zeroOf: (%, Symbol) -> %
zeroOf(p, y) returns y such that p(y) = 0. The value y is expressed in terms of radicals if possible, and otherwise as an implicit algebraic quantity which displays as 'y.
zeroOf: (SparseUnivariatePolynomial %, Symbol) -> %
from AlgebraicallyClosedField
zeroOf: Polynomial % -> %
from AlgebraicallyClosedField
zeroOf: SparseUnivariatePolynomial % -> %
from AlgebraicallyClosedField
zerosOf: % -> List %
zerosOf(p) returns [y1, ..., yn] such that p(yi) = 0. The yi's are expressed in radicals if possible. Note: the returned values y1, ..., yn contain new symbols which are bound in the interpreter to the respective values. Error: if p has more than one variable.
zerosOf: (%, Symbol) -> List %
zerosOf(p, y) returns [y1, ..., yn] such that p(yi) = 0. The yi's are expressed in radicals if possible, and otherwise as implicit algebraic quantities containing new symbols which display as '\%z0, '\%z1, ...; The new symbols are bound in the interpreter to the respective values.
zerosOf: (SparseUnivariatePolynomial %, Symbol) -> List %
from AlgebraicallyClosedField
zerosOf: Polynomial % -> List %
from AlgebraicallyClosedField
zerosOf: SparseUnivariatePolynomial % -> List %
from AlgebraicallyClosedField

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra %

Algebra Fraction Integer

Algebra R

AlgebraicallyClosedField

BasicType

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer)

BiModule(R, R)

CancellationAbelianMonoid

canonicalsClosed

canonicalUnitNormal

CharacteristicNonZero if R has CharacteristicNonZero

CharacteristicZero if R has CharacteristicZero

CoercibleTo OutputForm

CommutativeRing

CommutativeStar

Comparable

ConvertibleTo InputForm if R has ConvertibleTo InputForm

ConvertibleTo Pattern Float if R has ConvertibleTo Pattern Float

ConvertibleTo Pattern Integer if R has ConvertibleTo Pattern Integer

DivisionRing

EntireRing

EuclideanDomain

Evalable %

ExpressionSpace

Field

FullyLinearlyExplicitOver R

FullyPatternMatchable R

FullyRetractableTo R

FunctionSpace R

GcdDomain

Group if R has Group

InnerEvalable(%, %)

InnerEvalable(Kernel %, %)

IntegralDomain

LeftModule %

LeftModule Fraction Integer

LeftModule R

LeftOreRing

LinearlyExplicitOver Integer if R has LinearlyExplicitOver Integer

LinearlyExplicitOver R

Magma

MagmaWithUnit

Module %

Module Fraction Integer

Module R

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

PartialDifferentialRing Symbol

Patternable R

PatternMatchable Float if R has PatternMatchable Float

PatternMatchable Integer if R has PatternMatchable Integer

PrincipalIdealDomain

RadicalCategory

RetractableTo AlgebraicNumber if R has RetractableTo Integer

RetractableTo Fraction Integer if R has RetractableTo Integer or R has RetractableTo Fraction Integer

RetractableTo Fraction Polynomial R

RetractableTo Integer if R has RetractableTo Integer

RetractableTo Kernel %

RetractableTo Polynomial R

RetractableTo R

RetractableTo Symbol

RightModule %

RightModule Fraction Integer

RightModule R

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

UniqueFactorizationDomain

unitsKnown