This domain allows rational numbers to be presented as repeating decimal expansions or more generally as repeating expansions in any base.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from LeftModule %

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

from AbelianGroup

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

+: (%, %) -> %

from AbelianSemiGroup

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

/: (%, %) -> %

from Field

/: (Integer, Integer) -> %
<=: (%, %) -> Boolean

from PartialOrder

<: (%, %) -> Boolean

from PartialOrder

=: (%, %) -> Boolean

from BasicType

>=: (%, %) -> Boolean

from PartialOrder

>: (%, %) -> Boolean

from PartialOrder

^: (%, Integer) -> %

from DivisionRing

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

abs: % -> %

from OrderedRing

annihilate?: (%, %) -> Boolean

from Rng

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

from EntireRing

associator: (%, %, %) -> %
ceiling: % -> Integer
characteristic: () -> NonNegativeInteger
charthRoot: % -> Union(%, failed) if Integer has CharacteristicNonZero or % has CharacteristicNonZero
coerce: % -> %

from Algebra %

coerce: % -> Fraction Integer

`coerce(rx)` converts a radix expansion to a rational number.

coerce: % -> OutputForm
coerce: Fraction Integer -> %
coerce: Integer -> %
coerce: Symbol -> % if Integer has RetractableTo Symbol
commutator: (%, %) -> %
conditionP: Matrix % -> Union(Vector %, failed) if % has CharacteristicNonZero
convert: % -> DoubleFloat
convert: % -> Float
convert: % -> InputForm
convert: % -> Pattern Float if Integer has ConvertibleTo Pattern Float
convert: % -> Pattern Integer
cycleRagits: % -> List Integer

`cycleRagits(rx)` returns the cyclic part of the ragits of the fractional part of a radix expansion. For example, if `x = 3/28 = 0.10 714285 714285 ...`, then `cycleRagits(x) = [7, 1, 4, 2, 8, 5]`.

D: % -> %

from DifferentialRing

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

from DifferentialRing

D: (%, Symbol) -> % if Integer has PartialDifferentialRing Symbol
D: (%, Symbol, NonNegativeInteger) -> % if Integer has PartialDifferentialRing Symbol
denom: % -> Integer
denominator: % -> %
differentiate: % -> %

from DifferentialRing

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

from DifferentialRing

differentiate: (%, Symbol) -> % if Integer has PartialDifferentialRing Symbol
differentiate: (%, Symbol, NonNegativeInteger) -> % if Integer has PartialDifferentialRing Symbol
divide: (%, %) -> Record(quotient: %, remainder: %)

from EuclideanDomain

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

from Eltable(Integer, %)

euclideanSize: % -> NonNegativeInteger

from EuclideanDomain

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

from Evalable Integer

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

from InnerEvalable(Integer, Integer)

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

from Evalable Integer

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

from InnerEvalable(Integer, Integer)

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

from InnerEvalable(Symbol, Integer)

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

from InnerEvalable(Symbol, Integer)

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 %
factorPolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial %
factorSquareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial %
floor: % -> Integer
fractionPart: % -> %
fractionPart: % -> Fraction Integer

`fractionPart(rx)` returns the fractional part of a radix expansion.

fractRadix: (List Integer, List Integer) -> %

`fractRadix(pre, cyc)` creates a fractional radix expansion from a list of prefix ragits and a list of cyclic ragits. For example, `fractRadix([1], [6])` will return `0.16666666...`.

fractRagits: % -> Stream Integer

`fractRagits(rx)` returns the ragits of the fractional part of a radix expansion.

gcd: (%, %) -> %

from GcdDomain

gcd: List % -> %

from GcdDomain

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

from GcdDomain

init: %

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: (Integer -> Integer, %) -> %
max: (%, %) -> %

from OrderedSet

min: (%, %) -> %

from OrderedSet

multiEuclidean: (List %, %) -> Union(List %, failed)

from EuclideanDomain

negative?: % -> Boolean

from OrderedRing

nextItem: % -> Union(%, failed)

from StepThrough

numer: % -> Integer
numerator: % -> %
one?: % -> Boolean

from MagmaWithUnit

opposite?: (%, %) -> Boolean

from AbelianMonoid

patternMatch: (%, Pattern Float, PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if Integer has PatternMatchable Float
patternMatch: (%, Pattern Integer, PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %)
plenaryPower: (%, PositiveInteger) -> %
positive?: % -> Boolean

from OrderedRing

prefixRagits: % -> List Integer

`prefixRagits(rx)` returns the non-cyclic part of the ragits of the fractional part of a radix expansion. For example, if `x = 3/28 = 0.10 714285 714285 ...`, then `prefixRagits(x)=[1, 0]`.

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)
reducedSystem: Matrix % -> Matrix Integer
rem: (%, %) -> %

from EuclideanDomain

retract: % -> Fraction Integer
retract: % -> Integer
retract: % -> Symbol if Integer has RetractableTo Symbol
retractIfCan: % -> Union(Fraction Integer, failed)
retractIfCan: % -> Union(Integer, failed)
retractIfCan: % -> Union(Symbol, failed) if Integer has RetractableTo Symbol
rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

sample: %

from AbelianMonoid

sign: % -> Integer

from OrderedRing

sizeLess?: (%, %) -> Boolean

from EuclideanDomain

smaller?: (%, %) -> Boolean

from Comparable

solveLinearPolynomialEquation: (List SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> Union(List SparseUnivariatePolynomial %, failed)
squareFree: % -> Factored %
squareFreePart: % -> %
squareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial %
subtractIfCan: (%, %) -> Union(%, failed)
unit?: % -> Boolean

from EntireRing

unitCanonical: % -> %

from EntireRing

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

from EntireRing

wholePart: % -> Integer

`wholeRadix(l)` creates an integral radix expansion from a list of ragits. For example, `wholeRadix([1, 3, 4])` will return `134`.

wholeRagits: % -> List Integer

`wholeRagits(rx)` returns the ragits of the integer part of a radix expansion.

zero?: % -> Boolean

from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

BasicType

BiModule(%, %)

CancellationAbelianMonoid

canonicalsClosed

canonicalUnitNormal

CharacteristicZero

CommutativeRing

CommutativeStar

Comparable

DifferentialRing

DivisionRing

Eltable(Integer, %) if Integer has Eltable(Integer, Integer)

EntireRing

EuclideanDomain

Field

GcdDomain

IntegralDomain

LeftOreRing

Magma

MagmaWithUnit

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

OrderedAbelianGroup

OrderedAbelianMonoid

OrderedAbelianSemiGroup

OrderedCancellationAbelianMonoid

OrderedIntegralDomain

OrderedRing

OrderedSet

PartialOrder

PolynomialFactorizationExplicit

PrincipalIdealDomain

RealConstant

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

StepThrough

TwoSidedRecip

UniqueFactorizationDomain

unitsKnown