org.saddle

Type Members

trait Buffer[T] extends AnyRef

Buffer provides a mutable data structure specialized on several primitive types.
type CLM[C] = ClassManifest[C]

Shorthand for class manifest typeclass
Shorthand for class manifest typeclass

Definition Classes
package
class Frame[RX, CX, T] extends NumericOps[Frame[RX, CX, T]] with Serializable

Frame is an immutable container for 2D data which is indexed along both axes (rows, columns) by associated keys (i.
trait Index[T] extends Serializable

Index provides a constant-time look-up of a value within array-backed storage, as well as operations to support joining and slicing.
trait Mat[A] extends NumericOps[Mat[A]] with Serializable

Mat is an immutable container for 2D homogeneous data (a "matrix").
type NUM[C] = Numeric[C]

Shorthand for numeric typeclass
Shorthand for numeric typeclass

Definition Classes
package
type ORD[C] = Ordering[C]

Shorthand for ordering typeclass
Shorthand for ordering typeclass

Definition Classes
package
type ST[C] = ScalarTag[C]

Shorthand for scalar tag typeclass
Shorthand for scalar tag typeclass

Definition Classes
package
class Series[X, T] extends NumericOps[Series[X, T]] with Serializable

Series is an immutable container for 1D homogeneous data which is indexed by a an associated sequence of keys.
trait Vec[T] extends NumericOps[Vec[T]] with Serializable

Vec is an immutable container for 1D homogeneous data (a "vector").

Value Members

def *: SliceAll

Syntactic sugar, placeholder for 'slice-all'
Syntactic sugar, placeholder for 'slice-all'
```
  val v = Vec(1,2,3, 4)
  val u = v(*)
```
Definition Classes
package
object Buffer extends AnyRef
object Frame extends BinOpFrame with Serializable
object Index extends Serializable
object Mat extends BinOpMat with Serializable
object Panel extends AnyRef

Convenience constructors for a Frame[RX, CX, Any] that accept arbitrarily-typed Vectors and Series as constructor parameters, leaving their internal representations unchanged.
object Series extends BinOpSeries with Serializable
val UTF8: String

Constant used in string byte-level manipulation
Constant used in string byte-level manipulation

Definition Classes
package
object Vec extends BinOpVec with VecStatsImplicits with VecBoolEnricher with Serializable
package array

This package contains utilities for working with arrays that are specialized for numeric types.
package buffer
def clock[T](op: ⇒ T): (Double, T)

Allow timing of an operation
Allow timing of an operation
```
  clock { bigMat.T dot bigMat }
```
Definition Classes
package
package groupby
package index
package io
package locator
package mat
object na extends AnyRef

na provides syntactic sugar for constructing primitives recognized as NA.
package ops

Provides type aliases for a few basic operations
implicit def pair2Slice[T](p: (T, T)): SliceDefault[T]

Syntactic sugar, allow '->' to generate an (inclusive) index slice
Syntactic sugar, allow '->' to generate an (inclusive) index slice
```
  val v = Vec(1,2,3,4)
  val u = v(0 -> 2)
```
Definition Classes
package
implicit def pair2SliceFrom[T](p: (T, SliceAll)): SliceFrom[T]

Syntactic sugar, allow ' -> *' to generate an (inclusive) index slice, open on right
Syntactic sugar, allow ' -> *' to generate an (inclusive) index slice, open on right
```
  val v = Vec(1,2,3,4)
  val u = v(1 -> *)
```
Definition Classes
package
implicit def pair2SliceSingle[T](k: T): SliceDefault[T]

Provides for one-element slicing, e.
Provides for one-element slicing, e.g.
```
  val v = Vec(1,2,3, 4)
  val u = v(1)
```
Definition Classes
package
implicit def pair2SliceTo[T](p: (SliceAll, T)): SliceTo[T]

Syntactic sugar, allow '* -> ' to generate an (inclusive) index slice, open on left
Syntactic sugar, allow '* -> ' to generate an (inclusive) index slice, open on left
```
  val v = Vec(1,2,3,4)
  val u = v(* -> 2)
```
Definition Classes
package
package scalar
implicit def seqToFrame[RX, CX, T](s: Seq[(RX, CX, T)])(implicit arg0: ST[RX], arg1: ORD[RX], arg2: ST[CX], arg3: ORD[CX], arg4: ST[T]): AnyRef { def toFrame: org.saddle.Frame[RX,CX,T] }

Augments Seq with a toFrame method that returns a new Frame instance.
Augments Seq with a toFrame method that returns a new Frame instance.
For example,
```
  val t = IndexedSeq(("a", "x", 3), ("b", "y", 4))
  val f = t.toFrame

  res0: org.saddle.Frame[java.lang.String,java.lang.String,Int] =
  [2 x 2]
        x  y
       -- --
  a ->  3 NA
  b -> NA  4
```
RX
Type of row index elements of Frame
CX
Type of col index elements of Frame
T
Type of data elements of Frame
s
A value of type Seq[(RX, CX, T)]

Definition Classes
package
implicit def seqToIndex[X](ix: Seq[X])(implicit arg0: ST[X], arg1: ORD[X]): AnyRef { def toIndex: org.saddle.Index[X] }

Augments Seq with a toIndex method that returns a new Index instance.
Augments Seq with a toIndex method that returns a new Index instance.
For example,
```
  val i = IndexedSeq(1,2,3)
  val s = i.toIndex
```
X
Type of index elements
ix
A value of type Seq[X]

Definition Classes
package
implicit def seqToSeries[T, X](s: Seq[(X, T)])(implicit arg0: ST[T], arg1: ST[X], arg2: ORD[X]): AnyRef { def toSeries: org.saddle.Series[X,T] }

Augments Seq with a toSeries method that returns a new Series instance.
Augments Seq with a toSeries method that returns a new Series instance.
For example,
```
  val p = IndexedSeq(1,2,3) zip IndexedSeq(4,5,6)
  val s = p.toSeries
```
T
Type of data elements of Series
X
Type of index elements of Series
s
A value of type Seq[(X, T)]

Definition Classes
package
implicit def seqToVec[T](s: Seq[T])(implicit arg0: ST[T]): AnyRef { def toVec: org.saddle.Vec[T] }

Augments Seq with a toVec method that returns a new Vec instance.
Augments Seq with a toVec method that returns a new Vec instance.
For example,
```
  val s = IndexedSeq(1,2,3)
  val v = s.toVec
```
T
Type of elements of Vec
s
A value of type Seq[T]

Definition Classes
package
package stats
package time

Functionality to assist in TimeSeries related operations
package util

Additional utilities that need a home
package vec

Factory methods to generate Vec instances

saddle

package saddle

Saddle

Type Members

trait Buffer[T] extends AnyRef

type CLM[C] = ClassManifest[C]

class Frame[RX, CX, T] extends NumericOps[Frame[RX, CX, T]] with Serializable

trait Index[T] extends Serializable

trait Mat[A] extends NumericOps[Mat[A]] with Serializable

type NUM[C] = Numeric[C]

type ORD[C] = Ordering[C]

type ST[C] = ScalarTag[C]

class Series[X, T] extends NumericOps[Series[X, T]] with Serializable

trait Vec[T] extends NumericOps[Vec[T]] with Serializable

Value Members

def *: SliceAll

object Buffer extends AnyRef

object Frame extends BinOpFrame with Serializable

object Index extends Serializable

object Mat extends BinOpMat with Serializable

object Panel extends AnyRef

object Series extends BinOpSeries with Serializable

val UTF8: String

object Vec extends BinOpVec with VecStatsImplicits with VecBoolEnricher with Serializable

package array

package buffer

def clock[T](op: ⇒ T): (Double, T)

package groupby

package index

package io

package locator

package mat

object na extends AnyRef

package ops

implicit def pair2Slice[T](p: (T, T)): SliceDefault[T]

implicit def pair2SliceFrom[T](p: (T, SliceAll)): SliceFrom[T]

implicit def pair2SliceSingle[T](k: T): SliceDefault[T]

implicit def pair2SliceTo[T](p: (SliceAll, T)): SliceTo[T]

package scalar

implicit def seqToFrame[RX, CX, T](s: Seq[(RX, CX, T)])(implicit arg0: ST[RX], arg1: ORD[RX], arg2: ST[CX], arg3: ORD[CX], arg4: ST[T]): AnyRef { def toFrame: org.saddle.Frame[RX,CX,T] }

implicit def seqToIndex[X](ix: Seq[X])(implicit arg0: ST[X], arg1: ORD[X]): AnyRef { def toIndex: org.saddle.Index[X] }

implicit def seqToSeries[T, X](s: Seq[(X, T)])(implicit arg0: ST[T], arg1: ST[X], arg2: ORD[X]): AnyRef { def toSeries: org.saddle.Series[X,T] }

implicit def seqToVec[T](s: Seq[T])(implicit arg0: ST[T]): AnyRef { def toVec: org.saddle.Vec[T] }

package stats

package time

package util

package vec