aboutsummaryrefslogtreecommitdiff
path: root/src/algebra
diff options
context:
space:
mode:
Diffstat (limited to 'src/algebra')
-rw-r--r--src/algebra/sf.spad.pamphlet56
-rw-r--r--src/algebra/strap/DFLOAT.lsp720
2 files changed, 415 insertions, 361 deletions
diff --git a/src/algebra/sf.spad.pamphlet b/src/algebra/sf.spad.pamphlet
index b78d9bdb..d4291701 100644
--- a/src/algebra/sf.spad.pamphlet
+++ b/src/algebra/sf.spad.pamphlet
@@ -289,9 +289,11 @@ DoubleFloat(): Join(FloatingPointSystem, DifferentialRing, OpenMath,
import %fneg: % -> % from Foreign Builtin
import %ftrunc: % -> Integer from Foreign Builtin
import %fmul: (%,%) -> % from Foreign Builtin
+ import %imulf: (Integer,%) -> % from Foreign Builtin
import %fadd: (%,%) -> % from Foreign Builtin
import %fsub: (%,%) -> % from Foreign Builtin
import %fdiv: (%,%) -> % from Foreign Builtin
+ import %fdivi: (%,Integer) -> % from Foreign Builtin
import %fmin: (%,%) -> % from Foreign Builtin
import %fmax: (%,%) -> % from Foreign Builtin
import %feq: (%,%) -> Boolean from Foreign Builtin
@@ -299,14 +301,25 @@ DoubleFloat(): Join(FloatingPointSystem, DifferentialRing, OpenMath,
import %fle: (%,%) -> Boolean from Foreign Builtin
import %fgt: (%,%) -> Boolean from Foreign Builtin
import %fge: (%,%) -> Boolean from Foreign Builtin
+ import %fpowi: (%,Integer) -> % from Foreign Builtin
+ import %fpowf: (%,%) -> % from Foreign Builtin
+ import %fsqrt: % -> % from Foreign Builtin
+ import %fexp: % -> % from Foreign Builtin
+ import %flog: % -> % from Foreign Builtin
+ import %flog2: % -> % from Foreign Builtin
+ import %flog10: % -> % from Foreign Builtin
import %fsin: % -> % from Foreign Builtin
import %fcos: % -> % from Foreign Builtin
import %ftan: % -> % from Foreign Builtin
import %fcot: % -> % from Foreign Builtin
import %fsec: % -> % from Foreign Builtin
import %fcsc: % -> % from Foreign Builtin
+ import %fasin: % -> % from Foreign Builtin
+ import %facos: % -> % from Foreign Builtin
import %fatan: % -> % from Foreign Builtin
import %facot: % -> % from Foreign Builtin
+ import %fasec: % -> % from Foreign Builtin
+ import %facsc: % -> % from Foreign Builtin
import %fsinh: % -> % from Foreign Builtin
import %fcosh: % -> % from Foreign Builtin
import %ftanh: % -> % from Foreign Builtin
@@ -314,7 +327,11 @@ DoubleFloat(): Join(FloatingPointSystem, DifferentialRing, OpenMath,
import %fcoth: % -> % from Foreign Builtin
import %fsech: % -> % from Foreign Builtin
import %fasinh: % -> % from Foreign Builtin
+ import %facosh: % -> % from Foreign Builtin
+ import %fatanh: % -> % from Foreign Builtin
import %facsch: % -> % from Foreign Builtin
+ import %facoth: % -> % from Foreign Builtin
+ import %fasech: % -> % from Foreign Builtin
import %fcstpi: () -> % from Foreign Builtin
manexp: % -> MER
@@ -355,11 +372,6 @@ DoubleFloat(): Join(FloatingPointSystem, DifferentialRing, OpenMath,
if wholeObj then
OMputEndObject(dev)
- checkComplex(x:%):% == C_-TO_-R(x)$Lisp
- -- In AKCL we used to have to make the arguments to ASIN ACOS ACOSH ATANH
- -- complex to get the correct behaviour.
- --makeComplex(x: %):% == COMPLEX(x, 0$%)$Lisp
-
base() == %fbase()
mantissa x == manexp(x).MANTISSA
exponent x == manexp(x).EXPONENT
@@ -386,31 +398,31 @@ DoubleFloat(): Join(FloatingPointSystem, DifferentialRing, OpenMath,
x + y == %fadd(x,y)
x:% - y:% == %fsub(x,y)
x:% * y:% == %fmul(x,y)
- i:Integer * x:% == (i*x)$Lisp
+ i:Integer * x:% == %imulf(i,x)
max(x,y) == %fmax(x,y)
min(x,y) == %fmin(x,y)
x = y == %feq(x,y)
- x:% / i:Integer == (x/i)$Lisp
- sqrt x == checkComplex SQRT(x)$Lisp
- log10 x == checkComplex log(x)$Lisp
- x:% ** i:Integer == EXPT(x,i)$Lisp
- x:% ** y:% == checkComplex EXPT(x,y)$Lisp
+ x:% / i:Integer == %fdivi(x,i)
+ sqrt x == %fsqrt x
+ log10 x == %flog10 x
+ x:% ** i:Integer == %fpowi(x,i)
+ x:% ** y:% == %fpowf(x,y)
coerce(i:Integer):% == %i2f i
- exp x == EXP(x)$Lisp
- log x == checkComplex LN(x)$Lisp
- log2 x == checkComplex LOG2(x)$Lisp
+ exp x == %fexp x
+ log x == %flog x
+ log2 x == %flog2 x
sin x == %fsin x
cos x == %fcos x
tan x == %ftan x
cot x == %fcot x
sec x == %fsec x
csc x == %fcsc x
- asin x == checkComplex ASIN(x)$Lisp -- can be complex
- acos x == checkComplex ACOS(x)$Lisp -- can be complex
+ asin x == %fasin x
+ acos x == %facos x
atan x == %fatan x
- acsc x == checkComplex ACSC(x)$Lisp
+ acsc x == %facsc x
acot x == %facot x
- asec x == checkComplex ASEC(x)$Lisp
+ asec x == %fasec x
sinh x == %fsinh x
cosh x == %fcosh x
tanh x == %ftanh x
@@ -418,11 +430,11 @@ DoubleFloat(): Join(FloatingPointSystem, DifferentialRing, OpenMath,
coth x == %fcoth x
sech x == %fsech x
asinh x == %fasinh x
- acosh x == checkComplex ACOSH(x)$Lisp -- can be complex
- atanh x == checkComplex ATANH(x)$Lisp -- can be complex
+ acosh x == %facosh x
+ atanh x == %fatanh x
acsch x == %facsch x
- acoth x == checkComplex ACOTH(x)$Lisp
- asech x == checkComplex ASECH(x)$Lisp
+ acoth x == %facoth x
+ asech x == %fasech x
x:% / y:% == %fdiv(x,y)
negative? x == x < 0
zero? x == x = 0
diff --git a/src/algebra/strap/DFLOAT.lsp b/src/algebra/strap/DFLOAT.lsp
index 3f9d2dcb..21ed3bb1 100644
--- a/src/algebra/strap/DFLOAT.lsp
+++ b/src/algebra/strap/DFLOAT.lsp
@@ -15,356 +15,377 @@
|%Void|)
|DFLOAT;OMwrite;Omd$BV;4|))
-(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;checkComplex|))
-
-(PUT '|DFLOAT;checkComplex| '|SPADreplace| 'C-TO-R)
-
(DECLAIM (FTYPE (FUNCTION (|%Shell|) (|%IntegerSection| 1))
- |DFLOAT;base;Pi;6|))
+ |DFLOAT;base;Pi;5|))
-(PUT '|DFLOAT;base;Pi;6| '|SPADreplace| '|%fbase|)
+(PUT '|DFLOAT;base;Pi;5| '|SPADreplace| '|%fbase|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Integer|)
- |DFLOAT;mantissa;$I;7|))
+ |DFLOAT;mantissa;$I;6|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Integer|)
- |DFLOAT;exponent;$I;8|))
+ |DFLOAT;exponent;$I;7|))
(DECLAIM (FTYPE (FUNCTION (|%Shell|) (|%IntegerSection| 1))
- |DFLOAT;precision;Pi;9|))
+ |DFLOAT;precision;Pi;8|))
-(PUT '|DFLOAT;precision;Pi;9| '|SPADreplace| '|%fprec|)
+(PUT '|DFLOAT;precision;Pi;8| '|SPADreplace| '|%fprec|)
(DECLAIM (FTYPE (FUNCTION (|%Shell|) (|%IntegerSection| 1))
- |DFLOAT;bits;Pi;10|))
+ |DFLOAT;bits;Pi;9|))
-(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;max;$;11|))
+(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;max;$;10|))
-(PUT '|DFLOAT;max;$;11| '|SPADreplace| '|%fmaxval|)
+(PUT '|DFLOAT;max;$;10| '|SPADreplace| '|%fmaxval|)
-(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;min;$;12|))
+(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;min;$;11|))
-(PUT '|DFLOAT;min;$;12| '|SPADreplace| '|%fminval|)
+(PUT '|DFLOAT;min;$;11| '|SPADreplace| '|%fminval|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Integer|)
- |DFLOAT;order;$I;13|))
+ |DFLOAT;order;$I;12|))
(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|)
- |DFLOAT;Zero;$;14|))
+ |DFLOAT;Zero;$;13|))
-(PUT '|DFLOAT;Zero;$;14| '|SPADreplace| '(XLAM NIL (|%i2f| 0)))
+(PUT '|DFLOAT;Zero;$;13| '|SPADreplace| '(XLAM NIL (|%i2f| 0)))
-(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;One;$;15|))
+(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;One;$;14|))
-(PUT '|DFLOAT;One;$;15| '|SPADreplace| '(XLAM NIL (|%i2f| 1)))
+(PUT '|DFLOAT;One;$;14| '|SPADreplace| '(XLAM NIL (|%i2f| 1)))
(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|)
- |DFLOAT;exp1;$;16|))
+ |DFLOAT;exp1;$;15|))
-(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;pi;$;17|))
+(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;pi;$;16|))
-(PUT '|DFLOAT;pi;$;17| '|SPADreplace| '|%fcstpi|)
+(PUT '|DFLOAT;pi;$;16| '|SPADreplace| '|%fcstpi|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Thing|)
- |DFLOAT;coerce;$Of;18|))
+ |DFLOAT;coerce;$Of;17|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Thing|)
- |DFLOAT;convert;$If;19|))
+ |DFLOAT;convert;$If;18|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
|%Boolean|)
- |DFLOAT;<;2$B;20|))
+ |DFLOAT;<;2$B;19|))
-(PUT '|DFLOAT;<;2$B;20| '|SPADreplace| '|%flt|)
+(PUT '|DFLOAT;<;2$B;19| '|SPADreplace| '|%flt|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
|%Boolean|)
- |DFLOAT;>;2$B;21|))
+ |DFLOAT;>;2$B;20|))
-(PUT '|DFLOAT;>;2$B;21| '|SPADreplace| '|%fgt|)
+(PUT '|DFLOAT;>;2$B;20| '|SPADreplace| '|%fgt|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
|%Boolean|)
- |DFLOAT;<=;2$B;22|))
+ |DFLOAT;<=;2$B;21|))
-(PUT '|DFLOAT;<=;2$B;22| '|SPADreplace| '|%fle|)
+(PUT '|DFLOAT;<=;2$B;21| '|SPADreplace| '|%fle|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
|%Boolean|)
- |DFLOAT;>=;2$B;23|))
+ |DFLOAT;>=;2$B;22|))
-(PUT '|DFLOAT;>=;2$B;23| '|SPADreplace| '|%fge|)
+(PUT '|DFLOAT;>=;2$B;22| '|SPADreplace| '|%fge|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;-;2$;24|))
+ |DFLOAT;-;2$;23|))
-(PUT '|DFLOAT;-;2$;24| '|SPADreplace| '|%fneg|)
+(PUT '|DFLOAT;-;2$;23| '|SPADreplace| '|%fneg|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
|%DoubleFloat|)
- |DFLOAT;+;3$;25|))
+ |DFLOAT;+;3$;24|))
-(PUT '|DFLOAT;+;3$;25| '|SPADreplace| '|%fadd|)
+(PUT '|DFLOAT;+;3$;24| '|SPADreplace| '|%fadd|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
|%DoubleFloat|)
- |DFLOAT;-;3$;26|))
+ |DFLOAT;-;3$;25|))
-(PUT '|DFLOAT;-;3$;26| '|SPADreplace| '|%fsub|)
+(PUT '|DFLOAT;-;3$;25| '|SPADreplace| '|%fsub|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
|%DoubleFloat|)
- |DFLOAT;*;3$;27|))
+ |DFLOAT;*;3$;26|))
-(PUT '|DFLOAT;*;3$;27| '|SPADreplace| '|%fmul|)
+(PUT '|DFLOAT;*;3$;26| '|SPADreplace| '|%fmul|)
(DECLAIM (FTYPE (FUNCTION (|%Integer| |%DoubleFloat| |%Shell|)
|%DoubleFloat|)
- |DFLOAT;*;I2$;28|))
+ |DFLOAT;*;I2$;27|))
-(PUT '|DFLOAT;*;I2$;28| '|SPADreplace| '*)
+(PUT '|DFLOAT;*;I2$;27| '|SPADreplace| '|%imulf|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
|%DoubleFloat|)
- |DFLOAT;max;3$;29|))
+ |DFLOAT;max;3$;28|))
-(PUT '|DFLOAT;max;3$;29| '|SPADreplace| '|%fmax|)
+(PUT '|DFLOAT;max;3$;28| '|SPADreplace| '|%fmax|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
|%DoubleFloat|)
- |DFLOAT;min;3$;30|))
+ |DFLOAT;min;3$;29|))
-(PUT '|DFLOAT;min;3$;30| '|SPADreplace| '|%fmin|)
+(PUT '|DFLOAT;min;3$;29| '|SPADreplace| '|%fmin|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
|%Boolean|)
- |DFLOAT;=;2$B;31|))
+ |DFLOAT;=;2$B;30|))
-(PUT '|DFLOAT;=;2$B;31| '|SPADreplace| '|%feq|)
+(PUT '|DFLOAT;=;2$B;30| '|SPADreplace| '|%feq|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Integer| |%Shell|)
|%DoubleFloat|)
- |DFLOAT;/;$I$;32|))
+ |DFLOAT;/;$I$;31|))
-(PUT '|DFLOAT;/;$I$;32| '|SPADreplace| '/)
+(PUT '|DFLOAT;/;$I$;31| '|SPADreplace| '|%fdivi|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;sqrt;2$;33|))
+ |DFLOAT;sqrt;2$;32|))
+
+(PUT '|DFLOAT;sqrt;2$;32| '|SPADreplace| '|%fsqrt|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;log10;2$;34|))
+ |DFLOAT;log10;2$;33|))
+
+(PUT '|DFLOAT;log10;2$;33| '|SPADreplace| '|%flog10|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Integer| |%Shell|)
|%DoubleFloat|)
- |DFLOAT;**;$I$;35|))
+ |DFLOAT;**;$I$;34|))
-(PUT '|DFLOAT;**;$I$;35| '|SPADreplace| 'EXPT)
+(PUT '|DFLOAT;**;$I$;34| '|SPADreplace| '|%fpowi|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
|%DoubleFloat|)
- |DFLOAT;**;3$;36|))
+ |DFLOAT;**;3$;35|))
+
+(PUT '|DFLOAT;**;3$;35| '|SPADreplace| '|%fpowf|)
(DECLAIM (FTYPE (FUNCTION (|%Integer| |%Shell|) |%DoubleFloat|)
- |DFLOAT;coerce;I$;37|))
+ |DFLOAT;coerce;I$;36|))
-(PUT '|DFLOAT;coerce;I$;37| '|SPADreplace| '|%i2f|)
+(PUT '|DFLOAT;coerce;I$;36| '|SPADreplace| '|%i2f|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;exp;2$;38|))
+ |DFLOAT;exp;2$;37|))
-(PUT '|DFLOAT;exp;2$;38| '|SPADreplace| 'EXP)
+(PUT '|DFLOAT;exp;2$;37| '|SPADreplace| '|%fexp|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;log;2$;39|))
+ |DFLOAT;log;2$;38|))
+
+(PUT '|DFLOAT;log;2$;38| '|SPADreplace| '|%flog|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;log2;2$;40|))
+ |DFLOAT;log2;2$;39|))
+
+(PUT '|DFLOAT;log2;2$;39| '|SPADreplace| '|%flog2|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;sin;2$;41|))
+ |DFLOAT;sin;2$;40|))
-(PUT '|DFLOAT;sin;2$;41| '|SPADreplace| '|%fsin|)
+(PUT '|DFLOAT;sin;2$;40| '|SPADreplace| '|%fsin|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;cos;2$;42|))
+ |DFLOAT;cos;2$;41|))
-(PUT '|DFLOAT;cos;2$;42| '|SPADreplace| '|%fcos|)
+(PUT '|DFLOAT;cos;2$;41| '|SPADreplace| '|%fcos|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;tan;2$;43|))
+ |DFLOAT;tan;2$;42|))
-(PUT '|DFLOAT;tan;2$;43| '|SPADreplace| '|%ftan|)
+(PUT '|DFLOAT;tan;2$;42| '|SPADreplace| '|%ftan|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;cot;2$;44|))
+ |DFLOAT;cot;2$;43|))
-(PUT '|DFLOAT;cot;2$;44| '|SPADreplace| '|%fcot|)
+(PUT '|DFLOAT;cot;2$;43| '|SPADreplace| '|%fcot|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;sec;2$;45|))
+ |DFLOAT;sec;2$;44|))
-(PUT '|DFLOAT;sec;2$;45| '|SPADreplace| '|%fsec|)
+(PUT '|DFLOAT;sec;2$;44| '|SPADreplace| '|%fsec|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;csc;2$;46|))
+ |DFLOAT;csc;2$;45|))
-(PUT '|DFLOAT;csc;2$;46| '|SPADreplace| '|%fcsc|)
+(PUT '|DFLOAT;csc;2$;45| '|SPADreplace| '|%fcsc|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;asin;2$;47|))
+ |DFLOAT;asin;2$;46|))
+
+(PUT '|DFLOAT;asin;2$;46| '|SPADreplace| '|%fasin|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;acos;2$;48|))
+ |DFLOAT;acos;2$;47|))
+
+(PUT '|DFLOAT;acos;2$;47| '|SPADreplace| '|%facos|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;atan;2$;49|))
+ |DFLOAT;atan;2$;48|))
-(PUT '|DFLOAT;atan;2$;49| '|SPADreplace| '|%fatan|)
+(PUT '|DFLOAT;atan;2$;48| '|SPADreplace| '|%fatan|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;acsc;2$;50|))
+ |DFLOAT;acsc;2$;49|))
+
+(PUT '|DFLOAT;acsc;2$;49| '|SPADreplace| '|%facsc|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;acot;2$;51|))
+ |DFLOAT;acot;2$;50|))
-(PUT '|DFLOAT;acot;2$;51| '|SPADreplace| '|%facot|)
+(PUT '|DFLOAT;acot;2$;50| '|SPADreplace| '|%facot|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;asec;2$;52|))
+ |DFLOAT;asec;2$;51|))
+
+(PUT '|DFLOAT;asec;2$;51| '|SPADreplace| '|%fasec|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;sinh;2$;53|))
+ |DFLOAT;sinh;2$;52|))
-(PUT '|DFLOAT;sinh;2$;53| '|SPADreplace| '|%fsinh|)
+(PUT '|DFLOAT;sinh;2$;52| '|SPADreplace| '|%fsinh|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;cosh;2$;54|))
+ |DFLOAT;cosh;2$;53|))
-(PUT '|DFLOAT;cosh;2$;54| '|SPADreplace| '|%fcosh|)
+(PUT '|DFLOAT;cosh;2$;53| '|SPADreplace| '|%fcosh|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;tanh;2$;55|))
+ |DFLOAT;tanh;2$;54|))
-(PUT '|DFLOAT;tanh;2$;55| '|SPADreplace| '|%ftanh|)
+(PUT '|DFLOAT;tanh;2$;54| '|SPADreplace| '|%ftanh|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;csch;2$;56|))
+ |DFLOAT;csch;2$;55|))
-(PUT '|DFLOAT;csch;2$;56| '|SPADreplace| '|%fcsch|)
+(PUT '|DFLOAT;csch;2$;55| '|SPADreplace| '|%fcsch|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;coth;2$;57|))
+ |DFLOAT;coth;2$;56|))
-(PUT '|DFLOAT;coth;2$;57| '|SPADreplace| '|%fcoth|)
+(PUT '|DFLOAT;coth;2$;56| '|SPADreplace| '|%fcoth|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;sech;2$;58|))
+ |DFLOAT;sech;2$;57|))
-(PUT '|DFLOAT;sech;2$;58| '|SPADreplace| '|%fsech|)
+(PUT '|DFLOAT;sech;2$;57| '|SPADreplace| '|%fsech|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;asinh;2$;59|))
+ |DFLOAT;asinh;2$;58|))
-(PUT '|DFLOAT;asinh;2$;59| '|SPADreplace| '|%fasinh|)
+(PUT '|DFLOAT;asinh;2$;58| '|SPADreplace| '|%fasinh|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;acosh;2$;60|))
+ |DFLOAT;acosh;2$;59|))
+
+(PUT '|DFLOAT;acosh;2$;59| '|SPADreplace| '|%facosh|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;atanh;2$;61|))
+ |DFLOAT;atanh;2$;60|))
+
+(PUT '|DFLOAT;atanh;2$;60| '|SPADreplace| '|%fatanh|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;acsch;2$;62|))
+ |DFLOAT;acsch;2$;61|))
-(PUT '|DFLOAT;acsch;2$;62| '|SPADreplace| '|%facsch|)
+(PUT '|DFLOAT;acsch;2$;61| '|SPADreplace| '|%facsch|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;acoth;2$;63|))
+ |DFLOAT;acoth;2$;62|))
+
+(PUT '|DFLOAT;acoth;2$;62| '|SPADreplace| '|%facoth|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;asech;2$;64|))
+ |DFLOAT;asech;2$;63|))
+
+(PUT '|DFLOAT;asech;2$;63| '|SPADreplace| '|%fasech|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
|%DoubleFloat|)
- |DFLOAT;/;3$;65|))
+ |DFLOAT;/;3$;64|))
-(PUT '|DFLOAT;/;3$;65| '|SPADreplace| '|%fdiv|)
+(PUT '|DFLOAT;/;3$;64| '|SPADreplace| '|%fdiv|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Boolean|)
- |DFLOAT;negative?;$B;66|))
+ |DFLOAT;negative?;$B;65|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Boolean|)
- |DFLOAT;zero?;$B;67|))
+ |DFLOAT;zero?;$B;66|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Boolean|)
- |DFLOAT;one?;$B;68|))
+ |DFLOAT;one?;$B;67|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Short|)
- |DFLOAT;hash;$Si;69|))
+ |DFLOAT;hash;$Si;68|))
-(PUT '|DFLOAT;hash;$Si;69| '|SPADreplace| '|%hash|)
+(PUT '|DFLOAT;hash;$Si;68| '|SPADreplace| '|%hash|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Pair|)
- |DFLOAT;recip;$U;70|))
+ |DFLOAT;recip;$U;69|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;differentiate;2$;71|))
+ |DFLOAT;differentiate;2$;70|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;Gamma;2$;72|))
+ |DFLOAT;Gamma;2$;71|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
|%DoubleFloat|)
- |DFLOAT;Beta;3$;73|))
+ |DFLOAT;Beta;3$;72|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Integer|)
- |DFLOAT;wholePart;$I;74|))
+ |DFLOAT;wholePart;$I;73|))
-(PUT '|DFLOAT;wholePart;$I;74| '|SPADreplace| '|%ftrunc|)
+(PUT '|DFLOAT;wholePart;$I;73| '|SPADreplace| '|%ftrunc|)
(DECLAIM (FTYPE (FUNCTION
(|%Integer| |%Integer| (|%IntegerSection| 1)
|%Shell|)
|%DoubleFloat|)
- |DFLOAT;float;2IPi$;75|))
+ |DFLOAT;float;2IPi$;74|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;convert;2$;76|))
+ |DFLOAT;convert;2$;75|))
-(PUT '|DFLOAT;convert;2$;76| '|SPADreplace| '(XLAM (|x|) |x|))
+(PUT '|DFLOAT;convert;2$;75| '|SPADreplace| '(XLAM (|x|) |x|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Thing|)
- |DFLOAT;convert;$F;77|))
+ |DFLOAT;convert;$F;76|))
(DECLAIM (FTYPE (FUNCTION
(|%DoubleFloat| (|%IntegerSection| 0) |%Shell|)
|%Thing|)
- |DFLOAT;rationalApproximation;$NniF;78|))
+ |DFLOAT;rationalApproximation;$NniF;77|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
|%DoubleFloat|)
- |DFLOAT;atan;3$;79|))
+ |DFLOAT;atan;3$;78|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Thing|)
- |DFLOAT;retract;$F;80|))
+ |DFLOAT;retract;$F;79|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Pair|)
- |DFLOAT;retractIfCan;$U;81|))
+ |DFLOAT;retractIfCan;$U;80|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Integer|)
- |DFLOAT;retract;$I;82|))
+ |DFLOAT;retract;$I;81|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Pair|)
- |DFLOAT;retractIfCan;$U;83|))
+ |DFLOAT;retractIfCan;$U;82|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Integer|)
- |DFLOAT;sign;$I;84|))
+ |DFLOAT;sign;$I;83|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
- |DFLOAT;abs;2$;85|))
+ |DFLOAT;abs;2$;84|))
-(PUT '|DFLOAT;abs;2$;85| '|SPADreplace| '|%fabs|)
+(PUT '|DFLOAT;abs;2$;84| '|SPADreplace| '|%fabs|)
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Pair|)
|DFLOAT;manexp|))
@@ -373,25 +394,25 @@
(|%DoubleFloat| (|%IntegerSection| 0)
(|%IntegerSection| 0) |%Shell|)
|%Thing|)
- |DFLOAT;rationalApproximation;$2NniF;87|))
+ |DFLOAT;rationalApproximation;$2NniF;86|))
(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Thing| |%Shell|)
|%DoubleFloat|)
- |DFLOAT;**;$F$;88|))
+ |DFLOAT;**;$F$;87|))
-(PUT '|DFLOAT;exp1;$;16| '|SPADreplace|
+(PUT '|DFLOAT;exp1;$;15| '|SPADreplace|
'(XLAM NIL (|%fdiv| (|%i2f| 534625820200) (|%i2f| 196677847971))))
-(PUT '|DFLOAT;negative?;$B;66| '|SPADreplace|
+(PUT '|DFLOAT;negative?;$B;65| '|SPADreplace|
'(XLAM (|x|) (|%flt| |x| (|%i2f| 0))))
-(PUT '|DFLOAT;zero?;$B;67| '|SPADreplace|
+(PUT '|DFLOAT;zero?;$B;66| '|SPADreplace|
'(XLAM (|x|) (|%feq| |x| (|%i2f| 0))))
-(PUT '|DFLOAT;one?;$B;68| '|SPADreplace|
+(PUT '|DFLOAT;one?;$B;67| '|SPADreplace|
'(XLAM (|x|) (|%feq| |x| (|%i2f| 1))))
-(PUT '|DFLOAT;differentiate;2$;71| '|SPADreplace|
+(PUT '|DFLOAT;differentiate;2$;70| '|SPADreplace|
'(XLAM (|x|) (|%i2f| 0)))
(DEFUN |DFLOAT;OMwrite;$S;1| (|x| $)
@@ -425,202 +446,222 @@
(EXIT (COND
(|wholeObj| (SPADCALL |dev| (|getShellEntry| $ 16)))))))
-(DEFUN |DFLOAT;checkComplex| (|x| $)
- (DECLARE (IGNORE $))
- (C-TO-R |x|))
-
-(DEFUN |DFLOAT;base;Pi;6| ($) (DECLARE (IGNORE $)) 2)
+(DEFUN |DFLOAT;base;Pi;5| ($) (DECLARE (IGNORE $)) 2)
-(DEFUN |DFLOAT;mantissa;$I;7| (|x| $) (CAR (|DFLOAT;manexp| |x| $)))
+(DEFUN |DFLOAT;mantissa;$I;6| (|x| $) (CAR (|DFLOAT;manexp| |x| $)))
-(DEFUN |DFLOAT;exponent;$I;8| (|x| $) (CDR (|DFLOAT;manexp| |x| $)))
+(DEFUN |DFLOAT;exponent;$I;7| (|x| $) (CDR (|DFLOAT;manexp| |x| $)))
-(DEFUN |DFLOAT;precision;Pi;9| ($) (DECLARE (IGNORE $)) 53)
+(DEFUN |DFLOAT;precision;Pi;8| ($) (DECLARE (IGNORE $)) 53)
-(DEFUN |DFLOAT;bits;Pi;10| ($)
+(DEFUN |DFLOAT;bits;Pi;9| ($)
(COND
((EQL 2 2) 53)
((EQL 2 16) (* 4 53))
- (T (LET ((#0=#:G1406
+ (T (LET ((#0=#:G1405
(TRUNCATE
(SPADCALL 53
- (|DFLOAT;log2;2$;40|
- (FLOAT 2 |$DoubleFloatMaximum|) $)
+ (C-TO-R (LOG (FLOAT 2 |$DoubleFloatMaximum|)
+ 2))
(|getShellEntry| $ 32)))))
(|check-subtype| (AND (NOT (MINUSP #0#)) (PLUSP #0#))
'(|PositiveInteger|) #0#)))))
-(DEFUN |DFLOAT;max;$;11| ($)
+(DEFUN |DFLOAT;max;$;10| ($)
(DECLARE (IGNORE $))
|$DoubleFloatMaximum|)
-(DEFUN |DFLOAT;min;$;12| ($)
+(DEFUN |DFLOAT;min;$;11| ($)
(DECLARE (IGNORE $))
|$DoubleFloatMinimum|)
-(DEFUN |DFLOAT;order;$I;13| (|a| $)
- (- (+ 53 (|DFLOAT;exponent;$I;8| |a| $)) 1))
+(DEFUN |DFLOAT;order;$I;12| (|a| $)
+ (- (+ 53 (|DFLOAT;exponent;$I;7| |a| $)) 1))
-(DEFUN |DFLOAT;Zero;$;14| ($) (DECLARE (IGNORE $)) 0.0)
+(DEFUN |DFLOAT;Zero;$;13| ($) (DECLARE (IGNORE $)) 0.0)
-(DEFUN |DFLOAT;One;$;15| ($) (DECLARE (IGNORE $)) 1.0)
+(DEFUN |DFLOAT;One;$;14| ($) (DECLARE (IGNORE $)) 1.0)
-(DEFUN |DFLOAT;exp1;$;16| ($)
+(DEFUN |DFLOAT;exp1;$;15| ($)
(DECLARE (IGNORE $))
(/ (FLOAT 534625820200 |$DoubleFloatMaximum|)
(FLOAT 196677847971 |$DoubleFloatMaximum|)))
-(DEFUN |DFLOAT;pi;$;17| ($)
+(DEFUN |DFLOAT;pi;$;16| ($)
(DECLARE (IGNORE $))
(COERCE PI '|%DoubleFloat|))
-(DEFUN |DFLOAT;coerce;$Of;18| (|x| $)
+(DEFUN |DFLOAT;coerce;$Of;17| (|x| $)
(SPADCALL |x| (|getShellEntry| $ 48)))
-(DEFUN |DFLOAT;convert;$If;19| (|x| $)
+(DEFUN |DFLOAT;convert;$If;18| (|x| $)
(SPADCALL |x| (|getShellEntry| $ 51)))
-(DEFUN |DFLOAT;<;2$B;20| (|x| |y| $) (DECLARE (IGNORE $)) (< |x| |y|))
+(DEFUN |DFLOAT;<;2$B;19| (|x| |y| $) (DECLARE (IGNORE $)) (< |x| |y|))
-(DEFUN |DFLOAT;>;2$B;21| (|x| |y| $) (DECLARE (IGNORE $)) (< |y| |x|))
+(DEFUN |DFLOAT;>;2$B;20| (|x| |y| $) (DECLARE (IGNORE $)) (< |y| |x|))
-(DEFUN |DFLOAT;<=;2$B;22| (|x| |y| $)
+(DEFUN |DFLOAT;<=;2$B;21| (|x| |y| $)
(DECLARE (IGNORE $))
(<= |x| |y|))
-(DEFUN |DFLOAT;>=;2$B;23| (|x| |y| $)
+(DEFUN |DFLOAT;>=;2$B;22| (|x| |y| $)
(DECLARE (IGNORE $))
(>= |x| |y|))
-(DEFUN |DFLOAT;-;2$;24| (|x| $) (DECLARE (IGNORE $)) (- |x|))
+(DEFUN |DFLOAT;-;2$;23| (|x| $) (DECLARE (IGNORE $)) (- |x|))
-(DEFUN |DFLOAT;+;3$;25| (|x| |y| $) (DECLARE (IGNORE $)) (+ |x| |y|))
+(DEFUN |DFLOAT;+;3$;24| (|x| |y| $) (DECLARE (IGNORE $)) (+ |x| |y|))
-(DEFUN |DFLOAT;-;3$;26| (|x| |y| $) (DECLARE (IGNORE $)) (- |x| |y|))
+(DEFUN |DFLOAT;-;3$;25| (|x| |y| $) (DECLARE (IGNORE $)) (- |x| |y|))
-(DEFUN |DFLOAT;*;3$;27| (|x| |y| $) (DECLARE (IGNORE $)) (* |x| |y|))
+(DEFUN |DFLOAT;*;3$;26| (|x| |y| $) (DECLARE (IGNORE $)) (* |x| |y|))
-(DEFUN |DFLOAT;*;I2$;28| (|i| |x| $) (DECLARE (IGNORE $)) (* |i| |x|))
+(DEFUN |DFLOAT;*;I2$;27| (|i| |x| $) (DECLARE (IGNORE $)) (* |i| |x|))
-(DEFUN |DFLOAT;max;3$;29| (|x| |y| $)
+(DEFUN |DFLOAT;max;3$;28| (|x| |y| $)
(DECLARE (IGNORE $))
(MAX |x| |y|))
-(DEFUN |DFLOAT;min;3$;30| (|x| |y| $)
+(DEFUN |DFLOAT;min;3$;29| (|x| |y| $)
(DECLARE (IGNORE $))
(MIN |x| |y|))
-(DEFUN |DFLOAT;=;2$B;31| (|x| |y| $) (DECLARE (IGNORE $)) (= |x| |y|))
+(DEFUN |DFLOAT;=;2$B;30| (|x| |y| $) (DECLARE (IGNORE $)) (= |x| |y|))
-(DEFUN |DFLOAT;/;$I$;32| (|x| |i| $) (DECLARE (IGNORE $)) (/ |x| |i|))
+(DEFUN |DFLOAT;/;$I$;31| (|x| |i| $) (DECLARE (IGNORE $)) (/ |x| |i|))
-(DEFUN |DFLOAT;sqrt;2$;33| (|x| $) (C-TO-R (SQRT |x|)))
+(DEFUN |DFLOAT;sqrt;2$;32| (|x| $)
+ (DECLARE (IGNORE $))
+ (C-TO-R (SQRT |x|)))
-(DEFUN |DFLOAT;log10;2$;34| (|x| $) (C-TO-R (|log| |x|)))
+(DEFUN |DFLOAT;log10;2$;33| (|x| $)
+ (DECLARE (IGNORE $))
+ (C-TO-R (LOG |x| 10)))
-(DEFUN |DFLOAT;**;$I$;35| (|x| |i| $)
+(DEFUN |DFLOAT;**;$I$;34| (|x| |i| $)
(DECLARE (IGNORE $))
(EXPT |x| |i|))
-(DEFUN |DFLOAT;**;3$;36| (|x| |y| $) (C-TO-R (EXPT |x| |y|)))
+(DEFUN |DFLOAT;**;3$;35| (|x| |y| $)
+ (DECLARE (IGNORE $))
+ (C-TO-R (EXPT |x| |y|)))
-(DEFUN |DFLOAT;coerce;I$;37| (|i| $)
+(DEFUN |DFLOAT;coerce;I$;36| (|i| $)
(DECLARE (IGNORE $))
(FLOAT |i| |$DoubleFloatMaximum|))
-(DEFUN |DFLOAT;exp;2$;38| (|x| $) (DECLARE (IGNORE $)) (EXP |x|))
+(DEFUN |DFLOAT;exp;2$;37| (|x| $) (DECLARE (IGNORE $)) (EXP |x|))
-(DEFUN |DFLOAT;log;2$;39| (|x| $) (C-TO-R (LN |x|)))
+(DEFUN |DFLOAT;log;2$;38| (|x| $)
+ (DECLARE (IGNORE $))
+ (C-TO-R (LOG |x|)))
-(DEFUN |DFLOAT;log2;2$;40| (|x| $) (C-TO-R (LOG2 |x|)))
+(DEFUN |DFLOAT;log2;2$;39| (|x| $)
+ (DECLARE (IGNORE $))
+ (C-TO-R (LOG |x| 2)))
-(DEFUN |DFLOAT;sin;2$;41| (|x| $) (DECLARE (IGNORE $)) (SIN |x|))
+(DEFUN |DFLOAT;sin;2$;40| (|x| $) (DECLARE (IGNORE $)) (SIN |x|))
-(DEFUN |DFLOAT;cos;2$;42| (|x| $) (DECLARE (IGNORE $)) (COS |x|))
+(DEFUN |DFLOAT;cos;2$;41| (|x| $) (DECLARE (IGNORE $)) (COS |x|))
-(DEFUN |DFLOAT;tan;2$;43| (|x| $) (DECLARE (IGNORE $)) (TAN |x|))
+(DEFUN |DFLOAT;tan;2$;42| (|x| $) (DECLARE (IGNORE $)) (TAN |x|))
-(DEFUN |DFLOAT;cot;2$;44| (|x| $) (DECLARE (IGNORE $)) (COT |x|))
+(DEFUN |DFLOAT;cot;2$;43| (|x| $) (DECLARE (IGNORE $)) (COT |x|))
-(DEFUN |DFLOAT;sec;2$;45| (|x| $) (DECLARE (IGNORE $)) (SEC |x|))
+(DEFUN |DFLOAT;sec;2$;44| (|x| $) (DECLARE (IGNORE $)) (SEC |x|))
-(DEFUN |DFLOAT;csc;2$;46| (|x| $) (DECLARE (IGNORE $)) (CSC |x|))
+(DEFUN |DFLOAT;csc;2$;45| (|x| $) (DECLARE (IGNORE $)) (CSC |x|))
-(DEFUN |DFLOAT;asin;2$;47| (|x| $) (C-TO-R (ASIN |x|)))
+(DEFUN |DFLOAT;asin;2$;46| (|x| $)
+ (DECLARE (IGNORE $))
+ (C-TO-R (ASIN |x|)))
-(DEFUN |DFLOAT;acos;2$;48| (|x| $) (C-TO-R (ACOS |x|)))
+(DEFUN |DFLOAT;acos;2$;47| (|x| $)
+ (DECLARE (IGNORE $))
+ (C-TO-R (ACOS |x|)))
-(DEFUN |DFLOAT;atan;2$;49| (|x| $) (DECLARE (IGNORE $)) (ATAN |x|))
+(DEFUN |DFLOAT;atan;2$;48| (|x| $) (DECLARE (IGNORE $)) (ATAN |x|))
-(DEFUN |DFLOAT;acsc;2$;50| (|x| $) (C-TO-R (ACSC |x|)))
+(DEFUN |DFLOAT;acsc;2$;49| (|x| $)
+ (DECLARE (IGNORE $))
+ (C-TO-R (ACSC |x|)))
-(DEFUN |DFLOAT;acot;2$;51| (|x| $) (DECLARE (IGNORE $)) (ACOT |x|))
+(DEFUN |DFLOAT;acot;2$;50| (|x| $) (DECLARE (IGNORE $)) (ACOT |x|))
-(DEFUN |DFLOAT;asec;2$;52| (|x| $) (C-TO-R (ASEC |x|)))
+(DEFUN |DFLOAT;asec;2$;51| (|x| $)
+ (DECLARE (IGNORE $))
+ (C-TO-R (ASEC |x|)))
-(DEFUN |DFLOAT;sinh;2$;53| (|x| $) (DECLARE (IGNORE $)) (SINH |x|))
+(DEFUN |DFLOAT;sinh;2$;52| (|x| $) (DECLARE (IGNORE $)) (SINH |x|))
-(DEFUN |DFLOAT;cosh;2$;54| (|x| $) (DECLARE (IGNORE $)) (COSH |x|))
+(DEFUN |DFLOAT;cosh;2$;53| (|x| $) (DECLARE (IGNORE $)) (COSH |x|))
-(DEFUN |DFLOAT;tanh;2$;55| (|x| $) (DECLARE (IGNORE $)) (TANH |x|))
+(DEFUN |DFLOAT;tanh;2$;54| (|x| $) (DECLARE (IGNORE $)) (TANH |x|))
-(DEFUN |DFLOAT;csch;2$;56| (|x| $) (DECLARE (IGNORE $)) (CSCH |x|))
+(DEFUN |DFLOAT;csch;2$;55| (|x| $) (DECLARE (IGNORE $)) (CSCH |x|))
-(DEFUN |DFLOAT;coth;2$;57| (|x| $) (DECLARE (IGNORE $)) (COTH |x|))
+(DEFUN |DFLOAT;coth;2$;56| (|x| $) (DECLARE (IGNORE $)) (COTH |x|))
-(DEFUN |DFLOAT;sech;2$;58| (|x| $) (DECLARE (IGNORE $)) (SECH |x|))
+(DEFUN |DFLOAT;sech;2$;57| (|x| $) (DECLARE (IGNORE $)) (SECH |x|))
-(DEFUN |DFLOAT;asinh;2$;59| (|x| $) (DECLARE (IGNORE $)) (ASINH |x|))
+(DEFUN |DFLOAT;asinh;2$;58| (|x| $) (DECLARE (IGNORE $)) (ASINH |x|))
-(DEFUN |DFLOAT;acosh;2$;60| (|x| $) (C-TO-R (ACOSH |x|)))
+(DEFUN |DFLOAT;acosh;2$;59| (|x| $)
+ (DECLARE (IGNORE $))
+ (C-TO-R (ACOSH |x|)))
-(DEFUN |DFLOAT;atanh;2$;61| (|x| $) (C-TO-R (ATANH |x|)))
+(DEFUN |DFLOAT;atanh;2$;60| (|x| $)
+ (DECLARE (IGNORE $))
+ (C-TO-R (ATANH |x|)))
-(DEFUN |DFLOAT;acsch;2$;62| (|x| $) (DECLARE (IGNORE $)) (ACSCH |x|))
+(DEFUN |DFLOAT;acsch;2$;61| (|x| $) (DECLARE (IGNORE $)) (ACSCH |x|))
-(DEFUN |DFLOAT;acoth;2$;63| (|x| $) (C-TO-R (ACOTH |x|)))
+(DEFUN |DFLOAT;acoth;2$;62| (|x| $)
+ (DECLARE (IGNORE $))
+ (C-TO-R (ACOTH |x|)))
-(DEFUN |DFLOAT;asech;2$;64| (|x| $) (C-TO-R (ASECH |x|)))
+(DEFUN |DFLOAT;asech;2$;63| (|x| $) (DECLARE (IGNORE $)) (ASECH |x|))
-(DEFUN |DFLOAT;/;3$;65| (|x| |y| $) (DECLARE (IGNORE $)) (/ |x| |y|))
+(DEFUN |DFLOAT;/;3$;64| (|x| |y| $) (DECLARE (IGNORE $)) (/ |x| |y|))
-(DEFUN |DFLOAT;negative?;$B;66| (|x| $)
+(DEFUN |DFLOAT;negative?;$B;65| (|x| $)
(DECLARE (IGNORE $))
(MINUSP |x|))
-(DEFUN |DFLOAT;zero?;$B;67| (|x| $) (DECLARE (IGNORE $)) (ZEROP |x|))
+(DEFUN |DFLOAT;zero?;$B;66| (|x| $) (DECLARE (IGNORE $)) (ZEROP |x|))
-(DEFUN |DFLOAT;one?;$B;68| (|x| $) (DECLARE (IGNORE $)) (= |x| 1.0))
+(DEFUN |DFLOAT;one?;$B;67| (|x| $) (DECLARE (IGNORE $)) (= |x| 1.0))
-(DEFUN |DFLOAT;hash;$Si;69| (|x| $) (DECLARE (IGNORE $)) (SXHASH |x|))
+(DEFUN |DFLOAT;hash;$Si;68| (|x| $) (DECLARE (IGNORE $)) (SXHASH |x|))
-(DEFUN |DFLOAT;recip;$U;70| (|x| $)
+(DEFUN |DFLOAT;recip;$U;69| (|x| $)
(COND ((ZEROP |x|) (CONS 1 "failed")) (T (CONS 0 (/ 1.0 |x|)))))
-(DEFUN |DFLOAT;differentiate;2$;71| (|x| $) (DECLARE (IGNORE $)) 0.0)
+(DEFUN |DFLOAT;differentiate;2$;70| (|x| $) (DECLARE (IGNORE $)) 0.0)
-(DEFUN |DFLOAT;Gamma;2$;72| (|x| $)
+(DEFUN |DFLOAT;Gamma;2$;71| (|x| $)
(SPADCALL |x| (|getShellEntry| $ 106)))
-(DEFUN |DFLOAT;Beta;3$;73| (|x| |y| $)
+(DEFUN |DFLOAT;Beta;3$;72| (|x| |y| $)
(SPADCALL |x| |y| (|getShellEntry| $ 108)))
-(DEFUN |DFLOAT;wholePart;$I;74| (|x| $)
+(DEFUN |DFLOAT;wholePart;$I;73| (|x| $)
(DECLARE (IGNORE $))
(TRUNCATE |x|))
-(DEFUN |DFLOAT;float;2IPi$;75| (|ma| |ex| |b| $)
+(DEFUN |DFLOAT;float;2IPi$;74| (|ma| |ex| |b| $)
(* |ma| (EXPT (FLOAT |b| |$DoubleFloatMaximum|) |ex|)))
-(DEFUN |DFLOAT;convert;2$;76| (|x| $) (DECLARE (IGNORE $)) |x|)
+(DEFUN |DFLOAT;convert;2$;75| (|x| $) (DECLARE (IGNORE $)) |x|)
-(DEFUN |DFLOAT;convert;$F;77| (|x| $)
+(DEFUN |DFLOAT;convert;$F;76| (|x| $)
(SPADCALL |x| (|getShellEntry| $ 112)))
-(DEFUN |DFLOAT;rationalApproximation;$NniF;78| (|x| |d| $)
- (|DFLOAT;rationalApproximation;$2NniF;87| |x| |d| 10 $))
+(DEFUN |DFLOAT;rationalApproximation;$NniF;77| (|x| |d| $)
+ (|DFLOAT;rationalApproximation;$2NniF;86| |x| |d| 10 $))
-(DEFUN |DFLOAT;atan;3$;79| (|x| |y| $)
+(DEFUN |DFLOAT;atan;3$;78| (|x| |y| $)
(PROG (|theta|)
(RETURN
(SEQ (COND
@@ -630,7 +671,7 @@
((MINUSP |y|) (- (/ (COERCE PI '|%DoubleFloat|) 2)))
(T 0.0)))
(T (SEQ (LETT |theta| (ATAN (ABS (/ |y| |x|)))
- |DFLOAT;atan;3$;79|)
+ |DFLOAT;atan;3$;78|)
(COND
((MINUSP |x|)
(SETQ |theta|
@@ -638,63 +679,63 @@
(COND ((MINUSP |y|) (SETQ |theta| (- |theta|))))
(EXIT |theta|))))))))
-(DEFUN |DFLOAT;retract;$F;80| (|x| $)
- (|DFLOAT;rationalApproximation;$2NniF;87| |x|
- (LET ((#0=#:G1489 (- 53 1)))
+(DEFUN |DFLOAT;retract;$F;79| (|x| $)
+ (|DFLOAT;rationalApproximation;$2NniF;86| |x|
+ (LET ((#0=#:G1488 (- 53 1)))
(|check-subtype| (NOT (MINUSP #0#)) '(|NonNegativeInteger|)
#0#))
2 $))
-(DEFUN |DFLOAT;retractIfCan;$U;81| (|x| $)
+(DEFUN |DFLOAT;retractIfCan;$U;80| (|x| $)
(CONS 0
- (|DFLOAT;rationalApproximation;$2NniF;87| |x|
- (LET ((#0=#:G1497 (- 53 1)))
+ (|DFLOAT;rationalApproximation;$2NniF;86| |x|
+ (LET ((#0=#:G1496 (- 53 1)))
(|check-subtype| (NOT (MINUSP #0#))
'(|NonNegativeInteger|) #0#))
2 $)))
-(DEFUN |DFLOAT;retract;$I;82| (|x| $)
+(DEFUN |DFLOAT;retract;$I;81| (|x| $)
(PROG (|n|)
(RETURN
(COND
((= |x|
- (FLOAT (LETT |n| (TRUNCATE |x|) |DFLOAT;retract;$I;82|)
+ (FLOAT (LETT |n| (TRUNCATE |x|) |DFLOAT;retract;$I;81|)
|$DoubleFloatMaximum|))
|n|)
(T (|error| "Not an integer"))))))
-(DEFUN |DFLOAT;retractIfCan;$U;83| (|x| $)
+(DEFUN |DFLOAT;retractIfCan;$U;82| (|x| $)
(PROG (|n|)
(RETURN
(COND
((= |x|
(FLOAT (LETT |n| (TRUNCATE |x|)
- |DFLOAT;retractIfCan;$U;83|)
+ |DFLOAT;retractIfCan;$U;82|)
|$DoubleFloatMaximum|))
(CONS 0 |n|))
(T (CONS 1 "failed"))))))
-(DEFUN |DFLOAT;sign;$I;84| (|x| $)
- (|DFLOAT;retract;$I;82| (FLOAT-SIGN |x| 1.0) $))
+(DEFUN |DFLOAT;sign;$I;83| (|x| $)
+ (|DFLOAT;retract;$I;81| (FLOAT-SIGN |x| 1.0) $))
-(DEFUN |DFLOAT;abs;2$;85| (|x| $) (DECLARE (IGNORE $)) (ABS |x|))
+(DEFUN |DFLOAT;abs;2$;84| (|x| $) (DECLARE (IGNORE $)) (ABS |x|))
(DEFUN |DFLOAT;manexp| (|x| $)
(PROG (|s| |me| |two53|)
(RETURN
(SEQ (COND
((ZEROP |x|) (CONS 0 0))
- (T (SEQ (LETT |s| (|DFLOAT;sign;$I;84| |x| $)
+ (T (SEQ (LETT |s| (|DFLOAT;sign;$I;83| |x| $)
|DFLOAT;manexp|)
(SETQ |x| (ABS |x|))
(COND
((< |$DoubleFloatMaximum| |x|)
(RETURN-FROM |DFLOAT;manexp|
(CONS (+ (* |s|
- (|DFLOAT;mantissa;$I;7|
+ (|DFLOAT;mantissa;$I;6|
|$DoubleFloatMaximum| $))
1)
- (|DFLOAT;exponent;$I;8|
+ (|DFLOAT;exponent;$I;7|
|$DoubleFloatMaximum| $)))))
(LETT |me| (MANEXP |x|) |DFLOAT;manexp|)
(LETT |two53| (EXPT 2 53) |DFLOAT;manexp|)
@@ -702,15 +743,15 @@
(TRUNCATE (* |two53| (CAR |me|))))
(- (CDR |me|) 53))))))))))
-(DEFUN |DFLOAT;rationalApproximation;$2NniF;87| (|f| |d| |b| $)
- (PROG (BASE |de| |tol| |s| |t| |p0| |p1| |q0| |q1| |#G107| |q| |r|
- |p2| |q2| |#G108| |#G109| |#G110| |#G111| |#G112|
- |#G113|)
+(DEFUN |DFLOAT;rationalApproximation;$2NniF;86| (|f| |d| |b| $)
+ (PROG (BASE |de| |tol| |s| |t| |p0| |p1| |q0| |q1| |#G106| |q| |r|
+ |p2| |q2| |#G107| |#G108| |#G109| |#G110| |#G111|
+ |#G112|)
(RETURN
- (LET* ((|#G106| (|DFLOAT;manexp| |f| $)) (|nu| (CAR |#G106|))
- (|ex| (CDR |#G106|)))
- (SEQ |#G106|
- (LETT BASE 2 |DFLOAT;rationalApproximation;$2NniF;87|)
+ (LET* ((|#G105| (|DFLOAT;manexp| |f| $)) (|nu| (CAR |#G105|))
+ (|ex| (CDR |#G105|)))
+ (SEQ |#G105|
+ (LETT BASE 2 |DFLOAT;rationalApproximation;$2NniF;86|)
(EXIT (COND
((NOT (MINUSP |ex|))
(SPADCALL
@@ -721,52 +762,52 @@
(|getShellEntry| $ 134)))
(T (SEQ (LETT |de|
(EXPT BASE
- (LET ((#0=#:G1525 (- |ex|)))
+ (LET ((#0=#:G1524 (- |ex|)))
(|check-subtype|
(NOT (MINUSP #0#))
'(|NonNegativeInteger|) #0#)))
- |DFLOAT;rationalApproximation;$2NniF;87|)
+ |DFLOAT;rationalApproximation;$2NniF;86|)
(EXIT (COND
((< |b| 2)
(|error| "base must be > 1"))
(T
(SEQ
(LETT |tol| (EXPT |b| |d|)
- |DFLOAT;rationalApproximation;$2NniF;87|)
+ |DFLOAT;rationalApproximation;$2NniF;86|)
(LETT |s| |nu|
- |DFLOAT;rationalApproximation;$2NniF;87|)
+ |DFLOAT;rationalApproximation;$2NniF;86|)
(LETT |t| |de|
- |DFLOAT;rationalApproximation;$2NniF;87|)
+ |DFLOAT;rationalApproximation;$2NniF;86|)
(LETT |p0| 0
- |DFLOAT;rationalApproximation;$2NniF;87|)
+ |DFLOAT;rationalApproximation;$2NniF;86|)
(LETT |p1| 1
- |DFLOAT;rationalApproximation;$2NniF;87|)
+ |DFLOAT;rationalApproximation;$2NniF;86|)
(LETT |q0| 1
- |DFLOAT;rationalApproximation;$2NniF;87|)
+ |DFLOAT;rationalApproximation;$2NniF;86|)
(LETT |q1| 0
- |DFLOAT;rationalApproximation;$2NniF;87|)
+ |DFLOAT;rationalApproximation;$2NniF;86|)
(EXIT
(LOOP
(COND
(NIL (RETURN NIL))
(T
(SEQ
- (LETT |#G107|
+ (LETT |#G106|
(MULTIPLE-VALUE-CALL
#'CONS
(TRUNCATE |s| |t|))
- |DFLOAT;rationalApproximation;$2NniF;87|)
- (LETT |q| (CAR |#G107|)
- |DFLOAT;rationalApproximation;$2NniF;87|)
- (LETT |r| (CDR |#G107|)
- |DFLOAT;rationalApproximation;$2NniF;87|)
- |#G107|
+ |DFLOAT;rationalApproximation;$2NniF;86|)
+ (LETT |q| (CAR |#G106|)
+ |DFLOAT;rationalApproximation;$2NniF;86|)
+ (LETT |r| (CDR |#G106|)
+ |DFLOAT;rationalApproximation;$2NniF;86|)
+ |#G106|
(LETT |p2|
(+ (* |q| |p1|) |p0|)
- |DFLOAT;rationalApproximation;$2NniF;87|)
+ |DFLOAT;rationalApproximation;$2NniF;86|)
(LETT |q2|
(+ (* |q| |q1|) |q0|)
- |DFLOAT;rationalApproximation;$2NniF;87|)
+ |DFLOAT;rationalApproximation;$2NniF;86|)
(COND
((OR (ZEROP |r|)
(<
@@ -778,32 +819,32 @@
143))
(* |de| (ABS |p2|))))
(RETURN-FROM
- |DFLOAT;rationalApproximation;$2NniF;87|
+ |DFLOAT;rationalApproximation;$2NniF;86|
(SPADCALL |p2| |q2|
(|getShellEntry| $
141)))))
- (LETT |#G108| |p1|
- |DFLOAT;rationalApproximation;$2NniF;87|)
- (LETT |#G109| |p2|
- |DFLOAT;rationalApproximation;$2NniF;87|)
- (SETQ |p0| |#G108|)
- (SETQ |p1| |#G109|)
- (LETT |#G110| |q1|
- |DFLOAT;rationalApproximation;$2NniF;87|)
- (LETT |#G111| |q2|
- |DFLOAT;rationalApproximation;$2NniF;87|)
- (SETQ |q0| |#G110|)
- (SETQ |q1| |#G111|)
+ (LETT |#G107| |p1|
+ |DFLOAT;rationalApproximation;$2NniF;86|)
+ (LETT |#G108| |p2|
+ |DFLOAT;rationalApproximation;$2NniF;86|)
+ (SETQ |p0| |#G107|)
+ (SETQ |p1| |#G108|)
+ (LETT |#G109| |q1|
+ |DFLOAT;rationalApproximation;$2NniF;86|)
+ (LETT |#G110| |q2|
+ |DFLOAT;rationalApproximation;$2NniF;86|)
+ (SETQ |q0| |#G109|)
+ (SETQ |q1| |#G110|)
(EXIT
(PROGN
- (LETT |#G112| |t|
- |DFLOAT;rationalApproximation;$2NniF;87|)
- (LETT |#G113| |r|
- |DFLOAT;rationalApproximation;$2NniF;87|)
- (SETQ |s| |#G112|)
- (SETQ |t| |#G113|)))))))))))))))))))))
-
-(DEFUN |DFLOAT;**;$F$;88| (|x| |r| $)
+ (LETT |#G111| |t|
+ |DFLOAT;rationalApproximation;$2NniF;86|)
+ (LETT |#G112| |r|
+ |DFLOAT;rationalApproximation;$2NniF;86|)
+ (SETQ |s| |#G111|)
+ (SETQ |t| |#G112|)))))))))))))))))))))
+
+(DEFUN |DFLOAT;**;$F$;87| (|x| |r| $)
(PROG (|n| |d|)
(RETURN
(SEQ (COND
@@ -818,35 +859,36 @@
1.0)
((SPADCALL |r| (|getShellEntry| $ 147)) |x|)
(T (SEQ (LETT |n| (SPADCALL |r| (|getShellEntry| $ 148))
- |DFLOAT;**;$F$;88|)
+ |DFLOAT;**;$F$;87|)
(LETT |d| (SPADCALL |r| (|getShellEntry| $ 149))
- |DFLOAT;**;$F$;88|)
+ |DFLOAT;**;$F$;87|)
(EXIT (COND
((MINUSP |x|)
(COND
((ODDP |d|)
(COND
((ODDP |n|)
- (RETURN-FROM |DFLOAT;**;$F$;88|
+ (RETURN-FROM |DFLOAT;**;$F$;87|
(-
- (|DFLOAT;**;$F$;88| (- |x|) |r|
+ (|DFLOAT;**;$F$;87| (- |x|) |r|
$))))
(T
- (RETURN-FROM |DFLOAT;**;$F$;88|
- (|DFLOAT;**;$F$;88| (- |x|) |r|
+ (RETURN-FROM |DFLOAT;**;$F$;87|
+ (|DFLOAT;**;$F$;87| (- |x|) |r|
$)))))
(T (|error| "negative root"))))
((EQL |d| 2)
- (EXPT (|DFLOAT;sqrt;2$;33| |x| $) |n|))
- (T (|DFLOAT;**;3$;36| |x|
- (/
- (FLOAT |n| |$DoubleFloatMaximum|)
- (FLOAT |d| |$DoubleFloatMaximum|))
- $)))))))))))
+ (EXPT (C-TO-R (SQRT |x|)) |n|))
+ (T (C-TO-R (EXPT |x|
+ (/
+ (FLOAT |n|
+ |$DoubleFloatMaximum|)
+ (FLOAT |d|
+ |$DoubleFloatMaximum|))))))))))))))
(DEFUN |DoubleFloat| ()
(DECLARE (SPECIAL |$ConstructorCache|))
- (PROG (#0=#:G1556)
+ (PROG (#0=#:G1555)
(RETURN
(COND
((SETQ #0# (HGET |$ConstructorCache| '|DoubleFloat|))
@@ -873,63 +915,63 @@
(LIST '#(NIL NIL NIL NIL NIL NIL (|OpenMathEncoding|)
(0 . |OMencodingXML|) (|String|) (|OpenMathDevice|)
(4 . |OMopenString|) (|Void|) (10 . |OMputObject|)
- (|DoubleFloat|) |DFLOAT;convert;2$;76| (15 . |OMputFloat|)
+ (|DoubleFloat|) |DFLOAT;convert;2$;75| (15 . |OMputFloat|)
(21 . |OMputEndObject|) (26 . |OMclose|)
|DFLOAT;OMwrite;$S;1| (|Boolean|) |DFLOAT;OMwrite;$BS;2|
|DFLOAT;OMwrite;Omd$V;3| |DFLOAT;OMwrite;Omd$BV;4|
- (|PositiveInteger|) |DFLOAT;base;Pi;6| (|Integer|)
- |DFLOAT;mantissa;$I;7| |DFLOAT;exponent;$I;8|
- |DFLOAT;precision;Pi;9| (31 . =) (37 . *)
- |DFLOAT;log2;2$;40| (43 . *) |DFLOAT;wholePart;$I;74|
- |DFLOAT;bits;Pi;10| |DFLOAT;max;$;11| |DFLOAT;min;$;12|
- (49 . +) (55 . |One|) (59 . -) |DFLOAT;order;$I;13|
+ (|PositiveInteger|) |DFLOAT;base;Pi;5| (|Integer|)
+ |DFLOAT;mantissa;$I;6| |DFLOAT;exponent;$I;7|
+ |DFLOAT;precision;Pi;8| (31 . =) (37 . *)
+ |DFLOAT;log2;2$;39| (43 . *) |DFLOAT;wholePart;$I;73|
+ |DFLOAT;bits;Pi;9| |DFLOAT;max;$;10| |DFLOAT;min;$;11|
+ (49 . +) (55 . |One|) (59 . -) |DFLOAT;order;$I;12|
(65 . |Zero|)
(CONS IDENTITY
- (FUNCALL (|dispatchFunction| |DFLOAT;Zero;$;14|) $))
+ (FUNCALL (|dispatchFunction| |DFLOAT;Zero;$;13|) $))
(CONS IDENTITY
- (FUNCALL (|dispatchFunction| |DFLOAT;One;$;15|) $))
- |DFLOAT;/;3$;65| |DFLOAT;exp1;$;16| |DFLOAT;pi;$;17|
- (|OutputForm|) (69 . |outputForm|) |DFLOAT;coerce;$Of;18|
- (|InputForm|) (74 . |convert|) |DFLOAT;convert;$If;19|
- |DFLOAT;<;2$B;20| |DFLOAT;>;2$B;21| |DFLOAT;<=;2$B;22|
- |DFLOAT;>=;2$B;23| |DFLOAT;-;2$;24| |DFLOAT;+;3$;25|
- |DFLOAT;-;3$;26| |DFLOAT;*;3$;27| |DFLOAT;*;I2$;28|
- |DFLOAT;max;3$;29| |DFLOAT;min;3$;30| |DFLOAT;=;2$B;31|
- |DFLOAT;/;$I$;32| |DFLOAT;sqrt;2$;33| |DFLOAT;log10;2$;34|
- |DFLOAT;**;$I$;35| |DFLOAT;**;3$;36| (79 . |coerce|)
- |DFLOAT;exp;2$;38| |DFLOAT;log;2$;39| |DFLOAT;sin;2$;41|
- |DFLOAT;cos;2$;42| |DFLOAT;tan;2$;43| |DFLOAT;cot;2$;44|
- |DFLOAT;sec;2$;45| |DFLOAT;csc;2$;46| |DFLOAT;asin;2$;47|
- |DFLOAT;acos;2$;48| |DFLOAT;atan;2$;49|
- |DFLOAT;acsc;2$;50| |DFLOAT;acot;2$;51|
- |DFLOAT;asec;2$;52| |DFLOAT;sinh;2$;53|
- |DFLOAT;cosh;2$;54| |DFLOAT;tanh;2$;55|
- |DFLOAT;csch;2$;56| |DFLOAT;coth;2$;57|
- |DFLOAT;sech;2$;58| |DFLOAT;asinh;2$;59|
- |DFLOAT;acosh;2$;60| |DFLOAT;atanh;2$;61|
- |DFLOAT;acsch;2$;62| |DFLOAT;acoth;2$;63|
- |DFLOAT;asech;2$;64| |DFLOAT;negative?;$B;66|
- |DFLOAT;zero?;$B;67| |DFLOAT;one?;$B;68| (|SingleInteger|)
- |DFLOAT;hash;$Si;69| (|Union| $ '"failed")
- |DFLOAT;recip;$U;70| |DFLOAT;differentiate;2$;71|
+ (FUNCALL (|dispatchFunction| |DFLOAT;One;$;14|) $))
+ |DFLOAT;/;3$;64| |DFLOAT;exp1;$;15| |DFLOAT;pi;$;16|
+ (|OutputForm|) (69 . |outputForm|) |DFLOAT;coerce;$Of;17|
+ (|InputForm|) (74 . |convert|) |DFLOAT;convert;$If;18|
+ |DFLOAT;<;2$B;19| |DFLOAT;>;2$B;20| |DFLOAT;<=;2$B;21|
+ |DFLOAT;>=;2$B;22| |DFLOAT;-;2$;23| |DFLOAT;+;3$;24|
+ |DFLOAT;-;3$;25| |DFLOAT;*;3$;26| |DFLOAT;*;I2$;27|
+ |DFLOAT;max;3$;28| |DFLOAT;min;3$;29| |DFLOAT;=;2$B;30|
+ |DFLOAT;/;$I$;31| |DFLOAT;sqrt;2$;32| |DFLOAT;log10;2$;33|
+ |DFLOAT;**;$I$;34| |DFLOAT;**;3$;35| (79 . |coerce|)
+ |DFLOAT;exp;2$;37| |DFLOAT;log;2$;38| |DFLOAT;sin;2$;40|
+ |DFLOAT;cos;2$;41| |DFLOAT;tan;2$;42| |DFLOAT;cot;2$;43|
+ |DFLOAT;sec;2$;44| |DFLOAT;csc;2$;45| |DFLOAT;asin;2$;46|
+ |DFLOAT;acos;2$;47| |DFLOAT;atan;2$;48|
+ |DFLOAT;acsc;2$;49| |DFLOAT;acot;2$;50|
+ |DFLOAT;asec;2$;51| |DFLOAT;sinh;2$;52|
+ |DFLOAT;cosh;2$;53| |DFLOAT;tanh;2$;54|
+ |DFLOAT;csch;2$;55| |DFLOAT;coth;2$;56|
+ |DFLOAT;sech;2$;57| |DFLOAT;asinh;2$;58|
+ |DFLOAT;acosh;2$;59| |DFLOAT;atanh;2$;60|
+ |DFLOAT;acsch;2$;61| |DFLOAT;acoth;2$;62|
+ |DFLOAT;asech;2$;63| |DFLOAT;negative?;$B;65|
+ |DFLOAT;zero?;$B;66| |DFLOAT;one?;$B;67| (|SingleInteger|)
+ |DFLOAT;hash;$Si;68| (|Union| $ '"failed")
+ |DFLOAT;recip;$U;69| |DFLOAT;differentiate;2$;70|
(|DoubleFloatSpecialFunctions|) (84 . |Gamma|)
- |DFLOAT;Gamma;2$;72| (89 . |Beta|) |DFLOAT;Beta;3$;73|
- |DFLOAT;float;2IPi$;75| (|Float|) (95 . |convert|)
- |DFLOAT;convert;$F;77| (|Fraction| 25)
+ |DFLOAT;Gamma;2$;71| (89 . |Beta|) |DFLOAT;Beta;3$;72|
+ |DFLOAT;float;2IPi$;74| (|Float|) (95 . |convert|)
+ |DFLOAT;convert;$F;76| (|Fraction| 25)
(|NonNegativeInteger|)
- |DFLOAT;rationalApproximation;$2NniF;87|
- |DFLOAT;rationalApproximation;$NniF;78| |DFLOAT;abs;2$;85|
- |DFLOAT;atan;3$;79| (100 . |One|) |DFLOAT;retract;$F;80|
- (|Union| 114 '"failed") |DFLOAT;retractIfCan;$U;81|
- |DFLOAT;retract;$I;82| (|Union| 25 '"failed")
- |DFLOAT;retractIfCan;$U;83| |DFLOAT;sign;$I;84| (104 . *)
+ |DFLOAT;rationalApproximation;$2NniF;86|
+ |DFLOAT;rationalApproximation;$NniF;77| |DFLOAT;abs;2$;84|
+ |DFLOAT;atan;3$;78| (100 . |One|) |DFLOAT;retract;$F;79|
+ (|Union| 114 '"failed") |DFLOAT;retractIfCan;$U;80|
+ |DFLOAT;retract;$I;81| (|Union| 25 '"failed")
+ |DFLOAT;retractIfCan;$U;82| |DFLOAT;sign;$I;83| (104 . *)
(110 . **) (116 . |Zero|) (120 . |Zero|) (124 . >=)
(130 . **) (136 . |coerce|) (141 . -) (146 . <) (152 . **)
(|Record| (|:| |quotient| $) (|:| |remainder| $))
(158 . |divide|) (164 . =) (170 . /) (176 . |abs|)
(181 . *) (187 . <) (193 . |zero?|) (198 . |negative?|)
(203 . |one?|) (208 . |numer|) (213 . |denom|)
- (218 . |odd?|) |DFLOAT;**;$F$;88| |DFLOAT;coerce;I$;37|
+ (218 . |odd?|) |DFLOAT;**;$F$;87| |DFLOAT;coerce;I$;36|
(|PatternMatchResult| 111 $) (|Pattern| 111)
(|Factored| $) (|List| $) (|Union| 156 '"failed")
(|Record| (|:| |coef1| $) (|:| |coef2| $)
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-03 22:09:58 +0000