suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Worked around new typed/rackunit limitations in "array-tests.rkt" and

Browse Source 
"mandelbrot-test.rkt"

Fixed error in `array-count' revealed by correctly failing test

Simplified Mandelbrot test
This commit is contained in:
Neil Toronto 2012-11-29 15:44:58 -07:00
parent 5a43f2c6bc
commit 0182a6c491
4 changed files with 60 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
collects/math/private/array/array-special-folds.rkt
View File

@ -13,14 +13,15 @@
(define array-count
(case-lambda:
[([f : (A -> Any)] [arr0 : (Array A)])
(assert (array-all-sum (inline-array-map (λ: ([a : A]) (if (f a) 1 0)) arr0)) index?)]
(assert (array-all-sum (inline-array-map (λ: ([a : A]) (if (f a) 1 0)) arr0) 0) index?)]
[([f : (A B -> Any)] [arr0 : (Array A)] [arr1 : (Array B)])
(assert
(array-all-sum (inline-array-map (λ: ([a : A] [b : B]) (if (f a b) 1 0)) arr0 arr1))
(array-all-sum (inline-array-map (λ: ([a : A] [b : B]) (if (f a b) 1 0)) arr0 arr1) 0)
index?)]
[([f : (A B T ... T -> Any)] [arr0 : (Array A)] [arr1 : (Array B)] . [arrs : (Array T) ... T])
(assert
(array-all-sum (apply array-map
(λ: ([a : A] [b : B] . [ts : T ... T]) (if (apply f a b ts) 1 0))
arr0 arr1 arrs))
arr0 arr1 arrs)
0)
index?)]))

4
collects/math/scribblings/math.scrbl
View File

@ -14,10 +14,10 @@ for working with numbers and collections of numbers. These include
@item{Additional constants and elementary functions}
@item{Special functions}
@item{@racket[Bigfloat]s, or arbitrary-precision floating-point numbers}
@item{Probability distributions}
@item{Statistical functions (currently undergoing refactoring)}
@item{Number-theoretic functions}
@item{@racket[Array]s for storing and transforming large rectangular data sets}
@item{Probability distributions}
@item{Statistical functions (currently undergoing refactoring)}
@item{Linear algebra functions (currently under review)}
]

42
collects/math/tests/array-tests.rkt
View File

@ -2,13 +2,35 @@
(require racket/flonum
math/array
typed/rackunit
(rename-in
(except-in typed/rackunit check-eq?)
[check-equal? old:check-equal?])
math/private/array/utils)
(define-predicate listof-index? (Listof Index))
(define-predicate listof-flonum? (Listof Float))
(define-predicate undefined? Undefined)
;; This gets around the fact that typed/rackunit can no longer test higher-order values for equality,
;; since TR has firmed up its rules on passing `Any' types in and out of untyped code
(define-syntax-rule (check-equal? a b . message)
(check-true (equal? a b) . message))
(define-syntax-rule (check-eq? a b . message)
(check-equal? (eq-hash-code a) (eq-hash-code b) . message))
(define-syntax-rule (array-axis-andmap arr k pred?)
(array-axis-and (array-map pred? arr) k))
(define-syntax-rule (array-axis-ormap arr k pred?)
(array-axis-or (array-map pred? arr) k))
(define-syntax-rule (array-all-andmap arr pred?)
(array-all-and (array-map pred? arr)))
(define-syntax-rule (array-all-ormap arr pred?)
(array-all-or (array-map pred? arr)))
;; ---------------------------------------------------------------------------------------------------
;; array-mutable
@ -343,7 +365,7 @@
(let ([arr (array #[#[1.0 1.0 2.0 3.0] #[0.0 -1.0 2.0 3.0]])])
(check-equal? (array-axis-count arr 0 positive?) (array #[1 1 2 2]))
(check-equal? (array-axis-count arr 1 positive?) (array #[4 2]))
(check-equal? (array-all-count arr positive?) 6))
(check-equal? (array-count positive? arr) 6))
(let ([arr (array #[#[1.0 1.0 2.0 3.0] #[0.0 -1.0 2.0 3.0]])])
(check-equal? (array-axis-andmap arr 0 positive?) (array #[#f #f #t #t]))
@ -366,12 +388,12 @@
(check-equal? (array-all-ormap arr positive?) #f))
(let ([arr (make-array #() 0.0)])
(check-equal? (array-all-count arr positive?) 0)
(check-equal? (array-count positive? arr) 0)
(check-equal? (array-all-andmap arr positive?) #f)
(check-equal? (array-all-ormap arr positive?) #f))
(let ([arr (make-array #() 1.0)])
(check-equal? (array-all-count arr positive?) 1)
(check-equal? (array-count positive? arr) 1)
(check-equal? (array-all-andmap arr positive?) #t)
(check-equal? (array-all-ormap arr positive?) #t))
@ -382,7 +404,7 @@
(check-equal? (array-axis-count arr 1 positive?) (array #[0 0 0 0]))
(check-equal? (array-axis-andmap arr 1 positive?) (array #[#t #t #t #t]))
(check-equal? (array-axis-ormap arr 1 positive?) (array #[#f #f #f #f]))
(check-equal? (array-all-count arr positive?) 0)
(check-equal? (array-count positive? arr) 0)
(check-equal? (array-all-andmap arr positive?) #t)
(check-equal? (array-all-ormap arr positive?) #f))
@ -394,12 +416,12 @@
(check-exn exn? (λ () (array-fft (make-array #(3) 1))))
(let ([arr (make-array #(4) 1)])
(check array-all= (array-fft arr) (array #[4 0 0 0]))
(check array-all= (array-inverse-fft (array-fft arr)) arr))
(check-true (array-all-and (array= (array-fft arr) (array #[4 0 0 0]))))
(check-true (array-all-and (array= (array-inverse-fft (array-fft arr)) arr))))
(let ([arr (make-array #(2 2) 1)])
(check array-all= (array-fft arr) (array #[#[4 0] #[0 0]]))
(check array-all= (array-inverse-fft (array-fft arr)) arr))
(check-true (array-all-and (array= (array-fft arr) (array #[#[4 0] #[0 0]]))))
(check-true (array-all-and (array= (array-inverse-fft (array-fft arr)) arr))))
;; ---------------------------------------------------------------------------------------------------
;; Unsafe ref
@ -744,7 +766,7 @@
(let ([arr (indexes-array #(4))])
(check-exn exn? (λ () (array-axis-ref arr 1 0)))
(check-equal? (array-axis-ref arr 0 2)
(array #(2))))
(array '#(2))))
(let ([arr (indexes-array #(2 2))])
(check-equal? (array-axis-ref arr 0 0)

44
collects/math/tests/mandelbrot-test.rkt
View File

@ -6,39 +6,39 @@
(: mandelbrot (Float Integer -> (Array Integer)))
(define (mandelbrot step max-iters)
(define xs (sequence->list (in-range -2.0 0.800001 step)))
(define ys (sequence->list (in-range -1.4 1.400001 step)))
(define x ((inst list*->array Float) xs flonum?))
(define y (array-slice-ref ((inst list*->array Float) ys flonum?) (list ::... (::new 1))))
(define x (list->array (sequence->list (in-range -2.0 0.800001 step))))
(define y (array-slice-ref (list->array (sequence->list (in-range -1.4 1.400001 step)))
(list ::... (::new 1))))
(define c (array->fcarray (array+ x (array-scale y +1.0i))))
(define-values (z divtime)
(for/fold: ([z : FCArray c]
[divtime : (Array Integer) (make-array (array-shape c) max-iters)]
) ([i (in-range max-iters)])
(let ([z (fcarray+ (fcarray-sqr z) c)])
(values z (array-strict (array-if (array-and (flarray> (fcarray-magnitude z) (flarray 4.0))
(values z (array-strict (array-if (array-and (array> (fcarray-magnitude z) (flarray 4.0))
(array= divtime (array max-iters)))
(array i)
divtime))))))
divtime)
(check-equal? (mandelbrot 0.2 20)
(array #[#[0 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
#[1 1 1 1 1 1 2 2 2 3 2 2 1 1 1]
#[1 1 1 1 1 2 2 2 3 6 20 3 2 1 1]
#[1 1 1 2 2 2 3 4 5 20 17 4 3 2 1]
#[1 1 2 2 3 3 4 11 20 20 20 10 14 2 2]
#[1 2 3 4 6 6 6 20 20 20 20 20 9 3 2]
#[2 3 4 6 18 20 14 20 20 20 20 20 20 3 2]
#[20 20 20 20 20 20 20 20 20 20 20 20 5 3 2]
#[2 3 4 6 18 20 14 20 20 20 20 20 20 3 2]
#[1 2 3 4 6 6 6 20 20 20 20 20 9 3 2]
#[1 1 2 2 3 3 4 11 20 20 20 10 14 2 2]
#[1 1 1 2 2 2 3 4 5 20 17 4 3 2 1]
#[1 1 1 1 1 2 2 2 3 6 20 3 2 1 1]
#[1 1 1 1 1 1 2 2 2 3 2 2 1 1 1]
#[0 1 1 1 1 1 1 1 1 1 1 1 1 1 1]]))
(check-true
(equal? (mandelbrot 0.2 20)
(array #[#[0 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
#[1 1 1 1 1 1 2 2 2 3 2 2 1 1 1]
#[1 1 1 1 1 2 2 2 3 6 20 3 2 1 1]
#[1 1 1 2 2 2 3 4 5 20 17 4 3 2 1]
#[1 1 2 2 3 3 4 11 20 20 20 10 14 2 2]
#[1 2 3 4 6 6 6 20 20 20 20 20 9 3 2]
#[2 3 4 6 18 20 14 20 20 20 20 20 20 3 2]
#[20 20 20 20 20 20 20 20 20 20 20 20 5 3 2]
#[2 3 4 6 18 20 14 20 20 20 20 20 20 3 2]
#[1 2 3 4 6 6 6 20 20 20 20 20 9 3 2]
#[1 1 2 2 3 3 4 11 20 20 20 10 14 2 2]
#[1 1 1 2 2 2 3 4 5 20 17 4 3 2 1]
#[1 1 1 1 1 2 2 2 3 6 20 3 2 1 1]
#[1 1 1 1 1 1 2 2 2 3 2 2 1 1 1]
#[0 1 1 1 1 1 1 1 1 1 1 1 1 1 1]])))
#;
(begin
(require images/flomap)