NemoAlgebraicNumber

jnemo.spad line 264 [edit on github]

This domain allows the manipulation of Nemo algebraic numbers represented by minimal polynomials using the Nemo package for Julia (Calcium based). https://fredrikj.net/calcium/

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from Magma

*: (%, Fraction Integer) -> %

from RightModule Fraction Integer

*: (%, Integer) -> %

a*z multitiplies a by the integer z.

*: (%, NemoInteger) -> %

from RightModule NemoInteger

*: (%, NemoRational) -> %

from RightModule NemoRational

*: (Fraction Integer, %) -> %

from LeftModule Fraction Integer

*: (Integer, %) -> %

from AbelianGroup

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

+: (%, %) -> %

from AbelianSemiGroup

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

/: (%, %) -> %

from Field

=: (%, %) -> Boolean

from BasicType

^: (%, %) -> %

a^b returns the value of a raised to power b.

^: (%, Fraction Integer) -> %

from RadicalCategory

^: (%, Integer) -> %

from DivisionRing

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

abs2: % -> %

abs(a) returns the squared absolute value of a.

abs: % -> %

abs(a) returns the absolute value of a.

acospi: % -> %

acospi(x) returns acos(x)/%pi

algebraicInteger?: % -> Boolean

algebraicInteger?(a) tests whether or not a is an algebraic integer.

annihilate?: (%, %) -> Boolean

from Rng

antiCommutator: (%, %) -> %

from NonAssociativeSemiRng

asinpi: % -> %

asinpi(x) returns asin(x)/%pi

associates?: (%, %) -> Boolean

from EntireRing

associator: (%, %, %) -> %

from NonAssociativeRng

atanpi: % -> %

atanpi(x) returns atan(x)/%pi

belong?: BasicOperator -> Boolean

from ExpressionSpace2 Kernel %

box: % -> %

from ExpressionSpace2 Kernel %

ceiling: % -> %

ceiling(a) returns the smallest integer above or equal to a.

characteristic: () -> NonNegativeInteger

from NonAssociativeRing

coerce: % -> %

from Algebra %

coerce: % -> AlgebraicNumber

coerce(nan) coerces nan to AlgebraicNumber if it is rational.

coerce: % -> OutputForm

from CoercibleTo OutputForm

coerce: Fraction Integer -> %

from Algebra Fraction Integer

coerce: Integer -> %

from NonAssociativeRing

coerce: Kernel % -> %

from CoercibleFrom Kernel %

coerce: NemoInteger -> %

from CoercibleFrom NemoInteger

coerce: NemoRational -> %

from CoercibleFrom NemoRational

commutator: (%, %) -> %

from NonAssociativeRng

conj: % -> %

conj(a) returns the complex conjugate of a.

conjugates: % -> JuliaVector %

conjugates(a) returns all the roots of a.

convert: % -> String

from ConvertibleTo String

cospi: % -> %

cospi(x) returns cos(%pi*x).

crandom: (NonNegativeInteger, NonNegativeInteger) -> %

random(deg, bits) returns a random algebraic number (complex) of degree up to deg and coefficients size up to bits. Requires at least degree 2.

csgn: % -> %

csgn(a) returns an extension of the real sign function equivalent to a/sqrt(a^2).

D: % -> %

from DifferentialRing

D: (%, NonNegativeInteger) -> %

from DifferentialRing

definingPolynomial: % -> %

from ExpressionSpace2 Kernel %

degree: % -> JuliaInt64

degree(a) returns the degree of the minimal polynomial of a.

denominator: % -> NemoInteger

numeraor(a) returns the denominator of a, the leading coefficient of the minimal polynomial of a.

differentiate: % -> %

from DifferentialRing

differentiate: (%, NonNegativeInteger) -> %

from DifferentialRing

distribute: % -> %

from ExpressionSpace2 Kernel %

distribute: (%, %) -> %

from ExpressionSpace2 Kernel %

divide: (%, %) -> Record(quotient: %, remainder: %)

from EuclideanDomain

elt: (BasicOperator, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %, %, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %, %, %, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %, %, %, %, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %, %, %, %, %, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, %, %, %, %, %, %, %, %, %) -> %

from ExpressionSpace2 Kernel %

elt: (BasicOperator, List %) -> %

from ExpressionSpace2 Kernel %

euclideanSize: % -> NonNegativeInteger

from EuclideanDomain

eval: (%, %, %) -> %

from InnerEvalable(%, %)

eval: (%, BasicOperator, % -> %) -> %

from ExpressionSpace2 Kernel %

eval: (%, BasicOperator, List % -> %) -> %

from ExpressionSpace2 Kernel %

eval: (%, Equation %) -> %

from Evalable %

eval: (%, Kernel %, %) -> %

from InnerEvalable(Kernel %, %)

eval: (%, List %, List %) -> %

from InnerEvalable(%, %)

eval: (%, List BasicOperator, List(% -> %)) -> %

from ExpressionSpace2 Kernel %

