NMRealField

jnball.spad line 673 [edit on github]

NMRealField implements arbitrary precision ball arithmetic using the Nemo Julia package.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from Magma

*: (%, Fraction Integer) -> %

from RightModule Fraction Integer

*: (%, Integer) -> %

x*i is the multplication by an integer.

*: (Fraction Integer, %) -> %

from LeftModule Fraction Integer

*: (Integer, %) -> %

from AbelianGroup

*: (NMInteger, %) -> JLObject

from JLObjectRing

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

+: (%, %) -> %

from AbelianSemiGroup

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

/: (%, %) -> %

from Field

/: (%, Integer) -> %

from FloatingPointSystem

/: (Integer, %) -> %

x/i returns the division of an integer by x.

<=: (%, %) -> Boolean

from PartialOrder

<: (%, %) -> Boolean

from PartialOrder

=: (%, %) -> Boolean

from BasicType

>=: (%, %) -> Boolean

from PartialOrder

>: (%, %) -> Boolean

from PartialOrder

^: (%, %) -> %

from ElementaryFunctionCategory

^: (%, Fraction Integer) -> %

from RadicalCategory

^: (%, Integer) -> %

from DivisionRing

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

abs2: % -> %

abs2(x) returns the square of the absolute value of x.

abs: % -> %

from OrderedAbelianGroup

accuracyBits: % -> JLInt64

accuracyBits(x) returns the relative accuracy of x in bits.

acos: % -> %

from ArcTrigonometricFunctionCategory

acosh: % -> %

from ArcHyperbolicFunctionCategory

acot: % -> %

from ArcTrigonometricFunctionCategory

acoth: % -> %

from ArcHyperbolicFunctionCategory

acsc: % -> %

from ArcTrigonometricFunctionCategory

acsch: % -> %

from ArcHyperbolicFunctionCategory

addError!: (%, %) -> %

addError!(x, y) adds the values (absolute) of the midpoint and radius of y to the radius of x.

annihilate?: (%, %) -> Boolean

from Rng

antiCommutator: (%, %) -> %

from NonAssociativeSemiRng

asec: % -> %

from ArcTrigonometricFunctionCategory

asech: % -> %

from ArcHyperbolicFunctionCategory

asin: % -> %

from ArcTrigonometricFunctionCategory

asinh: % -> %

from ArcHyperbolicFunctionCategory

associates?: (%, %) -> Boolean

from EntireRing

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

from NonAssociativeRng

atan: % -> %

from ArcTrigonometricFunctionCategory

atan: (%, %) -> %

atan(x, y) computes the inverse tangent of x/y.

atanh: % -> %

from ArcHyperbolicFunctionCategory

base: () -> PositiveInteger

from FloatingPointSystem

bits: () -> PositiveInteger

from FloatingPointSystem

bits: PositiveInteger -> PositiveInteger

from FloatingPointSystem

catalan: () -> %

catalan() returns the Catalan's constant.

ceiling: % -> %

from RealNumberSystem

characteristic: () -> NonNegativeInteger

from NonAssociativeRing

coerce: % -> %

from Algebra %

coerce: % -> JLObject

from JLObjectType

coerce: % -> OutputForm

from CoercibleTo OutputForm

coerce: Float -> %

coerce(x) coerces x.

coerce: Fraction Integer -> %

coerce(q) coerces q.

coerce: Integer -> %

from NonAssociativeRing

coerce: JLFloat64 -> %

coerce(x) coerces(x).

commutator: (%, %) -> %

from NonAssociativeRng

contains?: (%, %) -> Boolean

contains?(x,y) checks whether or not y is contained in x.

contains?: (%, JLFloat) -> Boolean

contains?(x,y) checks whether or not y is contained in x.

contains?: (%, NMFraction NMInteger) -> Boolean

contains?(x,y) checks whether or not y is contained in x.

contains?: (%, NMInteger) -> Boolean

contains?(x,y) checks whether or not y is contained in x.

containsNegative?: % -> Boolean

