+++ /dev/null
-MIT Scheme now has native code (and SVM) support on aarch64.
+++ /dev/null
-The AMD x86-64 ABI has been changed.
-
-- Newer Scheme versions must be cross-compiled from older ones using
- `./configure --enable-cross-compiling'.
-- Old .com files must be recompiled.
-- The changes have performance improvements on many workloads, by
- reducing the amount of self-modifying code and by making better use
- of the CPU branch predictor.
+++ /dev/null
-New procedures:
-
-. (log1p x) = log (1 + x) for any x in (-1, +\infty), -inf for -1.
- [The primitive flo:log1p has a range restriction due to the Intel
- i387 CPU instruction.]
-. (expm1 x) = e^x - 1 for any real x.
- [The primitive flo:expm1 has a range restriction due to the Intel
- i387 CPU instruction.]
-. (log1mexp x) = log (1 - e^x), for x < 0
-. (log1pexp x) = log (1 + e^x)
-. (logistic x) = 1/(1 + e^{-x}), inverse of logit
-. (logit p) = log p/(1 - p), inverse of logistic
-. (log-logistic x) = log 1/(1 + e^{-x}), inverse of logit-exp
-. (logit-exp t) = log e^t/(1 - e^t), inverse of log-logistic
-. (logit1/2+ p) = (logit (+ 1/2 p)), inverse of logistic-1/2
-. (logistic-1/2 x) = (- (logistic x) 1/2), inverse of logit1/2+
-. (logsumexp (list x y z ...)) = log (e^x + e^y + e^z + ...),
- guaranteed not to overflow or underflow
-. (copysign m s) returns a real number with the magnitude of m and
- the sign of s.
+++ /dev/null
-Bug fix: (angle z) now correctly handles edge cases with signed zero.
+++ /dev/null
-Bug fix: A number of bugs on big-endian systems have been fixed:
-
-- SVM1 byte code interpreter works on big-endian systems now
-- compiler can now cross-compile to big-endian systems
-- fixed wrong byte ordering in MD5 microcode primitive
+++ /dev/null
-Bug fix: The <= and >= procedures now return false for NaN inputs; they
-previously returned true. Additionally, on amd64, all of the numerical
-comparison routines now raise floating-point exceptions for NaN inputs
-according to the rules of IEEE 754-2008, which can be tested and can
-trap. (The new procedures flo:safe<, flo:safe<= flo:safe>, flo:safe>=,
-flo:safe=, flo:safe<>, and flo:unordered? avoid exceptions.)
-
-(The i386 compiler back end does not correctly raise floating-point
-exceptions, and the C and SVM back ends may or may not depending on
-your C compiler's IEEE 754-2008 conformance.)
+++ /dev/null
-Bug fix: Complex numbers with nonfinite real and imaginary parts can be
-read and printed in rectangular notation now.
+++ /dev/null
-Bug fix: Several bugs were fixed involving signed zero and branch cuts
-in complex numbers:
-
-- -0.+i is now correctly parses as negative zero real part; previously
- the negative was discarded and it was parsed as positive zero.
-- -0.i is now correctly printed as such, not as `+-0.i'.
-- (atan -2i) now returns the same result as (atan 0.-2i), not (atan -0.-2i).
+++ /dev/null
-Bug fix: Multiplying by purely imaginary numbers preserves zero sign.
-
-- (* +i (make-rectangular x y)) = (make-rectangular (* -1 y) x)
-- (* (make-rectangular x y) +i) = (make-rectangular (* -1 y) x)
-- (/ (make-rectangular x y) -i) = (make-rectangular (* -1 y) x)
-- (* -1 (make-rectangular x y)) = (make-rectangular y (* -1 x))
-- (* (make-rectangular x y) -i) = (make-rectangular y (* -1 x))
-- (/ (make-rectangular x y) +i) = (make-rectangular y (* -1 x))
+++ /dev/null
-Bug fix: abs now always correctly adjusts the sign of a NaN and never
-raises a floating-point exception, following IEEE 754-2008.
+++ /dev/null
-Bug fix: Floating-point primitives now raise floating-point exceptions,
-rather than signalling argument range errors, and trap (i.e., signal a
-condition) only if floating-point exceptions are trapped.
+++ /dev/null
-Bug fix: (* 0 +inf.0) now returns NaN; previously it returned 0.
+++ /dev/null
-Bug fix: The integer? procedure no longer returns true for infinities.
-
-A side effect of this bug was that the compile's common subexpression
-elimination would crash when handling infinities, either written
-literally or due to constant folding:
-
-; Compiling file: "./floenv.bin" => "./floenv.com"...
-;The object +inf.0, passed as the first argument to flonum-normalize, is not the correct type.
+++ /dev/null
-Bug fix: LIAR previously miscompiled local procedures with optional
-parameters if they were never passed.
-
-Formerly MIT Scheme used unassigned reference traps for optional
-parameters without values; now it uses a #!default object. But LIAR
-hadn't gotten the memo, and if every call site omitted the argument,
-LIAR would constant-fold an unassigned reference trap instead of
-#!default.
-
-(let ()
- (define (test #!optional x)
- (pp (map-reference-trap (lambda () x))))
- (test))
+++ /dev/null
-Bug fix: The (magnitude z) procedure no longer overflows with large and
-angles near odd multiples of pi/4.
+++ /dev/null
-Bug fix: (flo:min x y) and (flo:max x y) now conform to IEEE 754-2008,
-as minNum/maxNum.
-
-When one input is a quiet NaN, they return the other input. Only when
-both inputs are NaN or one input is a signalling NaN do they return a
-NaN, and in either case, it is a quiet NaN[*]. These trap only when
-the floating-point invalid-operation exception is trapped.
-
-[*] Caveat: The IEEE 754 committee is considering changing the
-behaviour of these operations on signalling NaN, because the current
-semantics is nonassociative: min(1, min(2, sNaN)) = 1, whereas
-min(min(1, 2), sNaN) = qNaN. So don't go around relying on this
-semantics for sNaN inputs too heavily!
+++ /dev/null
-Bug fix: `+nan.0' and `-nan.0' are now read as floating-point
-not-a-number; `nan.0' was incorrectly read as that, but is now read as
-a symbol as it should be.
+++ /dev/null
-Bug fix: SF no longer incorrectly transforms (- x) into (- 0 x). This
-means when x is a floating-point zero, (- x) reliably changes its sign.
+++ /dev/null
-Bug fix: (make-polar magnitude 0) now returns magnitude, even if it is
-infinite or NaN; previously for infinite magnitudes it returned a
-rectangular number with NaN imaginary part.
+++ /dev/null
-Bug fix: Floating-point exceptions now work on PowerPC.
+++ /dev/null
-Bug fix: The reader and string->number now reject `#e+inf.0', `#e+nan.0', &c.
-
-Infinities and NaNs are not exact numbers and as such there is no way
-to interpret them with the #e prefix. (The #i prefix still works.)
+++ /dev/null
-Bug fix: The microcode is now compiled with -frounding-math so that the
-rounding mode can be reliably changed.
-
-Note: GCC >=7 sometimes miscompiles math under -O3 even if
--frounding-math is specified. In particular, (floor 0.5) sometimes
-returns -0. instead of +0. as it should.
+++ /dev/null
-Bug fix: The printer procedure now handles multiple back references.
+++ /dev/null
-Bug fix: The sqrt procedure now correctly propagates NaNs, handles
-complex numbers with infinities, and raises floating-point exceptions
-only where appropriate.
+++ /dev/null
-Bug fix: The printer no longer spuriously escapes | in "string
-notation" or " in |symbol notation|.
\ No newline at end of file
+++ /dev/null
-New procedure (bytevector-zero-explicit! bv [start [end]]) intended not
-to be optimized away.
-
-This isn't correctly implemented yet -- an old copy of the data may
-remain elsewhere in memory after a GC -- but it may be useful to mark
-where you _would_ want to zero the bytevector if we fixed it in the
-future.
+++ /dev/null
-Support for cross-compilation has been improved.
-
-On your x86 workstation, with mit-scheme-x86-64 in $PATH:
-
- ./configure \
- --enable-native-code=aarch64le \
- --enable-cross-compiling
- make toolchain
- make cross-host
-
-On your aarch64 laptop:
-
- make cross-target
-
-Eventually, it ought to be possible to run entirely on your x86
-workstation, if you have aarch64--netbsd-gcc in $PATH too and a
-prepopulated installation of the target OS at /path/to/destir.aarch64:
-
- ./configure \
- --host=x86_64--netbsd \
- --build=aarch64--netbsd \
- --enable-native-code=aarch64le \
- --enable-cross-compiling \
- CFLAGS=--sysroot=/path/to/destdir.aarch64 \
- LDFLAGS=--sysroot=/path/to/destdir.aarch64 \
- ac_cv_func_setpgrp_void=no \
- ac_cv_func_mmap_fixed_mapped=yes \
- HOST_CC=cc
- make toolchain
- make cross-host
- make cross-target
-
-(The ac_cv_* stuff is because autoconf can't detect some features when
-cross-compiling.) However, currently Scheme does not support static
-linking, only cold-loading code and dumping an image on the target
-machine.
+++ /dev/null
-New flonum-related definitions:
-
-. flo:radix - Floating-point radix as an integer. This is essentially
- always 2 but useful for assertions if you want to future-proof code
- that assumes it with a noisy failure in case we ever violate the
- assumption.
-. flo:radix. - Floating-point radix as a flonum.
-. flo:precision - Number of digits in a significand, including the hidden
- one bit for normal binary floating-point numbers. For binary64
- floating-point, this is 53.
-. flo:error-bound - Greatest possible relative error in rounding to nearest.
-. flo:log-error-bound = (log flo:error-bound)
-. flo:ulp-of-one - Distance from 1 to next greater floating-point number.
- Equal to twice flo:error-bound.
-. flo:log-ulp-of-one = (log flo:ulp-of-one)
-. (flo:ulp x) - Distance from x to the next floating-point number
- larger in magnitude with the same sign.
-. flo:normal-exponent-max - Exponent of greatest integer power of
- flo:radix that is a finite floating-point number, as an exact
- integer. Note that there are floating-point numbers greater than
- (expt flo:radix. flo:normal-exponent-max) -- the greatest one is just
- below flo:radix times that. But there are none that are a greater
- _integer_ power of flo:radix.
-. flo:normal-exponent-min - Exponent of least positive integer power of
- flo:radix that is a normal floating-point number, as an exact
- integer. (expt flo:radix. flo:normal-exponent-min) is also named
- flo:smallest-positive-normal.
-. flo:subnormal-exponent-min - Exponent of least positive integer power
- of flo:radix that is a nonzero, subnormal floating-point number, as
- an exact integer. (expt flo:radix. flo:subnormal-exponent-min) is
- the least positive floating-point number, also named
- flo:smallest-positive-subnormal.
-. flo:smallest-positive-subnormal - Smallest positive subnormal.
-. flo:smallest-positive-normal - Smallest positive normal.
-. flo:largest-positive-normal - Largest positive normal.
-. flo:least-subnormal-exponent-base-2 - Least flonum input x for which
- (expt 2. x) gives a nonzero result.
-. flo:least-subnormal-exponent-base-e - Least flonum input x for which
- (exp x) gives a nonzero result.
-. flo:least-subnormal-exponent-base-10 - Least flonum input x for which
- (expt 10. x) gives a nonzero result.
-. flo:least-normal-exponent-base-2 - Least flonum input x for which
- (expt 2. x) gives a normal result.
-. flo:least-normal-exponent-base-e - Least flonum input x for which
- (exp x) gives a normal result.
-. flo:least-normal-exponent-base-10 - Least flonum input x for which
- (expt 10. x) gives a normal result.
-. flo:greatest-normal-exponent-base-2 - Greatest flonum input x for
- which (expt 2. x) gives a finite result.
-. flo:greatest-normal-exponent-base-e - Greatest flonum input x for
- which (exp x) gives a finite result.
-. flo:greatest-normal-exponent-base-10 - Greatest flonum input x for
- which (expt 10. x) gives a finite result.
-. (flo:ldexp x e) = x * 2^e
-. (flo:scalbn x e) = x * b^e, where b is flo:radix and e is an integer
-. (flo:logb y) = e such that y = x * b^e for x = (flo:scalbn y (- e)),
- and 1 <= x < b, and e is an integer
-. (flo:classify x) returns one of the symbols
- - zero
- - subnormal
- - normal
- - infinite
- - nan
-. (flo:subnormal? x) is true if x is subnormal; false if zero, normal,
- infinite, or NaN
-- (flo:safe-zero? x) is true if x is zero; false if subnormal, normal,
- infinite, or NaN. flo:zero? raises an invalid-operation exception on
- NaN; flo:safe-zero? never does even on signalling NaN.
-- (flo:sign-negative? x) returns true if x has negative sign, false if
- x has positive sign. Note that (flo:negative? 0.) and (flo:negative?
- -0.) both return false, while (flo:sign-negative? -0.) returns true.
- Also, flo:negative? raises invalid-operation exception on NaN, while
- flo:sign-negative? never does even on signalling NaN.
-- (flo:safe< x y), (flo:safe<= x y), (flo:safe> x y), (flo:safe>= x y),
- (flo:safe= x y), (flo:safe<> x y), (flo:unordered? x y) perform
- unordered floating-point comparisons and, unlike flo:< &c., do not
- raise invalid-operation exceptions on quiet NaNs. (However, they do
- raise invalid-operation exceptions on signalling NaNs.)
-- (flo:<> x y) returns true if x is less or greater than y, false if
- equal or unordered, and raises invalid-operation exceptions on any
- NaNs.
-- (flo:total< x y) is true if x < y in the total ordering defined in
- IEEE 754-2008 Sec. 5.10; (flo:total-order x y) is a three-way
- comparison, -1 if x < y, 0 if x = y, +1 if x > y.
-- (flo:total-mag< x y) = (flo:total< (flo:abs x) (flo:abs y))
-- (flo:total-order-mag x y) = (flo:total-order (flo:abs x) (flo:abs y))
-- The eight min/max operations of IEEE 754-2019 are now supported:
- . flo:min
- . flo:max
- . flo:min-mag
- . flo:max-mag
- . flo:min-num
- . flo:max-num
- . flo:min-mag-num
- . flo:max-mag-num
- The `-mag' variants compare magnitudes. The `-num' variants treat
- NaN as missing data -- if one operand is numeric and the other is
- NaN, they return the numeric operand and ignore the NaN, as the
- minNum/maxNum operations from IEEE 754-2008 did.
-- (flo:make-nan negative? quiet? payload) returns a NaN with the
- specified payload, which must not exceed (- (expt 2
- flo:significand-digits-base-2 2) 1).
-- (flo:nan-quiet? nan) returns true for quiet NaNs, false for
- signalling NaNs.
-- (flo:nan-payload nan) returns the payload of NaN, an integer between
- 0 (inclusive) and 2^51 (exclusive).
+++ /dev/null
-Floating-point exceptions are now _not_ trapped by default.
-
-This follows IEEE 754's semantics for the default mode, and it has been
-the case on some platforms (e.g, macOS) for some time.
-
-If you want to trap on (e.g.) invalid-operation, you can do
-
-(flo:with-exceptions-trapped (flo:exception:invalid-operation)
- (lambda ()
- ...))
-
-(flo:trappable-exceptions) gives the set of all exceptions that can be
-trapped. Human-readable names are available by (flo:exceptions->names
-(flo:trappable-exceptions)).
-
-You can also test for floating-point exceptions after a computation
-without trapping. Before you can do this for the first time in any
-thread, you must clear the floating-point exceptions (otherwise there
-may be residual garbage from past computations):
-
-(flo:preserving-environment
- (lambda ()
- (flo:clear-exceptions! (flo:supported-exceptions))
- (let ((x (do-big-computation)))
- (if (not (zero? (flo:test-exceptions (flo:exception:underflow))))
- (warn "underflow"))
- x)))
+++ /dev/null
-New procedures for floating-point fused-multiply/add:
-
-- (flo:*+ u v a) computes u*v + a correctly rounded with no
- intermediate overflow or underflow
-- (flo:fma u v) is the same, with a more familiar name
-- (flo:fast-fma?) returns true if fma is hardware-supported and false
- if it is emulated in software with Dekker's double-precision
- algorithm
+++ /dev/null
-Added support for hexadecimal floating-point notation. Example:
-
-(parameterize ((param:printer-radix #x10))
- (write-to-string (list #x1.5p10 1.5e10 0.1 (flo:nextafter 0.1 1.0))))
-;Value: "(#x1.5p+10 #x1.bf08ebp+33 #x1.999999999999ap-4 #x1.999999999999bp-4)"
+++ /dev/null
-New IEEE 754 procedures:
-
-. (decompose-ieee754 x base emax precision if-zero if-subnormal if-normal if-infinite if-nan)
-. (decompoes-ieee754-binary x exponent-bits precision) -> [sign biased-exponent trailing-significand]
-. (decompose-ieee754-binary32 x) -> [sign biased-exponent trailing-significand]
-. (decompose-ieee754-binary64 x) -> [sign biased-exponent trailing-significand]
-. (decompose-ieee754-binary128 x) -> [sign biased-exponent trailing-significand]
-. (compose-ieee754-binary sign biased-exponent trailing-significand exponent-bits precision) -> real
-. (compose-ieee754-binary32 sign biased-exponent trailing-significand) -> real
-. (compose-ieee754-binary64 sign biased-exponent trailing-significand) -> real
-. (compose-ieee754-binary128 sign biased-exponent trailing-significand) -> real
-. (compose-ieee754-zero sign) -> real
-. (compose-ieee754-subnormal sign significand base emin precision) -> real
-. (compose-ieee754-normal sign exponent significand base emin precision) -> real
-. (compose-ieee754-infinity sign) -> real
-. (compose-ieee754-nan sign quiet payload) -> nan
-. (ieee754-binary32-exact? x) -> boolean
-. (ieee754-binary64-exact? x) -> boolean
-. (ieee754-binary128-exact? x) -> boolean
-. (ieee754-binary-hex-string x exponent-bits precision) -> string
-. (ieee754-binary32-hex-string x) -> string
-. (ieee754-binary64-hex-string x) -> string
-. (ieee754-binary128-hex-string x) -> string
+++ /dev/null
-The reader and printer now support notation for all distinct NaNs.
-
-The sequence is <sign> <type> "." <payload>, where <sign> is "+" or
-"-", <type> is "nan" for quiet NaNs and "snan" for signalling NaNs, and
-<payload> is an integer represented in the current radix.
-
-The notations +snan.0 and -snan.0 are forbidden because the bit pattern
-they would mean represents +inf.0 and -inf.0 instead.
+++ /dev/null
-New pseudorandom number generator algorithm for random API.
-
-The PRNG algorithm is based on the stream cipher ChaCha. The state is
-a 32-byte seed s; each output x is obtained by breaking the 64-byte
-quantity ChaCha_s(0) into two 32-byte halves s' and x, and replacing
-the state s by s'.
-
-The state is a little smaller than the old algorithm, and we now
-implement random-source-pseudo-randomize! keyed by two 128-bit integer
-seeds which can safely be drawn from the random source itself to attain
-reproducible randomized subtrees of computation with no danger of
-collisions in the seeds.
-
-. (flo:random-unit state) is now deprecated: use flo:random-unit-open
- if you must for essentially the same semantics, but prefer
- flo:random-unit-closed.
-
-. (flo:random-unit-open state) samples from the uniform distribution on
- real numbers in (2^{emin - p}/2, 1 - 2^p/2) rounded to the nearest
- floating-point number. Previously, flo:random-unit and random-real
- were limited to a narrower range and excluded many floating-point
- numbers in that range.
-
-. (flo:random-unit-closed state) samples from the uniform distribution
- on real numbers in [0, 1] rounded to the nearest floating-point
- number. Effectively, though, it samples from (0, 1], because the
- probability of getting 0 is smaller than 2^emin which is negligible
- even for IEEE 754 binary32 (single-precision) where it is 2^-127,
- whereas the probability of getting 1 is the small but nonnegligible
- 2^{-p}/2, e.g. 2^-54 in binary64. Thus, it is safe to pass the
- outcome to log, but not safe to pass the outcome to log1p.
-
-WARNING: The SRFI 27 and old MIT Scheme RNG API are not widely
-implemented as cryptographic PRNGs, so code written against them can't
-rely on them to be cryptographically secure in general. Further,
-anything involving random-integer, random-real, or bignums is likely to
-be vulnerable to timing attacks. But if you accidentally do use this
-API to generate cryptographic key material (like SRFI 27 suggests) then
-you might not be as bad off as you would have been before.
+++ /dev/null
-The x86-specific floating-point subnormal operand exception is now
-supported, and can be tested and trapped on x86 systems.
projects / mit-scheme.git / commitdiff