Allow full range for nextInt and nextLong.
Add an immutable random Generator and Uniform.
Add Gaussian implicit distribution.

This also includes instances for Float, Double and BigDecimal.
Fix bug in ULong#toBigInt (thanks tpolecat)
Abstract Ops rewriting allowing custom symbol->name mapping

Previously, all users of spire-macros had to use the same mapping
between symbols and names. This commit allows users to extend Ops
and produce their own mappings. For example:

    object MyOps extends Ops {
      val operatorNames = Map(
        "$plus$plus" -> "concat",
        "$plus$eq" -> "append",
        "$eq$plus" -> "prepend"
      )
    }

The previous Ops object still exists, so this chagne should not affect
code that is relying on the previous mapping.
Add tests for gaussian distributions.
Merge remote-tracking branch 'upstream/master' into topic/immutable-generators
Fix bug in Quaternion ScalaCheck test.
Fix bug with Generator#copy and gaussian state.

Previously, copied generators would have a 50% chance of returning
different values for nextGaussian. This commit fixes that.
fix missing string interpolator
Merge pull request #161 from xuwei-k/s-interpolator

fix missing string interpolator
 Added longToByte, intToByte, longFromBytes & intFromBytes; Associated changes

Changed intToBytes's argument from (n: Long) to (n: Int)
long|intFromBytes has a new 8|4 byte arg method
Clean up pull request, and add tests.

I did a few things here:

 * Removed tab characters
 * Improved efficiency a bit with inlined private methods
 * Removed "dangerous" intToByte and longToByte
 * Added ScalaCheck test
 * Fixed a bug that I found

I decided that intToByte and longToByte were "dangerous" since there
aren't very many "correct" ways of calling them (only 4/8 valid second
arguments, respectively). Also, by using the new private inlined
methods I can avoid doing a bunch of arithmetic.

Thanks to flavuit for the pull request and the efficiency improvements!
Added macro to prevent IndexOutOfBounds exception, added single value byte unpacker method and associated tests.
Fix some bugs with cforRange.

This commit makes cforRange a bit less ugly, and supports negative
iterating by a negative step.

The macro needs to be documented. Here are the current assumptions:

  1. (a to b) and (a until b) are supported for any tree types.

  2. (a to b by c) and (a until b by c) are only supported when c is
     a literal tree (a known constant stride).

  3. ranges that don't fit these two categories are not supported

Unsupported ranges will fall back to using:

  r.foreach(body)

This will still be correct but will be much slower. In these cases
the macro will print a warning.
use sbt 0.13.0
use resetLocalAttrs to fix inlining bugs
Refactor spire.math.Interval for speed and correctness.

This commit changes the way Spire handles intervals. It removes the
bound objects (whose unop/binop logic was a bit faulty), instead
using interval subtypes and flags. There are four types of intervals:

  1. All: the interval containing all values
  2. Above(lower): the interval above a lower bound
  3. Below(upper): the interval below an upper bound
  4. Ranged(lower, upper): an interval bounded by two values

Each bound may be open or closed using a flag, which are not meant to
be user-visible. There were a lot of issues with unbound intervals
that stemmed from treaing open/closed/unbound with the same logic,
which this design fixes.
add Interval#translate using Polynomial
Add reified Bound[A] type back to Interval.

It's no longer used internally, but it's useful for expressing fold
and maybe some other functions eventually. This also adds the
Interval.fromBounds(x, y) constructor.