FunctionSpace2(R, K)

fspace.spad line 389 [edit on github]

• R : Comparable
• K : KernelCategory(%)

A space of formal functions with arguments in an arbitrary ordered set.

* : (%, %) -> % if R has SemiGroup

from Magma

* : (%, R) -> % if R has Ring

from RightModule(R)

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

from RightModule(Fraction(Integer))

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

from RightModule(Integer)

* : (R, %) -> % if R has CommutativeRing

from LeftModule(R)

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

from LeftModule(Fraction(Integer))

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

from AbelianGroup

* : (NonNegativeInteger, %) -> % if R has AbelianSemiGroup

from AbelianMonoid

* : (PositiveInteger, %) -> % if R has AbelianSemiGroup

from AbelianSemiGroup

+ : (%, %) -> % if R has AbelianSemiGroup

from AbelianSemiGroup

- : % -> % if R has AbelianGroup

from AbelianGroup

- : (%, %) -> % if R has AbelianGroup

from AbelianGroup

/ : (%, %) -> % if R has IntegralDomain or R has Group

from Group

/ : (SparseMultivariatePolynomial(R, K), SparseMultivariatePolynomial(R, K)) -> % if R has IntegralDomain

p1/p2 returns the quotient of p1 and p2 as an element of %.

0 : () -> % if R has AbelianSemiGroup

from AbelianMonoid

1 : () -> % if R has SemiGroup

from MagmaWithUnit

= : (%, %) -> Boolean

from BasicType

D : (%, List(Symbol)) -> % if R has Ring

from PartialDifferentialRing(Symbol)

D : (%, List(Symbol), List(NonNegativeInteger)) -> % if R has Ring

from PartialDifferentialRing(Symbol)

D : (%, Symbol) -> % if R has Ring

from PartialDifferentialRing(Symbol)

D : (%, Symbol, NonNegativeInteger) -> % if R has Ring

from PartialDifferentialRing(Symbol)

^ : (%, Integer) -> % if R has IntegralDomain or R has Group

from Group

^ : (%, NonNegativeInteger) -> % if R has SemiGroup

from MagmaWithUnit

^ : (%, PositiveInteger) -> % if R has SemiGroup

from Magma

algtower : % -> List(K) if R has IntegralDomain

algtower(f) is algtower([f])

algtower : List(%) -> List(K) if R has IntegralDomain

algtower([f1, ..., fn]) returns list of kernels [ak1, ..., akl] such that each toplevel algebraic kernel in one of f1, ..., fn or in arguments of ak1, ..., akl is one of ak1, ..., akl.

annihilate? : (%, %) -> Boolean if R has Ring

from Rng

antiCommutator : (%, %) -> % if R has Ring

from NonAssociativeSemiRng

applyQuote : (Symbol, %) -> %

applyQuote(foo, x) returns 'foo(x).

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

applyQuote(foo, x, y) returns 'foo(x, y).

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

applyQuote(foo, x, y, z) returns 'foo(x, y, z).

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

applyQuote(foo, x, y, z, t) returns 'foo(x, y, z, t).

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

applyQuote(foo, [x1, ..., xn]) returns 'foo(x1, ..., xn).

associates? : (%, %) -> Boolean if R has IntegralDomain

from EntireRing

associator : (%, %, %) -> % if R has Ring

from NonAssociativeRng

belong? : BasicOperator -> Boolean

from ExpressionSpace2(K)

box : % -> %

from ExpressionSpace2(K)

characteristic : () -> NonNegativeInteger if R has Ring

from NonAssociativeRing

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

from CharacteristicNonZero

coerce : % -> % if R has IntegralDomain

from Algebra(%)

coerce : K -> %

from CoercibleFrom(K)

coerce : R -> %

from CoercibleFrom(R)

coerce : Fraction(R) -> % if R has IntegralDomain

coerce(q) returns q as an element of %.

