InnerNemoExactComplexField Options

jnemo.spad line 842 [edit on github]

InnerNemoExactComplexField implements exact complex field arithmetic using the Nemo package Inner domain using options, see https://fredrikj.net/calcium/ca.html#context-options for hints). Reference: https://nemocas.github.io/Nemo.jl See https://flintlib.org/doc/introduction_calcium.html for the C library.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from Magma

*: (%, Integer) -> %

*: (Integer, %) -> %

from AbelianGroup

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

+: (%, %) -> %

from AbelianSemiGroup

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

/: (%, Integer) -> %

/: (Integer, %) -> %

=: (%, %) -> Boolean

from BasicType

^: (%, %) -> %

from ElementaryFunctionCategory

^: (%, Fraction Integer) -> %

from RadicalCategory

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

acos: % -> %

from ArcTrigonometricFunctionCategory

acos: (%, JuliaSymbol) -> %

acos(x,repr) returns acos(x) using one of the repr representations: :default (since ‘default’ is a FriCAS keyword use jsym(String) to coerce it) :logarithm :direct

acosh: % -> %

from ArcHyperbolicFunctionCategory

acot: % -> %

from ArcTrigonometricFunctionCategory

acoth: % -> %

from ArcHyperbolicFunctionCategory

acsc: % -> %

from ArcTrigonometricFunctionCategory

acsch: % -> %

from ArcHyperbolicFunctionCategory

algebraic?: % -> Boolean

algebraic?(x) checks whether or not x is algebraic.

annihilate?: (%, %) -> Boolean

from Rng

antiCommutator: (%, %) -> %

from NonAssociativeSemiRng

argument: % -> %

from ComplexCategory %

asec: % -> %

from ArcTrigonometricFunctionCategory

asech: % -> %

from ArcHyperbolicFunctionCategory

asin: % -> %

from ArcTrigonometricFunctionCategory

asin: (%, JuliaSymbol) -> %

asin(x, repr) returns asin(x) using one of the repr representations: :default (since ‘default’ is a FriCAS keyword use jsym(String) to coerce it) :logarithm :direct

asinh: % -> %

from ArcHyperbolicFunctionCategory

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

from NonAssociativeRng

atan: % -> %

from ArcTrigonometricFunctionCategory

atan: (%, JuliaSymbol) -> %

atan(x, repr) returns atan(x) using one of the repr representations: :default (since ‘default’ is a FriCAS keyword use jsym(String) to coerce it) :logarithm :direct or :arctangent

atanh: % -> %

from ArcHyperbolicFunctionCategory

basis: () -> Vector %

from FramedModule %

ceiling: % -> %

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

characteristic: () -> NonNegativeInteger

from NonAssociativeRing

characteristicPolynomial: % -> SparseUnivariatePolynomial %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

coerce: % -> %

from Algebra %

coerce: % -> OutputForm

from CoercibleTo OutputForm

coerce: Complex Integer -> %

coerce(z) coerces z. Convenience function.

coerce: Fraction Integer -> %

coerce(q) coerces q. Convenience function.

coerce: Integer -> %

from NonAssociativeRing

coerce: NemoAlgebraicNumber -> %

coerce(qbar) coerces qbar. Convenience function.

coerce: NemoRational -> %

coerce(q) coerces q. Convenience function.

coerce: PositiveInteger -> %

coerce(pi) coerces pi. Convenience function.

commutator: (%, %) -> %

from NonAssociativeRng

complex: (%, %) -> %

from ComplexCategory %

complexNormalForm: % -> %

complexNormalForm(x) returns x rewritten using standard transformations. See the Nemo.jl documentation fo more informations.

conditionP: Matrix % -> Union(Vector %, failed) if % has CharacteristicNonZero and % has EuclideanDomain and % has PolynomialFactorizationExplicit or % has FiniteFieldCategory

from PolynomialFactorizationExplicit

conjugate: % -> %

from ComplexCategory %

conjugate: (%, JuliaSymbol) -> %

conjugate(x, repr) returns conjugate(x) using one of the repr representations: :default (since ‘default’ is a FriCAS keyword use jsym(String) to coerce it) :deep (recursively) :shallow (a new extension, ā, is used if there is no express simplification)

convert: % -> SparseUnivariatePolynomial %

from ConvertibleTo SparseUnivariatePolynomial %

convert: % -> String

from ConvertibleTo String

convert: % -> Vector %

from FramedModule %

convert: SparseUnivariatePolynomial % -> %

from MonogenicAlgebra(%, SparseUnivariatePolynomial %)

convert: Vector % -> %

from FramedModule %

coordinates: % -> Vector %

from FramedModule %

coordinates: (%, Vector %) -> Vector %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

coordinates: (Vector %, Vector %) -> Matrix %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

coordinates: Vector % -> Matrix %

