This is a basic demo I've written to show some basic improvements in speed we can get with a specialized Numeric trait. I hope to release this as an independent jar that people can plug in to do fast generic math, and eventually I hope to get code like this integrated into the mainline scala.math.Numeric trait.

=== BENCHMARKS ===

You can run the performance tests with "sbt run".

The output shows the speed (in ms) of a direct implementation (without generics), a new implementation (using my own Numeric) and an old implementation (using the builtin Numeric).

n:d is how new compares to direct o:d is how old compares to direct o:n is how old compares to new

It also creates a benchmark.html file which colorizes the output.

=== RESULTS ===

There are some interesting results:

1. scala.math.Numeric performs terribly on integral types but does a bit better on fractional ones.

2. scala.util.Sorting.quickSort lacks a direct Long implementation, so using it with Longs is ~5x slower than Int, Float or Double.

3. The specialized Numeric class basically performs as well as direct except when using infix operators. The current Numeric is clearly inappropriate for any application where performance is important.

=== NUMERIC DIFFERENCES ===

While very similar to scala.math.Numeric, my Numeric trait has some differences. The most significant ones are:

1. It does not inherit from the Ordering typeclass, but rather directly implements the comparison methods. I will try to do some cleanup on this and make it more compatible with Ordering, but it was important to me that the comparison methods are also specialized.

2. It does not implement Integral/Fractional. I think that leaving division/modulo off of Numeric is a mistake, and don't think that forcing users to use Integral/Fractional is a good idea. Given that Scala uses the same symbol (/) to mean both "integer division" and "true division" it seems clear that Numeric can too.

3. It's in a different package (com.azavea.math).