AlgebraicallyClosedFunctionSpace R¶

Model for algebraically closed function spaces.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from LeftModule %

*: (%, Fraction Integer) -> %
*: (%, Integer) -> % if R has LinearlyExplicitOver Integer
*: (%, R) -> %

from RightModule R

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

from AbelianGroup

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

*: (R, %) -> %

from LeftModule R

+: (%, %) -> %

from AbelianSemiGroup

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

/: (%, %) -> %

from Field

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

from FunctionSpace R

=: (%, %) -> Boolean

from BasicType

^: (%, Fraction Integer) -> %

^: (%, Integer) -> %

from DivisionRing

^: (%, 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: (%, %) -> %
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: (%, %, %) -> %
belong?: BasicOperator -> Boolean

from ExpressionSpace

box: % -> %

from ExpressionSpace

characteristic: () -> NonNegativeInteger
charthRoot: % -> Union(%, failed) if R has CharacteristicNonZero
coerce: % -> %

from Algebra %

coerce: % -> OutputForm
coerce: AlgebraicNumber -> % if R has RetractableTo Integer
coerce: Fraction Integer -> %
coerce: Fraction Polynomial Fraction R -> %

from FunctionSpace R

coerce: Fraction Polynomial R -> %
coerce: Fraction R -> %

from FunctionSpace R

coerce: Integer -> %
coerce: Kernel % -> %

from CoercibleFrom Kernel %

coerce: Polynomial Fraction R -> %

from FunctionSpace R

coerce: Polynomial R -> %
coerce: R -> %

from CoercibleFrom R

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

from FunctionSpace R

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

from Group

convert: % -> InputForm if R has ConvertibleTo InputForm
convert: % -> Pattern Float if R has ConvertibleTo Pattern Float
convert: % -> Pattern Integer if R has ConvertibleTo Pattern Integer
convert: Factored % -> %

from FunctionSpace R

D: (%, List Symbol) -> %
D: (%, List Symbol, List NonNegativeInteger) -> %
D: (%, Symbol) -> %
D: (%, Symbol, NonNegativeInteger) -> %
definingPolynomial: % -> %

from ExpressionSpace

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

from FunctionSpace R

denominator: % -> %

from FunctionSpace R

differentiate: (%, List Symbol) -> %
differentiate: (%, List Symbol, List NonNegativeInteger) -> %
differentiate: (%, Symbol) -> %
differentiate: (%, Symbol, NonNegativeInteger) -> %
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: (%, %, %) -> %

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 %, Symbol) -> % if R has ConvertibleTo InputForm

from FunctionSpace R

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

from ExpressionSpace

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

from ExpressionSpace

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

from Evalable %

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

from InnerEvalable(Kernel %, %)

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

from FunctionSpace R

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

from FunctionSpace R

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

from ExpressionSpace

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

from ExpressionSpace

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

from ExpressionSpace

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

from ExpressionSpace

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

from FunctionSpace R

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

from FunctionSpace R

even?: % -> Boolean if % has RetractableTo Integer

from ExpressionSpace

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

from EntireRing

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

from EuclideanDomain

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

from EuclideanDomain

factor: % -> Factored %
freeOf?: (%, %) -> Boolean

from ExpressionSpace

freeOf?: (%, Symbol) -> Boolean

from ExpressionSpace

gcd: (%, %) -> %

from GcdDomain

gcd: List % -> %

from GcdDomain

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

from GcdDomain

ground?: % -> Boolean

from FunctionSpace R

ground: % -> R

from FunctionSpace R

height: % -> NonNegativeInteger

from ExpressionSpace

inv: % -> %

from DivisionRing

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

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
patternMatch: (%, Pattern Integer, PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if R has PatternMatchable Integer
plenaryPower: (%, PositiveInteger) -> %
prime?: % -> Boolean
principalIdeal: List % -> Record(coef: List %, generator: %)
quo: (%, %) -> %

from EuclideanDomain

recip: % -> Union(%, failed)

from MagmaWithUnit

reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if R has LinearlyExplicitOver Integer
reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix R, vec: Vector R)

from LinearlyExplicitOver R

reducedSystem: Matrix % -> Matrix Integer if R has LinearlyExplicitOver Integer
reducedSystem: Matrix % -> Matrix R

from LinearlyExplicitOver R

rem: (%, %) -> %

from EuclideanDomain

retract: % -> AlgebraicNumber if R has RetractableTo Integer
retract: % -> Fraction Integer if R has RetractableTo Fraction Integer or R has RetractableTo Integer
retract: % -> Fraction Polynomial R
retract: % -> Integer if R has RetractableTo Integer
retract: % -> Kernel %

from RetractableTo Kernel %

retract: % -> Polynomial R
retract: % -> R

from RetractableTo R

retract: % -> Symbol
retractIfCan: % -> Union(AlgebraicNumber, failed) if R has RetractableTo Integer
retractIfCan: % -> Union(Fraction Integer, failed) if R has RetractableTo Fraction Integer or R has RetractableTo Integer
retractIfCan: % -> Union(Fraction Polynomial R, failed)
retractIfCan: % -> Union(Integer, failed) if R has RetractableTo Integer
retractIfCan: % -> Union(Kernel %, failed)

from RetractableTo Kernel %

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

from RetractableTo R

retractIfCan: % -> Union(Symbol, failed)
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) -> %
rootOf: Polynomial % -> %
rootOf: SparseUnivariatePolynomial % -> %
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 %
rootsOf: Polynomial % -> List %
rootsOf: SparseUnivariatePolynomial % -> List %

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

sample: %

from AbelianMonoid

sizeLess?: (%, %) -> Boolean

from EuclideanDomain

smaller?: (%, %) -> Boolean

from Comparable

sqrt: % -> %

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

from ExpressionSpace

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

from ExpressionSpace

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

from ExpressionSpace

subtractIfCan: (%, %) -> Union(%, failed)
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) -> %
zeroOf: Polynomial % -> %
zeroOf: SparseUnivariatePolynomial % -> %
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 %
zerosOf: Polynomial % -> List %
zerosOf: SparseUnivariatePolynomial % -> List %

AbelianGroup

AbelianMonoid

AbelianSemiGroup

AlgebraicallyClosedField

BasicType

BiModule(%, %)

BiModule(R, R)

CancellationAbelianMonoid

canonicalsClosed

canonicalUnitNormal

CommutativeRing

CommutativeStar

Comparable

DivisionRing

EntireRing

EuclideanDomain

ExpressionSpace

Field

GcdDomain

Group if R has Group

InnerEvalable(%, %)

InnerEvalable(Kernel %, %)

IntegralDomain

LeftOreRing

Magma

MagmaWithUnit

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

PrincipalIdealDomain

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

TwoSidedRecip

UniqueFactorizationDomain

unitsKnown