axle

Type Members

case class Combinations[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable
case class CombinationsFast[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable
case class CrossProduct[E](collections: IndexedSeq[IndexedSeq[E]]) extends Iterable[List[E]] with Product with Serializable
case class EnrichedArray[T](arr: Array[T])(implicit evidence$1: Manifest[T]) extends Product with Serializable
case class EnrichedByteArray(barr: Array[Byte]) extends Product with Serializable
case class EnrichedGenSeq[T](genSeq: GenSeq[T]) extends Product with Serializable
case class EnrichedGenTraversable[+T](gt: GenTraversable[T])(implicit evidence$1: Manifest[T]) extends Product with Serializable
case class EnrichedIndexedSeq[T](is: IndexedSeq[T])(implicit evidence$1: Manifest[T]) extends Product with Serializable
case class EnrichedInt(n: Int) extends Product with Serializable
class EnrichedIterator[T] extends AnyRef
case class EnrichedMutableBuffer[T](buffer: Buffer[T]) extends Product with Serializable
trait HtmlFrom[T] extends AnyRef

Annotations
@implicitNotFound( ... )
case class IndexedCrossProduct[E](lists: Seq[IndexedSeq[E]]) extends Iterable[Seq[E]] with Product with Serializable
case class IndexedPowerSet[E](all: IndexedSeq[E]) extends Iterable[Set[E]] with Product with Serializable

A ℘ (IndexedPowerSet) constructed with a collection with elements of type E can construct an Iterator which enumerates all possible subsets (of type Collection<E>) of the collection used to construct the PowerSet.
case class Permutations[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable

Based on Python's itertools.permutations function
Based on Python's itertools.permutations function
http://docs.python.org/library/itertools.html#itertools.permutations
Permutations("ABCD".toIndexedSeq, 2) Permutations(0 until 3)
case class PermutationsFast[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable

Value Members

object HtmlFrom
def ackermann(m: Long, n: Long): Long

http://en.wikipedia.org/wiki/Ackermann_function
package algebra
def applyForever[N](f: (N) ⇒ N, x0: N): Iterator[N]
def applyK[N](f: (N) ⇒ N, x0: N, k: Int): N
def arcCosine[N](x: N)(implicit arg0: Trig[N], converter: AngleConverter[N]): UnittedQuantity[Angle, N]
def arcSine[N](x: N)(implicit arg0: Trig[N], converter: AngleConverter[N]): UnittedQuantity[Angle, N]
def arcTangent[N](x: N)(implicit arg0: Trig[N], converter: AngleConverter[N]): UnittedQuantity[Angle, N]
def arcTangent2[N](x: N, y: N)(implicit arg0: Trig[N], converter: AngleConverter[N]): UnittedQuantity[Angle, N]
package ast
def cosine[N](a: UnittedQuantity[Angle, N])(implicit arg0: MultiplicativeMonoid[N], arg1: Eq[N], arg2: Trig[N], converter: AngleConverter[N]): N
def distanceOnSphere[N](angle: UnittedQuantity[Angle, N], sphereRadius: UnittedQuantity[Distance, N])(implicit arg0: MultiplicativeMonoid[N], angleConverter: AngleConverter[N], ctn: ConvertableTo[N], angleModule: Module[UnittedQuantity[Angle, N], N], distanceModule: Module[UnittedQuantity[Distance, N], N]): UnittedQuantity[Distance, N]
def dropOutput(s: String): Unit
implicit def enrichArray[T](arr: Array[T])(implicit arg0: Manifest[T]): EnrichedArray[T]
implicit def enrichByteArray(barr: Array[Byte]): EnrichedByteArray
implicit def enrichGenSeq[T](genSeq: GenSeq[T]): EnrichedGenSeq[T]
implicit def enrichGenTraversable[T](gt: GenTraversable[T])(implicit arg0: Manifest[T]): EnrichedGenTraversable[T]
implicit def enrichIndexedSeq[T](is: IndexedSeq[T])(implicit arg0: Manifest[T]): EnrichedIndexedSeq[T]
implicit def enrichInt(n: Int): EnrichedInt
implicit def enrichIterator[T](it: Iterator[T]): EnrichedIterator[T]
implicit def enrichMutableBuffer[T](buffer: Buffer[T]): EnrichedMutableBuffer[T]
implicit val eqSymbol: Eq[Symbol]
def exponentiateByRecursiveSquaring[B, N](base: B, pow: N)(implicit multB: MultiplicativeSemigroup[B], eucRingN: EuclideanRing[N], eqN: Eq[N]): B
def fibonacciByFold(n: Int): Int
def fibonacciRecursively(n: Int): Int
object forall
package game
def gaps[T](xs: Seq[T])(implicit ringT: Ring[T]): Seq[(T, T)]

gaps
gaps
assumes that the input xs are already sorted
def getLine(): String
def html[T](t: T)(implicit arg0: HtmlFrom[T]): Node
def id[A](x: A): A
def inMandelbrotSet[N](radius: N, R: N, I: N, maxIt: Int)(implicit rng: Rng[N], o: Order[N]): Boolean
def inMandelbrotSetAt[N](radius: N, R: N, I: N, maxIt: Int)(implicit rng: Rng[N], o: Order[N]): Option[Int]
def intersperse[T](d: T)(l: List[T]): List[T]
package logic
def logisticMap[N](λ: N)(implicit arg0: Ring[N]): (N) ⇒ N

https://en.wikipedia.org/wiki/Logistic_map
def mandelbrotContinue[N](radius: N)(implicit rng: Rng[N], o: Order[N]): ((N, N)) ⇒ Boolean
def mandelbrotNext[N](R: N, I: N)(implicit rng: Rng[N]): ((N, N)) ⇒ (N, N)

https://en.wikipedia.org/wiki/Mandelbrot_set
def monteCarloPiEstimate[F, N, V, G](trials: F, n2v: (N) ⇒ V)(implicit arg0: ConvertableTo[V], finite: Finite[F, N], functor: Functor[F, N, V, G], agg: Aggregatable[G, V, V], field: Field[V]): V

Monte Carlo approximation of pi http://en.wikipedia.org/wiki/Monte_Carlo_method
Monte Carlo approximation of pi http://en.wikipedia.org/wiki/Monte_Carlo_method
TODO get n2v implicitly?
def orbit[N](f: (N) ⇒ N, x0: N, close: (N) ⇒ (N) ⇒ Boolean): List[N]
implicit val orderSymbol: Order[Symbol]
def prefixedDisplay(prefix: String)(display: (String) ⇒ Unit): (String) ⇒ Unit
def print[T](t: T)(implicit arg0: Show[T]): Unit
package quanta
def replicate[T](n: Int)(v: T): List[T]
def reverse[T](l: List[T]): List[T]
def runs[T](xs: Seq[T])(implicit ringT: Ring[T], orderT: Order[T]): Seq[(T, T)]

runs
runs
assumes xs is already sorted
def runs[T](xs: Seq[T], breaks: Set[T]): Seq[(T, T)]
def show[T](t: T)(implicit arg0: Show[T]): String
implicit val showBD: Show[BigDecimal]
def showDoubleWithPrecision(p: Int = 6): Show[Double]
implicit val showNode: Show[Node]
implicit val showRational: Show[Rational]
def sine[N](a: UnittedQuantity[Angle, N])(implicit arg0: MultiplicativeMonoid[N], arg1: Eq[N], arg2: Trig[N], converter: AngleConverter[N]): N
def square[N](x: N)(implicit arg0: Field[N]): N
package stats
def string[T](t: T)(implicit arg0: Show[T]): String
package syntax
def tangent[N](a: UnittedQuantity[Angle, N])(implicit arg0: MultiplicativeMonoid[N], arg1: Eq[N], arg2: Trig[N], converter: AngleConverter[N]): N
object thereexists
def trace[N](f: (N) ⇒ N, x0: N): Iterator[(N, Set[N])]
def wallisΠ(iterations: Int = 10000): Rational

Englishman John Wallis (1616 - 1703) approximation of π in 1655
object ℘
val ∀: forall.type
val ∃: thereexists.type
def √[N](x: N)(implicit arg0: NRoot[N]): N

package axle

Type Members

case class Combinations[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable

case class CombinationsFast[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable

case class CrossProduct[E](collections: IndexedSeq[IndexedSeq[E]]) extends Iterable[List[E]] with Product with Serializable

case class EnrichedArray[T](arr: Array[T])(implicit evidence$1: Manifest[T]) extends Product with Serializable

case class EnrichedByteArray(barr: Array[Byte]) extends Product with Serializable

case class EnrichedGenSeq[T](genSeq: GenSeq[T]) extends Product with Serializable

case class EnrichedGenTraversable[+T](gt: GenTraversable[T])(implicit evidence$1: Manifest[T]) extends Product with Serializable

case class EnrichedIndexedSeq[T](is: IndexedSeq[T])(implicit evidence$1: Manifest[T]) extends Product with Serializable

case class EnrichedInt(n: Int) extends Product with Serializable

class EnrichedIterator[T] extends AnyRef

case class EnrichedMutableBuffer[T](buffer: Buffer[T]) extends Product with Serializable

trait HtmlFrom[T] extends AnyRef

case class IndexedCrossProduct[E](lists: Seq[IndexedSeq[E]]) extends Iterable[Seq[E]] with Product with Serializable

case class IndexedPowerSet[E](all: IndexedSeq[E]) extends Iterable[Set[E]] with Product with Serializable

case class Permutations[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable

case class PermutationsFast[E](pool: IndexedSeq[E], r: Int)(implicit evidence$1: Manifest[E]) extends Iterable[IndexedSeq[E]] with Product with Serializable

Value Members

object HtmlFrom

def ackermann(m: Long, n: Long): Long

package algebra

def applyForever[N](f: (N) ⇒ N, x0: N): Iterator[N]

def applyK[N](f: (N) ⇒ N, x0: N, k: Int): N

def arcCosine[N](x: N)(implicit arg0: Trig[N], converter: AngleConverter[N]): UnittedQuantity[Angle, N]

def arcSine[N](x: N)(implicit arg0: Trig[N], converter: AngleConverter[N]): UnittedQuantity[Angle, N]

def arcTangent[N](x: N)(implicit arg0: Trig[N], converter: AngleConverter[N]): UnittedQuantity[Angle, N]

def arcTangent2[N](x: N, y: N)(implicit arg0: Trig[N], converter: AngleConverter[N]): UnittedQuantity[Angle, N]

package ast

def cosine[N](a: UnittedQuantity[Angle, N])(implicit arg0: MultiplicativeMonoid[N], arg1: Eq[N], arg2: Trig[N], converter: AngleConverter[N]): N

def dropOutput(s: String): Unit

implicit def enrichArray[T](arr: Array[T])(implicit arg0: Manifest[T]): EnrichedArray[T]

implicit def enrichByteArray(barr: Array[Byte]): EnrichedByteArray

implicit def enrichGenSeq[T](genSeq: GenSeq[T]): EnrichedGenSeq[T]

implicit def enrichGenTraversable[T](gt: GenTraversable[T])(implicit arg0: Manifest[T]): EnrichedGenTraversable[T]

implicit def enrichIndexedSeq[T](is: IndexedSeq[T])(implicit arg0: Manifest[T]): EnrichedIndexedSeq[T]

implicit def enrichInt(n: Int): EnrichedInt

implicit def enrichIterator[T](it: Iterator[T]): EnrichedIterator[T]

implicit def enrichMutableBuffer[T](buffer: Buffer[T]): EnrichedMutableBuffer[T]

implicit val eqSymbol: Eq[Symbol]

def exponentiateByRecursiveSquaring[B, N](base: B, pow: N)(implicit multB: MultiplicativeSemigroup[B], eucRingN: EuclideanRing[N], eqN: Eq[N]): B

def fibonacciByFold(n: Int): Int

def fibonacciRecursively(n: Int): Int

object forall

package game

def gaps[T](xs: Seq[T])(implicit ringT: Ring[T]): Seq[(T, T)]

def getLine(): String

def html[T](t: T)(implicit arg0: HtmlFrom[T]): Node

def id[A](x: A): A

def inMandelbrotSet[N](radius: N, R: N, I: N, maxIt: Int)(implicit rng: Rng[N], o: Order[N]): Boolean

def inMandelbrotSetAt[N](radius: N, R: N, I: N, maxIt: Int)(implicit rng: Rng[N], o: Order[N]): Option[Int]

def intersperse[T](d: T)(l: List[T]): List[T]

package logic

def logisticMap[N](λ: N)(implicit arg0: Ring[N]): (N) ⇒ N

def mandelbrotContinue[N](radius: N)(implicit rng: Rng[N], o: Order[N]): ((N, N)) ⇒ Boolean

def mandelbrotNext[N](R: N, I: N)(implicit rng: Rng[N]): ((N, N)) ⇒ (N, N)

def monteCarloPiEstimate[F, N, V, G](trials: F, n2v: (N) ⇒ V)(implicit arg0: ConvertableTo[V], finite: Finite[F, N], functor: Functor[F, N, V, G], agg: Aggregatable[G, V, V], field: Field[V]): V

def orbit[N](f: (N) ⇒ N, x0: N, close: (N) ⇒ (N) ⇒ Boolean): List[N]

implicit val orderSymbol: Order[Symbol]

def prefixedDisplay(prefix: String)(display: (String) ⇒ Unit): (String) ⇒ Unit

def print[T](t: T)(implicit arg0: Show[T]): Unit

package quanta

def replicate[T](n: Int)(v: T): List[T]

def reverse[T](l: List[T]): List[T]

def runs[T](xs: Seq[T])(implicit ringT: Ring[T], orderT: Order[T]): Seq[(T, T)]

def runs[T](xs: Seq[T], breaks: Set[T]): Seq[(T, T)]

def show[T](t: T)(implicit arg0: Show[T]): String

implicit val showBD: Show[BigDecimal]

def showDoubleWithPrecision(p: Int = 6): Show[Double]

implicit val showNode: Show[Node]

implicit val showRational: Show[Rational]

def sine[N](a: UnittedQuantity[Angle, N])(implicit arg0: MultiplicativeMonoid[N], arg1: Eq[N], arg2: Trig[N], converter: AngleConverter[N]): N

def square[N](x: N)(implicit arg0: Field[N]): N

package stats

def string[T](t: T)(implicit arg0: Show[T]): String

package syntax

def tangent[N](a: UnittedQuantity[Angle, N])(implicit arg0: MultiplicativeMonoid[N], arg1: Eq[N], arg2: Trig[N], converter: AngleConverter[N]): N

object thereexists

def trace[N](f: (N) ⇒ N, x0: N): Iterator[(N, Set[N])]