from FramedModule %

cos: % -> %

from TrigonometricFunctionCategory

cos: (%, JuliaSymbol) -> %

cos(x, repr) returns cos(x) using one of the repr representations: :default (since ‘default’ is a FriCAS keyword use jsym(String) to coerce it) :exponential :tangent :direct or :sine_cosine

cosh: % -> %

from HyperbolicFunctionCategory

cot: % -> %

from TrigonometricFunctionCategory

coth: % -> %

from HyperbolicFunctionCategory

csc: % -> %

from TrigonometricFunctionCategory

csch: % -> %

from HyperbolicFunctionCategory

csign: % -> %

csign(x) is an extension of the real sign function, x/sqrt(x^2) unless x is 0 (0 in this case).

D: (%, % -> %) -> %

from DifferentialExtension %

D: (%, % -> %, NonNegativeInteger) -> %

from DifferentialExtension %

definingPolynomial: () -> SparseUnivariatePolynomial %

from MonogenicAlgebra(%, SparseUnivariatePolynomial %)

differentiate: % -> % if % has DifferentialRing

from DifferentialRing

differentiate: (%, % -> %) -> %

from DifferentialExtension %

differentiate: (%, % -> %, NonNegativeInteger) -> %

from DifferentialExtension %

differentiate: (%, NonNegativeInteger) -> % if % has DifferentialRing

from DifferentialRing

discriminant: () -> %

from FramedAlgebra(%, SparseUnivariatePolynomial %)

discriminant: Vector % -> %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

divide: (%, %) -> Record(quotient: %, remainder: %) if % has Field or % has IntegerNumberSystem

from EuclideanDomain

enumerate: () -> List % if % has Finite

from Finite

erf: % -> %

erf(x) is the error function evaluated at x.

erfc: % -> %

erfc(x) is the complementary error function evaluated at x.

erfi: % -> %

erfi(x) is the imaginary error function evaluated at x.

euclideanSize: % -> NonNegativeInteger if % has Field or % has IntegerNumberSystem

from EuclideanDomain

eulerGamma: () -> %

eulerGamma() returns the Euler's constant gamma (γ).

exp1: () -> %

exp() returns ℯ (exp(1)).

exp: % -> %

from ElementaryFunctionCategory

exp: () -> %

exp() returns ℯ (exp(1)).

expressIdealMember: (List %, %) -> Union(List %, failed) if % has Field or % has IntegerNumberSystem

from PrincipalIdealDomain

extendedEuclidean: (%, %) -> Record(coef1: %, coef2: %, generator: %) if % has Field or % has IntegerNumberSystem

from EuclideanDomain

extendedEuclidean: (%, %, %) -> Union(Record(coef1: %, coef2: %), failed) if % has Field or % has IntegerNumberSystem

from EuclideanDomain

factor: % -> Factored % if % has Field or % has IntegerNumberSystem or % has EuclideanDomain and % has PolynomialFactorizationExplicit

from UniqueFactorizationDomain

factorPolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if % has EuclideanDomain and % has PolynomialFactorizationExplicit or % has FiniteFieldCategory

from PolynomialFactorizationExplicit

factorSquareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if % has EuclideanDomain and % has PolynomialFactorizationExplicit or % has FiniteFieldCategory

from PolynomialFactorizationExplicit

floor: % -> %

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

Gamma: % -> %

Gamma(x) is the Euler Gamma function evaluated at x.

gcd: (%, %) -> % if % has EuclideanDomain and % has PolynomialFactorizationExplicit or % has Field or % has IntegerNumberSystem

from GcdDomain

gcd: List % -> % if % has EuclideanDomain and % has PolynomialFactorizationExplicit or % has Field or % has IntegerNumberSystem

from GcdDomain

gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial % if % has EuclideanDomain and % has PolynomialFactorizationExplicit or % has Field or % has IntegerNumberSystem

from GcdDomain

generator: () -> %

from MonogenicAlgebra(%, SparseUnivariatePolynomial %)

hashUpdate!: (HashState, %) -> HashState if % has Hashable

from Hashable

imag: % -> %

from ComplexCategory %

imaginary?: % -> Boolean

imaginary?(x) checks whether or not x is imaginary.

imaginary: () -> %

from ComplexCategory %

index: PositiveInteger -> % if % has Finite

from Finite

infinity?: % -> Boolean

infinity?(x) checks whether or not x is an infinity.

infinity: % -> %

infinity(x) returns signed infinity depending on x sign.

infinity: () -> %

infinity() returns unsigned infinity.

integer?: % -> Boolean

integer?(z) checks whether or not z is an integer.

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

jlOptions: % -> JuliaObjDict

jlOptions(x) returns the options set at instantion time that affect different aspects of computations using this object.

jlRef: % -> SExpression

from JuliaObjectType