eval: (%, List BasicOperator, List(List % -> %)) -> %

from ExpressionSpace2 Kernel %

eval: (%, List Equation %) -> %

from Evalable %

eval: (%, List Kernel %, List %) -> %

from InnerEvalable(Kernel %, %)

eval: (%, List Symbol, List(% -> %)) -> %

from ExpressionSpace2 Kernel %

eval: (%, List Symbol, List(List % -> %)) -> %

from ExpressionSpace2 Kernel %

eval: (%, Symbol, % -> %) -> %

from ExpressionSpace2 Kernel %

eval: (%, Symbol, List % -> %) -> %

from ExpressionSpace2 Kernel %

even?: % -> Boolean

from ExpressionSpace2 Kernel %

expPiI: % -> %

expPiI(a) returns exp(%pi*%i*a).

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

floor: % -> %

floor(a) returns the largest integer below or equal ot a.

freeOf?: (%, %) -> Boolean

from ExpressionSpace2 Kernel %

freeOf?: (%, Symbol) -> Boolean

from ExpressionSpace2 Kernel %

gcd: (%, %) -> %

from GcdDomain

gcd: List % -> %

from GcdDomain

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

from GcdDomain

height: % -> NonNegativeInteger

from ExpressionSpace2 Kernel %

imag: % -> %

imag(x) returns imaginary part of x.

imagSign: % -> %

imagSign(a) returns the sign of the imaginary part.

integer?: % -> Boolean

integer?(x) tests whether or not x is an integer.

inv: % -> %

from DivisionRing

is?: (%, BasicOperator) -> Boolean

from ExpressionSpace2 Kernel %

is?: (%, Symbol) -> Boolean

from ExpressionSpace2 Kernel %

jlAbout: % -> Void

from JuliaObjectType

jlApply: (String, %) -> %

from JuliaObjectType

jlApply: (String, %, %) -> %

from JuliaObjectType

jlApply: (String, %, %, %) -> %

from JuliaObjectType

jlApply: (String, %, %, %, %) -> %

from JuliaObjectType

jlApply: (String, %, %, %, %, %) -> %

from JuliaObjectType

jlApply: (String, %, %, %, %, %, %) -> %

from JuliaObjectType

jlId: % -> String

from JuliaObjectType

jlRef: % -> SExpression

from JuliaObjectType

jlref: String -> %

from JuliaObjectType

jlType: % -> String

from JuliaObjectType

jnan: NemoInteger -> %

jnan: NemoRational -> %

jnan: String -> %

kernel: (BasicOperator, %) -> %

from ExpressionSpace2 Kernel %

kernel: (BasicOperator, List %) -> %

from ExpressionSpace2 Kernel %

kernels: % -> List Kernel %

from ExpressionSpace2 Kernel %

kernels: List % -> List Kernel %

from ExpressionSpace2 Kernel %

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

logPiI: % -> %

logPiI(a) returns log(a)/(%pi*%i).

mainKernel: % -> Union(Kernel %, failed)

from ExpressionSpace2 Kernel %

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

from ExpressionSpace2 Kernel %

minimalPolynomial: % -> SparseUnivariatePolynomial %

minimalPolynomial(an) returns the minimal polynomial of an over algebraic number.

minimalPolynomial: % -> SparseUnivariatePolynomial Integer

minimalPolynomial(an) returns the minimal polynomial of an.

minPoly: Kernel % -> SparseUnivariatePolynomial %

from ExpressionSpace2 Kernel %

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

from EuclideanDomain

mutable?: % -> Boolean

from JuliaObjectType

nothing?: % -> Boolean

from JuliaObjectType

nthRoot: (%, Integer) -> %

from RadicalCategory

numerator: % -> %

numerator(a) returns a multiplied by its denominator i.e. an algebraic integer.

odd?: % -> Boolean

from ExpressionSpace2 Kernel %

one?: % -> Boolean

from MagmaWithUnit

operator: BasicOperator -> BasicOperator

from ExpressionSpace2 Kernel %

operators: % -> List BasicOperator

from ExpressionSpace2 Kernel %

opposite?: (%, %) -> Boolean

from AbelianMonoid

paren: % -> %

from ExpressionSpace2 Kernel %

plenaryPower: (%, PositiveInteger) -> %

from NonAssociativeAlgebra Fraction Integer

prime?: % -> Boolean

from UniqueFactorizationDomain

principalIdeal: List % -> Record(coef: List %, generator: %)

from PrincipalIdealDomain

quo: (%, %) -> %

from EuclideanDomain

random: (NonNegativeInteger, NonNegativeInteger) -> %

random(deg, bits) returns a random algebraic number (real) of degree up to deg and coefficients size up to bits.

rational?: % -> Boolean

rational?(x) tests whether or not x is a rational number.

real?: % -> Boolean

real?(x) tests whether or not x is a real number.

real: % -> %

real(x) returns real part of x.

realSign: % -> %

realSign(a) returns the sign of the real part.

recip: % -> Union(%, failed)

