Value Members

1.  final def IEEEremainder(x: Double, d: Double): Double
2.  final def abs[A](a: A)(implicit ev: Signed[A]): A
3.  final def abs(n: Double): Double
4.  final def abs(n: Float): Float
5.  final def abs(n: Long): Long
6.  final def abs(n: Int): Int
7.  final def abs(n: Short): Short
8.  final def abs(n: Byte): Byte

   abs

9.  final def acos[A](a: A)(implicit ev: Trig[A]): A
10.  final def asin[A](a: A)(implicit ev: Trig[A]): A
11.  final def atan[A](a: A)(implicit ev: Trig[A]): A
12.  final def atan2[A](y: A, x: A)(implicit ev: Trig[A]): A
13.  final def cbrt(x: Double): Double
14.  final def ceil[A](a: A)(implicit ev: IsReal[A]): A
15.  final def ceil(n: BigDecimal): BigDecimal
16.  final def ceil(n: Double): Double
17.  final def ceil(n: Float): Float

    ceil

18.  def choose(n: Long, k: Long): BigInt

    choose (binomial coefficient)

19.  final def copySign(m: Float, s: Float): Float
20.  final def copySign(m: Double, s: Double): Double
21.  final def cos[A](a: A)(implicit ev: Trig[A]): A
22.  final def cosh(x: Double): Double
23.  final def cosh[A](x: A)(implicit ev: Trig[A]): A
24.  final def e[A](implicit ev: Trig[A]): A
25.  final def e: Double

    e

26.  final def exp[A](a: A)(implicit t: Trig[A]): A
27.  final def exp(k: BigDecimal): BigDecimal
28.  final def exp(k: Int, precision: Int): BigDecimal
29.  final def exp(n: Double): Double

    exp

30.  final def expm1(x: Double): Double
31.  def fact(n: Long): BigInt

    factorial

32.  def fib(n: Long): BigInt

    fibonacci

33.  final def floor[A](a: A)(implicit ev: IsReal[A]): A
34.  final def floor(n: BigDecimal): BigDecimal
35.  final def floor(n: Double): Double
36.  final def floor(n: Float): Float

    floor

37.  final def gcd[A](x: A, y: A, z: A, rest: A*)(implicit arg0: Eq[A], ev: GCDRing[A]): A
38.  final def gcd[A](xs: Seq[A])(implicit arg0: Eq[A], ev: GCDRing[A]): A
39.  final def gcd[A](x: A, y: A)(implicit arg0: Eq[A], ev: GCDRing[A]): A
40.  final def gcd(a: BigInt, b: BigInt): BigInt
41.  final def gcd(_x: Long, _y: Long): Long

    gcd

42.  final def getExponent(x: Float): Int
43.  final def getExponent(x: Double): Int
44.  final def hypot[A](x: A, y: A)(implicit f: Field[A], n: NRoot[A], s: Signed[A]): A
45.  final def lcm[A](x: A, y: A)(implicit arg0: Eq[A], ev: GCDRing[A]): A
46.  final def lcm(a: BigInt, b: BigInt): BigInt
47.  final def lcm(x: Long, y: Long): Long

    lcm

48.  final def log[A](a: A, base: Int)(implicit f: Field[A], t: Trig[A]): A
49.  final def log[A](a: A)(implicit t: Trig[A]): A
50.  def log(n: BigDecimal, base: Int): BigDecimal
51.  final def log(n: BigDecimal): BigDecimal
52.  final def log(n: Double, base: Int): Double
53.  final def log(n: Double): Double

    log

54.  final def log10(x: Double): Double
55.  final def log1p(x: Double): Double
56.  final def max[A](x: A, y: A)(implicit ev: Order[A]): A
57.  final def max(x: Double, y: Double): Double
58.  final def max(x: Float, y: Float): Float
59.  final def max(x: Long, y: Long): Long
60.  final def max(x: Int, y: Int): Int
61.  final def max(x: Short, y: Short): Short
62.  final def max(x: Byte, y: Byte): Byte

    max

