PAdicRationalConstructor(p, PADIC)

padic.spad line 327 [edit on github]

This is the category of stream-based representations of Qp.

* : (%, %) -> %
from Magma
* : (%, PADIC) -> %
from RightModule(PADIC)
* : (%, Fraction(Integer)) -> %
from RightModule(Fraction(Integer))
* : (%, Integer) -> % if PADIC has LinearlyExplicitOver(Integer)
from RightModule(Integer)
* : (PADIC, %) -> %
from LeftModule(PADIC)
* : (Fraction(Integer), %) -> %
from LeftModule(Fraction(Integer))
* : (Integer, %) -> %
from AbelianGroup
* : (NonNegativeInteger, %) -> %
from AbelianMonoid
* : (PositiveInteger, %) -> %
from AbelianSemiGroup
+ : (%, %) -> %
from AbelianSemiGroup
- : % -> %
from AbelianGroup
- : (%, %) -> %
from AbelianGroup
/ : (%, %) -> %
from Field
/ : (PADIC, PADIC) -> %
from QuotientFieldCategory(PADIC)
0 : () -> %
from AbelianMonoid
1 : () -> %
from MagmaWithUnit
< : (%, %) -> Boolean if PADIC has OrderedSet
from PartialOrder
<= : (%, %) -> Boolean if PADIC has OrderedSet
from PartialOrder
= : (%, %) -> Boolean
from BasicType
> : (%, %) -> Boolean if PADIC has OrderedSet
from PartialOrder
>= : (%, %) -> Boolean if PADIC has OrderedSet
from PartialOrder
D : % -> % if PADIC has DifferentialRing
from DifferentialRing
D : (%, List(Symbol)) -> % if PADIC has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
D : (%, List(Symbol), List(NonNegativeInteger)) -> % if PADIC has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
D : (%, Mapping(PADIC, PADIC)) -> %
from DifferentialExtension(PADIC)
D : (%, Mapping(PADIC, PADIC), NonNegativeInteger) -> %
from DifferentialExtension(PADIC)
D : (%, NonNegativeInteger) -> % if PADIC has DifferentialRing
from DifferentialRing
D : (%, Symbol) -> % if PADIC has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
D : (%, Symbol, NonNegativeInteger) -> % if PADIC has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
^ : (%, Integer) -> %
from DivisionRing
^ : (%, NonNegativeInteger) -> %
from MagmaWithUnit
^ : (%, PositiveInteger) -> %
from Magma
abs : % -> % if PADIC has OrderedIntegralDomain
from OrderedRing
annihilate? : (%, %) -> Boolean
from Rng
antiCommutator : (%, %) -> %
from NonAssociativeSemiRng
approximate : (%, Integer) -> Fraction(Integer)

approximate(x, n) returns a rational number y such that y = x (mod p^n).

associates? : (%, %) -> Boolean
from EntireRing
associator : (%, %, %) -> %
from NonAssociativeRng
ceiling : % -> PADIC if PADIC has IntegerNumberSystem
from QuotientFieldCategory(PADIC)
characteristic : () -> NonNegativeInteger
from NonAssociativeRing
charthRoot : % -> Union(%, "failed") if PADIC has CharacteristicNonZero or PADIC has PolynomialFactorizationExplicit and % has CharacteristicNonZero
from CharacteristicNonZero
coerce : % -> %
from Algebra(%)
coerce : PADIC -> %
from Algebra(PADIC)
coerce : Fraction(Integer) -> %
from CoercibleFrom(Fraction(Integer))
coerce : Integer -> %
from NonAssociativeRing
coerce : Symbol -> % if PADIC has RetractableTo(Symbol)
from CoercibleFrom(Symbol)
coerce : % -> OutputForm
from CoercibleTo(OutputForm)
commutator : (%, %) -> %
from NonAssociativeRng
conditionP : Matrix(%) -> Union(Vector(%), "failed") if PADIC has PolynomialFactorizationExplicit and % has CharacteristicNonZero
from PolynomialFactorizationExplicit
continuedFraction : % -> ContinuedFraction(Fraction(Integer))

continuedFraction(x) converts the p-adic rational number x to a continued fraction.

