Factored R¶

Factored creates a domain whose objects are kept in factored form as long as possible. Thus certain operations like multiplication and `gcd` are relatively easy to do. Others, like addition require somewhat more work, and unless the argument domain provides a factor function, the result may not be completely factored. Each object consists of a unit and a list of factors, where a factor has a member of `R` (the “base”), and exponent and a flag indicating what is known about the base. A flag may be one of “nil”, “sqfr”, “irred” or “prime”, which respectively mean that nothing is known about the base, it is square-free, it is irreducible, or it is prime. The current restriction to integral domains allows simplification to be performed without worrying about multiplication order.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from LeftModule %

*: (%, R) -> %

from RightModule R

*: (Integer, %) -> %

from AbelianGroup

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

*: (R, %) -> %

from LeftModule R

+: (%, %) -> %

from AbelianSemiGroup

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

=: (%, %) -> Boolean

from BasicType

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

annihilate?: (%, %) -> Boolean

from Rng

antiCommutator: (%, %) -> %
associates?: (%, %) -> Boolean

from EntireRing

associator: (%, %, %) -> %
characteristic: () -> NonNegativeInteger
coerce: % -> %

from Algebra %

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

from CoercibleFrom R

commutator: (%, %) -> %
convert: % -> DoubleFloat if R has RealConstant
convert: % -> Float if R has RealConstant
convert: % -> InputForm if R has ConvertibleTo InputForm
D: % -> % if R has DifferentialRing

from DifferentialRing

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

from DifferentialRing