63.  final def min[A](x: A, y: A)(implicit ev: Order[A]): A
64.  final def min(x: Double, y: Double): Double
65.  final def min(x: Float, y: Float): Float
66.  final def min(x: Long, y: Long): Long
67.  final def min(x: Int, y: Int): Int
68.  final def min(x: Short, y: Short): Short
69.  final def min(x: Byte, y: Byte): Byte

    min

70.  final def nextAfter(x: Float, y: Float): Float
71.  final def nextAfter(x: Double, y: Double): Double
72.  final def nextUp(x: Float): Float
73.  final def nextUp(x: Double): Double
74.  def nroot(a: BigDecimal, k: Int, ctxt: MathContext): BigDecimal

    An implementation of the shifting n-th root algorithm for BigDecimal.

    An implementation of the shifting n-th root algorithm for BigDecimal. For the BigDecimal a, this is guaranteed to be accurate up to the precision specified in ctxt.

    See http://en.wikipedia.org/wiki/Shifting_nth_root_algorithm

    a

    A (positive if k % 2 == 0) BigDecimal.

    k

    A positive Int greater than 1.

    ctxt

    The MathContext to bound the precision of the result. returns A BigDecimal approximation to the k-th root of a.

75.  final def pi[A](implicit ev: Trig[A]): A
76.  final def pi: Double

    pi

77.  final def pow(base: Double, exponent: Double): Double
78.  final def pow(base: Long, exponent: Long): Long

    Exponentiation function, e.g.

    Exponentiation function, e.g. x^y

    If base^ex doesn't fit in a Long, the result will overflow (unlike Math.pow which will return +/- Infinity).

79.  final def pow(base: BigInt, ex: BigInt): BigInt
80.  final def pow(base: BigDecimal, exponent: BigDecimal): BigDecimal

    pow

81.  final def random(): Double
82.  final def rint(x: Double): Double
83.  final def round[A](a: A)(implicit ev: IsReal[A]): A
84.  final def round(a: BigDecimal): BigDecimal
85.  final def round(a: Double): Double
86.  final def round(a: Float): Float

    round

87.  final def scalb(d: Float, s: Int): Float
88.  final def scalb(d: Double, s: Int): Double
89.  final def signum[A](a: A)(implicit ev: Signed[A]): Int
90.  final def signum(x: Float): Float
91.  final def signum(x: Double): Double

    signum

92.  final def sin[A](a: A)(implicit ev: Trig[A]): A
93.  final def sinh[A](x: A)(implicit ev: Trig[A]): A
94.  final def sqrt[A](a: A)(implicit ev: NRoot[A]): A
95.  final def sqrt(x: Double): Double

    sqrt

96.  final def tan[A](a: A)(implicit ev: Trig[A]): A
97.  final def tanh[A](x: A)(implicit ev: Trig[A]): A
98.  final def toDegrees(a: Double): Double
99.  final def toRadians(a: Double): Double
100.  final def ulp(x: Float): Double
101.  final def ulp(x: Double): Double
102.  object Algebraic extends AlgebraicInstances with Serializable
103.  object BinaryMerge extends Merge

     Merge that uses binary search to reduce the number of comparisons

     Merge that uses binary search to reduce the number of comparisons

     This can be orders of magnitude quicker than a linear merge for types that have a relatively expensive comparison operation (e.g. Rational, BigInt, tuples) and will not be much slower than linear merge even in the worst case for types that have a very fast comparison (e.g. Int)

