Frame

object Frame extends BinOpFrame
Companion:
class
class Object
trait Matchable
class Any
Frame.type

Type members

Inherited classlikes

final class FrFrEOp[OP <: ScalarOp, X, Y, A, B, C](opv: BinOp[OP, Vec[A], Vec[B], Vec[C]])(implicit evidence$2: ScalarTag[X], evidence$3: Order[X], evidence$4: ScalarTag[Y], evidence$5: Order[Y], evidence$6: ScalarTag[B], evidence$7: ScalarTag[C]) extends BinOp[OP, Frame[X, Y, A], Frame[X, Y, B], Frame[X, Y, C]]
Inherited from:
BinOpFrame
final class FrScEOp[OP <: ScalarOp, X, Y, A, B, C](opv: BinOp[OP, Vec[A], B, Vec[C]])(implicit evidence$1: ScalarTag[C]) extends BinOp[OP, Frame[X, Y, A], B, Frame[X, Y, C]]
Inherited from:
BinOpFrame

Value members

Concrete methods

def apply[@specialized(Int, Long, Double) T : ScalarTag](values: Vec[T]*): Frame[Int, Int, T]

Factory method to create a Frame from a sequence of Vec objects

Factory method to create a Frame from a sequence of Vec objects

def apply[RX : ScalarTag, CX : ScalarTag, @specialized(Int, Long, Double) T : ScalarTag](values: Seq[Vec[T]], rowIx: Index[RX], colIx: Index[CX]): Frame[RX, CX, T]

Factory method to create a Frame from a sequence of Vec objects, a row index, and a column index.

Factory method to create a Frame from a sequence of Vec objects, a row index, and a column index.

def apply[RX : ScalarTag, CX : Order, @specialized(Int, Long, Double) T : ScalarTag](values: Vec[Vec[T]], rowIx: Index[RX], colIx: Index[CX]): Frame[RX, CX, T]
def apply[CX : Order, @specialized(Int, Long, Double) T : ScalarTag](values: Seq[Vec[T]], colIx: Index[CX]): Frame[Int, CX, T]

Factory method to create a Frame from a sequence of Vec objects and a column index.

Factory method to create a Frame from a sequence of Vec objects and a column index.

def apply[CX : Order, @specialized(Int, Long, Double) T : ScalarTag](values: (CX, Vec[T])*): Frame[Int, CX, T]

Factory method to create a Frame from tuples whose first element is the column label and the second is a Vec of values.

Factory method to create a Frame from tuples whose first element is the column label and the second is a Vec of values.

@nowarn
def apply[RX : Order, T : ([T] =>> T => T)](values: Series[RX, T]*): Frame[RX, Int, T]

Factory method to create a Frame from a sequence of Series. The row labels of the result are the outer join of the indexes of the series provided.

Factory method to create a Frame from a sequence of Series. The row labels of the result are the outer join of the indexes of the series provided.

This method repeatedly joins the rows indices. Mind the combinatorial semantics of joins, if the indices contain duplicates, the resulting Frame can grow quickly. An alternative is Frame.fromCols.

def apply[RX : Order, CX : Order, T : ScalarTag](values: Seq[Series[RX, T]], colIx: Index[CX]): Frame[RX, CX, T]

Factory method to create a Frame from a sequence of series, also specifying the column index to use. The row labels of the result are the outer join of the indexes of the series provided.

Factory method to create a Frame from a sequence of series, also specifying the column index to use. The row labels of the result are the outer join of the indexes of the series provided.

This method repeatedly joins the rows indices. Mind the combinatorial semantics of joins, if the indices contain duplicates, the resulting Frame can grow quickly. An alternative is Frame.fromCols.

def apply[RX : ScalarTag, CX : ScalarTag, T : ScalarTag](values: (CX, Series[RX, T])*): Frame[RX, CX, T]

Factory method to create a Frame from a sequence of tuples, where the first element of the tuple is a column label, and the second a series of values. The row labels of the result are the outer join of the indexes of the series provided.

Factory method to create a Frame from a sequence of tuples, where the first element of the tuple is a column label, and the second a series of values. The row labels of the result are the outer join of the indexes of the series provided.

This method repeatedly joins the rows indices. Mind the combinatorial semantics of joins, if the indices contain duplicates, the resulting Frame can grow quickly. An alternative is Frame.fromCols.