containsNegative?(x) cheks whether or not x contains any negative value.

containsNonNegative?: % -> Boolean

containsNonNegative?(x) cheks whether or not x contains any non negative value.

containsNonPositive?: % -> Boolean

containsNonPositive?(x) checks whether or not x contains any non positive value.

containsPositive?: % -> Boolean

containsPositive?(x) cheks whether or not x contains any positive value.

containsZero?: % -> Boolean

containsZero?(x) checks whether or not 0 is contained in x.

convert: % -> DoubleFloat

from ConvertibleTo DoubleFloat

convert: % -> Float

from ConvertibleTo Float

convert: % -> JLFloat

convert(x) converts x to a JLFloat.

convert: % -> NMFraction NMInteger

convert(x) converts x to a NMFraction(NMInteger).

convert: % -> Pattern Float

from ConvertibleTo Pattern Float

convert: % -> String

from ConvertibleTo String

cos: % -> %

from TrigonometricFunctionCategory

cosh: % -> %

from HyperbolicFunctionCategory

cot: % -> %

from TrigonometricFunctionCategory

coth: % -> %

from HyperbolicFunctionCategory

csc: % -> %

from TrigonometricFunctionCategory

csch: % -> %

from HyperbolicFunctionCategory

D: % -> %

from DifferentialRing

D: (%, NonNegativeInteger) -> %

from DifferentialRing

decreasePrecision: Integer -> PositiveInteger

from FloatingPointSystem

differentiate: % -> %

from DifferentialRing

differentiate: (%, NonNegativeInteger) -> %

from DifferentialRing

digits: () -> PositiveInteger

from FloatingPointSystem

digits: PositiveInteger -> PositiveInteger

from FloatingPointSystem

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

from EuclideanDomain

equal?: (%, %) -> Boolean

from NMRing

euclideanSize: % -> NonNegativeInteger

from EuclideanDomain

eulerGamma: () -> %

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

exact?: % -> Boolean

exact?(x) checks whether x is exact i.e. with 0 radius.

exactDivide: (%, %) -> %

from NMRing

exp1: () -> %

exp1() returns the NMRealField represenation of ℯ (exp(1)).

exp: % -> %

from ElementaryFunctionCategory

exp: () -> %

exp() returns the NMRealField represenation of ℯ (exp(1)).

expm1: % -> %

expm1(x) computes accurately e^x-1. It avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small values of x.

exponent: % -> Integer

from FloatingPointSystem

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

finite?: % -> Boolean

finite?(x) checks whether or not x is finite, not an infinity for example.

float: (Integer, Integer) -> %

from FloatingPointSystem

float: (Integer, Integer, PositiveInteger) -> %

from FloatingPointSystem

floor: % -> %

from RealNumberSystem

fractionPart: % -> %

from RealNumberSystem

Gamma: % -> %

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

Gamma: (%, %) -> %

Gamma(x,y) is the incomplete Gamma function.

gcd: (%, %) -> %

from GcdDomain

gcd: List % -> %

from GcdDomain

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

from GcdDomain

glaisher: () -> %

glaisher() returns the Glaisher's constant.

guess: (%, NonNegativeInteger) -> NMAlgebraicNumber

guess(a, deg) returns the reconstructed algebraic number found if it succeeds, up to degree deg.

hurwitzZeta: (%, %) -> %

hurwitzZeta(s,a) returns the Hurwitz zeta function of s and a.

increasePrecision: Integer -> PositiveInteger

from FloatingPointSystem

integer?: % -> Boolean

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

inv: % -> %

from DivisionRing

jlAbout: % -> Void

from JLObjectType

jlApply: (String, %) -> JLObject

from JLObjectType

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

from JLObjectType

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

from JLObjectType

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

from JLObjectType

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

from JLObjectType

jlDisplay: % -> Void

from JLObjectType

jlDump: JLObject -> Void

from JLObjectType

jlFieldNames: % -> JLObject

from JLObjectType

jlGetField: (%, JLSymbol) -> JLObject

from JLObjectType