104.  object BitString extends Serializable
105.  object Complex extends ComplexInstances with Serializable
106.  object ConvertableFrom
107.  object ConvertableTo
108.  object FastComplex

     FastComplex is an ugly, beautiful hack.

     FastComplex is an ugly, beautiful hack.

     The basic idea is to encode two 32-bit Floats into a single 64-bit Long. The lower-32 bits are the "real" Float and the upper-32 are the "imaginary" Float.

     Since we're overloading the meaning of Long, all the operations have to be defined on the FastComplex object, meaning the syntax for using this is a bit ugly. To add to the ugly beauty of the whole thing I could imagine defining implicit operators on Long like +@, -@, *@, /@, etc.

     You might wonder why it's even worth doing this. The answer is that when you need to allocate an array of e.g. 10-20 million complex numbers, the GC overhead of using *any* object is HUGE. Since we can't build our own "pass-by-value" types on the JVM we are stuck doing an encoding like this.

     Here are some profiling numbers for summing an array of complex numbers, timed against a concrete case class implementation using Float (in ms):

     size | encoded | class 1M | 5.1 | 5.8 5M | 28.5 | 91.7 10M | 67.7 | 828.1 20M | 228.0 | 2687.0

     Not bad, eh?

109.  object FloatComplex
110.  object FpFilter
111.  object FpFilterApprox
112.  object FpFilterExact
113.  object Fractional extends Serializable
114.  object InsertionSort extends Sort

     Simple implementation of insertion sort.

     Simple implementation of insertion sort.

     Works for small arrays but due to O(n^2) complexity is not generally good.