def apply[T : ScalarTag](values: Mat[T]): Frame[Int, Int, T]

Build a Frame from a provided Mat

Build a Frame from a provided Mat

def apply[RX : ScalarTag, CX : ScalarTag, T : ScalarTag](mat: Mat[T], rowIx: Index[RX], colIx: Index[CX]): Frame[RX, CX, T]

Build a Frame from a provided Mat, row index, and col index

Build a Frame from a provided Mat, row index, and col index

def empty[RX : Order, CX : ScalarTag, @specialized(Int, Long, Double) T : ScalarTag]: Frame[RX, CX, T]

Factory method to create an empty Frame

Factory method to create an empty Frame

Type parameters:
CX

Type of col keys

RX

Type of row keys

T

Type of values

@nowarn
def fromCols[RX : Order, T : ScalarTag](values: Series[RX, T]*): Frame[RX, Int, T]

Factory method to create a Frame from a sequence of Series. The row labels of the result are the outer join of the indexes of the series provided.

Factory method to create a Frame from a sequence of Series. The row labels of the result are the outer join of the indexes of the series provided.

Row indices are disambiguated before the join via the Index.makeUnique method which turns each row index into a unique index resolving ties.

This methods avoids a combinatorial increase in the resulting row count in case of duplicate elements in the row indices, however the join of rows with the same index is arbitrary. Alternatively see Frame.apply .

def fromCols[RX : ScalarTag, CX : ScalarTag, T : ScalarTag](values: Seq[Series[RX, T]], colIx: Index[CX]): Frame[RX, CX, T]

Factory method to create a Frame from a sequence of series, also specifying the column index to use. The row labels of the result are the outer join of the indexes of the series provided.

Factory method to create a Frame from a sequence of series, also specifying the column index to use. The row labels of the result are the outer join of the indexes of the series provided.

Row indices are disambiguated before the join via the Index.makeUnique method which turns each row index into a unique index resolving ties.

This methods avoids a combinatorial increase in the resulting row count in case of duplicate elements in the row indices, however the join of rows with the same index is arbitrary. Alternatively see Frame.apply .

def fromCols[RX : Order, CX : ScalarTag, T : ScalarTag](values: (CX, Series[RX, T])*): Frame[RX, CX, T]

Factory method to create a Frame from a sequence of tuples, where the first element of the tuple is a column label, and the second a series of values. The row labels of the result are the outer join of the indexes of the series provided.

Factory method to create a Frame from a sequence of tuples, where the first element of the tuple is a column label, and the second a series of values. The row labels of the result are the outer join of the indexes of the series provided.

Row indices are disambiguated before the join via the Index.makeUnique method which turns each row index into a unique index resolving ties.

This methods avoids a combinatorial increase in the resulting row count in case of duplicate elements in the row indices, however the join of rows with the same index is arbitrary. Alternatively see Frame.apply .

def table[RX : Order, CX : Order](values: Vec[(RX, CX)]): Frame[RX, CX, Int]

Implicits

Inherited implicits

