[racket] Math library ready for testing

Woah, this is very impressive! And now I can convince more people to use
Racket!


On Fri, Dec 7, 2012 at 9:33 PM, Neil Toronto <neil.toronto at gmail.com> wrote:

> I've just pushed the last commits that make the new math library ready for
> wider testing. Almost everything ready for use is documented, the tests
> keep passing, and everything *seems* to work.
>
> We (the Racket development team) need people to use the heck out of it, to
> find the majority of the remaining logic and design errors before the next
> release. This is a big chunk of new code - ~20k lines in ~100 nontrivial
> files - so the more eyes, the better.
>
> If all you have time for is checking documentation, we'll take it. The
> latest docs are here:
>
>     http://pre.racket-lang.org/**docs/html/math/<http://pre.racket-lang.org/docs/html/math/>
>
> The nightly builds are here:
>
>     http://pre.racket-lang.org/**installers/<http://pre.racket-lang.org/installers/>
>
> For Windows and Mac, the nightlies should include two new libraries used
> by `math/bigfloat': libgmp and libmpfr. Linux users almost certainly
> already have them; many packages (e.g. gcc) depend on libmpfr.
>
> If you prefer to build from source, clone the git repository here:
>
>     https://github.com/plt/racket
>
> If you're building on Windows or Mac, you can download pre-built libgmp
> and libmpfr from here:
>
>     http://download.racket-lang.**org/libs/10/<http://download.racket-lang.org/libs/10/>
>
> ************
>
> Once you have a pre-release build, do (require math), and away you go!
>
> Well, it's probably not obvious where to start. The following are the
> modules that `math' re-exports, and for some, what needs testing. Please
> feel free to skim. In decreasing order of attention they need:
>
> (require math/array)
>
>   NumPy/SciPy/Repa-like arrays, Typed-Racket-style. Provides a
>   covariant `Array' type and several mutable subtypes, array literals,
>   functional constructors, pointwise operations with automatic
>   broadcasting in SciPy/NumPy or permissive mode, slicing, indexing
>   tricks, folds, easy arbitrary transformations, and parallel FFT.
>
>   This one needs a lot of usability testing. In particular...
>
>   We're trying something that's been done only once before, in
>   Haskell's Repa: by default, arrays' elements are *non-strict*,
>   meaning that they're recomputed when referenced. Cool things about
>   this: pretty much everything can in principle be parallelized, and
>   most intermediate arrays use almost no memory. But it requires more
>   thought from users about when arrays should be made strict (computed
>   and stored all at once). If it totally sucks, we can change it. If
>   it's a worthwhile imposition, we'll leave it. If it's a wash, we
>   could parameterize the default behavior.
>
>   Also, I've been considering allowing negative axis numbers and row
>   indexes. Need feedback on how helpful it would be vs. confusing and
>   error-hiding.
>
>   Lastly, I'm looking for a dual of `array-axis-reduce' (a kind of
>   fold) that makes it easy to write `list-array->array', the inverse of
>   the existing `array->list-array'. If you're into functional design
>   puzzles, give this one a shot.
>
> (require math/bigfloat)
>
>   Floating-point numbers with arbitrarily large precision and
>   large exponents. Also elementary and special functions, whose results
>   are proved to be correct in many theses and dissertations. This is a
>   Racket interface to MPFR (www.mpfr.org).
>
>   This module needs platform-specific testing.
>
>   I think we've verified that `math/bigfloat' works on all the
>   supported 64-bit platforms, but not whether it works on supported
>   32-bit platforms. It should. ;)
>
>   There's an error in the current nightly build, which causes an
>   infinite loop when libmpfr isn't installed and a bigfloat function is
>   applied. I just pushed a fix; it should fail properly tomorrow.
>
> (require math/distributions)
>
>   Probability distributions: discrete, integer-valued and real-valued.
>   Distribution objects can compute pdfs, cdfs and inverse cdfs,
>   optionally in log space, and for cdfs and inverse cdfs, optionally
>   for upper tails. They can also generate samples.
>
>   Design ideas are welcome. More distributions are planned. Let me know
>   which you need, and I'll concentrate on those first.
>
>   Watch out, R. Our gamma cdf is more accurate.
>
> (require math/special-functions)
>
>   Non-elementary functions like gamma, erf, zeta, Lambert W, and
>   incomplete gamma and beta integrals. Most of these should be fairly
>   accurate; i.e. they compute answers with apparently < 5 ulps error
>   for the majority of their domains. But floating-point domains are
>   huge, so the more use, the better.
>
> (require math/number-theory)
>
>   Number theory! Chinese Remainder solutions, coprimality and primality
>   testing, factorization, congruence arithmetic parameterized on a
>   current modulus, integer nth roots, multiplicative functions, common
>   number sequences (Bernoulli, Eulerian, tangent, etc.), combinatorics,
>   primitive roots, and more.
>
>   Please thank Jens Axel Søgaard, who wrote this module, for his
>   excellent work.
>
> (require math/statistics)
>
>   Functions to compute summary values for collections of data, and to
>   manage weighted samples. Every function for which it makes sense
>   accepts weighted values, including the O(1)-space running statistics
>   update.
>
>   I'm in the middle of documenting this. I'll get around to documenting
>   correlation, kth-value order statistics (via quickselect), and
>   counting/binning at least by Dec. 18.
>
> (require math/flonum)
>
>   Re-exports `racket/flonum' along with many more floating-point
>   goodies. If you're a floating-point nut, you'll love it. If you're
>   not, at least check out `flsum'. If you're doing statistics, look
>   into log-space arithmetic (`lg+' and friends).
>
> (require math/base)
>
>   Re-exports `racket/math'; also exports some more constants like
>   gamma.0 (Euler-Mascheroni), a bit more float-complex support, inverse
>   hyperbolic functions, large random numbers, error measurement.
>
> Lastly, there's `math/matrix', which is currently not re-exported by
> `math' because I haven't reviewed it yet. This is more from Jens Axel, and
> if it's like his other fine work, it's correct and well-tested. I'll
> probably get to it by Christmas.
>
> To sum up, there are 8 modules that need pounding on, and we need YOU to
> do some pounding. If you're not terribly busy, please pick one that looks
> interesting/fun/useful, and try it out.
>
> Thanks!
>
> Neil ⊥
> ____________________
>  Racket Users list:
>  http://lists.racket-lang.org/**users <http://lists.racket-lang.org/users>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.racket-lang.org/users/archive/attachments/20121207/6e0b8cd1/attachment-0001.html>