QuotientFieldCategory(S)

fraction.spad line 81 [edit on github]

QuotientField(S) is the category of fractions of an Integral Domain S.

* : (%, %) -> %
from Magma
* : (%, S) -> %
from RightModule(S)
* : (%, Fraction(Integer)) -> %
from RightModule(Fraction(Integer))
* : (%, Integer) -> % if S has LinearlyExplicitOver(Integer)
from RightModule(Integer)
* : (S, %) -> %
from LeftModule(S)
* : (Fraction(Integer), %) -> %
from LeftModule(Fraction(Integer))
* : (Integer, %) -> %
from AbelianGroup
* : (NonNegativeInteger, %) -> %
from AbelianMonoid
* : (PositiveInteger, %) -> %
from AbelianSemiGroup
+ : (%, %) -> %
from AbelianSemiGroup
- : % -> %
from AbelianGroup
- : (%, %) -> %
from AbelianGroup
/ : (%, %) -> %
from Field
/ : (S, S) -> %

d1 / d2 returns the fraction d1 divided by d2.

0 : () -> %
from AbelianMonoid
1 : () -> %
from MagmaWithUnit
< : (%, %) -> Boolean if S has OrderedSet
from PartialOrder
<= : (%, %) -> Boolean if S has OrderedSet
from PartialOrder
= : (%, %) -> Boolean
from BasicType
> : (%, %) -> Boolean if S has OrderedSet
from PartialOrder
>= : (%, %) -> Boolean if S has OrderedSet
from PartialOrder
D : % -> % if S has DifferentialRing
from DifferentialRing
D : (%, List(Symbol)) -> % if S has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
D : (%, List(Symbol), List(NonNegativeInteger)) -> % if S has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
D : (%, Mapping(S, S)) -> %
from DifferentialExtension(S)
D : (%, Mapping(S, S), NonNegativeInteger) -> %
from DifferentialExtension(S)
D : (%, NonNegativeInteger) -> % if S has DifferentialRing
from DifferentialRing
D : (%, Symbol) -> % if S has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
D : (%, Symbol, NonNegativeInteger) -> % if S has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
^ : (%, Integer) -> %
from DivisionRing
^ : (%, NonNegativeInteger) -> %
from MagmaWithUnit
^ : (%, PositiveInteger) -> %
from Magma
abs : % -> % if S has OrderedIntegralDomain
from OrderedRing
annihilate? : (%, %) -> Boolean
from Rng
antiCommutator : (%, %) -> %
from NonAssociativeSemiRng
associates? : (%, %) -> Boolean
from EntireRing
associator : (%, %, %) -> %
from NonAssociativeRng
ceiling : % -> S if S has IntegerNumberSystem

ceiling(x) returns the smallest integral element above x.

characteristic : () -> NonNegativeInteger
from NonAssociativeRing
charthRoot : % -> Union(%, "failed") if % has CharacteristicNonZero and S has PolynomialFactorizationExplicit or S has CharacteristicNonZero
from CharacteristicNonZero
coerce : % -> %
from Algebra(%)
coerce : S -> %
from CoercibleFrom(S)
coerce : Fraction(Integer) -> %
from CoercibleFrom(Fraction(Integer))
coerce : Integer -> %
from NonAssociativeRing
coerce : Symbol -> % if S has RetractableTo(Symbol)
from CoercibleFrom(Symbol)
coerce : % -> OutputForm
from CoercibleTo(OutputForm)
commutator : (%, %) -> %
from NonAssociativeRng
conditionP : Matrix(%) -> Union(Vector(%), "failed") if % has CharacteristicNonZero and S has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
convert : % -> DoubleFloat if S has RealConstant
from ConvertibleTo(DoubleFloat)
convert : % -> Float if S has RealConstant
from ConvertibleTo(Float)
convert : % -> InputForm if S has ConvertibleTo(InputForm)
from ConvertibleTo(InputForm)
convert : % -> Pattern(Float) if S has ConvertibleTo(Pattern(Float))
from ConvertibleTo(Pattern(Float))
convert : % -> Pattern(Integer) if S has ConvertibleTo(Pattern(Integer))
from ConvertibleTo(Pattern(Integer))
denom : % -> S

denom(x) returns the denominator of the fraction x.

denominator : % -> %

denominator(x) is the denominator of the fraction x converted to %.

