summaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/math/exp-impl.myr73
-rw-r--r--lib/math/fpmath.myr97
-rw-r--r--lib/math/poly-impl.myr24
-rw-r--r--lib/math/round-impl.myr12
-rw-r--r--lib/math/scale2-impl.myr12
-rw-r--r--lib/math/sqrt-impl.myr80
-rw-r--r--lib/math/trunc-impl.myr56
7 files changed, 182 insertions, 172 deletions
diff --git a/lib/math/exp-impl.myr b/lib/math/exp-impl.myr
index d7f07d9..65cc868 100644
--- a/lib/math/exp-impl.myr
+++ b/lib/math/exp-impl.myr
@@ -10,15 +10,15 @@ use "util"
enough to be in the same function.
*/
pkg math =
- pkglocal const exp32 : (f : flt32 -> flt32)
- pkglocal const exp64 : (f : flt64 -> flt64)
+ pkglocal const exp32 : (x : flt32 -> flt32)
+ pkglocal const exp64 : (x : flt64 -> flt64)
- pkglocal const expm132 : (f : flt32 -> flt32)
- pkglocal const expm164 : (f : flt64 -> flt64)
+ pkglocal const expm132 : (x : flt32 -> flt32)
+ pkglocal const expm164 : (x : flt64 -> flt64)
;;
-extern const horner_polyu32 : (f : flt32, a : uint32[:] -> flt32)
-extern const horner_polyu64 : (f : flt64, a : uint64[:] -> flt64)
+extern const horner_polyu32 : (x : flt32, a : uint32[:] -> flt32)
+extern const horner_polyu64 : (x : flt64, a : uint64[:] -> flt64)
type fltdesc(@f, @u, @i) = struct
explode : (f : @f -> (bool, @i, @u))
@@ -50,7 +50,6 @@ type fltdesc(@f, @u, @i) = struct
L1 : @u
L2 : @u
S : (@u, @u)[32]
-
;;
const desc32 : fltdesc(flt32, uint32, int32) = [
@@ -194,18 +193,18 @@ const desc64 : fltdesc(flt64, uint64, int64) = [
.precision = 53,
]
-const exp32 = {f : flt32
- -> expgen(f, desc32)
+const exp32 = {x : flt32
+ -> expgen(x, desc32)
}
-const exp64 = {f : flt64
- -> expgen(f, desc64)
+const exp64 = {x : flt64
+ -> expgen(x, desc64)
}
-generic expgen = {f : @f, d : fltdesc(@f, @u, @i) :: numeric,floating,std.equatable @f, numeric,integral @u, numeric,integral @i, roundable @f -> @i
- var b = d.tobits(f)
+generic expgen = {x : @f, d : fltdesc(@f, @u, @i) :: numeric,floating,std.equatable @f, numeric,integral @u, numeric,integral @i, roundable @f -> @i
+ var b = d.tobits(x)
var n, e, s
- (n, e, s) = d.explode(f)
+ (n, e, s) = d.explode(x)
/*
Detect if exp(f) would round to outside representability.
@@ -226,7 +225,7 @@ generic expgen = {f : @f, d : fltdesc(@f, @u, @i) :: numeric,floating,std.equata
/* Argument reduction to [ -ln(2)/64, ln(2)/64 ] */
var inv_L = d.frombits(d.inv_L)
- var N = rn(f * inv_L)
+ var N = rn(x * inv_L)
var N2 = N % (32 : @i)
if N2 < 0
N2 += (32 : @i)
@@ -242,9 +241,9 @@ generic expgen = {f : @f, d : fltdesc(@f, @u, @i) :: numeric,floating,std.equata
(very well) f reduced into [ -ln(2)/64, ln(2)/64 ]
*/
if std.abs(N) >= (1 << d.nabs)
- R1 = (f - (N1 : @f) * d.frombits(d.L1)) - ((N2 : @f) * d.frombits(d.L1))
+ R1 = (x - (N1 : @f) * d.frombits(d.L1)) - ((N2 : @f) * d.frombits(d.L1))
else
- R1 = f - (N : @f) * d.frombits(d.L1)
+ R1 = x - (N : @f) * d.frombits(d.L1)
;;
R2 = -1.0 * (N : @f) * d.frombits(d.L2)
@@ -275,33 +274,33 @@ generic expgen = {f : @f, d : fltdesc(@f, @u, @i) :: numeric,floating,std.equata
-> exp
}
-const expm132 = {f : flt32
- -> expm1gen(f, desc32)
+const expm132 = {x : flt32
+ -> expm1gen(x, desc32)
}
-const expm164 = {f : flt64
- -> expm1gen(f, desc64)
+const expm164 = {x : flt64
+ -> expm1gen(x, desc64)
}
-generic expm1gen = {f : @f, d : fltdesc(@f, @u, @i) :: numeric,floating,std.equatable @f, numeric,integral @u, numeric,integral @i, roundable @f -> @i
- var b = d.tobits(f)
+generic expm1gen = {x : @f, d : fltdesc(@f, @u, @i) :: numeric,floating,std.equatable @f, numeric,integral @u, numeric,integral @i, roundable @f -> @i
+ var b = d.tobits(x)
var n, e, s
- (n, e, s) = d.explode(f)
+ (n, e, s) = d.explode(x)
/* Special cases: +/- 0, inf, NaN, tiny, and huge */
if (b & ~d.sgnmask == 0)
- -> f
+ -> x
elif n && (b & ~d.sgnmask == d.inf)
-> (-1.0 : @f)
elif (b & ~d.sgnmask == d.inf)
- -> f
- elif std.isnan(f)
+ -> x
+ elif std.isnan(x)
-> d.frombits(d.nan)
elif (b & ~d.sgnmask) <= d.thresh_tiny
var two_to_large = d.assem(false, 100, 0)
var two_to_small = d.assem(false, -100, 0)
- var abs_f = d.assem(false, e, s)
- -> (two_to_large * f + abs_f) * two_to_small
+ var abs_x = d.assem(false, e, s)
+ -> (two_to_large * x + abs_x) * two_to_small
elif !n && b >= d.thresh_1_max /* exp(x) = oo <=> expm1(x) = oo, as it turns out */
-> d.frombits(d.inf)
elif n && b >= d.thresh_huge_neg
@@ -312,25 +311,25 @@ generic expm1gen = {f : @f, d : fltdesc(@f, @u, @i) :: numeric,floating,std.equa
/* Procedure 2 */
/* compute x^2 / 2 with extra precision */
- var u = round(f, d)
- var v = f - u
+ var u = round(x, d)
+ var v = x - u
var y = u * u * (0.5 : @f)
- var z = v * (f + u) * (0.5 : @f)
- var q = f * f * f * d.horner(f, d.Bi)
+ var z = v * (x + u) * (0.5 : @f)
+ var q = x * x * x * d.horner(x, d.Bi)
var yn, ye, ys
(yn, ye, ys) = d.explode(y)
if (ye >= -7)
-> (u + y) + (q + (v + z))
else
- -> f + (y + (q + z))
+ -> x + (y + (q + z))
;;
;;
/* Procedure 1 */
var inv_L = d.frombits(d.inv_L)
- var N = rn(f * inv_L)
+ var N = rn(x * inv_L)
var N2 = N % (32 : @i)
if N2 < 0
N2 += (32 : @i)
@@ -344,9 +343,9 @@ generic expm1gen = {f : @f, d : fltdesc(@f, @u, @i) :: numeric,floating,std.equa
reduced into [ -ln(2)/64, ln(2)/64 ]
*/
if std.abs(N) >= (1 << d.nabs)
- R1 = (f - (N1 : @f) * d.frombits(d.L1)) - ((N2 : @f) * d.frombits(d.L1))
+ R1 = (x - (N1 : @f) * d.frombits(d.L1)) - ((N2 : @f) * d.frombits(d.L1))
else
- R1 = f - (N : @f) * d.frombits(d.L1)
+ R1 = x - (N : @f) * d.frombits(d.L1)
;;
R2 = -1.0 * (N : @f) * d.frombits(d.L2)
diff --git a/lib/math/fpmath.myr b/lib/math/fpmath.myr
index bfc6b11..0c8e8d6 100644
--- a/lib/math/fpmath.myr
+++ b/lib/math/fpmath.myr
@@ -4,8 +4,8 @@ pkg math =
trait fpmath @f =
/* exp-impl */
- exp : (f : @f -> @f)
- expm1 : (f : @f -> @f)
+ exp : (x : @f -> @f)
+ expm1 : (x : @f -> @f)
/* fma-impl */
fma : (x : @f, y : @f, z : @f -> @f)
@@ -15,24 +15,24 @@ pkg math =
horner_polyu : (x : @f, a : @u[:] -> @f)
/* scale2-impl */
- scale2 : (f : @f, m : @i -> @f)
+ scale2 : (x : @f, m : @i -> @f)
/* sqrt-impl */
- sqrt : (f : @f -> @f)
+ sqrt : (x : @f -> @f)
/* sum-impl */
kahan_sum : (a : @f[:] -> @f)
priest_sum : (a : @f[:] -> @f)
/* trunc-impl */
- trunc : (f : @f -> @f)
- ceil : (f : @f -> @f)
- floor : (f : @f -> @f)
+ trunc : (x : @f -> @f)
+ ceil : (x : @f -> @f)
+ floor : (x : @f -> @f)
;;
trait roundable @f -> @i =
/* round-impl */
- rn : (f : @f -> @i)
+ rn : (x : @f -> @i)
;;
impl std.equatable flt32
@@ -60,58 +60,67 @@ impl std.equatable flt64 =
;;
impl roundable flt32 -> int32 =
- rn = {f : flt32; -> rn32(f) }
+ rn = {x : flt32; -> rn32(x) }
;;
impl roundable flt64 -> int64 =
- rn = {f : flt64; -> rn64(f) }
+ rn = {x : flt64; -> rn64(x) }
;;
impl fpmath flt32 =
fma = {x, y, z; -> fma32(x, y, z)}
- exp = {f; -> exp32(f)}
- expm1 = {f; -> expm132(f)}
+ exp = {x; -> exp32(x)}
+ expm1 = {x; -> expm132(x)}
- horner_poly = {f, a; -> horner_poly32(f, a)}
- horner_polyu = {f, a; -> horner_polyu32(f, a)}
+ log = {x; -> log32(x)}
+ log1p = {x; -> log1p32(x)}
- scale2 = {f, m; -> scale232(f, m)}
+ horner_poly = {x, a; -> horner_poly32(x, a)}
+ horner_polyu = {x, a; -> horner_polyu32(x, a)}
- sqrt = {f; -> sqrt32(f)}
+ scale2 = {x, m; -> scale232(x, m)}
+
+ sqrt = {x; -> sqrt32(x)}
kahan_sum = {l; -> kahan_sum32(l) }
priest_sum = {l; -> priest_sum32(l) }
- trunc = {f; -> trunc32(f)}
- floor = {f; -> floor32(f)}
- ceil = {f; -> ceil32(f)}
+ trunc = {x; -> trunc32(x)}
+ floor = {x; -> floor32(x)}
+ ceil = {x; -> ceil32(x)}
;;
impl fpmath flt64 =
fma = {x, y, z; -> fma64(x, y, z)}
- exp = {f; -> exp64(f)}
- expm1 = {f; -> expm164(f)}
+ exp = {x; -> exp64(x)}
+ expm1 = {x; -> expm164(x)}
+
+ log = {x; -> log64(x)}
+ log1p = {x; -> log1p64(x)}
- horner_poly = {f, a; -> horner_poly64(f, a)}
- horner_polyu = {f, a; -> horner_polyu64(f, a)}
+ horner_poly = {x, a; -> horner_poly64(x, a)}
+ horner_polyu = {x, a; -> horner_polyu64(x, a)}
- scale2 = {f, m; -> scale264(f, m)}
+ scale2 = {x, m; -> scale264(x, m)}
- sqrt = {f; -> sqrt64(f)}
+ sqrt = {x; -> sqrt64(x)}
kahan_sum = {l; -> kahan_sum64(l) }
priest_sum = {l; -> priest_sum64(l) }
- trunc = {f; -> trunc64(f)}
- floor = {f; -> floor64(f)}
- ceil = {f; -> ceil64(f)}
+ trunc = {x; -> trunc64(x)}
+ floor = {x; -> floor64(x)}
+ ceil = {x; -> ceil64(x)}
;;
-extern const rn32 : (f : flt32 -> int32)
-extern const rn64 : (f : flt64 -> int64)
+extern const rn32 : (x : flt32 -> int32)
+extern const rn64 : (x : flt64 -> int64)
+
+extern const fma32 : (x : flt32, y : flt32, z : flt32 -> flt32)
+extern const fma64 : (x : flt64, y : flt64, z : flt64 -> flt64)
extern const exp32 : (x : flt32 -> flt32)
extern const exp64 : (x : flt64 -> flt64)
@@ -119,17 +128,17 @@ extern const exp64 : (x : flt64 -> flt64)
extern const expm132 : (x : flt32 -> flt32)
extern const expm164 : (x : flt64 -> flt64)
-extern const fma32 : (x : flt32, y : flt32, z : flt32 -> flt32)
-extern const fma64 : (x : flt64, y : flt64, z : flt64 -> flt64)
+extern const log32 : (x : flt32 -> flt32)
+extern const log64 : (x : flt64 -> flt64)
-extern const horner_poly32 : (f : flt32, a : flt32[:] -> flt32)
-extern const horner_poly64 : (f : flt64, a : flt64[:] -> flt64)
+extern const horner_poly32 : (x : flt32, a : flt32[:] -> flt32)
+extern const horner_poly64 : (x : flt64, a : flt64[:] -> flt64)
-extern const horner_polyu32 : (f : flt32, a : uint32[:] -> flt32)
-extern const horner_polyu64 : (f : flt64, a : uint64[:] -> flt64)
+extern const horner_polyu32 : (x : flt32, a : uint32[:] -> flt32)
+extern const horner_polyu64 : (x : flt64, a : uint64[:] -> flt64)
-extern const scale232 : (f : flt32, m : int32 -> flt32)
-extern const scale264 : (f : flt64, m : int64 -> flt64)
+extern const scale232 : (x : flt32, m : int32 -> flt32)
+extern const scale264 : (x : flt64, m : int64 -> flt64)
extern const sqrt32 : (x : flt32 -> flt32)
extern const sqrt64 : (x : flt64 -> flt64)
@@ -140,11 +149,11 @@ extern const kahan_sum64 : (l : flt64[:] -> flt64)
extern const priest_sum32 : (l : flt32[:] -> flt32)
extern const priest_sum64 : (l : flt64[:] -> flt64)
-extern const trunc32 : (f : flt32 -> flt32)
-extern const trunc64 : (f : flt64 -> flt64)
+extern const trunc32 : (x : flt32 -> flt32)
+extern const trunc64 : (x : flt64 -> flt64)
-extern const floor32 : (f : flt32 -> flt32)
-extern const floor64 : (f : flt64 -> flt64)
+extern const floor32 : (x : flt32 -> flt32)
+extern const floor64 : (x : flt64 -> flt64)
-extern const ceil32 : (f : flt32 -> flt32)
-extern const ceil64 : (f : flt64 -> flt64)
+extern const ceil32 : (x : flt32 -> flt32)
+extern const ceil64 : (x : flt64 -> flt64)
diff --git a/lib/math/poly-impl.myr b/lib/math/poly-impl.myr
index e7d645b..94118a0 100644
--- a/lib/math/poly-impl.myr
+++ b/lib/math/poly-impl.myr
@@ -2,44 +2,44 @@ use std
/* See [Mul16], section 5.1 */
pkg math =
- pkglocal const horner_poly32 : (f : flt32, a : flt32[:] -> flt32)
- pkglocal const horner_poly64 : (f : flt64, a : flt64[:] -> flt64)
+ pkglocal const horner_poly32 : (x : flt32, a : flt32[:] -> flt32)
+ pkglocal const horner_poly64 : (x : flt64, a : flt64[:] -> flt64)
- pkglocal const horner_polyu32 : (f : flt32, a : uint32[:] -> flt32)
- pkglocal const horner_polyu64 : (f : flt64, a : uint64[:] -> flt64)
+ pkglocal const horner_polyu32 : (x : flt32, a : uint32[:] -> flt32)
+ pkglocal const horner_polyu64 : (x : flt64, a : uint64[:] -> flt64)
;;
extern const fma32 : (x : flt32, y : flt32, z : flt32 -> flt32)
extern const fma64 : (x : flt64, y : flt64, z : flt64 -> flt64)
-const horner_poly32 = {f : flt32, a : flt32[:]
+const horner_poly32 = {x : flt32, a : flt32[:]
var r : flt32 = 0.0
for var j = a.len - 1; j >= 0; j--
- r = fma32(r, f, a[j])
+ r = fma32(r, x, a[j])
;;
-> r
}
-const horner_poly64 = {f : flt64, a : flt64[:]
+const horner_poly64 = {x : flt64, a : flt64[:]
var r : flt64 = 0.0
for var j = a.len - 1; j >= 0; j--
- r = fma64(r, f, a[j])
+ r = fma64(r, x, a[j])
;;
-> r
}
-const horner_polyu32 = {f : flt32, a : uint32[:]
+const horner_polyu32 = {x : flt32, a : uint32[:]
var r : flt32 = 0.0
for var j = a.len - 1; j >= 0; j--
- r = fma32(r, f, std.flt32frombits(a[j]))
+ r = fma32(r, x, std.flt32frombits(a[j]))
;;
-> r
}
-const horner_polyu64 = {f : flt64, a : uint64[:]
+const horner_polyu64 = {x : flt64, a : uint64[:]
var r : flt64 = 0.0
for var j = a.len - 1; j >= 0; j--
- r = fma64(r, f, std.flt64frombits(a[j]))
+ r = fma64(r, x, std.flt64frombits(a[j]))
;;
-> r
}
diff --git a/lib/math/round-impl.myr b/lib/math/round-impl.myr
index dc35869..589344f 100644
--- a/lib/math/round-impl.myr
+++ b/lib/math/round-impl.myr
@@ -3,14 +3,14 @@ use std
use "util"
pkg math =
- const rn64 : (f : flt64 -> int64)
- const rn32 : (f : flt32 -> int32)
+ const rn64 : (x : flt64 -> int64)
+ const rn32 : (x : flt32 -> int32)
;;
-const rn64 = {f : flt64
+const rn64 = {x : flt64
var n : bool, e : int64, s : uint64
- (n, e, s) = std.flt64explode(f)
+ (n, e, s) = std.flt64explode(x)
if e >= 63
-> -9223372036854775808
@@ -38,10 +38,10 @@ const rn64 = {f : flt64
;;
}
-const rn32 = {f : flt32
+const rn32 = {x : flt32
var n : bool, e : int32, s : uint32
- (n, e, s) = std.flt32explode(f)
+ (n, e, s) = std.flt32explode(x)
if e >= 31
-> -2147483648
diff --git a/lib/math/scale2-impl.myr b/lib/math/scale2-impl.myr
index 6301e14..e0683a7 100644
--- a/lib/math/scale2-impl.myr
+++ b/lib/math/scale2-impl.myr
@@ -9,20 +9,20 @@ use "util"
approach works quite well.
*/
pkg math =
- const scale232 : (f : flt32, m : int32 -> flt32)
- const scale264 : (f : flt64, m : int64 -> flt64)
+ const scale232 : (x : flt32, m : int32 -> flt32)
+ const scale264 : (x : flt64, m : int64 -> flt64)
;;
-const scale232 = {f : flt32, m : int32
+const scale232 = {x : flt32, m : int32
var n, e, s
- (n, e, s) = std.flt32explode(f)
+ (n, e, s) = std.flt32explode(x)
(n, e, s) = scale2gen(n, e, s, -126, 127, 24, m)
-> std.flt32assem(n, e, s)
}
-const scale264 = {f : flt64, m : int64
+const scale264 = {x : flt64, m : int64
var n, e, s
- (n, e, s) = std.flt64explode(f)
+ (n, e, s) = std.flt64explode(x)
(n, e, s) = scale2gen(n, e, s, -1022, 1023, 53, m)
-> std.flt64assem(n, e, s)
}
diff --git a/lib/math/sqrt-impl.myr b/lib/math/sqrt-impl.myr
index 4d6b40d..eec1b96 100644
--- a/lib/math/sqrt-impl.myr
+++ b/lib/math/sqrt-impl.myr
@@ -4,8 +4,8 @@ use "fpmath"
/* See [Mul+10], sections 5.4 and 8.7 */
pkg math =
- pkglocal const sqrt32 : (f : flt32 -> flt32)
- pkglocal const sqrt64 : (f : flt64 -> flt64)
+ pkglocal const sqrt32 : (x : flt32 -> flt32)
+ pkglocal const sqrt64 : (x : flt64 -> flt64)
;;
extern const fma32 : (x : flt32, y : flt32, z : flt32 -> flt32)
@@ -59,54 +59,56 @@ const ab64 : (uint64, uint64)[:] = [
(0x4010000000000000, 0x3fe0a5989f2dc59a), /* [3.4, 4.0) -> 0.520214377304159869552790951275 */
][:]
-const sqrt32 = {f : flt32
- const d : fltdesc(flt32, uint32, int32) = [
- .explode = std.flt32explode,
- .assem = std.flt32assem,
- .fma = fma32,
- .tobits = std.flt32bits,
- .frombits = std.flt32frombits,
- .nan = 0x7fc00000,
- .emin = -127,
- .emax = 128,
- .normmask = 1 << 23,
- .sgnmask = 1 << 31,
- .ab = ab32,
- .iterlim = 3,
- ]
- -> sqrtgen(f, d)
+const desc32 : fltdesc(flt32, uint32, int32) = [
+ .explode = std.flt32explode,
+ .assem = std.flt32assem,
+ .fma = fma32,
+ .tobits = std.flt32bits,
+ .frombits = std.flt32frombits,
+ .nan = 0x7fc00000,
+ .emin = -127,
+ .emax = 128,
+ .normmask = 1 << 23,
+ .sgnmask = 1 << 31,
+ .ab = ab32,
+ .iterlim = 3,
+]
+
+const desc64 : fltdesc(flt64, uint64, int64) = [
+ .explode = std.flt64explode,
+ .assem = std.flt64assem,
+ .fma = fma64,
+ .tobits = std.flt64bits,
+ .frombits = std.flt64frombits,
+ .nan = 0x7ff8000000000000,
+ .emin = -1023,
+ .emax = 1024,
+ .normmask = 1 << 52,
+ .sgnmask = 1 << 63,
+ .ab = ab64,
+ .iterlim = 4,
+]
+
+const sqrt32 = {x : flt32
+ -> sqrtgen(x, desc32)
}
-const sqrt64 = {f : flt64
- const d : fltdesc(flt64, uint64, int64) = [
- .explode = std.flt64explode,
- .assem = std.flt64assem,
- .fma = fma64,
- .tobits = std.flt64bits,
- .frombits = std.flt64frombits,
- .nan = 0x7ff8000000000000,
- .emin = -1023,
- .emax = 1024,
- .normmask = 1 << 52,
- .sgnmask = 1 << 63,
- .ab = ab64,
- .iterlim = 4,
- ]
- -> sqrtgen(f, d)
+const sqrt64 = {x : flt64
+ -> sqrtgen(x, desc64)
}
-generic sqrtgen = {f : @f, d : fltdesc(@f, @u, @i) :: numeric,floating,std.equatable @f, numeric,integral @u, numeric,integral @i
+generic sqrtgen = {x : @f, d : fltdesc(@f, @u, @i) :: numeric,floating,std.equatable @f, numeric,integral @u, numeric,integral @i
var n : bool, e : @i, s : @u, e2 : @i
- (n, e, s) = d.explode(f)
+ (n, e, s) = d.explode(x)
/* Special cases: +/- 0.0, negative, NaN, and +inf */
if e == d.emin && s == 0
- -> f
- elif n || std.isnan(f)
+ -> x
+ elif n || std.isnan(x)
/* Make sure to return a quiet NaN */
-> d.frombits(d.nan)
elif e == d.emax
- -> f
+ -> x
;;
/*
diff --git a/lib/math/trunc-impl.myr b/lib/math/trunc-impl.myr
index 0ce41ca..e0f916a 100644
--- a/lib/math/trunc-impl.myr
+++ b/lib/math/trunc-impl.myr
@@ -1,12 +1,12 @@
use std
pkg math =
- pkglocal const trunc32 : (f : flt32 -> flt32)
- pkglocal const floor32 : (f : flt32 -> flt32)
- pkglocal const ceil32 : (f : flt32 -> flt32)
- pkglocal const trunc64 : (f : flt64 -> flt64)
- pkglocal const floor64 : (f : flt64 -> flt64)
- pkglocal const ceil64 : (f : flt64 -> flt64)
+ pkglocal const trunc32 : (x : flt32 -> flt32)
+ pkglocal const floor32 : (x : flt32 -> flt32)
+ pkglocal const ceil32 : (x : flt32 -> flt32)
+ pkglocal const trunc64 : (x : flt64 -> flt64)
+ pkglocal const floor64 : (x : flt64 -> flt64)
+ pkglocal const ceil64 : (x : flt64 -> flt64)
;;
const Flt32NegMask : uint32 = (1 << 31)
@@ -15,13 +15,13 @@ const Flt32SigMask : uint32 = (1 << 23) - 1
const Flt64NegMask : uint64 = (1 << 63)
const Flt64SigMask : uint64 = (1 << 52) - 1
-pkglocal const floor32 = {f : flt32
+pkglocal const floor32 = {x : flt32
var n, e, s
- (n, e, s) = std.flt32explode(f)
+ (n, e, s) = std.flt32explode(x)
/* Many special cases */
- if e >= 23 || f == -0.0
- -> f
+ if e >= 23 || x == -0.0
+ -> x
elif e < 0
if n
-> -1.0
@@ -46,25 +46,25 @@ pkglocal const floor32 = {f : flt32
-> std.flt32assem(n, e, s & ~m)
}
-pkglocal const trunc32 = {f : flt32
- if std.flt32bits(f) & Flt32NegMask != 0
- -> -floor32(-f)
+pkglocal const trunc32 = {x : flt32
+ if std.flt32bits(x) & Flt32NegMask != 0
+ -> -floor32(-x)
else
- -> floor32(f)
+ -> floor32(x)
;;
}
-pkglocal const ceil32 = {f : flt32
- -> -floor32(-f)
+pkglocal const ceil32 = {x : flt32
+ -> -floor32(-x)
}
-pkglocal const floor64 = {f : flt64
+pkglocal const floor64 = {x : flt64
var n, e, s
- (n, e, s) = std.flt64explode(f)
+ (n, e, s) = std.flt64explode(x)
/* Many special cases */
- if e >= 52 || f == -0.0
- -> f
+ if e >= 52 || x == -0.0
+ -> x
elif e < 0
if n
-> -1.0
@@ -76,10 +76,10 @@ pkglocal const floor64 = {f : flt64
if n
var fractional_mask = Flt64SigMask >> (e : uint64)
if s & fractional_mask == 0
- -> f
+ -> x
else
/* Turns out the packing of exp and sig is useful */
- var u : uint64 = std.flt64bits(f) & ~fractional_mask
+ var u : uint64 = std.flt64bits(x) & ~fractional_mask
u += ((1 << 52) >> (e : uint64))
-> std.flt64frombits(u)
;;
@@ -89,15 +89,15 @@ pkglocal const floor64 = {f : flt64
-> std.flt64assem(n, e, s & ~m)
}
-pkglocal const trunc64 = {f : flt64
- if std.flt64bits(f) & Flt64NegMask != 0
- -> -floor64(-f)
+pkglocal const trunc64 = {x : flt64
+ if std.flt64bits(x) & Flt64NegMask != 0
+ -> -floor64(-x)
else
- -> floor64(f)
+ -> floor64(x)
;;
}
-pkglocal const ceil64 = {f : flt64
- -> -floor64(-f)
+pkglocal const ceil64 = {x : flt64
+ -> -floor64(-x)
}
generated by cgit v1.1 at 2021-01-21 11:59:53 +0000