implicit def FrFrEOpBBB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Boolean], Vec[Boolean], Vec[Boolean]]): FrFrEOp[Op, X, Y, Boolean, Boolean, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpDDB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Double], Vec[Double], Vec[Boolean]]): FrFrEOp[Op, X, Y, Double, Double, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpDDD[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Double], Vec[Double], Vec[Double]]): FrFrEOp[Op, X, Y, Double, Double, Double]
Inherited from:
BinOpFrame
implicit def FrFrEOpDIB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Double], Vec[Int], Vec[Boolean]]): FrFrEOp[Op, X, Y, Double, Int, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpDID[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Double], Vec[Int], Vec[Double]]): FrFrEOp[Op, X, Y, Double, Int, Double]
Inherited from:
BinOpFrame
implicit def FrFrEOpDLB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Double], Vec[Long], Vec[Boolean]]): FrFrEOp[Op, X, Y, Double, Long, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpDLD[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Double], Vec[Long], Vec[Double]]): FrFrEOp[Op, X, Y, Double, Long, Double]
Inherited from:
BinOpFrame
implicit def FrFrEOpIDB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Int], Vec[Double], Vec[Boolean]]): FrFrEOp[Op, X, Y, Int, Double, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpIDD[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Int], Vec[Double], Vec[Double]]): FrFrEOp[Op, X, Y, Int, Double, Double]
Inherited from:
BinOpFrame
implicit def FrFrEOpIIB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Int], Vec[Int], Vec[Boolean]]): FrFrEOp[Op, X, Y, Int, Int, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpIII[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Int], Vec[Int], Vec[Int]]): FrFrEOp[Op, X, Y, Int, Int, Int]
Inherited from:
BinOpFrame
implicit def FrFrEOpILB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Int], Vec[Long], Vec[Boolean]]): FrFrEOp[Op, X, Y, Int, Long, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpILL[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Int], Vec[Long], Vec[Long]]): FrFrEOp[Op, X, Y, Int, Long, Long]
Inherited from:
BinOpFrame
implicit def FrFrEOpLDB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Long], Vec[Double], Vec[Boolean]]): FrFrEOp[Op, X, Y, Long, Double, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpLDD[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Long], Vec[Double], Vec[Double]]): FrFrEOp[Op, X, Y, Long, Double, Double]
Inherited from:
BinOpFrame
implicit def FrFrEOpLIB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Long], Vec[Int], Vec[Boolean]]): FrFrEOp[Op, X, Y, Long, Int, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpLIL[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Long], Vec[Int], Vec[Long]]): FrFrEOp[Op, X, Y, Long, Int, Long]
Inherited from:
BinOpFrame
implicit def FrFrEOpLLB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Long], Vec[Long], Vec[Boolean]]): FrFrEOp[Op, X, Y, Long, Long, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpLLL[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Long], Vec[Long], Vec[Long]]): FrFrEOp[Op, X, Y, Long, Long, Long]
Inherited from:
BinOpFrame
implicit def FrScEOpBBB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Boolean], Boolean, Vec[Boolean]]): FrScEOp[Op, X, Y, Boolean, Boolean, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpDDB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Double, Vec[Boolean]]): FrScEOp[Op, X, Y, Double, Double, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpDDD[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Double, Vec[Double]]): FrScEOp[Op, X, Y, Double, Double, Double]
Inherited from:
BinOpFrame
implicit def FrScEOpDIB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Int, Vec[Boolean]]): FrScEOp[Op, X, Y, Double, Int, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpDID[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Int, Vec[Double]]): FrScEOp[Op, X, Y, Double, Int, Double]
Inherited from:
BinOpFrame
implicit def FrScEOpDLB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Long, Vec[Boolean]]): FrScEOp[Op, X, Y, Double, Long, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpDLD[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Long, Vec[Double]]): FrScEOp[Op, X, Y, Double, Long, Double]
Inherited from:
BinOpFrame
implicit def FrScEOpIDB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Double, Vec[Boolean]]): FrScEOp[Op, X, Y, Int, Double, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpIDD[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Double, Vec[Double]]): FrScEOp[Op, X, Y, Int, Double, Double]
Inherited from:
BinOpFrame
implicit def FrScEOpIIB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Int, Vec[Boolean]]): FrScEOp[Op, X, Y, Int, Int, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpIII[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Int, Vec[Int]]): FrScEOp[Op, X, Y, Int, Int, Int]
Inherited from:
BinOpFrame
implicit def FrScEOpILB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Long, Vec[Boolean]]): FrScEOp[Op, X, Y, Int, Long, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpILL[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Long, Vec[Long]]): FrScEOp[Op, X, Y, Int, Long, Long]
Inherited from:
BinOpFrame
implicit def FrScEOpLDB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Double, Vec[Boolean]]): FrScEOp[Op, X, Y, Long, Double, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpLDD[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Double, Vec[Double]]): FrScEOp[Op, X, Y, Long, Double, Double]
Inherited from:
BinOpFrame
implicit def FrScEOpLIB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Int, Vec[Boolean]]): FrScEOp[Op, X, Y, Long, Int, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpLIL[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Int, Vec[Long]]): FrScEOp[Op, X, Y, Long, Int, Long]
Inherited from:
BinOpFrame
implicit def FrScEOpLLB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Long, Vec[Boolean]]): FrScEOp[Op, X, Y, Long, Long, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpLLL[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Long, Vec[Long]]): FrScEOp[Op, X, Y, Long, Long, Long]
Inherited from:
BinOpFrame