convert : % -> DoubleFloat if PADIC has RealConstant
from ConvertibleTo(DoubleFloat)
convert : % -> Float if PADIC has RealConstant
from ConvertibleTo(Float)
convert : % -> InputForm if PADIC has ConvertibleTo(InputForm)
from ConvertibleTo(InputForm)
convert : % -> Pattern(Float) if PADIC has ConvertibleTo(Pattern(Float))
from ConvertibleTo(Pattern(Float))
convert : % -> Pattern(Integer) if PADIC has ConvertibleTo(Pattern(Integer))
from ConvertibleTo(Pattern(Integer))
denom : % -> PADIC
from QuotientFieldCategory(PADIC)
denominator : % -> %
from QuotientFieldCategory(PADIC)
differentiate : % -> % if PADIC has DifferentialRing
from DifferentialRing
differentiate : (%, List(Symbol)) -> % if PADIC has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
differentiate : (%, List(Symbol), List(NonNegativeInteger)) -> % if PADIC has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
differentiate : (%, Mapping(PADIC, PADIC)) -> %
from DifferentialExtension(PADIC)
differentiate : (%, Mapping(PADIC, PADIC), NonNegativeInteger) -> %
from DifferentialExtension(PADIC)
differentiate : (%, NonNegativeInteger) -> % if PADIC has DifferentialRing
from DifferentialRing
differentiate : (%, Symbol) -> % if PADIC has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
differentiate : (%, Symbol, NonNegativeInteger) -> % if PADIC has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
divide : (%, %) -> Record(quotient : %, remainder : %)
from EuclideanDomain
elt : (%, PADIC) -> % if PADIC has Eltable(PADIC, PADIC)
from Eltable(PADIC, %)
euclideanSize : % -> NonNegativeInteger
from EuclideanDomain
eval : (%, PADIC, PADIC) -> % if PADIC has Evalable(PADIC)
from InnerEvalable(PADIC, PADIC)
eval : (%, Equation(PADIC)) -> % if PADIC has Evalable(PADIC)
from Evalable(PADIC)
eval : (%, List(PADIC), List(PADIC)) -> % if PADIC has Evalable(PADIC)
from InnerEvalable(PADIC, PADIC)
eval : (%, List(Equation(PADIC))) -> % if PADIC has Evalable(PADIC)
from Evalable(PADIC)
eval : (%, List(Symbol), List(PADIC)) -> % if PADIC has InnerEvalable(Symbol, PADIC)
from InnerEvalable(Symbol, PADIC)
eval : (%, Symbol, PADIC) -> % if PADIC has InnerEvalable(Symbol, PADIC)
from InnerEvalable(Symbol, PADIC)
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 PADIC has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
factorSquareFreePolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if PADIC has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
floor : % -> PADIC if PADIC has IntegerNumberSystem
from QuotientFieldCategory(PADIC)
fractionPart : % -> %
from QuotientFieldCategory(PADIC)
gcd : (%, %) -> %
from GcdDomain
gcd : List(%) -> %
from GcdDomain
gcdPolynomial : (SparseUnivariatePolynomial(%), SparseUnivariatePolynomial(%)) -> SparseUnivariatePolynomial(%)
from PolynomialFactorizationExplicit
init : () -> % if PADIC 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(PADIC, PADIC), %) -> %
from FullyEvalableOver(PADIC)
max : (%, %) -> % if PADIC has OrderedSet
from OrderedSet
min : (%, %) -> % if PADIC has OrderedSet
from OrderedSet
multiEuclidean : (List(%), %) -> Union(List(%), "failed")
from EuclideanDomain
negative? : % -> Boolean if PADIC has OrderedIntegralDomain
from OrderedRing
nextItem : % -> Union(%, "failed") if PADIC has StepThrough
from StepThrough
numer : % -> PADIC
from QuotientFieldCategory(PADIC)
numerator : % -> %
from QuotientFieldCategory(PADIC)
one? : % -> Boolean
from MagmaWithUnit
opposite? : (%, %) -> Boolean
from AbelianMonoid
patternMatch : (%, Pattern(Float), PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if PADIC has PatternMatchable(Float)
from PatternMatchable(Float)
patternMatch : (%, Pattern(Integer), PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if PADIC has PatternMatchable(Integer)
from PatternMatchable(Integer)
plenaryPower : (%, PositiveInteger) -> %
from NonAssociativeAlgebra(%)
positive? : % -> Boolean if PADIC 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(PADIC)
from LinearlyExplicitOver(PADIC)
reducedSystem : Matrix(%) -> Matrix(Integer) if PADIC has LinearlyExplicitOver(Integer)
from LinearlyExplicitOver(Integer)
reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(PADIC), vec : Vector(PADIC))
from LinearlyExplicitOver(PADIC)
reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(Integer), vec : Vector(Integer)) if PADIC has LinearlyExplicitOver(Integer)
from LinearlyExplicitOver(Integer)
rem : (%, %) -> %
from EuclideanDomain
removeZeroes : % -> %

removeZeroes(x) removes leading zeroes from the representation of the p-adic rational x. A p-adic rational is represented by (1) an exponent and (2) a p-adic integer which may have leading zero digits. When the p-adic integer has a leading zero digit, a 'leading zero' is removed from the p-adic rational as follows: the number is rewritten by increasing the exponent by 1 and dividing the p-adic integer by p. Note: removeZeroes(f) removes all leading zeroes from f.

removeZeroes : (Integer, %) -> %