differentiate : % -> % if S has DifferentialRing
from DifferentialRing
differentiate : (%, List(Symbol)) -> % if S has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
differentiate : (%, List(Symbol), List(NonNegativeInteger)) -> % if S has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
differentiate : (%, Mapping(S, S)) -> %
from DifferentialExtension(S)
differentiate : (%, Mapping(S, S), NonNegativeInteger) -> %
from DifferentialExtension(S)
differentiate : (%, NonNegativeInteger) -> % if S has DifferentialRing
from DifferentialRing
differentiate : (%, Symbol) -> % if S has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
differentiate : (%, Symbol, NonNegativeInteger) -> % if S has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
divide : (%, %) -> Record(quotient : %, remainder : %)
from EuclideanDomain
elt : (%, S) -> % if S has Eltable(S, S)
from Eltable(S, %)
euclideanSize : % -> NonNegativeInteger
from EuclideanDomain
eval : (%, S, S) -> % if S has Evalable(S)
from InnerEvalable(S, S)
eval : (%, Equation(S)) -> % if S has Evalable(S)
from Evalable(S)
eval : (%, List(S), List(S)) -> % if S has Evalable(S)
from InnerEvalable(S, S)
eval : (%, List(Equation(S))) -> % if S has Evalable(S)
from Evalable(S)
eval : (%, List(Symbol), List(S)) -> % if S has InnerEvalable(Symbol, S)
from InnerEvalable(Symbol, S)
eval : (%, Symbol, S) -> % if S has InnerEvalable(Symbol, S)
from InnerEvalable(Symbol, S)
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
factorPolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if S has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
factorSquareFreePolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if S has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
floor : % -> S if S has IntegerNumberSystem

floor(x) returns the largest integral element below x.

fractionPart : % -> % if S has EuclideanDomain

fractionPart(x) returns the fractional part of x. x = wholePart(x) + fractionPart(x)

gcd : (%, %) -> %
from GcdDomain
gcd : List(%) -> %
from GcdDomain
gcdPolynomial : (SparseUnivariatePolynomial(%), SparseUnivariatePolynomial(%)) -> SparseUnivariatePolynomial(%)
from PolynomialFactorizationExplicit
init : () -> % if S has StepThrough
from StepThrough
inv : % -> %
from DivisionRing
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
map : (Mapping(S, S), %) -> %
from FullyEvalableOver(S)
max : (%, %) -> % if S has OrderedSet
from OrderedSet
min : (%, %) -> % if S has OrderedSet
from OrderedSet
multiEuclidean : (List(%), %) -> Union(List(%), "failed")
from EuclideanDomain
negative? : % -> Boolean if S has OrderedIntegralDomain
from OrderedRing
nextItem : % -> Union(%, "failed") if S has StepThrough
from StepThrough
numer : % -> S

numer(x) returns the numerator of the fraction x.

numerator : % -> %

numerator(x) is the numerator of the fraction x converted to %.

one? : % -> Boolean
from MagmaWithUnit
opposite? : (%, %) -> Boolean
from AbelianMonoid
patternMatch : (%, Pattern(Float), PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if S has PatternMatchable(Float)
from PatternMatchable(Float)
patternMatch : (%, Pattern(Integer), PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if S has PatternMatchable(Integer)
from PatternMatchable(Integer)
plenaryPower : (%, PositiveInteger) -> %
from NonAssociativeAlgebra(%)
positive? : % -> Boolean if S has OrderedIntegralDomain
from OrderedRing
prime? : % -> Boolean
from UniqueFactorizationDomain
principalIdeal : List(%) -> Record(coef : List(%), generator : %)
from PrincipalIdealDomain
quo : (%, %) -> %
from EuclideanDomain
recip : % -> Union(%, "failed")
from MagmaWithUnit
reducedSystem : Matrix(%) -> Matrix(S)
from LinearlyExplicitOver(S)
reducedSystem : Matrix(%) -> Matrix(Integer) if S has LinearlyExplicitOver(Integer)
from LinearlyExplicitOver(Integer)
reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(S), vec : Vector(S))
from LinearlyExplicitOver(S)
reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(Integer), vec : Vector(Integer)) if S has LinearlyExplicitOver(Integer)
from LinearlyExplicitOver(Integer)
rem : (%, %) -> %
from EuclideanDomain
retract : % -> S
from RetractableTo(S)
retract : % -> Fraction(Integer) if S has RetractableTo(Integer)
from RetractableTo(Fraction(Integer))
retract : % -> Integer if S has RetractableTo(Integer)
from RetractableTo(Integer)
retract : % -> Symbol if S has RetractableTo(Symbol)
from RetractableTo(Symbol)
retractIfCan : % -> Union(S, "failed")
from RetractableTo(S)
retractIfCan : % -> Union(Fraction(Integer), "failed") if S has RetractableTo(Integer)
from RetractableTo(Fraction(Integer))
retractIfCan : % -> Union(Integer, "failed") if S has RetractableTo(Integer)
from RetractableTo(Integer)
retractIfCan : % -> Union(Symbol, "failed") if S has RetractableTo(Symbol)
from RetractableTo(Symbol)
rightPower : (%, NonNegativeInteger) -> %
from MagmaWithUnit
rightPower : (%, PositiveInteger) -> %
from Magma
rightRecip : % -> Union(%, "failed")
from MagmaWithUnit
sample : () -> %
from AbelianMonoid
sign : % -> Integer if S has OrderedIntegralDomain
from OrderedRing
sizeLess? : (%, %) -> Boolean
from EuclideanDomain
smaller? : (%, %) -> Boolean if S has Comparable
from Comparable
solveLinearPolynomialEquation : (List(SparseUnivariatePolynomial(%)), SparseUnivariatePolynomial(%)) -> Union(List(SparseUnivariatePolynomial(%)), "failed") if S has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
squareFree : % -> Factored(%)
from UniqueFactorizationDomain
squareFreePart : % -> %
from UniqueFactorizationDomain
squareFreePolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if S has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
subtractIfCan : (%, %) -> Union(%, "failed")
from CancellationAbelianMonoid
unit? : % -> Boolean
from EntireRing
unitCanonical : % -> %
from EntireRing
unitNormal : % -> Record(unit : %, canonical : %, associate : %)
from EntireRing
wholePart : % -> S if S has EuclideanDomain