coerce : Fraction(Integer) -> % if R has IntegralDomain or R has RetractableTo(Fraction(Integer))

from CoercibleFrom(Fraction(Integer))

coerce : Fraction(Polynomial(R)) -> % if R has IntegralDomain

from CoercibleFrom(Fraction(Polynomial(R)))

coerce : Fraction(Polynomial(Fraction(R))) -> % if R has IntegralDomain

coerce(f) returns f as an element of %.

coerce : Integer -> % if R has Ring or R has RetractableTo(Integer)

from CoercibleFrom(Integer)

coerce : Polynomial(R) -> % if R has Ring

from CoercibleFrom(Polynomial(R))

coerce : Polynomial(Fraction(R)) -> % if R has IntegralDomain

coerce(p) returns p as an element of %.

coerce : SparseMultivariatePolynomial(R, K) -> % if R has Ring

coerce(p) returns p as an element of %.

coerce : Symbol -> %

from CoercibleFrom(Symbol)

coerce : % -> OutputForm

from CoercibleTo(OutputForm)

commutator : (%, %) -> % if R has Ring or R has Group

from NonAssociativeRng

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

from Group

convert : Factored(%) -> % if R has IntegralDomain

convert(f1^e1 ... fm^em) returns (f1)^e1 ... (fm)^em as an element of %, using formal kernels created using a paren.

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

definingPolynomial : % -> % if % has Ring

from ExpressionSpace2(K)

denom : % -> SparseMultivariatePolynomial(R, K) if R has IntegralDomain

denom(f) returns the denominator of f viewed as a polynomial in the kernels over R.

denominator : % -> % if R has IntegralDomain

denominator(f) returns the denominator of f converted to %.

differentiate : (%, List(Symbol)) -> % if R has Ring

from PartialDifferentialRing(Symbol)

differentiate : (%, List(Symbol), List(NonNegativeInteger)) -> % if R has Ring

from PartialDifferentialRing(Symbol)

differentiate : (%, Symbol) -> % if R has Ring

from PartialDifferentialRing(Symbol)

differentiate : (%, Symbol, NonNegativeInteger) -> % if R has Ring

from PartialDifferentialRing(Symbol)

distribute : % -> %

from ExpressionSpace2(K)

distribute : (%, %) -> %

from ExpressionSpace2(K)

divide : (%, %) -> Record(quotient : %, remainder : %) if R has IntegralDomain

from EuclideanDomain

elt : (BasicOperator, %) -> %

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

euclideanSize : % -> NonNegativeInteger if R has IntegralDomain

from EuclideanDomain

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

from InnerEvalable(%, %)

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

from InnerEvalable(K, %)

eval : (%, BasicOperator, %, Symbol) -> % if R has ConvertibleTo(InputForm)

eval(x, s, f, y) replaces every s(a) in x by f(y) with y replaced by a for any a.

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

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

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

from Evalable(%)

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

from InnerEvalable(%, %)

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

from InnerEvalable(K, %)

eval : (%, List(BasicOperator), List(%), Symbol) -> % if R has ConvertibleTo(InputForm)

eval(x, [s1, ..., sm], [f1, ..., fm], y) replaces every si(a) in x by fi(y) with y replaced by a for any a.

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

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

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

from Evalable(%)

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

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

eval : (%, List(Symbol), List(NonNegativeInteger), List(Mapping(%, %))) -> % if R has Ring

eval(x, [s1, ..., sm], [n1, ..., nm], [f1, ..., fm]) replaces every si(a)^ni in x by fi(a) for any a.

eval : (%, List(Symbol), List(NonNegativeInteger), List(Mapping(%, List(%)))) -> % if R has Ring

eval(x, [s1, ..., sm], [n1, ..., nm], [f1, ..., fm]) replaces every si(a1, ..., an)^ni in x by fi(a1, ..., an) for any a1, ..., am.

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

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