from MagmaWithUnit

reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Fraction Integer, vec: Vector Fraction Integer)

from LinearlyExplicitOver Fraction Integer

reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer)

from LinearlyExplicitOver Integer

reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix NemoInteger, vec: Vector NemoInteger)

from LinearlyExplicitOver NemoInteger

reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix NemoRational, vec: Vector NemoRational)

from LinearlyExplicitOver NemoRational

reducedSystem: Matrix % -> Matrix Fraction Integer

from LinearlyExplicitOver Fraction Integer

reducedSystem: Matrix % -> Matrix Integer

from LinearlyExplicitOver Integer

reducedSystem: Matrix % -> Matrix NemoInteger

from LinearlyExplicitOver NemoInteger

reducedSystem: Matrix % -> Matrix NemoRational

from LinearlyExplicitOver NemoRational

rem: (%, %) -> %

from EuclideanDomain

retract: % -> Fraction Integer

from RetractableTo Fraction Integer

retract: % -> Integer

from RetractableTo Integer

retract: % -> Kernel %

from RetractableTo Kernel %

retract: % -> NemoInteger

from RetractableTo NemoInteger

retract: % -> NemoRational

from RetractableTo NemoRational

retractIfCan: % -> Union(Fraction Integer, failed)

from RetractableTo Fraction Integer

retractIfCan: % -> Union(Integer, failed)

from RetractableTo Integer

retractIfCan: % -> Union(Kernel %, failed)

from RetractableTo Kernel %

retractIfCan: % -> Union(NemoInteger, failed)

from RetractableTo NemoInteger

retractIfCan: % -> Union(NemoRational, failed)

from RetractableTo NemoRational

rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

rootOfUnity?: % -> Boolean

rootOfUnity?(x) tests whether or not x is a root of unity.

rootOfUnity: (NonNegativeInteger, Integer) -> %

rootOfUnity(n,k)Return the root of unity exp(2*%pi*%i*k/n).

rootOfUnity: NonNegativeInteger -> %

rootOfUnity(n)Return the root of unity exp(2*%pi*%i/n).

sample: %

from AbelianMonoid

sign: % -> %

sign(a) returns the complex sign of a.

sinpi: % -> %

sinpi(x) returns sin(%pi*x).

sizeLess?: (%, %) -> Boolean

from EuclideanDomain

smaller?: (%, %) -> Boolean

from Comparable

sqrt: % -> %

from RadicalCategory

squareFree: % -> Factored %

from UniqueFactorizationDomain

squareFreePart: % -> %

from UniqueFactorizationDomain

string: % -> String

from JuliaObjectType

subst: (%, Equation %) -> %

from ExpressionSpace2 Kernel %

subst: (%, List Equation %) -> %

from ExpressionSpace2 Kernel %

subst: (%, List Kernel %, List %) -> %

from ExpressionSpace2 Kernel %

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

from CancellationAbelianMonoid

tanpi: % -> %

tanpi(x) returns tan(%pi*x).

tower: % -> List Kernel %

from ExpressionSpace2 Kernel %

tower: List % -> List Kernel %

from ExpressionSpace2 Kernel %

unit?: % -> Boolean

from EntireRing

unitCanonical: % -> %

from EntireRing

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

from EntireRing

zero?: % -> Boolean

from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra %

Algebra Fraction Integer

BasicType

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer)

CancellationAbelianMonoid

canonicalsClosed

canonicalUnitNormal

CharacteristicZero

CoercibleFrom Fraction Integer

CoercibleFrom Integer

CoercibleFrom Kernel %

CoercibleFrom NemoInteger

CoercibleFrom NemoRational

CoercibleTo OutputForm

CommutativeRing

CommutativeStar

Comparable

ConvertibleTo String

DifferentialRing

DivisionRing

EntireRing

EuclideanDomain

Evalable %

ExpressionSpace

ExpressionSpace2 Kernel %

Field

GcdDomain

InnerEvalable(%, %)

InnerEvalable(Kernel %, %)

IntegralDomain

JuliaObjectRing

JuliaObjectType

JuliaRing

JuliaType

LeftModule %

LeftModule Fraction Integer

LeftOreRing

LinearlyExplicitOver Fraction Integer

LinearlyExplicitOver Integer

LinearlyExplicitOver NemoInteger

LinearlyExplicitOver NemoRational

Magma

MagmaWithUnit

Module %

Module Fraction Integer

Monoid

NemoAlgebraicallyClosedField

NemoRing

NemoType

NonAssociativeAlgebra %

NonAssociativeAlgebra Fraction Integer

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

PrincipalIdealDomain

RadicalCategory

RetractableTo Fraction Integer

RetractableTo Integer

RetractableTo Kernel %

RetractableTo NemoInteger

RetractableTo NemoRational

RightModule %

RightModule Fraction Integer

RightModule Integer

RightModule NemoInteger

RightModule NemoRational

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

TwoSidedRecip

UniqueFactorizationDomain

unitsKnown