make insertion bench's NOOP behavior more obvious

Conflicts:
	benchmark/src/main/scala/spire/benchmark/SortingBenchmarks.scala
Handle NaN more gracefully.
Revert "Handle NaN more gracefully."

This reverts commit ae016ffae99986e5f6c227dba1b020f9bab03458.

The performance impact is relatively minor but real. I think a better
way to go will be to have another instance of Order[Double] which
provides a total ordering including NaN.
Introduce spire.optional package.

This package will contain alternate typeclass implementations, for
situations where users may want to easily override the default
behavior.

This commit includes spire.optional.totalfloat, an object containing
typeclass instances for Eq[Double], Order[Double], Eq[Float], and
Order[Float]. These instances use a total order which places NaN
above PositiveInfinity. This breaks the IEEE convention of having
comparisons involving NaN always return false.

Conflicts:
	src/main/scala/spire/package.scala
Added Semiring and Rng to spire.algebra hierarchy.

This commit further subdivides Ring functionality. At this point, we
have the following:

  Semiring: (+) (*) with distributivity
  Rig: Semiring with 0 and 1
  Rng: Semiring with 0 and additive inverse (-)
  Ring: Semiring with 0, 1, and (-)

Another way of putting this is:

  Semiring: additive semigroup + multiplicative semigroup
  Rig: additive monoid + multiplicative monoid
  Rng: additive abelian group + multiplicative semigroup
  Ring: additive abelian group + multiplicative monoid

There are currently no types requiring Rng or Semiring in Spire.
However, it would be difficult for users to add these type classes
later (due to ambiguity) so we are adding them anyway.

Finally, the commit attempts to add more detailed descriptions of the
type classes to the README.

Conflicts:
	src/main/scala/spire/algebra/Additive.scala
	src/main/scala/spire/algebra/Multiplicative.scala
	src/main/scala/spire/algebra/Rig.scala
	src/main/scala/spire/package.scala
improve README formatting
fix embarassing gaffe
Fix more documentation blunders.

Thanks to @ijuma, @jedws, and @tixxit for their vigilance.
Get examples compiling again.
First pass at a KleeneAlgebra example.

The example is taken from: http://r6.ca/blog/20110808T035622Z.html

The code can currently compute transitive closure using an intance of
KleeneAlgebra[Graph]. About 1/3 of the example has been translated to Scala.
Some things to think about:

1. It would be really nice to have a Bounded[A] type class like Haskell.
2. We should probably implement Semiring and Rig for Boolean.
3. Consider better ways to encode square matrix dimension in types.
add Boolean to Rig
get regex and shortest-path examples working
Specialize Semigroup, Monoid and (Ab)Group.
Add some initial Scala Map algebras.

This also adds some benchmarks to make sure our impl of the map
operators is no worse than Algebirds.
RingAlgebra is actually a Rng now.
Add type class instances for Map[K, V].

Adds type class instances for Map. This treats map like a sparse
product, so we can go all the way up to InnerProductSpace.
Add some monoid instances.

Conflicts:
	src/main/scala/spire/algebra/Group.scala
	src/main/scala/spire/algebra/Semigroup.scala
Add more collection monoids.
Add monoid for arrays.
Add "vector space" instances for collections.

This adds instances for various seq-like collections that are Modules,
VectorSpaces, and InnerProductSpaces. This let's us use + to do "vector"
addition, dot product, etc.

Conflicts:
	src/main/scala/spire/algebra/InnerProductSpace.scala
	src/main/scala/spire/algebra/Module.scala
	src/main/scala/spire/algebra/VectorSpace.scala