eval : (%, Symbol, NonNegativeInteger, Mapping(%, %)) -> % if R has Ring

eval(x, s, n, f) replaces every s(a)^n in x by f(a) for any a.

eval : (%, Symbol, NonNegativeInteger, Mapping(%, List(%))) -> % if R has Ring

eval(x, s, n, f) replaces every s(a1, ..., am)^n in x by f(a1, ..., am) for any a1, ..., am.

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

from ExpressionSpace2(K)

expressIdealMember : (List(%), %) -> Union(List(%), "failed") if R has IntegralDomain

from PrincipalIdealDomain

exquo : (%, %) -> Union(%, "failed") if R has IntegralDomain

from EntireRing

extendedEuclidean : (%, %) -> Record(coef1 : %, coef2 : %, generator : %) if R has IntegralDomain

from EuclideanDomain

extendedEuclidean : (%, %, %) -> Union(Record(coef1 : %, coef2 : %), "failed") if R has IntegralDomain

from EuclideanDomain

factor : % -> Factored(%) if R has IntegralDomain

from UniqueFactorizationDomain

freeOf? : (%, %) -> Boolean

from ExpressionSpace2(K)

freeOf? : (%, Symbol) -> Boolean

from ExpressionSpace2(K)

gcd : (%, %) -> % if R has IntegralDomain

from GcdDomain

gcd : List(%) -> % if R has IntegralDomain

from GcdDomain

gcdPolynomial : (SparseUnivariatePolynomial(%), SparseUnivariatePolynomial(%)) -> SparseUnivariatePolynomial(%) if R has IntegralDomain

from GcdDomain

ground : % -> R

ground(f) returns f as an element of R. An error occurs if f is not an element of R.

ground? : % -> Boolean

ground?(f) tests if f is an element of R.

height : % -> NonNegativeInteger

from ExpressionSpace2(K)

inv : % -> % if R has IntegralDomain or R has Group

from Group

is? : (%, BasicOperator) -> Boolean

from ExpressionSpace2(K)

is? : (%, Symbol) -> Boolean

from ExpressionSpace2(K)

isExpt : % -> Union(Record(var : K, exponent : Integer), "failed") if R has SemiGroup

isExpt(p) returns [x, n] if p = x^n and n ~= 0.

isExpt : (%, BasicOperator) -> Union(Record(var : K, exponent : Integer), "failed") if R has Ring

isExpt(p, op) returns [x, n] if p = x^n and n ~= 0 and x = op(a).

isExpt : (%, Symbol) -> Union(Record(var : K, exponent : Integer), "failed") if R has Ring

isExpt(p, f) returns [x, n] if p = x^n and n ~= 0 and x = f(a).

isMult : % -> Union(Record(coef : Integer, var : K), "failed") if R has AbelianSemiGroup

isMult(p) returns [n, x] if p = n * x and n ~= 0.

isPlus : % -> Union(List(%), "failed") if R has AbelianSemiGroup

isPlus(p) returns [m1, ..., mn] if p = m1 +...+ mn and n > 1.

isPower : % -> Union(Record(val : %, exponent : Integer), "failed") if R has Ring

isPower(p) returns [x, n] if p = x^n and n ~= 0.

isTimes : % -> Union(List(%), "failed") if R has SemiGroup

isTimes(p) returns [a1, ..., an] if p = a1*...*an and n > 1.

kernel : (BasicOperator, %) -> %

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

kernels : % -> List(K)

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

latex : % -> String

from SetCategory

lcm : (%, %) -> % if R has IntegralDomain

from GcdDomain

lcm : List(%) -> % if R has IntegralDomain

from GcdDomain

lcmCoef : (%, %) -> Record(llcm_res : %, coeff1 : %, coeff2 : %) if R has IntegralDomain

from LeftOreRing

leftPower : (%, NonNegativeInteger) -> % if R has SemiGroup

from MagmaWithUnit

leftPower : (%, PositiveInteger) -> % if R has SemiGroup