115.  object Integral extends Serializable
116.  object Interval extends Serializable
117.  object Jet extends JetInstances with Serializable

     A simple implementation of N-dimensional dual numbers, for automatically computing exact derivatives of functions.

     Overview

     A simple implementation of N-dimensional dual numbers, for automatically computing exact derivatives of functions. This code (and documentation) closely follow the one in Google's "Ceres" library of non-linear least-squares solvers (see Sameer Agarwal, Keir Mierle, and others: Ceres Solver.)

     While a complete treatment of the mechanics of automatic differentiation is beyond the scope of this header (see http://en.wikipedia.org/wiki/Automatic_differentiation for details), the basic idea is to extend normal arithmetic with an extra element "h" such that h != 0, but h² = 0. Dual numbers are extensions of the real numbers analogous to complex numbers: whereas complex numbers augment the reals by introducing an imaginary unit i such that i² = -1, dual numbers introduce an "infinitesimal" unit h such that h² = 0. Analogously to a complex number c = x + y*i, a dual number d = x * y*h has two components: the "real" component x, and an "infinitesimal" component y. Surprisingly, this leads to a convenient method for computing exact derivatives without needing to manipulate complicated symbolic expressions.

     For example, consider the function

     f(x) = x * x ,

     evaluated at 10. Using normal arithmetic, f(10) = 100, and df/dx(10) = 20. Next, augment 10 with an infinitesimal h to get:

     f(10 + h) = (10 + h) * (10 + h)
               = 100 + 2 * 10 * h + h * h
               = 100 + 20 * h       +---
                       +-----       |
                       |            +--- This is zero
                       |
                       +----------------- This is df/dx

     Note that the derivative of f with respect to x is simply the infinitesimal component of the value of f(x + h). So, in order to take the derivative of any function, it is only necessary to replace the numeric "object" used in the function with one extended with infinitesimals. The class Jet, defined in this header, is one such example of this, where substitution is done with generics.

     To handle derivatives of functions taking multiple arguments, different infinitesimals are used, one for each variable to take the derivative of. For example, consider a scalar function of two scalar parameters x and y:

     f(x, y) = x * x + x * y

     Following the technique above, to compute the derivatives df/dx and df/dy for f(1, 3) involves doing two evaluations of f, the first time replacing x with x + h, the second time replacing y with y + h.

     For df/dx:

     f(1 + h, y) = (1 + h) * (1 + h) + (1 + h) * 3
                 = 1 + 2 * h + 3 + 3 * h
                 = 4 + 5 * h
     
     Therefore df/dx = 5

     For df/dy:

     f(1, 3 + h) = 1 * 1 + 1 * (3 + h)
                 = 1 + 3 + h
                 = 4 + h
     
     Therefore df/dy = 1

     To take the gradient of f with the implementation of dual numbers ("jets") in this file, it is necessary to create a single jet type which has components for the derivative in x and y, and pass them to a routine computing function f. It is convenient to use a generic version of f, that can be called also with non-jet numbers for standard evaluation:

     def f[@specialized(Double) T : Field](x: T, y: T): T = x * x + x * y
     
     val xValue = 9.47892774
     val yValue = 0.287740
     
     // The "2" means there should be 2 dual number components.
     implicit val dimension = JetDim(2)
     val x: Jet[Double] = xValue + Jet.h[Double](0);  // Pick the 0th dual number for x.
     val y: Jet[Double] = yValue + Jet.h[Double](1);  // Pick the 1th dual number for y.
     
     val z: Jet[Double] = f(x, y);
     println("df/dx = " + z.infinitesimal(0) + ", df/dy = " + z.infinitesimal(1));

     For the more mathematically inclined, this file implements first-order "jets". A 1st order jet is an element of the ring

     T[N] = T[t_1, ..., t_N] / (t_1, ..., t_N)^2

     which essentially means that each jet consists of a "scalar" value 'a' from T and a 1st order perturbation vector 'v' of length N:

     x = a + \sum_i v[i] t_i

     A shorthand is to write an element as x = a + u, where u is the perturbation. Then, the main point about the arithmetic of jets is that the product of perturbations is zero:

     (a + u) * (b + v) = ab + av + bu + uv
                       = ab + (av + bu) + 0

     which is what operator* implements below. Addition is simpler:

     (a + u) + (b + v) = (a + b) + (u + v).

     The only remaining question is how to evaluate the function of a jet, for which we use the chain rule:

     f(a + u) = f(a) + f'(a) u

     where f'(a) is the (scalar) derivative of f at a.

     By pushing these things through generics, we can write routines that at same time evaluate mathematical functions and compute their derivatives through automatic differentiation.

118.  object LinearMerge extends Merge

     Simple linear merge

119.  object LinearSelect extends SelectLike with HighBranchingMedianOf5
120.  object MergeSort extends Sort

     In-place merge sort implementation.

     In-place merge sort implementation. This sort is stable but does mutate the given array. It is an in-place sort but it does allocate a temporary array of the same size as the input. It uses InsertionSort for sorting very small arrays.

121.  object Natural extends NaturalInstances with Serializable
122.  object Number extends NumberInstances with Serializable

     Convenient apply and implicits for Numbers

123.  object NumberTag
124.  object Numeric extends Serializable
125.  object Polynomial extends PolynomialInstances

     Polynomial A univariate polynomial class and EuclideanRing extension trait for arithmetic operations.

     Polynomial A univariate polynomial class and EuclideanRing extension trait for arithmetic operations. Polynomials can be instantiated using any type C for which a Ring[C] and Eq[C] are in scope, with exponents given by Int values. Some operations require more precise algebraic structures, such as GCDRing, EuclideanRing or Field to be in scope.

126.  object Quaternion extends QuaternionInstances with Serializable
127.  object QuickSelect extends SelectLike with HighBranchingMedianOf5
128.  object QuickSort

     In-place quicksort implementation.

     In-place quicksort implementation. It is not stable, but does not allocate extra space (other than stack). Like MergeSort, it uses InsertionSort for sorting very small arrays.

129.  object Rational extends RationalInstances with Serializable
130.  object Real extends RealInstances with Serializable
131.  object SafeLong extends SafeLongInstances with Serializable
132.  object Searching
133.  object Selection
134.  object Sorting

     Object providing in-place sorting capability for arrays.

     Object providing in-place sorting capability for arrays.

     Sorting.sort() uses quickSort() by default (in-place, not stable, generally fastest but might hit bad cases where it's O(n^2)). Also provides mergeSort() (in-place, stable, uses extra memory, still pretty fast) and insertionSort(), which is slow except for small arrays.

135.  object Trilean
136.  object UByte extends UByteInstances
137.  object UInt extends UIntInstances
138.  object ULong extends ULongInstances
139.  object UShort extends UShortInstances