wholePart(x) returns the whole part of the fraction x i.e. the truncated quotient of the numerator by the denominator.

zero? : % -> Boolean
from AbelianMonoid
~= : (%, %) -> Boolean
from BasicType

LinearlyExplicitOver(S)

Module(Fraction(Integer))

ConvertibleTo(Float)

PrincipalIdealDomain

PartialOrder

NonAssociativeSemiRing

BiModule(%, %)

ConvertibleTo(InputForm)

Field

canonicalUnitNormal

Rng

CoercibleFrom(Integer)

TwoSidedRecip

SemiRing

EntireRing

NonAssociativeAlgebra(Fraction(Integer))

CharacteristicNonZero

DifferentialExtension(S)

unitsKnown

InnerEvalable(Symbol, S)

NonAssociativeAlgebra(S)

Patternable(S)

LinearlyExplicitOver(Integer)

noZeroDivisors

RetractableTo(Fraction(Integer))

FullyPatternMatchable(S)

CoercibleFrom(S)

SemiGroup

RightModule(Fraction(Integer))

Magma

GcdDomain

IntegralDomain

LeftModule(%)

NonAssociativeRing

PatternMatchable(Float)

UniqueFactorizationDomain

RetractableTo(S)

PartialDifferentialRing(Symbol)

CharacteristicZero

InnerEvalable(S, S)

RightModule(S)

OrderedIntegralDomain

Algebra(%)

DifferentialRing

OrderedAbelianMonoid

DivisionRing

CommutativeRing

canonicalsClosed

NonAssociativeSemiRng

CancellationAbelianMonoid

EuclideanDomain

Module(S)

Comparable

RetractableTo(Integer)

OrderedCancellationAbelianMonoid

OrderedRing

RetractableTo(Symbol)

OrderedSet

CommutativeStar

AbelianMonoid

MagmaWithUnit

CoercibleFrom(Symbol)

RightModule(%)

RealConstant

Evalable(S)

LeftModule(S)

ConvertibleTo(DoubleFloat)

OrderedAbelianSemiGroup

Module(%)

CoercibleTo(OutputForm)

ConvertibleTo(Pattern(Integer))

SemiRng

Monoid

PolynomialFactorizationExplicit

LeftOreRing

NonAssociativeAlgebra(%)

Algebra(Fraction(Integer))

ConvertibleTo(Pattern(Float))

Algebra(S)

BiModule(S, S)

BasicType

Ring

RightModule(Integer)

Eltable(S, %)

LeftModule(Fraction(Integer))

AbelianSemiGroup

SetCategory

FullyLinearlyExplicitOver(S)

CoercibleFrom(Fraction(Integer))

FullyEvalableOver(S)

NonAssociativeRng

PatternMatchable(Integer)

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

OrderedAbelianGroup

StepThrough

AbelianGroup