# 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

hash: % -> SingleInteger

from SetCategory

hashUpdate!: (HashState, %) -> HashState

from SetCategory

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

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