mbutterick
/
describe
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

remove bigfloat support to avoid bug in v.5.3.x

Browse Source
pull/1/head
Matthew Butterick 11 years ago
parent 21308f2855
commit 589305ee09
4 changed files with 209 additions and 281 deletions
Show Stats Download Patch File Download Diff File

401
describe/describe-test.rkt
Unescape Escape View File

@ -1,202 +1,199 @@
#lang racket #lang racket
;;; describe-test.rkt ;;; describe-test.rkt
;;; Copyright (c) 2009-2010 M. Douglas Williams ;;; Copyright (c) 2009-2010 M. Douglas Williams
;;; ;;;
;;; This program is free software: you can redistribute it and/or modify ;;; This program is free software: you can redistribute it and/or modify
;;; it under the terms of the GNU General Public License as published by ;;; it under the terms of the GNU General Public License as published by
;;; the Free Software Foundation, either version 3 of the License, or ;;; the Free Software Foundation, either version 3 of the License, or
;;; (at your option) any later version. ;;; (at your option) any later version.
;;; ;;;
;;; This program is distributed in the hope that it will be useful, ;;; This program is distributed in the hope that it will be useful,
;;; but WITHOUT ANY WARRANTY; without even the implied warranty of ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;; GNU General Public License for more details. ;;; GNU General Public License for more details.
;;; ;;;
;;; You should have received a copy of the GNU General Public License ;;; You should have received a copy of the GNU General Public License
;;; along with this program. If not, see <http://www.gnu.org/licenses/>. ;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;; ;;;
(require math/bigfloat (require racket/mpair)
racket/mpair) (require (planet williams/describe/describe))
(require (planet williams/describe/describe))
;;; Booleans
;;; Booleans (printf "~n--- Booleans ---~n")
(printf "~n--- Booleans ---~n") (describe #t)
(describe #t) (describe #f)
(describe #f)
;;; Numbers
;;; Numbers (printf "~n--- Numbers ---~n")
(printf "~n--- Numbers ---~n")
(define (! n)
(define (! n) (if (= n 0)
(if (= n 0) 1
1 (* n (! (sub1 n)))))
(* n (! (sub1 n)))))
(describe +inf.0)
(describe +inf.0) (describe -inf.0)
(describe -inf.0) (describe +nan.0)
(describe +nan.0)
(describe 0)
(describe 0) (describe (! 10))
(describe (! 10)) (describe (! 40))
(describe (! 40)) (describe (- (! 40) (! 41)))
(describe (- (! 40) (! 41))) (describe (! 100))
(describe (! 100)) (describe (/ (! 10) (add1 (! 11))))
(describe (/ (! 10) (add1 (! 11)))) (describe -1+3i)
(describe -1+3i)
(describe 0.0)
(describe 0.0) (describe 0.1e0)
(describe 0.1e0) (describe 0.1f0)
(describe 0.1f0) (describe 0.1t0)
(describe 0.1t0) (describe (* (! 10) 1.0))
(describe (* (! 10) 1.0)) (describe 6.0221313e23)
(describe 6.0221313e23) (describe 6.0221313f23)
(describe 6.0221313f23) (describe 6.0221313t23)
(describe 6.0221313t23) (describe (exact->inexact (! 40)))
(describe (exact->inexact (! 40))) (describe (sqrt 10))
(describe (sqrt 10)) (describe (sqrt -10))
(describe (sqrt -10)) (describe (+ (sqrt 10) (sqrt -10)))
(describe (+ (sqrt 10) (sqrt -10)))
(describe (bf 1/10)) ;;; Strings
(describe (bf "15e200000000"))
(printf "~n--- Strings ---~n")
;;; Strings (describe "abc")
(describe (string #\1 #\2 #\3))
(printf "~n--- Strings ---~n")
(describe "abc") ;;; Byte Strings
(describe (string #\1 #\2 #\3))
(printf "~n--- Byte Strings ---~n")
;;; Byte Strings (describe #"abc")
(describe (bytes 48 49 50))
(printf "~n--- Byte Strings ---~n")
(describe #"abc") ;;; Characters
(describe (bytes 48 49 50))
(printf "~n--- Characters ---~n")
;;; Characters (describe #\a)
(describe #\A)
(printf "~n--- Characters ---~n") (describe #\0)
(describe #\a) (describe #\()
(describe #\A)
(describe #\0) ;;; Symbols
(describe #\()
(printf "~n--- Symbols ---~n")
;;; Symbols (describe 'abc)
(describe '|(a + b)|)
(printf "~n--- Symbols ---~n") (describe (gensym))
(describe 'abc)
(describe '|(a + b)|) ;;; Regular Expressions
(describe (gensym))
(printf "~n--- Regular Expressions ---~n")
;;; Regular Expressions (describe #rx"Ap*le")
(describe #px"Ap*le")
(printf "~n--- Regular Expressions ---~n")
(describe #rx"Ap*le") ;;; Byte Regular Expressions
(describe #px"Ap*le")
(printf "~n--- Byte Regular Expressions ---~n")
;;; Byte Regular Expressions (describe #rx#"Ap*le")
(describe #px#"Ap*le")
(printf "~n--- Byte Regular Expressions ---~n")
(describe #rx#"Ap*le") ;;; Keywords
(describe #px#"Ap*le")
(printf "~n--- Keywords ---~n")
;;; Keywords (describe '#:key)
(printf "~n--- Keywords ---~n") ;;; Lists and Pairs
(describe '#:key)
(printf "~n--- Lists and Pairs ---~n")
;;; Lists and Pairs (describe '(this is a proper list))
(describe '(this is an improper . list))
(printf "~n--- Lists and Pairs ---~n") (describe (list '(this . is) '(also . a) '(proper . list)))
(describe '(this is a proper list))
(describe '(this is an improper . list)) ;;; Mutable Lists and Pairs
(describe (list '(this . is) '(also . a) '(proper . list)))
(printf "~n--- Mutable Lists and Pairs ---~n")
;;; Mutable Lists and Pairs (describe (mlist 'this 'is 'a 'proper 'list))
(describe (mcons 'this (mcons 'is (mcons 'an (mcons 'improper 'list)))))
(printf "~n--- Mutable Lists and Pairs ---~n") (describe (mlist '(this . is) '(also . a) '(proper . list)))
(describe (mlist 'this 'is 'a 'proper 'list))
(describe (mcons 'this (mcons 'is (mcons 'an (mcons 'improper 'list))))) ;;; Vectors
(describe (mlist '(this . is) '(also . a) '(proper . list)))
(printf "~n--- Vectors ---~n")
;;; Vectors (describe #(1 2 3))
(printf "~n--- Vectors ---~n") ;;; Boxes
(describe #(1 2 3))
(printf "~n--- Boxes ---~n")
;;; Boxes (describe (box 12))
(describe (box (box 'a)))
(printf "~n--- Boxes ---~n") (describe (box (sqrt 10)))
(describe (box 12))
(describe (box (box 'a))) ;;; Weak Boxes
(describe (box (sqrt 10)))
(printf "~n--- Weak Boxes ---~n")
;;; Weak Boxes (describe (make-weak-box 12))
(describe (make-weak-box (make-weak-box 'a)))
(printf "~n--- Weak Boxes ---~n") (describe (make-weak-box (sqrt 10)))
(describe (make-weak-box 12))
(describe (make-weak-box (make-weak-box 'a))) ;;; Hashes
(describe (make-weak-box (sqrt 10)))
(printf "~n--- Hashes ---~n")
;;; Hashes (describe #hash((a . 12) (b . 14) (c . 16)))
(describe #hasheq((a . a) (b . b) (c . c)))
(printf "~n--- Hashes ---~n") (describe #hasheqv((a . #\a) (b . #\b) (c . #\c)))
(describe #hash((a . 12) (b . 14) (c . 16)))
(describe #hasheq((a . a) (b . b) (c . c))) (define ht (make-hash))
(describe #hasheqv((a . #\a) (b . #\b) (c . #\c))) (hash-set! ht 'a 12)
(hash-set! ht 'b 14)
(define ht (make-hash)) (hash-set! ht 'c 16)
(hash-set! ht 'a 12) (describe ht)
(hash-set! ht 'b 14)
(hash-set! ht 'c 16) (define wht (make-weak-hash))
(describe ht) (hash-set! wht 'a 12)
(hash-set! wht 'b 14)
(define wht (make-weak-hash)) (hash-set! wht 'c 16)
(hash-set! wht 'a 12) (describe wht)
(hash-set! wht 'b 14)
(hash-set! wht 'c 16) ;;; Procedures
(describe wht)
(printf "~n--- Procedures ---~n")
;;; Procedures (describe car)
(describe open-output-file)
(printf "~n--- Procedures ---~n") (describe current-input-port)
(describe car) (describe (lambda (x) x))
(describe open-output-file)
(describe current-input-port) ;;; Ports
(describe (lambda (x) x))
(printf "~n--- Ports ---~n")
;;; Ports (describe (current-input-port))
(describe (current-output-port))
(printf "~n--- Ports ---~n")
(describe (current-input-port)) ;;; Void
(describe (current-output-port))
(printf "~n--- Void ---~n")
;;; Void (describe (void))
(printf "~n--- Void ---~n") ;;; EOF
(describe (void))
(printf "~n--- EOF ---~n")
;;; EOF (describe eof)
(printf "~n--- EOF ---~n") ;;; Paths
(describe eof)
(printf "~n--- Paths ---~n")
;;; Paths (describe (string->path "C:\\Program-files\\PLT"))
(describe (string->path "../dir/file.ext"))
(printf "~n--- Paths ---~n")
(describe (string->path "C:\\Program-files\\PLT")) ;;; Structures
(describe (string->path "../dir/file.ext"))
(printf "~n--- Structures ---~n")
;;; Structures (define-struct transparent-struct (a b c) #:transparent)
(define ts-1 (make-transparent-struct 'a 'b 'c))
(printf "~n--- Structures ---~n") (describe ts-1)
(define-struct transparent-struct (a b c) #:transparent)
(define ts-1 (make-transparent-struct 'a 'b 'c)) ;;; Other Named Things (I.E., Opaque Structures)
(describe ts-1)
(printf "~n--- Other Named Things ---~n")
;;; Other Named Things (I.E., Opaque Structures) (define-struct opaque-struct (a b c))
(define os-1 (make-opaque-struct 'a 'b 'c))
(printf "~n--- Other Named Things ---~n") (describe os-1)
(define-struct opaque-struct (a b c))
(define os-1 (make-opaque-struct 'a 'b 'c))
(describe os-1)

39
describe/float-test-bigfloat.rkt
Unescape Escape View File

@ -1,39 +0,0 @@
#lang racket
(require math/bigfloat)
(require (planet williams/describe/describe))
(printf "--- Using literals (big float) ---~n")
(describe (bf 1/10))
(describe (bf 2/10))
(describe (bf 3/10))
(describe (bf 4/10))
(describe (bf 5/10))
(describe (bf 6/10))
(describe (bf 7/10))
(describe (bf 8/10))
(describe (bf 9/10))
(describe (bf 10/10))
(printf "--- Exact decimal values of big floats ---~n")
(float->string (bf 1/10))
(float->string (bf 2/10))
(float->string (bf 3/10))
(float->string (bf 4/10))
(float->string (bf 5/10))
(float->string (bf 6/10))
(float->string (bf 7/10))
(float->string (bf 8/10))
(float->string (bf 9/10))
(float->string (bf 10/10))
(printf "--- Using summation (big float) ---~n")
(for/fold ((sum 0.bf))
((i (in-range 10)))
(define new-sum (bf+ sum (bf 1/10)))
(describe new-sum)
new-sum)
(printf "--- Using product (big float) ---~n")
(for ((i (in-range 1 11)))
(describe (bf* (bf i) (bf 1/10))))

30
describe/main.rkt
Unescape Escape View File

@ -70,8 +70,7 @@
;;; 2.0.1 08/26/13 Added exact decimal value for floats. (MDW) ;;; 2.0.1 08/26/13 Added exact decimal value for floats. (MDW)
;;; 2.0.1 09/26/13 Added bigfloat support to float->string. (MDW) ;;; 2.0.1 09/26/13 Added bigfloat support to float->string. (MDW)
(require math/bigfloat (require racket/extflonum
racket/extflonum
racket/mpair) racket/mpair)
;;; (variant x) -> symbol ;;; (variant x) -> symbol
@ -339,11 +338,7 @@
; ((extfl> x 0.0t0) +1.0) ; ((extfl> x 0.0t0) +1.0)
; (else 0.0)) ; (else 0.0))
; (sgn x))) ; (sgn x)))
(define sign (cond ((bigfloat? x) (define sign (cond ((extflonum? x)
(cond ((bf< x 0.bf) -1.0)
((bf> x 0.bf) +1.0)
(else 0.0)))
((extflonum? x)
(cond ((extfl< x 0.0t0) -1.0) (cond ((extfl< x 0.0t0) -1.0)
((extfl> x 0.0t0) +1.0) ((extfl> x 0.0t0) +1.0)
(else 0.0))) (else 0.0)))
@ -353,8 +348,7 @@
;(define exact-x (if (extflonum? x) ;(define exact-x (if (extflonum? x)
; (abs (extfl->exact x)) ; (abs (extfl->exact x))
; (abs (inexact->exact x)))) ; (abs (inexact->exact x))))
(define exact-x (cond ((bigfloat? x) (abs (bigfloat->rational x))) (define exact-x (cond ((extflonum? x) (abs (extfl->exact x)))
((extflonum? x) (abs (extfl->exact x)))
(else (inexact->exact x)))) (else (inexact->exact x))))
(define int (truncate exact-x)) (define int (truncate exact-x))
(define frac (- exact-x int)) (define frac (- exact-x int))
@ -421,20 +415,6 @@
(format "~s is an extended precision (80-bit) floating point number whose exact decimal value is ~a" (format "~s is an extended precision (80-bit) floating point number whose exact decimal value is ~a"
x (float->string x))))) x (float->string x)))))
;;; (bigfloat-description x) -> string
;;; x : extflonum?
;;; Returns a string describing the big float, x.
(define (bigfloat-description x)
(cond ((eqv? x +inf.bf)
(format "~s is positive infinity" x))
((eqv? x -inf.bf)
(format "~s is negative infinity" x))
((eqv? x +nan.bf)
(format "~s is non-a-number" x))
(else
(format "~s is a ~a big float with ~a bits of precision"
x (if (bfnegative? x) "negative" "positive")
(bigfloat-precision x)))))
;;; (string-description str) -> string? ;;; (string-description str) -> string?
;;; str : string? ;;; str : string?
@ -795,8 +775,6 @@
(number-description x)) (number-description x))
((extflonum? x) ((extflonum? x)
(extflonum-description x)) (extflonum-description x))
((bigfloat? x)
(bigfloat-description x))
((string? x) ((string? x)
(string-description x)) (string-description x))
((bytes? x) ((bytes? x)
@ -863,7 +841,7 @@
(integer->string (integer->string
(-> exact-integer? string?)) (-> exact-integer? string?))
(float->string (float->string
(-> (or/c flonum? single-flonum? extflonum? bigfloat?) string?)) (-> (or/c flonum? single-flonum? extflonum?) string?))
(description (description
(-> any/c string?)) (-> any/c string?))
(describe (describe

20
describe/scribblings/describe.scrbl
Unescape Escape View File

@ -8,12 +8,14 @@
@title[#:tag "describe"]{Describe} @title[#:tag "describe"]{Describe}
M. Douglas Williams
@(author+email @tt{M. Douglas Williams} "doug@cognidrome.org") @author[(author+email "M. Douglas Williams" "doug@cognidrome.org")]
This library provides functions to describe Racket objects. Currently, the following types of objects are described: This library provides functions to describe Racket objects. Currently, the following types of objects are described:
@margin-note{This is not the official version of Describe. It is the 1.5 version from PLaneT, retooled to use Racket's new package system, and with bigfloat support disabled (because of bugs related to v.5.3.x compatability.) The canonical version of Describe is on the @link["http://planet.racket-lang.org/display.ss?package=describe.plt&owner=williams" "PLaneT server"]. — MB}
@itemize{ @itemize{
@item{Booleans} @item{Booleans}
@item{Numbers} @item{Numbers}
@ -78,11 +80,8 @@ Examples:
@scheme[(integer->string (expt 10 150))] -> "at least 10^102" @scheme[(integer->string (expt 10 150))] -> "at least 10^102"
@defproc[(float->string (x (or/c flonum? single-flonum? extflonum? bigfloat?))) string?]{ @defproc[(float->string (x (or/c flonum? single-flonum? extflonum?))) string?]{
Returns a string with the exact decimal value of the floating-point number @scheme[x]. This works for single precision, double precision, extended precision, and big floating-point values. Note that internally @scheme[x] is converted to an exact rational number as part of converting to a string and the following warning from the Arbitrary-Precision Floating-Point Numbers (Bigfloats) section in the Math Library is important. Returns a string with the exact decimal value of the floating-point number @scheme[x]. This works for single precision, double precision, and extended precision values. Note that internally @scheme[x] is converted to an exact rational number as part of converting to a string.}
@bold{Be careful with exact conversions.} Bigfloats with large exponents may not fit in memory as integers or exact rationals. Worse, they might fit, but have all your RAM and swap space for lunch.
}
Examples: Examples:
@ -96,8 +95,6 @@ Examples:
@scheme[(float->string 0.1t0)] -> "0.1000000000000000000013552527156068805425093160010874271392822265625" @scheme[(float->string 0.1t0)] -> "0.1000000000000000000013552527156068805425093160010874271392822265625"
@scheme[(float->string (bf 1/10))] -> "0.10000000000000000000000000000000000000007346839692639296924804603357639035486366659729825547009429698164240107871592044830322265625"
@defproc[(describe (x any/c)) void?]{ @defproc[(describe (x any/c)) void?]{
Prints a description of @scheme[x] to the current output port.} Prints a description of @scheme[x] to the current output port.}
@ -169,9 +166,6 @@ racket
(describe (sqrt -10)) (describe (sqrt -10))
(describe (+ (sqrt 10) (sqrt -10))) (describe (+ (sqrt 10) (sqrt -10)))
(describe (bf 1/10))
(describe (bf "15e200000000"))
;;; Strings ;;; Strings
(printf "~n--- Strings ---~n") (printf "~n--- Strings ---~n")
@ -344,8 +338,6 @@ Produces the following output.
3.1622776601683795 is an inexact positive real number whose exact decimal value is 3.162277660168379522787063251598738133907318115234375 3.1622776601683795 is an inexact positive real number whose exact decimal value is 3.162277660168379522787063251598738133907318115234375
0+3.1622776601683795i is an inexact positive imaginary number whose exact decimal value is 0+3.162277660168379522787063251598738133907318115234375i 0+3.1622776601683795i is an inexact positive imaginary number whose exact decimal value is 0+3.162277660168379522787063251598738133907318115234375i
3.1622776601683795+3.1622776601683795i is an inexact complex number whose real part 3.1622776601683795 is an inexact positive real number whose exact decimal value is 3.162277660168379522787063251598738133907318115234375 and whose imaginary part 0+3.1622776601683795i is an inexact positive imaginary number whose exact decimal value is 0+3.162277660168379522787063251598738133907318115234375i 3.1622776601683795+3.1622776601683795i is an inexact complex number whose real part 3.1622776601683795 is an inexact positive real number whose exact decimal value is 3.162277660168379522787063251598738133907318115234375 and whose imaginary part 0+3.1622776601683795i is an inexact positive imaginary number whose exact decimal value is 0+3.162277660168379522787063251598738133907318115234375i
(bf #e0.1000000000000000000000000000000000000001) is a positive big float with 128 bits of precision
(bf "1.499999999999999999999999999999999999998e200000001") is a positive big float with 128 bits of precision
--- Strings --- --- Strings ---
"abc" is an immutable string of length 3 "abc" is an immutable string of length 3

Write Preview
Loading…
Cancel
Save