spire

math

package math

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. math
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. trait Approximation[A, B, C] extends (A, B) ⇒ C

    A typeclass approach for getting an approximation to an A using error B in type C.

  2. case class ApproximationContext[A](error: A) extends Product with Serializable

  3. trait ArrayEq[A] extends Eq[Array[A]]

  4. trait ArrayOrder[A] extends ArrayEq[A] with Order[Array[A]]

  5. trait ArrayVectorEq[A] extends Eq[Array[A]]

  6. trait ArrayVectorOrder[A] extends ArrayVectorEq[A] with Order[Array[A]]

  7. trait BigDecimalEq extends Eq[BigDecimal]

  8. trait BigDecimalIsFractional extends Fractional[BigDecimal] with BigDecimalIsField with BigDecimalIsNRoot with ConvertableFromBigDecimal with ConvertableToBigDecimal with BigDecimalOrder with BigDecimalIsSigned

  9. trait BigDecimalIsNumeric extends Numeric[BigDecimal] with BigDecimalIsField with BigDecimalIsNRoot with ConvertableFromBigDecimal with ConvertableToBigDecimal with BigDecimalOrder with BigDecimalIsSigned

  10. trait BigDecimalIsTrig extends Trig[BigDecimal]

  11. trait BigDecimalOrder extends Order[BigDecimal] with BigDecimalEq

  12. trait BigIntEq extends Eq[BigInt]

  13. trait BigIntIsIntegral extends Integral[BigInt] with BigIntIsEuclideanRing with ConvertableFromBigInt with ConvertableToBigInt with BigIntOrder with BigIntIsSigned

  14. trait BigIntIsNumeric extends Numeric[BigInt] with BigIntIsEuclideanRing with BigIntIsNRoot with ConvertableFromBigInt with ConvertableToBigInt with BigIntOrder with BigIntIsSigned

  15. trait BigIntOrder extends Order[BigInt] with BigIntEq

  16. sealed trait Bound[T] extends AnyRef

    A Bound represents one side of an interval; it is parameterized on T, the ordered type covered by the interval.

  17. trait ByteEq extends Eq[Byte]

  18. trait ByteOrder extends Order[Byte] with ByteEq

  19. trait CharEq extends Eq[Char]

  20. trait CharOrder extends Order[Char] with CharEq

  21. sealed trait Closed[T] extends AnyRef

    Closed is a closed bound (the interval contains this limit).

  22. final case class ClosedAbove[T](x: T)(implicit order: Order[T]) extends Upper[T] with Closed[T] with Product with Serializable

    ClosedAbove is a closed upper bound, e.

  23. final case class ClosedBelow[T](x: T)(implicit order: Order[T]) extends Lower[T] with Closed[T] with Product with Serializable

    ClosedBelow is a closed lower bound, e.

  24. final case class Complex[T](real: T, imag: T)(implicit f: Fractional[T], t: Trig[T]) extends ScalaNumber with ScalaNumericConversions with Serializable with Product

  25. trait ComplexEq[A] extends Eq[Complex[A]]

  26. class ComplexIsNumeric[A] extends ComplexIsField[A] with Numeric[Complex[A]] with ComplexEq[A] with NRoot[Complex[A]] with ConvertableFromComplex[A] with ConvertableToComplex[A] with Order[Complex[A]] with ComplexIsSigned[A]

  27. sealed trait Conversion[A, B] extends AnyRef

    A type class for numeric conversions.

  28. trait ConvertableFrom[A] extends AnyRef

  29. trait ConvertableFromBigDecimal extends ConvertableFrom[BigDecimal]

  30. trait ConvertableFromBigInt extends ConvertableFrom[BigInt]

  31. trait ConvertableFromByte extends ConvertableFrom[Byte]

  32. trait ConvertableFromComplex[A] extends ConvertableFrom[Complex[A]]

  33. trait ConvertableFromDouble extends ConvertableFrom[Double]

  34. trait ConvertableFromFloat extends ConvertableFrom[Float]

  35. trait ConvertableFromGaussian[A] extends ConvertableFrom[Gaussian[A]]

  36. trait ConvertableFromInt extends ConvertableFrom[Int]

  37. trait ConvertableFromLong extends ConvertableFrom[Long]

  38. trait ConvertableFromNumber extends ConvertableFrom[Number]

  39. final class ConvertableFromOps[A] extends AnyRef

  40. trait ConvertableFromRational extends ConvertableFrom[Rational]

  41. trait ConvertableFromReal extends ConvertableFrom[Real]

  42. trait ConvertableFromSafeLong extends ConvertableFrom[SafeLong]

  43. trait ConvertableFromShort extends ConvertableFrom[Short]

  44. trait ConvertableTo[A] extends AnyRef

  45. trait ConvertableToBigDecimal extends ConvertableTo[BigDecimal]

  46. trait ConvertableToBigInt extends ConvertableTo[BigInt]

  47. trait ConvertableToByte extends ConvertableTo[Byte]

  48. trait ConvertableToComplex[A] extends ConvertableTo[Complex[A]]

  49. trait ConvertableToDouble extends ConvertableTo[Double]

  50. trait ConvertableToFloat extends ConvertableTo[Float]

  51. trait ConvertableToGaussian[A] extends ConvertableTo[Gaussian[A]]

  52. trait ConvertableToInt extends ConvertableTo[Int]

  53. trait ConvertableToLong extends ConvertableTo[Long]

  54. trait ConvertableToNumber extends ConvertableTo[Number]

  55. trait ConvertableToRational extends ConvertableTo[Rational]

  56. trait ConvertableToReal extends ConvertableTo[Real]

  57. trait ConvertableToSafeLong extends ConvertableTo[SafeLong]

  58. trait ConvertableToShort extends ConvertableTo[Short]

  59. trait DoubleEq extends Eq[Double]

  60. trait DoubleIsFractional extends Fractional[Double] with DoubleIsField with DoubleIsNRoot with ConvertableFromDouble with ConvertableToDouble with DoubleOrder with DoubleIsSigned

  61. trait DoubleIsNumeric extends Numeric[Double] with DoubleIsField with DoubleIsNRoot with ConvertableFromDouble with ConvertableToDouble with DoubleOrder with DoubleIsSigned

  62. trait DoubleIsTrig extends Trig[Double]

  63. trait DoubleOrder extends Order[Double] with DoubleEq

  64. trait Eq[A] extends AnyRef

  65. trait Eq0 extends AnyRef

  66. trait Eq1 extends Eq0

  67. final class EqOps[A] extends AnyRef

  68. trait EqProduct10[A, B, C, D, E, F, G, H, I, J] extends Eq[(A, B, C, D, E, F, G, H, I, J)]

  69. trait EqProduct11[A, B, C, D, E, F, G, H, I, J, K] extends Eq[(A, B, C, D, E, F, G, H, I, J, K)]

  70. trait EqProduct12[A, B, C, D, E, F, G, H, I, J, K, L] extends Eq[(A, B, C, D, E, F, G, H, I, J, K, L)]

  71. trait EqProduct13[A, B, C, D, E, F, G, H, I, J, K, L, M] extends Eq[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

  72. trait EqProduct14[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends Eq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

  73. trait EqProduct15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends Eq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

  74. trait EqProduct16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends Eq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]

  75. trait EqProduct17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends Eq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]

  76. trait EqProduct18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends Eq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]

  77. trait EqProduct19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends Eq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

  78. trait EqProduct2[A, B] extends Eq[(A, B)]

    ************************************************************************ WARNING: This is an auto-generated file.

  79. trait EqProduct20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends Eq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]

  80. trait EqProduct21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends Eq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]

  81. trait EqProduct22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends Eq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]

  82. trait EqProduct3[A, B, C] extends Eq[(A, B, C)]

  83. trait EqProduct4[A, B, C, D] extends Eq[(A, B, C, D)]

  84. trait EqProduct5[A, B, C, D, E] extends Eq[(A, B, C, D, E)]

  85. trait EqProduct6[A, B, C, D, E, F] extends Eq[(A, B, C, D, E, F)]

  86. trait EqProduct7[A, B, C, D, E, F, G] extends Eq[(A, B, C, D, E, F, G)]

  87. trait EqProduct8[A, B, C, D, E, F, G, H] extends Eq[(A, B, C, D, E, F, G, H)]

  88. trait EqProduct9[A, B, C, D, E, F, G, H, I] extends Eq[(A, B, C, D, E, F, G, H, I)]

  89. trait EqProductImplicits extends AnyRef

  90. class EuLiterals extends AnyRef

  91. case class EuclideanRational[A](n: A, d: A)(implicit f: EuclideanRing[A]) extends Product with Serializable

  92. final class FloatComplex extends AnyVal

    Value class which encodes two floating point values in a Long.

  93. trait FloatEq extends Eq[Float]

  94. trait FloatIsFractional extends Fractional[Float] with FloatIsField with FloatIsNRoot with ConvertableFromFloat with ConvertableToFloat with FloatOrder with FloatIsSigned

  95. trait FloatIsNumeric extends Numeric[Float] with FloatIsField with FloatIsNRoot with ConvertableFromFloat with ConvertableToFloat with FloatOrder with FloatIsSigned

  96. trait FloatIsTrig extends Trig[Float]

  97. trait FloatOrder extends Order[Float] with FloatEq

  98. trait Fraction[A] extends AnyRef

  99. trait Fractional[A] extends Field[A] with NRoot[A] with Integral[A]

  100. final case class Gaussian[T](real: T, imag: T)(implicit f: Integral[T]) extends ScalaNumber with ScalaNumericConversions with Serializable with Product

  101. trait GaussianEq[A] extends Eq[Gaussian[A]]

  102. class GaussianIsNumeric[A] extends Numeric[Gaussian[A]] with NRoot[Gaussian[A]] with Order[Gaussian[A]] with GaussianIsSigned[A] with GaussianIsEuclideanRing[A] with GaussianEq[A] with ConvertableFromGaussian[A] with ConvertableToGaussian[A]

  103. trait HighBranchingMedianOf5 extends AnyRef

  104. trait IntEq extends Eq[Int]

  105. trait IntIsIntegral extends Integral[Int] with IntIsEuclideanRing with ConvertableFromInt with ConvertableToInt with IntOrder with IntIsSigned

  106. trait IntIsNumeric extends Numeric[Int] with IntIsEuclideanRing with IntIsNRoot with ConvertableFromInt with ConvertableToInt with IntOrder with IntIsSigned

  107. trait IntOrder extends Order[Int] with IntEq

  108. trait Integral[A] extends EuclideanRing[A] with ConvertableFrom[A] with ConvertableTo[A] with Order[A] with Signed[A]

  109. case class Interval[T](lower: Lower[T], upper: Upper[T])(implicit order: Order[T]) extends Product with Serializable

    Interval represents a set of values, usually numbers.

  110. case class InvalidNumber(msg: String) extends Exception with Product with Serializable

  111. class Literals extends AnyRef

  112. trait LongEq extends Eq[Long]

  113. trait LongIsIntegral extends Integral[Long] with LongIsEuclideanRing with ConvertableFromLong with ConvertableToLong with LongOrder with LongIsSigned

  114. trait LongIsNumeric extends Numeric[Long] with LongIsEuclideanRing with LongIsNRoot with ConvertableFromLong with ConvertableToLong with LongOrder with LongIsSigned

  115. trait LongOrder extends Order[Long] with LongEq

  116. sealed trait Lower[T] extends Bound[T]

    Lower represents a Bound which is a lower bound.

  117. trait MapEq[K, V] extends Eq[Map[K, V]]

  118. trait MapVectorEq[K, V] extends Eq[Map[K, V]]

  119. class MappedEq[A, B] extends Eq[A]

  120. class MappedOrder[A, B] extends Order[A]

  121. trait MutatingMedianOf5 extends AnyRef

  122. trait NarrowingConversion[A, B] extends Conversion[A, B]

    A narrowing conversion is one that may cause some information loss.

  123. trait NarrowingConversionLow extends AnyRef

  124. sealed trait Natural extends AnyRef

  125. trait NaturalEq extends Eq[Natural]

  126. trait NaturalOrder extends Order[Natural] with NaturalEq

  127. sealed trait Number extends ScalaNumber with ScalaNumericConversions

  128. trait NumberEq extends Eq[Number]

  129. trait NumberIsFractional extends Fractional[Number] with NumberIsField with NumberIsNRoot with ConvertableFromNumber with ConvertableToNumber with NumberOrder with NumberIsSigned

  130. trait NumberIsTrig extends Trig[Number]

  131. trait NumberOrder extends Order[Number] with NumberEq

  132. case class NumberOutOfRange(msg: String) extends Exception with Product with Serializable

  133. trait Numeric[A] extends Field[A] with NRoot[A] with ConvertableFrom[A] with ConvertableTo[A] with Order[A] with Signed[A]

    TODO 3.

  134. sealed trait Open[T] extends AnyRef

    Open is a open bound (the interval does not contain this limit).

  135. final case class OpenAbove[T](x: T)(implicit order: Order[T]) extends Upper[T] with Open[T] with Product with Serializable

    OpenAbove is an open upper bound, e.

  136. final case class OpenBelow[T](x: T)(implicit order: Order[T]) extends Lower[T] with Open[T] with Product with Serializable

    OpenBelow is an open lower bound, e.

  137. trait OptionEq[A] extends Eq[Option[A]]

  138. trait Order[A] extends Eq[A]

  139. trait Order0 extends AnyRef

  140. trait Order1 extends Order0

  141. final class OrderOps[A] extends AnyRef

  142. trait OrderProduct10[A, B, C, D, E, F, G, H, I, J] extends Order[(A, B, C, D, E, F, G, H, I, J)] with EqProduct10[A, B, C, D, E, F, G, H, I, J]

  143. trait OrderProduct11[A, B, C, D, E, F, G, H, I, J, K] extends Order[(A, B, C, D, E, F, G, H, I, J, K)] with EqProduct11[A, B, C, D, E, F, G, H, I, J, K]

  144. trait OrderProduct12[A, B, C, D, E, F, G, H, I, J, K, L] extends Order[(A, B, C, D, E, F, G, H, I, J, K, L)] with EqProduct12[A, B, C, D, E, F, G, H, I, J, K, L]

  145. trait OrderProduct13[A, B, C, D, E, F, G, H, I, J, K, L, M] extends Order[(A, B, C, D, E, F, G, H, I, J, K, L, M)] with EqProduct13[A, B, C, D, E, F, G, H, I, J, K, L, M]

  146. trait OrderProduct14[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends Order[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] with EqProduct14[A, B, C, D, E, F, G, H, I, J, K, L, M, N]

  147. trait OrderProduct15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends Order[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] with EqProduct15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]

  148. trait OrderProduct16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends Order[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] with EqProduct16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]

  149. trait OrderProduct17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends Order[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] with EqProduct17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q]

  150. trait OrderProduct18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends Order[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] with EqProduct18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R]

  151. trait OrderProduct19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends Order[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] with EqProduct19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]

  152. trait OrderProduct2[A, B] extends Order[(A, B)] with EqProduct2[A, B]

  153. trait OrderProduct20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends Order[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] with EqProduct20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T]

  154. trait OrderProduct21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends Order[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] with EqProduct21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U]

  155. trait OrderProduct22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends Order[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] with EqProduct22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V]

  156. trait OrderProduct3[A, B, C] extends Order[(A, B, C)] with EqProduct3[A, B, C]

  157. trait OrderProduct4[A, B, C, D] extends Order[(A, B, C, D)] with EqProduct4[A, B, C, D]

  158. trait OrderProduct5[A, B, C, D, E] extends Order[(A, B, C, D, E)] with EqProduct5[A, B, C, D, E]

  159. trait OrderProduct6[A, B, C, D, E, F] extends Order[(A, B, C, D, E, F)] with EqProduct6[A, B, C, D, E, F]

  160. trait OrderProduct7[A, B, C, D, E, F, G] extends Order[(A, B, C, D, E, F, G)] with EqProduct7[A, B, C, D, E, F, G]

  161. trait OrderProduct8[A, B, C, D, E, F, G, H] extends Order[(A, B, C, D, E, F, G, H)] with EqProduct8[A, B, C, D, E, F, G, H]

  162. trait OrderProduct9[A, B, C, D, E, F, G, H, I] extends Order[(A, B, C, D, E, F, G, H, I)] with EqProduct9[A, B, C, D, E, F, G, H, I]

  163. trait OrderProductImplicits extends AnyRef

  164. class Radix extends AnyRef

  165. sealed abstract class Rational extends ScalaNumber with ScalaNumericConversions with Ordered[Rational]

  166. trait RationalEq extends Eq[Rational]

  167. trait RationalIsFractional extends Fractional[Rational] with RationalIsField with RationalIsNRoot with ConvertableFromRational with ConvertableToRational with RationalOrder with RationalIsSigned

  168. trait RationalIsNumeric extends Numeric[Rational] with RationalIsField with RationalIsNRoot with ConvertableFromRational with ConvertableToRational with RationalOrder with RationalIsSigned

  169. trait RationalOrder extends Order[Rational] with RationalEq

  170. abstract class Rationals[A] extends AnyRef

    Attributes
    protected

  171. final class Real extends ScalaNumber with ScalaNumericConversions with RealLike[Real] with BMFSSBound[Real] with BigDecimalApprox[Real] with FPFilter[Real] with ConstantFolder[Real] with BubbleUpDivs[Real] with PrettyToString[Real] with Ordered[Real]

    An general Real type.

  172. trait RealEq extends Eq[Real]

  173. trait RealIsFractional extends Fractional[Real] with RealIsField with RealIsNRoot with ConvertableFromReal with ConvertableToReal with RealOrder with RealIsSigned

  174. trait RealIsNumeric extends Numeric[Real] with RealIsField with RealIsNRoot with ConvertableFromReal with ConvertableToReal with RealOrder with RealIsSigned

  175. trait RealOrder extends Order[Real] with RealEq

  176. class ReversedOrder[A] extends Order[A]

  177. sealed trait SafeLong extends ScalaNumber with ScalaNumericConversions with Ordered[SafeLong]

    Provides a type to do safe long arithmetic.

  178. case class SafeLongBigInt extends ScalaNumber with SafeLong with Product with Serializable

  179. trait SafeLongEq extends Eq[SafeLong]

  180. trait SafeLongIsIntegral extends Integral[SafeLong] with SafeLongIsEuclideanRing with ConvertableFromSafeLong with ConvertableToSafeLong with SafeLongOrder with SafeLongIsSigned

  181. case class SafeLongLong extends ScalaNumber with SafeLong with Product with Serializable

  182. trait SafeLongOrder extends Order[SafeLong] with SafeLongEq

  183. trait ScalaEquivWrapper[A] extends Equiv[A]

  184. trait ScalaFractionalWrapper[A] extends ScalaNumericWrapper[A] with scala.math.Fractional[A]

  185. trait ScalaIntegralWrapper[A] extends ScalaNumericWrapper[A] with scala.math.Integral[A]

  186. trait ScalaNumericWrapper[A] extends scala.math.Numeric[A] with ScalaOrderingWrapper[A]

  187. trait ScalaOrderingWrapper[A] extends Ordering[A]

  188. trait Select extends AnyRef

  189. trait SelectLike extends Select

    Given a function for finding approximate medians, this will create an exact median finder.

  190. trait SeqEq[A, SA <: SeqLike[A, SA]] extends Eq[SA]

  191. trait SeqOrder[A, SA <: SeqLike[A, SA]] extends SeqEq[A, SA] with Order[SA]

  192. trait SeqVectorEq[A, SA <: SeqLike[A, SA]] extends Eq[SA]

  193. trait SeqVectorOrder[A, SA <: SeqLike[A, SA]] extends SeqVectorEq[A, SA] with Order[SA]

  194. trait ShortEq extends Eq[Short]

  195. trait ShortOrder extends Order[Short] with ShortEq

  196. class SiLiterals extends AnyRef

  197. trait Sort extends AnyRef

    Interface for a sorting strategy object.

  198. trait StringEq extends Eq[String]

  199. trait Trig[A] extends AnyRef

  200. final class UByte extends AnyVal

  201. trait UByteEq extends Eq[UByte]

  202. trait UByteOrder extends Order[UByte] with UByteEq

  203. final class UInt extends AnyVal

  204. trait UIntEq extends Eq[UInt]

  205. trait UIntOrder extends Order[UInt] with UIntEq

  206. final class ULong extends AnyVal

  207. trait ULongEq extends Eq[ULong]

  208. trait ULongOrder extends Order[ULong] with ULongEq

  209. final class UShort extends AnyVal

  210. trait UShortEq extends Eq[UShort]

  211. trait UShortOrder extends Order[UShort] with UShortEq

  212. sealed trait Unbound[T] extends Bound[T]

    Unbound represents a boundary which does not limit its "side" of the interval, i.

  213. final case class UnboundAbove[T]()(implicit order: Order[T]) extends Upper[T] with Unbound[T] with Product with Serializable

    UnboundAbove represents an unrestrainted upper bound (i.

  214. final case class UnboundBelow[T]()(implicit order: Order[T]) extends Lower[T] with Unbound[T] with Product with Serializable

    UnboundBelow represents an unrestrainted lower bound (i.

  215. sealed trait Upper[T] extends Bound[T]

    Upper represents a Bound which is an upper bound.

  216. class UsLiterals extends AnyRef

  217. trait WideningConversion[A, B] extends Conversion[A, B]

    A widening conversion is one which does not cause any information lost.

  218. trait WideningConversionLow extends AnyRef

Value Members

  1. object Approximation

  2. object ApproximationContext extends Serializable

  3. object BigDecimalIsTrig

  4. object BigRationals extends Rationals[BigInt]

  5. object Complex extends Serializable

  6. object Conversion

  7. object ConvertableFrom

  8. object ConvertableTo

  9. object Eq extends Eq1 with EqProductImplicits

  10. object EuclideanRational extends Serializable

  11. object FastComplex

    FastComplex is an ugly, beautiful hack.

  12. object FloatComplex

  13. object Fractional

  14. object Gaussian extends Serializable

  15. object InsertionSort extends Sort

    Simple implementation of insertion sort.

  16. object Integral

  17. object Interval extends Serializable

  18. object LinearSelect extends SelectLike with HighBranchingMedianOf5

  19. object LongRationals extends Rationals[Long]

  20. object MergeSort extends Sort

    In-place merge sort implementation.

  21. object NarrowingConversion extends NarrowingConversionLow

  22. object Natural

  23. object Number extends Serializable

    Convenient apply and implicits for Numbers

  24. object Numeric

  25. object Order extends Order1 with OrderProductImplicits

  26. object QuickSelect extends SelectLike with HighBranchingMedianOf5

  27. object QuickSort

    In-place quicksort implementation.

  28. object Rational extends Serializable

  29. object Real extends Serializable

  30. object SafeLong extends Serializable

  31. object Selection

  32. object Sorting

    Object providing in-place sorting capability for arrays.

  33. object Trig

  34. object UByte

  35. object UInt

  36. object ULong

  37. object UShort

  38. object WideningConversion extends WideningConversionLow

  39. final def _pow(t: Long, b: Long, e: Long): Long

    Annotations
    @tailrec()

  40. object compat extends LowViz3

  41. final def exp(n: BigDecimal): BigDecimal

  42. final def exp(n: Double): Double

    exp() implementations

  43. package fpf

  44. final def gcd(a: BigInteger, b: BigInteger): BigInteger

  45. final def gcd(a: BigInt, b: BigInt): BigInt

  46. def gcd(_x: Long, _y: Long): Long

  47. final def log(n: BigDecimal): BigDecimal

  48. final def log(n: Double): Double

    log() implementations

  49. final def max[A](x: A, y: A)(implicit ev: Order[A]): A

  50. final def max(x: Double, y: Double): Double

    Annotations
    @inline()

  51. final def max(x: Float, y: Float): Float

    Annotations
    @inline()

  52. final def max(x: Long, y: Long): Long

    Annotations
    @inline()

  53. final def max(x: Int, y: Int): Int

    Annotations
    @inline()

  54. final def min[A](x: A, y: A)(implicit ev: Order[A]): A

  55. final def min(x: Double, y: Double): Double

    Annotations
    @inline()

  56. final def min(x: Float, y: Float): Float

    Annotations
    @inline()

  57. final def min(x: Long, y: Long): Long

    Annotations
    @inline()

  58. final def min(x: Int, y: Int): Int

    Annotations
    @inline()

  59. final def pow(base: Double, exponent: Double): Double

  60. final def pow(base: Long, ex: Long): Long

    Exponentiation function, e.

    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).

  61. final def pow(base: BigDecimal, ex: BigDecimal): BigDecimal

  62. package real

  63. def round(a: Double): Double

  64. def round(a: Float): Float

Inherited from AnyRef

Inherited from Any

Ungrouped