from Magma

leftRecip : % -> Union(%, "failed") if R has SemiGroup

from MagmaWithUnit

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

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

minPoly : K -> SparseUnivariatePolynomial(%) if % has Ring

from ExpressionSpace2(K)

multiEuclidean : (List(%), %) -> Union(List(%), "failed") if R has IntegralDomain

from EuclideanDomain

numer : % -> SparseMultivariatePolynomial(R, K) if R has Ring

numer(f) returns the numerator of f viewed as a polynomial in the kernels over R if R is an integral domain. If not, then numer(f) = f viewed as a polynomial in the kernels over R.

numerator : % -> % if R has Ring

numerator(f) returns the numerator of f converted to %.

odd? : % -> Boolean if % has RetractableTo(Integer)

from ExpressionSpace2(K)

one? : % -> Boolean if R has SemiGroup

from MagmaWithUnit

operator : BasicOperator -> BasicOperator

from ExpressionSpace2(K)

operators : % -> List(BasicOperator)

from ExpressionSpace2(K)

opposite? : (%, %) -> Boolean if R has AbelianSemiGroup

from AbelianMonoid

paren : % -> %

from ExpressionSpace2(K)

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)

plenaryPower : (%, PositiveInteger) -> % if R has CommutativeRing

from NonAssociativeAlgebra(R)

prime? : % -> Boolean if R has IntegralDomain

from UniqueFactorizationDomain

principalIdeal : List(%) -> Record(coef : List(%), generator : %) if R has IntegralDomain

from PrincipalIdealDomain

quo : (%, %) -> % if R has IntegralDomain

from EuclideanDomain

recip : % -> Union(%, "failed") if R has SemiGroup

from MagmaWithUnit

reducedSystem : Matrix(%) -> Matrix(R) if R has Ring

from LinearlyExplicitOver(R)

reducedSystem : Matrix(%) -> Matrix(Integer) if R has LinearlyExplicitOver(Integer) and R has Ring

from LinearlyExplicitOver(Integer)

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

from LinearlyExplicitOver(R)

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

from LinearlyExplicitOver(Integer)

rem : (%, %) -> % if R has IntegralDomain

from EuclideanDomain

retract : % -> K

from RetractableTo(K)

retract : % -> R

from RetractableTo(R)

retract : % -> Fraction(Integer) if R has RetractableTo(Integer) and R has IntegralDomain or R has RetractableTo(Fraction(Integer))

from RetractableTo(Fraction(Integer))

retract : % -> Fraction(Polynomial(R)) if R has IntegralDomain

from RetractableTo(Fraction(Polynomial(R)))

retract : % -> Integer if R has RetractableTo(Integer)

from RetractableTo(Integer)

retract : % -> Polynomial(R) if R has Ring

from RetractableTo(Polynomial(R))

retract : % -> Symbol

from RetractableTo(Symbol)

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

from RetractableTo(K)

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

from RetractableTo(R)

retractIfCan : % -> Union(Fraction(Integer), "failed") if R has RetractableTo(Integer) and R has IntegralDomain or R has RetractableTo(Fraction(Integer))

from RetractableTo(Fraction(Integer))

retractIfCan : % -> Union(Fraction(Polynomial(R)), "failed") if R has IntegralDomain

from RetractableTo(Fraction(Polynomial(R)))

retractIfCan : % -> Union(Integer, "failed") if R has RetractableTo(Integer)

from RetractableTo(Integer)

retractIfCan : % -> Union(Polynomial(R), "failed") if R has Ring

from RetractableTo(Polynomial(R))

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

from RetractableTo(Symbol)

rightPower : (%, NonNegativeInteger) -> % if R has SemiGroup

from MagmaWithUnit

rightPower : (%, PositiveInteger) -> % if R has SemiGroup

from Magma

rightRecip : % -> Union(%, "failed") if R has SemiGroup

