ref: a70379d7e4b822f532fb0a8ccdd1624a90b64a68
dir: /test/number-boundaries.sl/
; NUMBER BOUNDARIES ------------------------------------------------------------
(defmacro (half-max-signed numtype)
`(ash (,numtype 1)
(- (* 8 (sizeof ',numtype)) 2)))
(defmacro (high-border-signed numtype)
`(+ (- (half-max-signed ,numtype) 1)
(half-max-signed ,numtype)))
(defmacro (low-border-signed numtype)
`(- -1 (high-border-signed ,numtype)))
(defmacro (low-border numtype)
`(if (< (,numtype -1) 1)
(low-border-signed ,numtype)
(,numtype 0)))
(defmacro (high-border numtype)
`(lognot (low-border ,numtype)))
;`(numtype (lognot (low-border ,numtype))))
(defmacro (number-borders numtype)
`(cons (low-border ,numtype)
(high-border ,numtype)))
; TESTS ------------------------------------------------------------------------
(princ "---\n")
(princ "s8 " (number-borders s8) "\n")
(princ "s16 " (number-borders s16) "\n")
(princ "s32 " (number-borders s32) "\n")
(princ "s64 " (number-borders s64) "\n")
(princ "u8 " (number-borders u8) "\n")
(princ "u16 " (number-borders u16) "\n")
(princ "u32 " (number-borders u32) "\n")
(princ "u64 " (number-borders u64) "\n")
(princ "---\n")
; add/sub signed
(assert (= 128 (+ (high-border s8) 1)))
(assert (= 128 (+ 1 (high-border s8))))
(assert (= -129 (- (low-border s8) 1)))
(assert (= 129 (- 1 (low-border s8))))
(assert (= 32768 (+ (high-border s16) 1)))
(assert (= 32768 (+ 1 (high-border s16))))
(assert (= -32769 (- (low-border s16) 1)))
(assert (= 32769 (- 1 (low-border s16))))
(assert (= 2147483648 (+ (high-border s32) 1)))
(assert (= 2147483648 (+ 1 (high-border s32))))
(assert (= -2147483649 (- (low-border s32) 1)))
(assert (= 2147483649 (- 1 (low-border s32))))
(assert (= 9223372036854775808 (+ (high-border s64) 1)))
(assert (= 9223372036854775808 (+ 1 (high-border s64))))
(assert (= -9223372036854775809 (- (low-border s64) 1)))
(assert (= 9223372036854775809 (- 1 (low-border s64))))
(assert (= 27670116110564327421 (+ 9223372036854775807 9223372036854775807 9223372036854775807)))
(assert (= -12297829382473033728 (+ -3074457345618258432 -3074457345618258432 -3074457345618258432 -3074457345618258432)))
(assert (= 6148914691236516864 (- -3074457345618258432 -3074457345618258432 -3074457345618258432 -3074457345618258432)))
; conversions
(defmacro (int-conv- smaller bigger)
`(let* ((h (high-border ,smaller))
(L (low-border ,bigger))
(l (if (= L 0) 0 (low-border ,smaller))))
(assert (and (int? h) (int? l) (num? h) (num? l)))
(assert (and (num? (,smaller h)) (num? (,smaller l))))
(assert (and (int? (,smaller h)) (int? (,smaller l))))
(assert (and (int? (,bigger h)) (int? (,bigger l))))
(assert (and (num? (,bigger h)) (num? (,bigger l))))
(assert (and (int-valued? h) (int-valued? l)))
(assert (and (int-valued? (,smaller h)) (int-valued? (,smaller l))))
(assert (and (int-valued? (,bigger h)) (int-valued? (,bigger l))))
(assert (= h
(,smaller h) (,bigger h)
(,smaller (,bigger h)) (,bigger (,smaller h))))
(assert (= l
(,smaller l) (,bigger l)
(,smaller (,bigger l)) (,bigger (,smaller l))))))
(defmacro (int-conv smaller . biggers)
`(void ,@(map (λ (bigger) `(int-conv- ,smaller ,bigger)) biggers)))
(int-conv s8 s8 u8 s16 u16 s32 u32 s64 u64 bignum)
(int-conv s16 s16 u16 s32 u32 s64 u64 bignum)
(int-conv s32 s32 u32 s64 u64 bignum)
(int-conv s64 s64 u64 bignum)
(int-conv u8 u8 u16 s16 u32 s32 u64 s64 bignum)
(int-conv u16 u16 u32 s32 u64 s64 bignum)
(int-conv u32 u64 s64 bignum)
(int-conv u64 bignum)
(int-conv bignum bignum)
(defmacro (float-conv- type)
`(let ((l (low-border ,type))
(h (high-border ,type)))
(if (member ,type (list s64 u64))
(assert (= 12345 (,type (double 12345))))
(begin (assert (= l (,type (double l))))
(assert (= h (,type (double h))))))
(if (member ,type (list s32 u32 s64 u64))
(assert (= 12345 (,type (float 12345))))
(begin
(assert (= l (,type (float l))))
(assert (= h (,type (float h))))))))
(defmacro (float-conv . types)
`(void ,@(map (λ (type) `(float-conv- ,type)) types)))
(float-conv s8 u8 s16 u16 s32 u32 s64 u64)
(assert (= (low-border s32) (bignum (double (low-border s32)))))
(assert (= (high-border s32) (bignum (double (high-border s32)))))
(assert (= (low-border s16) (bignum (float (low-border s16)))))
(assert (= (high-border s16) (bignum (float (high-border s16)))))
(assert (= (low-border s32) (double (s64 (low-border s32)))))
(assert (= (high-border s32) (double (s64 (high-border s32)))))
(assert (= 0.5f (double (float 0.5))))
(assert (= 0.5 (float (double 0.5f))))
; comparison of different types
(assert (< (u64 (1- (high-border s64))) (s64 (high-border s64))))
(assert (< (s64 (high-border s64)) (u64 (1+ (high-border s64)))))
(assert (< (s64 (high-border s64)) (u64 (1+ (high-border s64)))))
(assert (< (u64 (1- (high-border s16))) (float (high-border s16))))
(assert (< (float (high-border s16)) (u64 (1+ (high-border s16)))))
(assert (< (u64 (1- (high-border s64))) (bignum (high-border s64))))
(assert (> (u64 (1+ (high-border s64))) (bignum (high-border s64))))
(assert (< (s64 (1- (high-border s64))) (bignum (high-border s64))))
(assert (> (s64 (high-border s64)) (bignum (1- (high-border s64)))))
(assert (< (u64 0) (s64 1)))
(assert (< (s64 0) (u64 1)))
(assert (> (u64 0) (s64 -1)))
(assert (< (s64 -1) (u64 0)))
(assert (< (u64 0) (bignum 1)))
(assert (< (s64 0) (bignum 1)))
(assert (> (u64 0) (bignum -1)))
(assert (> (s64 0) (bignum -1)))
(assert (< (s64 -1) (bignum 0)))
(assert (> (u64 (+ 10 (high-border s64))) (s64 (low-border s64))))
(assert (= (u64 1) (s64 1)))
(assert (= (s64 1) (u64 1)))
(assert (not (= (u64 (high-border u64)) (s64 -1))))
(assert (not (= (s64 -1) (u64 (high-border u64)))))
; add/sub unsigned
(assert (= 256 (+ (high-border u8) 1)))
(assert (= 256 (+ 1 (high-border u8))))
(assert (= -1 (- (low-border u8) 1)))
(assert (= 1 (- 1 (low-border u8))))
(assert (= 65536 (+ (high-border u16) 1)))
(assert (= 65536 (+ 1 (high-border u16))))
(assert (= -1 (- (low-border u16) 1)))
(assert (= 1 (- 1 (low-border u16))))
(assert (= 4294967296 (+ (high-border u32) 1)))
(assert (= 4294967296 (+ 1 (high-border u32))))
(assert (= -1 (- (low-border u32) 1)))
(assert (= 1 (- 1 (low-border u32))))
(assert (= 18446744073709551616 (+ (high-border u64) 1)))
(assert (= 18446744073709551616 (+ 1 (high-border u64))))
(assert (= 36893488147419103230 (+ (high-border u64) (high-border u64))))
(assert (= 36893488147419103231 (+ 1 (high-border u64) (high-border u64))))
(assert (= 36893488147419103231 (+ (high-border u64) 1 (high-border u64))))
(assert (= 36893488147419103231 (+ (high-border u64) (high-border u64) 1)))
(assert (= -1 (- (low-border u64) 1)))
(assert (= 1 (- 1 (low-border u64))))
; mul signed
(assert (= 18446744073709551614 (* (high-border s64) 2)))
(assert (= -18446744073709551614 (* (high-border s64) -2)))
(assert (= 18446744073709551614 (* 2 (high-border s64))))
(assert (= -18446744073709551616 (* (low-border s64) 2)))
(assert (= -18446744073709551616 (* 2 (low-border s64))))
; mul unsigned
(assert (= 36893488147419103230 (* (high-border u64) 2)))
(assert (= 36893488147419103230 (* 2 (high-border u64))))
(assert (= -36893488147419103230 (* (high-border u64) -2)))
(assert (= -36893488147419103230 (* -2 (high-border u64))))
(princ "all number boundaries tests pass")
(newline)