jlGetProperty: (%, JLSymbol) -> JLObject

from JLObjectType

jlId: % -> JLInt64

from JLObjectType

jlNMRing: () -> String

from NMRing

jlObject: () -> String

from JLObjectType

jlPropertyNames: % -> JLObject

from JLObjectType

jlRef: % -> SExpression

from JLObjectType

jlref: String -> %

from JLObjectType

jlText: (%, String) -> List String

from JLObjectType

jlType: % -> String

from JLObjectType

jnball: (%, %) -> %

jnball(x,r) returns a ball with midpoint x and radius r.

jnrf: Float -> %

jnrf(x) returns x as a NMRealField element.

jnrf: Fraction Integer -> %

jnrf(q) returns q as a NMRealField element.

jnrf: Integer -> %

jnrf(i) returns i as a NMRealField element.

jnrf: String -> %

jnrf(str) evaluates str in Julia to returns a NMRealField element.

khinchin: () -> %

khinchin() returns the Khinchin's constant.

latex: % -> String

from SetCategory

lcm: (%, %) -> %

from GcdDomain

lcm: List % -> %

from GcdDomain

lcmCoef: (%, %) -> Record(llcm_res: %, coeff1: %, coeff2: %)

from LeftOreRing

ldexp: (%, NMInteger) -> %

ldexp(x, n) returns x * 2^n.

leftPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower: (%, PositiveInteger) -> %

from Magma

leftRecip: % -> Union(%, failed)

from MagmaWithUnit

log1p: % -> %

log1p(x) logarithm of 1+x computed accurately.

log: % -> %

from ElementaryFunctionCategory

mantissa: % -> Integer

from FloatingPointSystem

max: (%, %) -> %

from OrderedSet

max: () -> % if

from FloatingPointSystem

midpoint: % -> %

midpoint(x) returns the midpoint of x.

min: (%, %) -> %

from OrderedSet

min: () -> % if

from FloatingPointSystem

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

from EuclideanDomain

mutable?: % -> Boolean

from JLObjectType

negative?: % -> Boolean

from OrderedAbelianGroup

nonNegative?: % -> Boolean

nonNegative?(v) checks whether or not x is greater or equal to zero.

nonPositive?: % -> Boolean

nonPositive?(v) checks whether or not x is lower or equal to zero.

nonZero?: % -> Boolean

nonZero?(x) returns true if x is equal to 0.

norm: % -> %

from RealNumberSystem

nothing?: % -> Boolean

from JLObjectType

nthRoot: (%, Integer) -> %

from RadicalCategory

one?: % -> Boolean

from MagmaWithUnit

opposite?: (%, %) -> Boolean

from AbelianMonoid

order: % -> Integer

from FloatingPointSystem

overlaps?: (%, %) -> Boolean

overlaps?(x,y) checks whether or not any part of x and y balls overlaps.

patternMatch: (%, Pattern Float, PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %)

from PatternMatchable Float

pi: () -> %

from TranscendentalFunctionCategory

plenaryPower: (%, PositiveInteger) -> %

from NonAssociativeAlgebra %

polyLog: (%, %) -> %

polyLog(x,y) returns the polyLog function applied to x and y.

positive?: % -> Boolean

from OrderedAbelianGroup

precision: () -> PositiveInteger

from FloatingPointSystem

precision: PositiveInteger -> PositiveInteger

from FloatingPointSystem

prime?: % -> Boolean

from UniqueFactorizationDomain

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

from PrincipalIdealDomain

quo: (%, %) -> %

from EuclideanDomain

radius: % -> %

radius(x) returns the radius of x.

randtest: JLSymbol -> %

randtest(randtype) returns a random number depending on the Julia symbol randtype. :urandom an uniformly distributed random number contained in [0,1]. To test corner cases: :randtest returns a finite random number, :randtest_exact returns a zero radius random number, :randtest_precise returns a precise random number i.e. with a radius of around 2^-precision() the magnitude of the midpoint, :randtest_special returns a special random number where midpoint and/or radius might be NaNs or infinities, :randtest_wide returns a random number with a large radius that might be big relative to its midpoint.