from MagmaWithUnit

sample : () -> % if R has SemiGroup or R has AbelianSemiGroup

from AbelianMonoid

sizeLess? : (%, %) -> Boolean if R has IntegralDomain

from EuclideanDomain

smaller? : (%, %) -> Boolean

from Comparable

squareFree : % -> Factored(%) if R has IntegralDomain

from UniqueFactorizationDomain

squareFreePart : % -> % if R has IntegralDomain

from UniqueFactorizationDomain

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

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

subtractIfCan : (%, %) -> Union(%, "failed") if R has AbelianGroup

from CancellationAbelianMonoid

tower : % -> List(K)

from ExpressionSpace2(K)

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

from ExpressionSpace2(K)

unit? : % -> Boolean if R has IntegralDomain

from EntireRing

unitCanonical : % -> % if R has IntegralDomain

from EntireRing

unitNormal : % -> Record(unit : %, canonical : %, associate : %) if R has IntegralDomain

from EntireRing

univariate : (%, K) -> Fraction(SparseUnivariatePolynomial(%)) if R has IntegralDomain

univariate(f, k) returns f viewed as a univariate fraction in k.

variables : % -> List(Symbol)

variables(f) returns the list of all the variables of f.

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

variables([f1, ..., fn]) returns the list of all the variables of f1, ..., fn.

zero? : % -> Boolean if R has AbelianSemiGroup

from AbelianMonoid

~= : (%, %) -> Boolean

from BasicType

Module(Fraction(Integer))

PrincipalIdealDomain

NonAssociativeSemiRing

RetractableTo(R)

LeftModule(R)

BiModule(%, %)

ConvertibleTo(InputForm)

NonAssociativeRng

Field

canonicalUnitNormal

CoercibleFrom(Integer)

TwoSidedRecip

FullyRetractableTo(R)

SemiRing

NonAssociativeAlgebra(Fraction(Integer))

EuclideanDomain

unitsKnown

FullyLinearlyExplicitOver(R)

Rng

CharacteristicNonZero

RetractableTo(Fraction(Polynomial(R)))

CoercibleFrom(R)

InnerEvalable(%, %)

SemiGroup

RightModule(Fraction(Integer))

Magma

RightModule(R)

RetractableTo(Symbol)

IntegralDomain

LeftModule(%)

ExpressionSpace2(K)

NonAssociativeRing

GcdDomain

PartialDifferentialRing(Symbol)

CharacteristicZero

Group

Algebra(%)

UniqueFactorizationDomain

InnerEvalable(K, %)

CoercibleFrom(K)

Module(R)

CoercibleFrom(Fraction(Polynomial(R)))

BiModule(R, R)

DivisionRing

Algebra(R)

canonicalsClosed

LinearlyExplicitOver(R)

PatternMatchable(Float)

CancellationAbelianMonoid

Comparable

RetractableTo(Integer)

CommutativeStar

AbelianMonoid

MagmaWithUnit

CoercibleFrom(Symbol)

RightModule(%)

CommutativeRing

CoercibleFrom(Polynomial(R))

RetractableTo(K)

Module(%)

CoercibleTo(OutputForm)

LinearlyExplicitOver(Integer)

LeftOreRing

ConvertibleTo(Pattern(Integer))

SemiRng

Patternable(R)

Monoid

NonAssociativeAlgebra(R)

NonAssociativeAlgebra(%)

Algebra(Fraction(Integer))

ConvertibleTo(Pattern(Float))

BasicType

RetractableTo(Polynomial(R))

Ring

RightModule(Integer)

LeftModule(Fraction(Integer))

AbelianSemiGroup

SetCategory

noZeroDivisors

EntireRing

CoercibleFrom(Fraction(Integer))

NonAssociativeSemiRng

Evalable(%)

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

FullyPatternMatchable(R)

RetractableTo(Fraction(Integer))

AbelianGroup

PatternMatchable(Integer)