JLObjFloat64¶

jobject.spad line 447 [edit on github]

Convenience domain for Julia Float64, objects that are used within Julia, and not directly by the underlying FriCAS Common Lisp. It is not meant to be used directly, but rather, for returned value or function argument for example. Only basic arithmetic operations are supported.

0: %: from AbelianMonoid

1: %: from MagmaWithUnit

*: (%, %) -> %: from Magma
*: (%, Fraction Integer) -> %: from RightModule Fraction Integer

*: (%, Integer) -> %: x*i is the integer multiplication.
*: (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) -> %: x/i is the division by an integer.

/: (Integer, %) -> %: i/x is the division of an integer by x.

<=: (%, %) -> Boolean: from PartialOrder

<: (%, %) -> Boolean: from PartialOrder

=: (%, %) -> Boolean: from BasicType

>=: (%, %) -> Boolean: from PartialOrder

>: (%, %) -> Boolean: from PartialOrder

^: (%, Fraction Integer) -> %: x^q is the exponentiation by a rational.
^: (%, Integer) -> %: from DivisionRing
^: (%, NonNegativeInteger) -> %: from MagmaWithUnit
^: (%, PositiveInteger) -> %: from Magma

~=: (%, %) -> Boolean: from BasicType

annihilate?: (%, %) -> Boolean: from Rng

antiCommutator: (%, %) -> %: from NonAssociativeSemiRng

associates?: (%, %) -> Boolean: from EntireRing

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

characteristic: () -> NonNegativeInteger: from NonAssociativeRing

cis: % -> JLObjComplexF64: cis(x) returns exp(%i*x) computed efficiently.

cispi: % -> JLObjComplexF64: cispi(x) returns cis(%pi*x) computed efficiently.

coerce: % -> %: from Algebra %
coerce: % -> JLObject: from JLObjectType
coerce: % -> OutputForm: from CoercibleTo OutputForm

coerce: DoubleFloat -> %: coerce(x) returns x as a JLObjFloat64.

coerce: Float -> %: coerce(x) returns x as a JLObjFloat64 (truncate it) Convenience function.
coerce: Fraction Integer -> %: from Algebra Fraction Integer
coerce: Integer -> %: from NonAssociativeRing

commutator: (%, %) -> %: from NonAssociativeRng

convert: % -> String: from ConvertibleTo String

convert: Float -> %: convert(x) returns x as a JLObjFloat64 (truncate it).

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

euclideanSize: % -> NonNegativeInteger: from EuclideanDomain

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

gcd: (%, %) -> %: from GcdDomain
gcd: List % -> %: from GcdDomain

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

inv: % -> %: from DivisionRing

jfloat64: Float -> %: jfloat64(x) returns x as a JLObjFloat64 (truncate it).

jfloat64: JLFloat64 -> %: jfloat64(x) returns x as a JLObjFloat64 i.e. returns a 64 bits float in the memory area of Julia from the memory area of the underlying Common Lisp implementation.

jfloat64: String -> %: jfloat64(str) evaluates str in Julia and returns the Julia Float64 object. For example: example{jfloat64(“sin(pi)”)} example{jfloat64(“0.7”)}

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

jlApprox?: (%, %) -> Boolean: jlApprox?(x,y) computes inexact equality comparison with default parameters. Two numbers compare equal if their relative distance or their absolute distance is within tolerance bounds.

jlApprox?: (%, %, %) -> Boolean: jlApprox?(x,y,atol) computes inexact equality comparison with absolute tolerance atol. Two numbers compare equal if their relative distance or their absolute distance is within tolerance bounds.

jlDisplay: % -> Void: from JLObjectType

jlDump: JLObject -> Void: from JLObjectType

jlF64CApply: (JLObjDynamicLinker, %) -> %: jlF64CApply(func,x) applies the function pointer func to x. For example: example{libm:= jlDlOpen “libopenlibm”} example{squareRoot:=jlDlSym(libm,jsym(sqrt))} example{jlF64CApply(squareRoot,jfloat64(2))}

jlF64CApply: (JLObjDynamicLinker, %, %) -> %: jlF64CApply(func,x,y) applies the function pointer func to x and y. For example: example{libm:= jlDlOpen “libopenlibm”} example{power:=jlDlSym(libm,jsym(pow))} example{jlF64CApply(power,jfloat64(2),jfloat64(7))}

jlF64CApply: (JLObjDynamicLinker, %, %, %) -> %: jlF64CApply(func,x,y,z) applies the function pointer func to x, y and z. For example with GSL-2.8: example{gsl:= jlDlOpen “libgsl.so.28”} example{hypot3:= jlDlSym(gsl,jsym(gsl_hypot3))} example{jlF64CApply(hypot3,jfloat64(2),jfloat64(7),jfloat64(9.0))}