recip: % -> Union(%, failed)

from MagmaWithUnit

rem: (%, %) -> %

from EuclideanDomain

retract: % -> Fraction Integer

from RetractableTo Fraction Integer

retract: % -> Integer

from RetractableTo Integer

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

from RetractableTo Fraction Integer

retractIfCan: % -> Union(Integer, failed)

from RetractableTo Integer

retractIfCan: NMAlgebraicNumber -> Union(%, failed)

retractIfCan(x) retracts x if possible. “failed” othewise.

rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

round: % -> %

from RealNumberSystem

sample: %

from AbelianMonoid

sec: % -> %

from TrigonometricFunctionCategory

sech: % -> %

from HyperbolicFunctionCategory

setUnion: (%, %) -> %

setUnion(x,y) returns the unions of the intervals x and y.

sign: % -> Integer

from OrderedAbelianGroup

sin: % -> %

from TrigonometricFunctionCategory

sinh: % -> %

from HyperbolicFunctionCategory

sizeLess?: (%, %) -> Boolean

from EuclideanDomain

smaller?: (%, %) -> Boolean

from Comparable

sqrt: % -> %

from RadicalCategory

squareFree: % -> Factored %

from UniqueFactorizationDomain

squareFreePart: % -> %

from UniqueFactorizationDomain

string: % -> String

from JLType

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

from CancellationAbelianMonoid

tan: % -> %

from TrigonometricFunctionCategory

tanh: % -> %

from HyperbolicFunctionCategory

toString: % -> String

from FloatingPointSystem

toString: (%, NonNegativeInteger) -> String

from FloatingPointSystem

trim: % -> %

trim(x) rounds off insignificant bits from the midpoint.

truncate: % -> %

from RealNumberSystem

uniqueInteger: % -> Union(NMInteger, failed)

uniqueInteger(x) returns a NMInteger if there is a unique integer in the interval x, “failed” otherwise.

unit?: % -> Boolean

from EntireRing

unitCanonical: % -> %

from EntireRing

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

from EntireRing

urand01: () -> %

urand01() returns an uniformly distributed random number contained in [0,1].

wholePart: % -> Integer

from RealNumberSystem

zero?: % -> Boolean

from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra %

Algebra Fraction Integer

Approximate

arbitraryPrecision

ArcHyperbolicFunctionCategory

ArcTrigonometricFunctionCategory

BasicType

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer)

CancellationAbelianMonoid

canonicalsClosed

canonicalUnitNormal

CharacteristicZero

CoercibleFrom Fraction Integer

CoercibleFrom Integer

CoercibleTo OutputForm

CommutativeRing

CommutativeStar

Comparable

ConvertibleTo DoubleFloat

ConvertibleTo Float

ConvertibleTo Pattern Float

ConvertibleTo String

DifferentialRing

DivisionRing

ElementaryFunctionCategory

EntireRing

EuclideanDomain

Field

FloatingPointSystem

GcdDomain

HyperbolicFunctionCategory

IntegralDomain

JLObjectRing

JLObjectType

JLRing

JLType

LeftModule %

LeftModule Fraction Integer

LeftOreRing

Magma

MagmaWithUnit

Module %

Module Fraction Integer

Monoid

NMRing

NMType

NonAssociativeAlgebra %

NonAssociativeAlgebra Fraction Integer

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

OrderedAbelianGroup

OrderedAbelianMonoid

OrderedAbelianSemiGroup

OrderedCancellationAbelianMonoid

OrderedMonoid

OrderedRing

OrderedSemiGroup

OrderedSet

PartialOrder

PatternMatchable Float

PrincipalIdealDomain

RadicalCategory

RealConstant

RealNumberSystem

RetractableTo Fraction Integer

RetractableTo Integer

RightModule %

RightModule Fraction Integer

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

TranscendentalFunctionCategory

TrigonometricFunctionCategory

TwoSidedRecip

UniqueFactorizationDomain

unitsKnown