removeZeroes(n, x) removes up to n leading zeroes from the p-adic rational x.

retract : % -> PADIC
from RetractableTo(PADIC)
retract : % -> Fraction(Integer) if PADIC has RetractableTo(Integer)
from RetractableTo(Fraction(Integer))
retract : % -> Integer if PADIC has RetractableTo(Integer)
from RetractableTo(Integer)
retract : % -> Symbol if PADIC has RetractableTo(Symbol)
from RetractableTo(Symbol)
retractIfCan : % -> Union(PADIC, "failed")
from RetractableTo(PADIC)
retractIfCan : % -> Union(Fraction(Integer), "failed") if PADIC has RetractableTo(Integer)
from RetractableTo(Fraction(Integer))
retractIfCan : % -> Union(Integer, "failed") if PADIC has RetractableTo(Integer)
from RetractableTo(Integer)
retractIfCan : % -> Union(Symbol, "failed") if PADIC 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 PADIC has OrderedIntegralDomain
from OrderedRing
sizeLess? : (%, %) -> Boolean
from EuclideanDomain
smaller? : (%, %) -> Boolean if PADIC has Comparable
from Comparable
solveLinearPolynomialEquation : (List(SparseUnivariatePolynomial(%)), SparseUnivariatePolynomial(%)) -> Union(List(SparseUnivariatePolynomial(%)), "failed") if PADIC has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
squareFree : % -> Factored(%)
from UniqueFactorizationDomain
squareFreePart : % -> %
from UniqueFactorizationDomain
squareFreePolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if PADIC has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
subtractIfCan : (%, %) -> Union(%, "failed")
from CancellationAbelianMonoid
unit? : % -> Boolean
from EntireRing
unitCanonical : % -> %
from EntireRing
unitNormal : % -> Record(unit : %, canonical : %, associate : %)
from EntireRing
wholePart : % -> PADIC
from QuotientFieldCategory(PADIC)
zero? : % -> Boolean
from AbelianMonoid
~= : (%, %) -> Boolean
from BasicType

Module(Fraction(Integer))

ConvertibleTo(Float)

PrincipalIdealDomain

PartialOrder

NonAssociativeSemiRing

BiModule(%, %)

ConvertibleTo(InputForm)

Field

canonicalUnitNormal

Rng

CoercibleFrom(Integer)

TwoSidedRecip

SemiRing

PatternMatchable(Float)

NonAssociativeAlgebra(Fraction(Integer))

CharacteristicNonZero

LeftModule(PADIC)

unitsKnown

DifferentialExtension(PADIC)

Module(PADIC)

noZeroDivisors

RetractableTo(Fraction(Integer))

UniqueFactorizationDomain

SemiGroup

RightModule(Fraction(Integer))

Magma

CoercibleFrom(PADIC)

IntegralDomain

LeftModule(%)

NonAssociativeRing

RetractableTo(PADIC)

GcdDomain

NonAssociativeAlgebra(%)

PartialDifferentialRing(Symbol)

CharacteristicZero

LinearlyExplicitOver(PADIC)

OrderedIntegralDomain

Algebra(%)

CoercibleFrom(Fraction(Integer))

DifferentialRing

OrderedAbelianMonoid

DivisionRing

CommutativeRing

OrderedAbelianGroup

NonAssociativeSemiRng

EntireRing

CancellationAbelianMonoid

EuclideanDomain

canonicalsClosed

RetractableTo(Integer)

RightModule(PADIC)

BiModule(PADIC, PADIC)

OrderedRing

StepThrough

RetractableTo(Symbol)

FullyLinearlyExplicitOver(PADIC)

CommutativeStar

AbelianMonoid

MagmaWithUnit

Comparable

RightModule(%)

Patternable(PADIC)

RealConstant

QuotientFieldCategory(PADIC)

ConvertibleTo(DoubleFloat)

OrderedAbelianSemiGroup

InnerEvalable(Symbol, PADIC)

LinearlyExplicitOver(Integer)

FullyPatternMatchable(PADIC)

CoercibleTo(OutputForm)

ConvertibleTo(Pattern(Float))

SemiRng

CoercibleFrom(Symbol)

Monoid

PolynomialFactorizationExplicit

OrderedCancellationAbelianMonoid

Evalable(PADIC)

LeftOreRing

OrderedSet

InnerEvalable(PADIC, PADIC)

Algebra(Fraction(Integer))

BasicType

Ring

RightModule(Integer)

LeftModule(Fraction(Integer))

AbelianSemiGroup

Module(%)

Eltable(PADIC, %)

SetCategory

Algebra(PADIC)

NonAssociativeAlgebra(PADIC)

NonAssociativeRng

PatternMatchable(Integer)

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

FullyEvalableOver(PADIC)

ConvertibleTo(Pattern(Integer))

AbelianGroup