jlref: String -> %

from JuliaObjectType

jlType: % -> String

from JuliaObjectType

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

jnecf: (NemoRational, NemoRational) -> %

jnecf: Fraction Integer -> %

jnecf: NemoAlgebraicNumber -> %

jnecf: NemoRational -> %

latex: % -> String

from SetCategory

lcm: (%, %) -> % if % has EuclideanDomain and % has PolynomialFactorizationExplicit or % has Field or % has IntegerNumberSystem

from GcdDomain

lcm: List % -> % if % has EuclideanDomain and % has PolynomialFactorizationExplicit or % has Field or % has IntegerNumberSystem

from GcdDomain

lcmCoef: (%, %) -> Record(llcm_res: %, coeff1: %, coeff2: %) if % has EuclideanDomain and % has PolynomialFactorizationExplicit or % has Field or % has IntegerNumberSystem

from LeftOreRing

leftPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower: (%, PositiveInteger) -> %

from Magma

leftRecip: % -> Union(%, failed)

from MagmaWithUnit

lift: % -> SparseUnivariatePolynomial %

from MonogenicAlgebra(%, SparseUnivariatePolynomial %)

log: % -> %

from ElementaryFunctionCategory

lookup: % -> PositiveInteger if % has Finite

from Finite

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

from FullyEvalableOver %

multiEuclidean: (List %, %) -> Union(List %, failed) if % has Field or % has IntegerNumberSystem

from EuclideanDomain

mutable?: % -> Boolean

from JuliaObjectType

negativeInfinity: () -> %

negativeInfinity() returns negtive infinity.

norm: % -> %

from ComplexCategory %

nothing?: % -> Boolean

from JuliaObjectType

nthRoot: (%, Integer) -> %

from RadicalCategory

number?: % -> Boolean

number?(x) checks whether or not x is a number, i.e. not an infinity or an undefined value.

one?: % -> Boolean

from MagmaWithUnit

opposite?: (%, %) -> Boolean

from AbelianMonoid

pi: () -> %

pi() returns π.

plenaryPower: (%, PositiveInteger) -> %

from NonAssociativeAlgebra Fraction Integer

positiveInfinity: () -> %

positiveInfinity() returns positive infinity.

pow: (%, Integer, JuliaSymbol) -> %

pow(x, i, repr) x raised to power i using one of the repr representations: :default (since ‘default’ is a FriCAS keyword use jsym(String) to coerce it) :arithmetic See the Nemo documentation for more information, and InnerNemoExactComplexField for more options.

prime?: % -> Boolean if % has Field or % has IntegerNumberSystem or % has EuclideanDomain and % has PolynomialFactorizationExplicit

from UniqueFactorizationDomain

principalIdeal: List % -> Record(coef: List %, generator: %) if % has Field or % has IntegerNumberSystem

from PrincipalIdealDomain

quo: (%, %) -> % if % has Field or % has IntegerNumberSystem

from EuclideanDomain

random: () -> % if % has Finite

from Finite

random: (Integer, Integer) -> %

random(depth, bits) returns a random number with size of coefficients up to bits. if depth is nonzero, apply a random arithmetic operation/function to operands produced using recursive calls with depth - 1.

random: (Integer, Integer, JuliaSymbol) -> %