D: (%, R -> R) -> %
D: (%, R -> R, NonNegativeInteger) -> %
D: (%, Symbol) -> % if R has PartialDifferentialRing Symbol
D: (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol
differentiate: % -> % if R has DifferentialRing

from DifferentialRing

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

from DifferentialRing

differentiate: (%, R -> R) -> %
differentiate: (%, R -> R, NonNegativeInteger) -> %
differentiate: (%, Symbol) -> % if R has PartialDifferentialRing Symbol
differentiate: (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol
elt: (%, %) -> % if R has Eltable(%, %)

from Eltable(%, %)

elt: (%, R) -> % if R has Eltable(R, R)

from Eltable(R, %)

eval: (%, %, %) -> % if R has Evalable %

from InnerEvalable(%, %)

eval: (%, Equation %) -> % if R has Evalable %

from Evalable %

eval: (%, Equation R) -> % if R has Evalable R

from Evalable R

eval: (%, List %, List %) -> % if R has Evalable %

from InnerEvalable(%, %)

eval: (%, List Equation %) -> % if R has Evalable %

from Evalable %

eval: (%, List Equation R) -> % if R has Evalable R

from Evalable R

eval: (%, List R, List R) -> % if R has Evalable R

from InnerEvalable(R, R)

eval: (%, List Symbol, List %) -> % if R has InnerEvalable(Symbol, %)

from InnerEvalable(Symbol, %)

eval: (%, List Symbol, List R) -> % if R has InnerEvalable(Symbol, R)

from InnerEvalable(Symbol, R)

eval: (%, R, R) -> % if R has Evalable R

from InnerEvalable(R, R)

eval: (%, Symbol, %) -> % if R has InnerEvalable(Symbol, %)

from InnerEvalable(Symbol, %)

eval: (%, Symbol, R) -> % if R has InnerEvalable(Symbol, R)

from InnerEvalable(Symbol, R)

expand: % -> R

`expand(f)` multiplies the unit and factors together, yielding an “unfactored” object. Note: this is purposely not called coerce which would cause the interpreter to do this automatically.

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

from EntireRing

factor: % -> Factored % if R has UniqueFactorizationDomain
factorList: % -> List Record(flag: Union(nil, sqfr, irred, prime), factor: R, exponent: NonNegativeInteger)

`factorList(u)` returns the list of factors with flags (for use by factoring code).

factors: % -> List Record(factor: R, exponent: NonNegativeInteger)

`factors(u)` returns a list of the factors in a form suitable for iteration. That is, it returns a list where each element is a record containing a base and exponent. The original object is the product of all the factors and the unit (which can be extracted by `unit(u)`).

flagFactor: (R, NonNegativeInteger, Union(nil, sqfr, irred, prime)) -> %

`flagFactor(base, exponent, flag)` creates a factored object with a single factor whose `base` is asserted to be properly described by the information flag.

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

from GcdDomain

gcd: List % -> % if R has GcdDomain

from GcdDomain

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

from GcdDomain

irreducibleFactor: (R, NonNegativeInteger) -> %

`irreducibleFactor(base, exponent)` creates a factored object with a single factor whose `base` is asserted to be irreducible (flag = “irred”).

latex: % -> String

from SetCategory

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

from GcdDomain

lcm: List % -> % if R has GcdDomain

from GcdDomain

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

from LeftOreRing

leftPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower: (%, PositiveInteger) -> %

from Magma

leftRecip: % -> Union(%, failed)

from MagmaWithUnit

makeFR: (R, List Record(flag: Union(nil, sqfr, irred, prime), factor: R, exponent: NonNegativeInteger)) -> %

`makeFR(unit, listOfFactors)` creates a factored object (for use by factoring code).

map: (R -> R, %) -> %

`map(fn, u)` maps the function userfun{`fn`} across the factors of spadvar{`u`} and creates a new factored object. Note: this clears the information flags (sets them to “nil”) because the effect of userfun{`fn`} is clearly not known in general.

mergeFactors: (%, %) -> %

`mergeFactors(u, v)` is used when the factorizations of spadvar{`u`} and spadvar{`v`} are known to be disjoint, e.g. resulting from a content/primitive part split. Essentially, it creates a new factored object by multiplying the units together and appending the lists of factors.

nilFactor: (R, NonNegativeInteger) -> %

`nilFactor(base, exponent)` creates a factored object with a single factor with no information about the kind of `base` (flag = “nil”).

numberOfFactors: % -> NonNegativeInteger

`numberOfFactors(u)` returns the number of factors in spadvar{`u`}.

one?: % -> Boolean

from MagmaWithUnit

opposite?: (%, %) -> Boolean

from AbelianMonoid

plenaryPower: (%, PositiveInteger) -> %
prime?: % -> Boolean if R has UniqueFactorizationDomain
primeFactor: (R, NonNegativeInteger) -> %

`primeFactor(base, exponent)` creates a factored object with a single factor whose `base` is asserted to be prime (flag = “prime”).

rational?: % -> Boolean if R has IntegerNumberSystem

`rational?(u)` tests if spadvar{`u`} is actually a rational number (see Fraction Integer).

rational: % -> Fraction Integer if R has IntegerNumberSystem

`rational(u)` assumes spadvar{`u`} is actually a rational number and does the conversion to rational number (see Fraction Integer).

rationalIfCan: % -> Union(Fraction Integer, failed) if R has IntegerNumberSystem

`rationalIfCan(u)` returns a rational number if `u` really is one, and “failed” otherwise.

recip: % -> Union(%, failed)

from MagmaWithUnit

retract: % -> Fraction Integer if R has RetractableTo Fraction Integer
retract: % -> Integer if R has RetractableTo Integer
retract: % -> R

from RetractableTo R

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

from RetractableTo R

rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

sample: %

from AbelianMonoid

sqfrFactor: (R, NonNegativeInteger) -> %

`sqfrFactor(base, exponent)` creates a factored object with a single factor whose `base` is asserted to be square-free (flag = “sqfr”).

squareFree: % -> Factored % if R has UniqueFactorizationDomain
squareFreePart: % -> % if R has UniqueFactorizationDomain
subtractIfCan: (%, %) -> Union(%, failed)
unit?: % -> Boolean

from EntireRing

unit: % -> R

`unit(u)` extracts the unit part of the factorization.

unitCanonical: % -> %

from EntireRing

unitNormal: % -> Record(unit: %, canonical: %, associate: %)

from EntireRing

unitNormalize: % -> %

`unitNormalize(u)` normalizes the unit part of the factorization. For example, when working with factored integers, this operation will ensure that the bases are all positive integers.

zero?: % -> Boolean

from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

BasicType

BiModule(%, %)

BiModule(R, R)

CancellationAbelianMonoid

CommutativeRing

CommutativeStar

ConvertibleTo Float if R has RealConstant

DifferentialRing if R has DifferentialRing

Eltable(%, %) if R has Eltable(%, %)

Eltable(R, %) if R has Eltable(R, R)

EntireRing

Evalable % if R has Evalable %

Evalable R if R has Evalable R

GcdDomain if R has GcdDomain

InnerEvalable(%, %) if R has Evalable %

InnerEvalable(R, R) if R has Evalable R

InnerEvalable(Symbol, %) if R has InnerEvalable(Symbol, %)

InnerEvalable(Symbol, R) if R has InnerEvalable(Symbol, R)

IntegralDomain

LeftOreRing if R has GcdDomain

Magma

MagmaWithUnit

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

RealConstant if R has RealConstant

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

TwoSidedRecip

unitsKnown