random(depth, bits, type) returns a random number with size of coefficients up to bits. if depth is nonzero, apply a random arithmetic operation/function to operands produced using recursive calls with depth - 1. depth is not used for rationals. type can be one of: :rational (returns a rational) :null (returns value with default settings) :special (returns a special value of a number - can throw an error if it isn't a number).

rank: () -> PositiveInteger

from FramedModule %

rational?: % -> Boolean

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

real?: % -> Boolean

real?(z) checks whether or not z is a real number.

real: % -> %

from ComplexCategory %

recip: % -> Union(%, failed)

from MagmaWithUnit

reduce: SparseUnivariatePolynomial % -> %

from MonogenicAlgebra(%, SparseUnivariatePolynomial %)

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

from LinearlyExplicitOver %

reducedSystem: Matrix % -> Matrix %

from LinearlyExplicitOver %

regularRepresentation: % -> Matrix %

from FramedAlgebra(%, SparseUnivariatePolynomial %)

regularRepresentation: (%, Vector %) -> Matrix %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

rem: (%, %) -> % if % has Field or % has IntegerNumberSystem

from EuclideanDomain

represents: (Vector %, Vector %) -> %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

represents: Vector % -> %

from FramedModule %

retract: % -> %

from RetractableTo %

retractIfCan: % -> Union(%, failed)

from RetractableTo %

retractIfCan: % -> Union(NemoAlgebraicNumber, failed)

retractIfCan(z) retracts if possible z to a NemoAlgebraicNumber.

retractIfCan: % -> Union(NemoInteger, failed)

retractIfCan(z) retracts if possible z to a Integer.

retractIfCan: % -> Union(NemoRational, failed)

retractIfCan(z) retracts if possible z to a NemoRational.

rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

sample: %

from AbelianMonoid

sec: % -> %

from TrigonometricFunctionCategory

sech: % -> %

from HyperbolicFunctionCategory

sign: % -> %

sign(x) returns sign of x.

signedInfinity?: % -> Boolean

signedInfinity?(x) checks whether or not x is a signed infinity.

sin: % -> %

from TrigonometricFunctionCategory

sin: (%, JuliaSymbol) -> %

sin(x, repr) return sin(x) using one of the repr representations: :default (since ‘default’ is a FriCAS keyword use jsym(String) to coerce it) :exponential :tangent :direct

sinh: % -> %

from HyperbolicFunctionCategory

size: () -> NonNegativeInteger if % has Finite

from Finite

sizeLess?: (%, %) -> Boolean if % has Field or % has IntegerNumberSystem

from EuclideanDomain

solveLinearPolynomialEquation: (List SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> Union(List SparseUnivariatePolynomial %, failed) if % has EuclideanDomain and % has PolynomialFactorizationExplicit or % has FiniteFieldCategory

from PolynomialFactorizationExplicit

sqrt: % -> %

from RadicalCategory

squareFree: % -> Factored % if % has Field or % has IntegerNumberSystem or % has EuclideanDomain and % has PolynomialFactorizationExplicit

from UniqueFactorizationDomain

squareFreePart: % -> % if % has Field or % has IntegerNumberSystem or % has EuclideanDomain and % has PolynomialFactorizationExplicit

from UniqueFactorizationDomain

squareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if % has EuclideanDomain and % has PolynomialFactorizationExplicit or % has FiniteFieldCategory

from PolynomialFactorizationExplicit

string: % -> String

from JuliaObjectType

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

from CancellationAbelianMonoid

tan: % -> %

from TrigonometricFunctionCategory

tan: (%, JuliaSymbol) -> %

tan(x, repr) returns tan(x) using one of the repr representations: :default (since ‘default’ is a FriCAS keyword use jsym(String) to coerce it) :exponential :direct or :tangent :sine_cosine

tanh: % -> %

from HyperbolicFunctionCategory

trace: % -> %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

traceMatrix: () -> Matrix %

from FramedAlgebra(%, SparseUnivariatePolynomial %)

traceMatrix: Vector % -> Matrix %

from FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

undefined?: % -> Boolean

undefined?(x) checks whether or not x is undefined.

undefined: () -> %

undefined() returns the undefined special value.

unknown?: % -> Boolean

unknown?(x) checks whether or not x is unknown.

unknown: () -> %

unknown() returns the unknown special value.

unsignedInfinity?: % -> Boolean

unsignedInfinity?(x) checks whether or not x is an unsigned infinity.

zero?: % -> Boolean

from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra %

ArcHyperbolicFunctionCategory

ArcTrigonometricFunctionCategory

BasicType

BiModule(%, %)

CancellationAbelianMonoid

CoercibleFrom %

CoercibleTo OutputForm

CommutativeRing

CommutativeStar

ComplexCategory %

ConvertibleTo SparseUnivariatePolynomial %

ConvertibleTo String

DifferentialExtension %

ElementaryFunctionCategory

EuclideanDomain if % has Field or % has IntegerNumberSystem

FiniteRankAlgebra(%, SparseUnivariatePolynomial %)

FramedAlgebra(%, SparseUnivariatePolynomial %)

FramedModule %

FullyEvalableOver %

FullyLinearlyExplicitOver %

FullyPatternMatchable %

FullyRetractableTo %

GcdDomain if % has EuclideanDomain and % has PolynomialFactorizationExplicit or % has Field or % has IntegerNumberSystem

HyperbolicFunctionCategory

JuliaObjectRing

JuliaObjectType

JuliaRing

JuliaType

LeftModule %

LeftOreRing if % has EuclideanDomain and % has PolynomialFactorizationExplicit or % has Field or % has IntegerNumberSystem

LinearlyExplicitOver %

Magma

MagmaWithUnit

Module %

MonogenicAlgebra(%, SparseUnivariatePolynomial %)

Monoid

NemoRing

NemoType

NonAssociativeAlgebra %

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

Patternable %

PolynomialFactorizationExplicit if % has EuclideanDomain

PrincipalIdealDomain if % has Field or % has IntegerNumberSystem

RadicalCategory

RetractableTo %

RightModule %

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

TranscendentalFunctionCategory

TrigonometricFunctionCategory

TwoSidedRecip

UniqueFactorizationDomain if % has IntegerNumberSystem or % has Field or % has EuclideanDomain and % has PolynomialFactorizationExplicit

unitsKnown