Packages

  • package root
    Definition Classes
    root
  • package org
    Definition Classes
    root
  • package saddle

    Saddle is a Scala Data Library.

    Saddle

    Saddle is a Scala Data Library.

    Saddle provides array-backed, indexed one- and two-dimensional data structures.

    These data structures are specialized on JVM primitives. With them one can often avoid the overhead of boxing and unboxing.

    Basic operations also aim to be robust to missing values (NA's)

    The building blocks are intended to be easily composed.

    The foundational building blocks are:

    Inspiration for Saddle comes from many sources, including the R programming language, the pandas data analysis library for Python, and the Scala collections library.

    Definition Classes
    org
  • package array

    This package contains utilities for working with arrays that are specialized for numeric types.

    This package contains utilities for working with arrays that are specialized for numeric types.

    Definition Classes
    saddle
  • package binary

    Binary serialization for Frame[String,String,T] or Mat[T] with primitive T

    Binary serialization for Frame[String,String,T] or Mat[T] with primitive T

    The layout of binary format is as follows: - The first 6 bytes are "SADDLE" - The next unsigned byte is the major version - The next unsigned byte is the minor version - The next 4 bytes form a little endian integer as HEADER_LENGTH - The next HEADER_LENGTH bytes form an UTF-8 string as the header. - The header is a valid JSON object with the following fields:

    • v: numeric positive integer is the version of the header structure
    • colix : a JSON array of strings, it is the column index of the frame
    • rowix : a JSON array of strings, it is the row index of the frame
    • numrows: numeric positive integer, number of rows
    • numcols: numeric positive integer, number of cols
    • Either one of rowix or numrows may be missing
    • Either one of colix or numcols may be missing
    • rowmajor : a boolean, indicating whether the data is stored in row-major or col-major order
    • datatype : string, either "double", "long", "int", "float", "byte" - The header is padded with spaces (0x20) such that HEADER_LENGTH+12 is divisible by 16. The count of spaces are included in HEADER_LENGTH. - The next width * numRows * numCols bytes form a little endian primitive array in row-major or col-major order. numRows and numCols are determined from the rowix/numrows and colix/numcols header fields. width is determined from the datatype field (8 for double and long, 4 for int and float, 1 for byte)
    Definition Classes
    saddle
  • package csv
    Definition Classes
    saddle
  • package groupby
    Definition Classes
    saddle
  • package index
    Definition Classes
    saddle
  • package io
    Definition Classes
    saddle
  • package linalg
    Definition Classes
    saddle
  • package locator
    Definition Classes
    saddle
  • package macros
    Definition Classes
    saddle
  • package mat
    Definition Classes
    saddle
  • package npy
    Definition Classes
    saddle
  • package ops

    Provides type aliases for a few basic operations

    Provides type aliases for a few basic operations

    Definition Classes
    saddle
  • package scalar
    Definition Classes
    saddle
  • package spire
    Definition Classes
    saddle
  • package stats
    Definition Classes
    saddle
  • package time

    Functionality to assist in TimeSeries related operations

    Functionality to assist in TimeSeries related operations

    Definition Classes
    saddle
  • package util

    Additional utilities that need a home

    Additional utilities that need a home

    Definition Classes
    saddle
  • package vec

    Factory methods to generate Vec instances

    Factory methods to generate Vec instances

    Definition Classes
    saddle
  • ArrToVec
  • Buffer
  • DiagOuterMBench
  • DotBench
  • FourInPlaceScalarLongOpBench
  • FourInPlaceScalarOpBench
  • Frame
  • Index
  • Mat
  • Numeric
  • OptionToScalar
  • Panel
  • PctMethod
  • PrimitiveToScalar
  • RankTie
  • SeqToFrame
  • SeqToFrame2
  • SeqToIndex
  • SeqToMat
  • SeqToSeries
  • SeqToVec
  • Series
  • SingleInPlaceScalarOpBench
  • TestImpl
  • TwoInPlaceScalarOpBench
  • Vec
  • VecDoubleOps
  • doubleIsNumeric
  • floatIsNumeric
  • intIsNumeric
  • longIsNumeric
  • na
  • order

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

Frame is an immutable container for 2D data which is indexed along both axes (rows, columns) by associated keys (i.e., indexes).

The primary use case is homogeneous data, but a secondary concern is to support heterogeneous data that is homogeneous ony within any given column.

The row index, column index, and constituent value data are all backed ultimately by arrays.

Frame is effectively a doubly-indexed associative map whose row keys and col keys each have an ordering provided by the natural (provided) order of their backing arrays.

Several factory and access methods are provided. In the following examples, assume that:

val f = Frame('a'->Vec(1,2,3), 'b'->Vec(4,5,6))

The apply method takes a row and col key returns a slice of the original Frame:

f(0,'a') == Frame('a'->Vec(1))

apply also accepts a org.saddle.index.Slice:

f(0->1, 'b') == Frame('b'->Vec(4,5))
f(0, *) == Frame('a'->Vec(1), 'b'->Vec(4))

You may slice using the col and row methods respectively, as follows:

f.col('a') == Frame('a'->Vec(1,2,3))
f.row(0) == Frame('a'->Vec(1), 'b'->Vec(4))
f.row(0->1) == Frame('a'->Vec(1,2), 'b'->Vec(4,5))

You can achieve a similar effect with rowSliceBy and colSliceBy

The colAt and rowAt methods take an integer offset i into the Frame, and return a Series indexed by the opposing axis:

f.rowAt(0) == Series('a'->1, 'b'->4)

If there is a one-to-one relationship between offset i and key (ie, no duplicate keys in the index), you may achieve the same effect via key as follows:

f.first(0) == Series('a'->1, 'b'->4)
f.firstCol('a') == Series(1,2,3)

The at method returns an instance of a org.saddle.scalar.Scalar, which behaves much like an Option; it can be either an instance of org.saddle.scalar.NA or a org.saddle.scalar.Value case class:

f.at(0, 0) == scalar.Scalar(1)

The rowSlice and colSlice methods allows slicing the Frame for locations in [i, j) irrespective of the value of the keys at those locations.

f.rowSlice(0,1) == Frame('a'->Vec(1), 'b'->Vec(4))

Finally, the method raw accesses a value directly, which may reveal the underlying representation of a missing value (so be careful).

f.raw(0,0) == 1

Frame may be used in arithmetic expressions which operate on two Frames or on a Frame and a scalar value. In the former case, the two Frames will automatically align along their indexes:

f + f.shift(1) == Frame('a'->Vec(NA,3,5), 'b'->Vec(NA,9,11))
RX

The type of row keys

CX

The type of column keys

T

The type of entries in the frame

Linear Supertypes
NumericOps[Frame[RX, CX, T]], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Frame
  2. NumericOps
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new Frame(values: MatCols[T], rowIx: Index[RX], colIx: Index[CX], cachedMat: Option[Mat[T]])(implicit arg0: ST[RX], arg1: ORD[RX], arg2: ST[CX], arg3: ORD[CX], st: ST[T])

    values

    A sequence of Vecs which comprise the columns of the Frame

    rowIx

    An index for the rows

    colIx

    An index for the columns

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. def %[B, That](other: B)(implicit op: BinOp[Mod, Frame[RX, CX, T], B, That]): That

    Integer modulus of division

    Integer modulus of division

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance (divisor)

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  4. def %=[B](other: B)(implicit op: BinOpInPlace[Mod, Frame[RX, CX, T], B]): Unit
    Definition Classes
    NumericOps
  5. def &[B, That](other: B)(implicit op: BinOp[BitAnd, Frame[RX, CX, T], B, That]): That

    Bit-wise AND

    Bit-wise AND

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  6. def &&[B, That](other: B)(implicit op: BinOp[AndOp, Frame[RX, CX, T], B, That]): That

    Logical AND

    Logical AND

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  7. def *[B, That](other: B)(implicit op: BinOp[Multiply, Frame[RX, CX, T], B, That]): That

    Multiplication

    Multiplication

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  8. def **[B, That](other: B)(implicit op: BinOp[Power, Frame[RX, CX, T], B, That]): That

    Exponentiation

    Exponentiation

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance (exponent)

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  9. def **=[B](other: B)(implicit op: BinOpInPlace[Power, Frame[RX, CX, T], B]): Unit
    Definition Classes
    NumericOps
  10. def *=[B](other: B)(implicit op: BinOpInPlace[Multiply, Frame[RX, CX, T], B]): Unit
    Definition Classes
    NumericOps
  11. def +[B, That](other: B)(implicit op: BinOp[Add, Frame[RX, CX, T], B, That]): That

    Addition

    Addition

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  12. def +=[B](other: B)(implicit op: BinOpInPlace[Add, Frame[RX, CX, T], B]): Unit
    Definition Classes
    NumericOps
  13. def -[B, That](other: B)(implicit op: BinOp[Subtract, Frame[RX, CX, T], B, That]): That

    Subtraction

    Subtraction

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  14. def -=[B](other: B)(implicit op: BinOpInPlace[Subtract, Frame[RX, CX, T], B]): Unit
    Definition Classes
    NumericOps
  15. def /[B, That](other: B)(implicit op: BinOp[Divide, Frame[RX, CX, T], B, That]): That

    Division

    Division

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance (divisor)

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  16. def /=[B](other: B)(implicit op: BinOpInPlace[Divide, Frame[RX, CX, T], B]): Unit
    Definition Classes
    NumericOps
  17. def <[B, That](other: B)(implicit op: BinOp[LtOp, Frame[RX, CX, T], B, That]): That

    Less-than comparison operator

    Less-than comparison operator

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  18. def <<[B, That](other: B)(implicit op: BinOp[BitShl, Frame[RX, CX, T], B, That]): That

    Bit-shift left

    Bit-shift left

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  19. def <=[B, That](other: B)(implicit op: BinOp[LteOp, Frame[RX, CX, T], B, That]): That

    Less-than-or-equal-to comparison operator

    Less-than-or-equal-to comparison operator

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  20. def <>[B, That](other: B)(implicit op: BinOp[NeqOp, Frame[RX, CX, T], B, That]): That

    Element-wise inequality operator

    Element-wise inequality operator

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  21. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  22. def =?[B, That](other: B)(implicit op: BinOp[EqOp, Frame[RX, CX, T], B, That]): That

    Element-wise equality operator

    Element-wise equality operator

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  23. def >[B, That](other: B)(implicit op: BinOp[GtOp, Frame[RX, CX, T], B, That]): That

    Greater-than comparison operator

    Greater-than comparison operator

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  24. def >=[B, That](other: B)(implicit op: BinOp[GteOp, Frame[RX, CX, T], B, That]): That

    Greater-than-or-equal-to comparison operator

    Greater-than-or-equal-to comparison operator

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  25. def >>[B, That](other: B)(implicit op: BinOp[BitShr, Frame[RX, CX, T], B, That]): That

    Bit-shift right (arithmetic)

    Bit-shift right (arithmetic)

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  26. def >>>[B, That](other: B)(implicit op: BinOp[BitUShr, Frame[RX, CX, T], B, That]): That

    Bit-shift right (logical)

    Bit-shift right (logical)

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  27. def T: Frame[CX, RX, T]

    The transpose of the frame (swapping the axes)

  28. def ^[B, That](other: B)(implicit op: BinOp[BitXor, Frame[RX, CX, T], B, That]): That

    Bit-wise EXCLUSIVE OR

    Bit-wise EXCLUSIVE OR

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  29. def addCol(other: Series[RX, T], how: JoinType): Frame[RX, Int, T]

    Add a new column.

    Add a new column. Resets column index

    The result is a Frame whose row index is the result of the join, and whose column index has been reset to [0, numcols], and whose values are sourced from the original Frame and Series.

    other

    Series to join with

    how

    How to perform the join

  30. def addCol(other: Series[RX, T], newColIx: CX, how: JoinType = OuterJoin): Frame[RX, CX, T]

    Same as addCol, but preserve the column index, adding the specified index value, newColIx as an index for the other Series.

  31. def addRow(other: Series[CX, T], how: JoinType): Frame[Int, CX, T]

    See addRow; operates row-wise.

  32. def addRow(other: Series[CX, T], newRowIx: RX, how: JoinType = OuterJoin): Frame[RX, CX, T]

    See addCol, operates row-wise.

  33. def align[U](other: Frame[RX, CX, U], rhow: JoinType = OuterJoin, chow: JoinType = OuterJoin)(implicit arg0: ST[U]): (Frame[RX, CX, T], Frame[RX, CX, U])

    Aligns this frame with another frame, returning the left and right frames aligned to each others indexes according to the the provided parameters

    Aligns this frame with another frame, returning the left and right frames aligned to each others indexes according to the the provided parameters

    other

    Other frame to align with

    rhow

    How to perform the join on the row indexes

    chow

    How to perform the join on the col indexes

  34. def apply(rix: Array[RX], cix: Array[CX]): Frame[RX, CX, T]

    Slice from by an array of row keys and an array of col keys

    Slice from by an array of row keys and an array of col keys

    rix

    An array of row keys

    cix

    An array of col keys

  35. def apply(rix: Array[RX], cix: Slice[CX]): Frame[RX, CX, T]

    Slice frame by array of row keys and a col slice

    Slice frame by array of row keys and a col slice

    rix

    An array of row keys

    cix

    A col slice

  36. def apply(rix: Slice[RX], cix: Array[CX]): Frame[RX, CX, T]

    Slice frame by row slice and array of column keys

    Slice frame by row slice and array of column keys

    rix

    A row slice

    cix

    An array of column keys

  37. def apply(rix: Slice[RX], cix: Slice[CX]): Frame[RX, CX, T]

    Slice frame by row and column slice specifiers

    Slice frame by row and column slice specifiers

    rix

    A row slice

    cix

    A col slice

  38. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  39. def at(r: Slice[Int], c: Slice[Int]): Frame[RX, CX, T]

    Access a slice of the Frame by Slice parameters

    Access a slice of the Frame by Slice parameters

    r

    Slice to apply to rows

    c

    Slice to apply to cols

  40. def at(r: Int, c: Array[Int]): Series[CX, T]

    Access a slice of the Frame by integer offsets

    Access a slice of the Frame by integer offsets

    r

    Integer row offset

    c

    Array of col offsets

  41. def at(r: Array[Int], c: Int): Series[RX, T]

    Access a slice of the Frame by integer offsets

    Access a slice of the Frame by integer offsets

    r

    Array of row offsets

    c

    Integer col offset

  42. def at(r: Array[Int], c: Array[Int]): Frame[RX, CX, T]

    Access a slice of the Frame by integer offsets

    Access a slice of the Frame by integer offsets

    r

    Array of row offsets

    c

    Array of col offsets

  43. def at(r: Int, c: Int): Scalar[T]

    Access a (Scalar-boxed) value from within the Frame

    Access a (Scalar-boxed) value from within the Frame

    r

    Integer row offset

    c

    Integer col offset

  44. def cbind(other: Frame[RX, CX, T], how: JoinType = OuterJoin): Frame[RX, CX, T]

    Same as rconcat.

    Same as rconcat. Concatenates two Frames by concatenating their lists of columns A1 A2 rconcat B1 B2 = A1 A2 B1 B2 A3 A4 B3 B4 A3 A4 B3 B4

  45. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  46. def col(keys: Array[CX]): Frame[RX, CX, T]

    Given an array of column keys, slice out the corresponding column(s)

    Given an array of column keys, slice out the corresponding column(s)

    keys

    Array of keys

  47. def col(slice: Slice[CX]): Frame[RX, CX, T]

    Given a Slice of type of column key, slice out corresponding column(s)

    Given a Slice of type of column key, slice out corresponding column(s)

    slice

    Slice containing appropriate key bounds

  48. def col(keys: CX*): Frame[RX, CX, T]

    Given one or more column keys, slice out the corresponding column(s)

    Given one or more column keys, slice out the corresponding column(s)

    keys

    Column key(s) (sequence)

  49. def colAt(slice: Slice[Int]): Frame[RX, CX, T]

    Access frame columns specified by a slice

    Access frame columns specified by a slice

    slice

    a slice specifier

  50. def colAt(locs: Array[Int]): Frame[RX, CX, T]

    Access frame columns at a particular integer offsets

    Access frame columns at a particular integer offsets

    locs

    an array of integer offsets

  51. def colAt(locs: Int*): Frame[RX, CX, T]

    Access frame columns at a particular integer offsets

    Access frame columns at a particular integer offsets

    locs

    a sequence of integer offsets

  52. def colAt(loc: Int): Series[RX, T]

    Access frame column at a particular integer offset

    Access frame column at a particular integer offset

    loc

    integer offset

  53. val colIx: Index[CX]
  54. def colSlice(from: Int, until: Int, stride: Int = 1): Frame[RX, CX, T]

    Access frame columns between two integer offsets, [from, until)

    Access frame columns between two integer offsets, [from, until)

    from

    Beginning offset

    until

    One past ending offset

    stride

    Optional increment between offsets

  55. def colSliceBy(from: CX, to: CX, inclusive: Boolean = true): Frame[RX, CX, T]

    Slice out a set of columns from the frame

    Slice out a set of columns from the frame

    from

    Key from which to begin slicing

    to

    Key at which to end slicing

    inclusive

    Whether to include 'to' key; true by default

  56. def colSplitAt(c: Int): (Frame[RX, CX, T], Frame[RX, CX, T])

    Split Frame into two frames at column position c

    Split Frame into two frames at column position c

    c

    Position at which to split Frame

  57. def colSplitBy(k: CX): (Frame[RX, CX, T], Frame[RX, CX, T])

    Split Frame into two frames at column key k

    Split Frame into two frames at column key k

    k

    Key at which to split Frame k is included in the right Frame [1,2,3,4] split at 2 yields [1] and [2,3,4]

  58. def colType[U1, U2](implicit arg0: ST[U1], arg1: ST[U2]): Frame[RX, CX, Any]

    Extract columns from a heterogeneous Frame which match either of the provided types.

    Extract columns from a heterogeneous Frame which match either of the provided types. The result is a heterogeneous frame consisting of the selected data.

    U1

    First type of columns to extract

    U2

    Second type of columns to extract

  59. def colType[U](implicit arg0: ST[U]): Frame[RX, CX, U]

    Extract columns from a heterogeneous Frame which match the provided type.

    Extract columns from a heterogeneous Frame which match the provided type. The result is a homogeneous frame consisting of the selected data.

    U

    The type of columns to extract

  60. def concat(other: Frame[RX, CX, T], how: JoinType = OuterJoin): Frame[RX, CX, T]

    Concatenate the Frame instances together (vertically, i.e.

    Concatenate the Frame instances together (vertically, i.e. concatenate as lists of rows) whose indexes share the same type of elements, and where there exists some way to join the values of the Frames. For instance, Frame[X, Y, Double] concat Frame[X, Y, Int] will promote Int to Double as a result of the implicit existence of a Promoter[Double, Int, Double] instance. The resulting row index will simply be the concatenation of the input row indexes, and the column index will be the joint index (with join type specified as argument).

    A1 A2 concat B1 B2 = A1 A2 A3 A4 B3 B4 A3 A4 B1 B2 B3 B4

    other

    Frame[RX, CX, U] to concat

  61. def count: Series[CX, Int]

    Count of the elements of each column, ignoring NA values

  62. def cshift(n: Int = 1): Frame[RX, CX, T]

    See shift; operates col-wise

  63. def distinct: Frame[RX, CX, T]

    Return the frame with the first occurence of each column key.

    Return the frame with the first occurence of each column key. Rows are not changed.

  64. def dot[B, That](other: B)(implicit op: BinOp[InnerProd, Frame[RX, CX, T], B, That]): That

    Dot (inner) product

    Dot (inner) product

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  65. def dropNA: Frame[RX, CX, T]

    Return Frame excluding any of those columns which have an NA value

  66. def emptyCol: Series[RX, T]

    Return empty series of type equivalent to a column of frame

  67. def emptyRow: Series[CX, T]

    Return empty series of type equivalent to a row of frame

  68. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  69. def equals(other: Any): Boolean
    Definition Classes
    Frame → AnyRef → Any
  70. def filter(pred: (Series[RX, T]) => Boolean): Frame[RX, CX, T]

    Return Frame whose columns satisfy a predicate function operating on that column

    Return Frame whose columns satisfy a predicate function operating on that column

    pred

    Predicate function from Series[RX, T] => Boolean

  71. def filterAt(pred: (Int) => Boolean): Frame[RX, CX, T]

    Return Frame whose columns satisfy a predicate function operating on the column index offset

    Return Frame whose columns satisfy a predicate function operating on the column index offset

    pred

    Predicate function from CX => Boolean

  72. def filterIx(pred: (CX) => Boolean): Frame[RX, CX, T]

    Return Frame whose columns satisfy a predicate function operating on the column index

    Return Frame whose columns satisfy a predicate function operating on the column index

    pred

    Predicate function from CX => Boolean

  73. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  74. def first(k: RX): Series[CX, T]

    Extract first row matching a particular key

    Extract first row matching a particular key

    k

    Key to match

  75. def firstCol(k: CX): Series[RX, T]

    Extract first col matching a particular key

    Extract first col matching a particular key

    k

    Key to match

  76. def flatMap[SX, DX, U](f: ((RX, CX, T)) => Iterable[(SX, DX, U)])(implicit arg0: ST[SX], arg1: ORD[SX], arg2: ST[DX], arg3: ORD[DX], arg4: ST[U]): Frame[SX, DX, U]

    Map over each triple (r, c, v) in the Frame, flattening results, and returning a new frame from the resulting triples.

  77. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  78. def groupBy[Y](ix: Index[Y])(implicit arg0: ST[Y], arg1: ORD[Y]): FrameGrouper[Y, RX, CX, T]

    Construct a org.saddle.groupby.FrameGrouper with which further computations, such as combine or transform, may be performed.

    Construct a org.saddle.groupby.FrameGrouper with which further computations, such as combine or transform, may be performed. The groups are constructed from the keys of the provided index, with each unique key corresponding to a group.

    Y

    Type of elements of ix

    ix

    Index with which to perform grouping

  79. def groupBy[Y](fn: (RX) => Y)(implicit arg0: ST[Y], arg1: ORD[Y]): FrameGrouper[Y, RX, CX, T]

    Construct a org.saddle.groupby.FrameGrouper with which further computations, such as combine or transform, may be performed.

    Construct a org.saddle.groupby.FrameGrouper with which further computations, such as combine or transform, may be performed. The groups are constructed from the result of the function applied to the keys of the row index; each unique result of calling the function on elements of the row index corresponds to a group.

    Y

    Type of function codomain

    fn

    Function from RX => Y

  80. def groupBy: FrameGrouper[RX, RX, CX, T]

    Construct a org.saddle.groupby.FrameGrouper with which further computations, such as combine or transform, may be performed.

    Construct a org.saddle.groupby.FrameGrouper with which further computations, such as combine or transform, may be performed. The groups are constructed from the keys of the row index, with each unique key corresponding to a group.

  81. def hashCode(): Int
    Definition Classes
    Frame → AnyRef → Any
  82. def head(n: Int): Frame[RX, CX, T]

    Extract first n rows

    Extract first n rows

    n

    number of rows to extract

  83. def headCol(n: Int): Frame[RX, CX, T]

    Extract first n columns

    Extract first n columns

    n

    number of columns to extract

  84. def isEmpty: Boolean

    Returns true if there are no values in the Frame

  85. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  86. def joinMap[U, V](other: Frame[RX, CX, U], rhow: JoinType = LeftJoin, chow: JoinType = RightJoin)(f: (T, U) => V)(implicit arg0: ST[U], arg1: ST[V]): Frame[RX, CX, V]

    Joins two frames along both their indexes and applies a function to each pair of values; when either value is NA, the result of the function is forced to be NA.

    Joins two frames along both their indexes and applies a function to each pair of values; when either value is NA, the result of the function is forced to be NA.

    U

    The type of other frame values

    V

    The result type of the function

    other

    Other Frame

    rhow

    The type of join to effect on the rows

    chow

    The type of join to effect on the cols

    f

    The function to apply

  87. def last(k: RX): Series[CX, T]

    Extract last row matching a particular key

    Extract last row matching a particular key

    k

    Key to match

  88. def lastCol(k: CX): Series[RX, T]

    Extract first col matching a particular key

    Extract first col matching a particular key

    k

    Key to match

  89. def map[SX, DX, U](f: ((RX, CX, T)) => (SX, DX, U))(implicit arg0: ST[SX], arg1: ORD[SX], arg2: ST[DX], arg3: ORD[DX], arg4: ST[U]): Frame[SX, DX, U]

    Map over each triple (r, c, v) in the Frame, returning a new frame from the resulting triples.

  90. def mapColIndex[Y](fn: (CX) => Y)(implicit arg0: ST[Y], arg1: ORD[Y]): Frame[RX, Y, T]

    Map a function over the col index, resulting in a new Frame

    Map a function over the col index, resulting in a new Frame

    Y

    Result type of index, ie Index[Y]

    fn

    The function CX => Y with which to map

  91. def mapCols[Y](fn: (CX, Vec[T]) => Vec[Y])(implicit arg0: ST[Y]): Frame[RX, CX, Y]

    Map a function over the columns, resulting in a new Frame

    Map a function over the columns, resulting in a new Frame

    Y

    Result type of mapped value

    fn

    The function (CX,Vec[T]) => Vec[Y] with which to map

  92. def mapRowIndex[Y](fn: (RX) => Y)(implicit arg0: ST[Y], arg1: ORD[Y]): Frame[Y, CX, T]

    Map a function over the row index, resulting in a new Frame

    Map a function over the row index, resulting in a new Frame

    Y

    Result type of index, ie Index[Y]

    fn

    The function RX => Y with which to map

  93. def mapRows[Y](fn: (RX, Vec[T]) => Vec[Y])(implicit arg0: ST[Y]): Frame[RX, CX, Y]

    Map a function over the rows, resulting in a new Frame

    Map a function over the rows, resulting in a new Frame

    Y

    Result type of mapped value

    fn

    The function (RX,Vec[T]) => Vec[Y] with which to map

  94. def mapValues[U](f: (T) => U)(implicit arg0: ST[U]): Frame[RX, CX, U]

    Map over the values of the Frame.

    Map over the values of the Frame. Applies a function to each (non-na) value in the frame, returning a new frame whose indices remain the same.

    U

    The type of the resulting values

    f

    Function from T to U

  95. def mapVec[U](f: (Vec[T]) => Vec[U])(implicit arg0: ST[U]): Frame[RX, CX, U]

    Map a function over each column vector and collect the results into a Frame respecting the original indexes.

    Map a function over each column vector and collect the results into a Frame respecting the original indexes.

    U

    Type of result Vec of the function

    f

    Function acting on Vec[T] and producing another Vec

  96. def mask(m: Vec[Boolean]): Frame[RX, CX, T]

    Create a new Frame whose columns follow the rule that, wherever the mask Vec is true, the column value is masked with NA

    Create a new Frame whose columns follow the rule that, wherever the mask Vec is true, the column value is masked with NA

    m

    Mask Vec[Boolean]

  97. def mask(f: (T) => Boolean): Frame[RX, CX, T]

    Create a new Frame that, whenever the mask predicate function evaluates to true on a value, is masked with NA

    Create a new Frame that, whenever the mask predicate function evaluates to true on a value, is masked with NA

    f

    Function from T to Boolean

  98. def max(implicit num: NUM[T]): Series[CX, T]

    Max of the elements of each column, ignoring NA values

  99. def mean(implicit num: NUM[T]): Series[CX, Double]

    Mean of each column

  100. def median(implicit num: NUM[T]): Series[CX, Double]

    Median of each column

  101. def melt[W](implicit melter: Melter[RX, CX, W]): Series[W, T]

    Melt stacks the row index of arity N with the column index of arity M to form a result index of arity N + M, producing a 1D Series whose values are from the original Frame as indexed by the corresponding keys.

    Melt stacks the row index of arity N with the column index of arity M to form a result index of arity N + M, producing a 1D Series whose values are from the original Frame as indexed by the corresponding keys.

    For example, given:

    Frame(1 -> Series('a' -> 1, 'b' -> 3), 2 -> Series('a' -> 2, 'b' -> 4)).melt

    produces:

    res0: org.saddle.Series[(Char, Int),Int] =
    [4 x 1]
     a 1 => 1
       2 => 2
     b 1 => 3
       2 => 4
    W

    Output type (tuple of arity N + M)

    melter

    Implicit evidence for a Melter for the two indexes

  102. def min(implicit num: NUM[T]): Series[CX, T]

    Min of the elements of each column, ignoring NA values

  103. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  104. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  105. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  106. def numCols: Int

    Number of cols in the Frame

  107. def numRows: Int

    Number of rows in the Frame

  108. def outer[B, That](other: B)(implicit op: BinOp[OuterProd, Frame[RX, CX, T], B, That]): That

    Outer product

    Outer product

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  109. def print(nrows: Int = 10, ncols: Int = 10, stream: OutputStream = System.out): Unit

    Pretty-printer for Frame, which simply outputs the result of stringify.

    Pretty-printer for Frame, which simply outputs the result of stringify.

    nrows

    Number of rows to display

    ncols

    Number of cols to display

  110. def prod(implicit num: NUM[T]): Series[CX, T]

    Product of the elements of each column, ignoring NA values

  111. def raw(r: Int, c: Int): T

    Access the raw (unboxed) value at an offset within the Frame

    Access the raw (unboxed) value at an offset within the Frame

    r

    Integer row offset

    c

    Integer col offset

  112. def rbind(other: Frame[RX, CX, T], how: JoinType = OuterJoin): Frame[RX, CX, T]

    Same as concat.

    Same as concat. Concatenates two Frames by concatenating their lists of rows A1 A2 concat B1 B2 = A1 A2 A3 A4 B3 B4 A3 A4 B1 B2 B3 B4

  113. def rconcat(other: Frame[RX, CX, T], how: JoinType = OuterJoin): Frame[RX, CX, T]

    See concat; operates row-wise.

    See concat; operates row-wise. Concetanates two Frames by concatenating their lists of columns A1 A2 rconcat B1 B2 = A1 A2 B1 B2 A3 A4 B3 B4 A3 A4 B3 B4

  114. def rdistinct: Frame[RX, CX, T]

    Return the series with the first occurence of each row key.

    Return the series with the first occurence of each row key. Columns are not changed.

  115. def rdropNA: Frame[RX, CX, T]

    See dropNA; operates row-wise

  116. def reduce[U](f: (Series[RX, T]) => U)(implicit arg0: ST[U]): Series[CX, U]

    Apply a function to each column series which results in a single value, and return the series of results indexed by original column index.

    Apply a function to each column series which results in a single value, and return the series of results indexed by original column index.

    U

    The output type of the function

    f

    Function taking a column (series) to a value

  117. def reindex(rix: Index[RX], cix: Index[CX]): Frame[RX, CX, T]

    Create a new Frame whose indexes are formed from the provided arguments, and whose values are derived from the original Frame.

    Create a new Frame whose indexes are formed from the provided arguments, and whose values are derived from the original Frame. Keys in the provided indices which do not map to existing values will map to NA in the new Frame.

    rix

    Sequence of keys to be the row index of the result Frame

    cix

    Sequence of keys to be the col index of the result Frame

  118. def reindexCol(cix: Index[CX]): Frame[RX, CX, T]

    Create a new Frame whose col index is formed of the provided argument, and whose values are derived from the original Frame.

    Create a new Frame whose col index is formed of the provided argument, and whose values are derived from the original Frame.

    cix

    Sequence of keys to be the col index of the result Frame

  119. def reindexRow(rix: Index[RX]): Frame[RX, CX, T]

    Create a new Frame whose row index is formed of the provided argument, and whose values are derived from the original Frame.

    Create a new Frame whose row index is formed of the provided argument, and whose values are derived from the original Frame.

    rix

    Sequence of keys to be the row index of the result Frame

  120. def resetColIndex: Frame[RX, Int, T]

    Create a new Frame whose values are the same, but whose col index has been changed to the bound [0, numCols - 1), as in an array.

  121. def resetRowIndex: Frame[Int, CX, T]

    Create a new Frame whose values are the same, but whose row index has been changed to the bound [0, numRows - 1), as in an array.

  122. def rfilter(pred: (Series[CX, T]) => Boolean): Frame[RX, CX, T]

    See filter; operates row-wise

  123. def rfilterAt(pred: (Int) => Boolean): Frame[RX, CX, T]

    See filterAt; operates row-wise

  124. def rfilterIx(pred: (RX) => Boolean): Frame[RX, CX, T]

    See filterIx; operates row-wise

  125. def rmapVec[U](f: (Vec[T]) => Vec[U])(implicit arg0: ST[U]): Frame[RX, CX, U]

    See mapVec; operates row-wise

  126. def rmask(b: Vec[Boolean]): Frame[RX, CX, T]

    See mask; operates row-wise

  127. def rolling[B](windowSize: Int, f: (Series[RX, T]) => B)(implicit arg0: ST[B]): Frame[RX, CX, B]

    Produce a Frame each of whose columns are the result of executing a function on a sliding window of each column series.

    Produce a Frame each of whose columns are the result of executing a function on a sliding window of each column series.

    B

    Result type of function

    f

    Function Series[X, T] => B to operate on sliding window

  128. def rollingFtoS[B](windowSize: Int, f: (Frame[RX, CX, T]) => B)(implicit arg0: ST[B]): Series[RX, B]

    Create a Series by rolling over winSz number of rows of the Frame at a time, and applying a function that takes those rows to a single value.

    Create a Series by rolling over winSz number of rows of the Frame at a time, and applying a function that takes those rows to a single value.

    B

    Result element type of Series

    f

    Function taking the (sub) frame to B

  129. def row(keys: Array[RX]): Frame[RX, CX, T]

    Given an array of row keys, slice out the corresponding row(s)

    Given an array of row keys, slice out the corresponding row(s)

    keys

    Array of keys

  130. def row(slice: Slice[RX]): Frame[RX, CX, T]

    Given a Slice of type of row key, slice out corresponding row(s)

    Given a Slice of type of row key, slice out corresponding row(s)

    slice

    Slice containing appropriate key bounds

  131. def row(keys: RX*): Frame[RX, CX, T]

    Given one or more row keys, slice out the corresponding row(s)

    Given one or more row keys, slice out the corresponding row(s)

    keys

    Row key(s) (sequence)

  132. def rowAt(slice: Slice[Int]): Frame[RX, CX, T]

    Access frame rows specified by a slice

    Access frame rows specified by a slice

    slice

    a slice specifier

  133. def rowAt(locs: Array[Int]): Frame[RX, CX, T]

    Access frame rows at a particular integer offsets

    Access frame rows at a particular integer offsets

    locs

    an array of integer offsets

  134. def rowAt(locs: Int*): Frame[RX, CX, T]

    Access frame rows at a particular integer offsets

    Access frame rows at a particular integer offsets

    locs

    a sequence of integer offsets

  135. def rowAt(loc: Int): Series[CX, T]

    Access frame row at a particular integer offset

    Access frame row at a particular integer offset

    loc

    integer offset

  136. def rowIterator: Iterator[(RX, Series[CX, T])]
  137. val rowIx: Index[RX]
  138. def rowSlice(from: Int, until: Int, stride: Int = 1): Frame[RX, CX, T]

    Access frame rows between two integer offsets, [from, until)

    Access frame rows between two integer offsets, [from, until)

    from

    Beginning offset

    until

    One past ending offset

    stride

    Optional increment between offsets

  139. def rowSliceBy(from: RX, to: RX, inclusive: Boolean = true): Frame[RX, CX, T]

    Slice out a set of rows from the frame

    Slice out a set of rows from the frame

    from

    Key from which to begin slicing

    to

    Key at which to end slicing

    inclusive

    Whether to include 'to' key; true by default

  140. def rowSplitAt(r: Int): (Frame[RX, CX, T], Frame[RX, CX, T])

    Split Frame into two frames at row position r

    Split Frame into two frames at row position r

    r

    Position at which to split Frame

  141. def rowSplitBy(k: RX): (Frame[RX, CX, T], Frame[RX, CX, T])

    Split Frame into two frames at row key k

    Split Frame into two frames at row key k

    k

    Key at which to split Frame

  142. def rreduce[U](f: (Series[CX, T]) => U)(implicit arg0: ST[U]): Series[RX, U]

    See reduce; operates row-wise

  143. def rsqueeze: Frame[RX, CX, T]

    See squeeze; operates row-wise

  144. def rtransform[U, SX](f: (Series[CX, T]) => Series[SX, U])(implicit arg0: ST[U], arg1: ST[SX], arg2: ORD[SX]): Frame[RX, SX, U]

    See transform; operates row-wise

  145. def rwhere(pred: Vec[Boolean]): Frame[RX, CX, T]

    See where; operates row-wise

  146. def rwhere(pred: Series[_, Boolean]): Frame[RX, CX, T]

    See where; operates row-wise

  147. def setColIndex[Y](newIx: Index[Y])(implicit arg0: ST[Y], arg1: ORD[Y]): Frame[RX, Y, T]

    Create a new Frame using the current values but with the new col index.

    Create a new Frame using the current values but with the new col index. Positions of the values do not change. Length of new index must be equal to number of cols.

    Y

    Type of elements of new Index

    newIx

    A new Index

  148. def setRowIndex[Y](newIx: Index[Y])(implicit arg0: ST[Y], arg1: ORD[Y]): Frame[Y, CX, T]

    Create a new Frame using the current values but with the new row index.

    Create a new Frame using the current values but with the new row index. Positions of the values do not change. Length of new index must be equal to number of rows.

    Y

    Type of elements of new Index

    newIx

    A new Index

  149. def shift(n: Int = 1): Frame[RX, CX, T]

    Shift the sequence of values relative to the row index by some offset, dropping those values which no longer associate with a key, and having those keys which no longer associate to a value instead map to NA.

    Shift the sequence of values relative to the row index by some offset, dropping those values which no longer associate with a key, and having those keys which no longer associate to a value instead map to NA.

    n

    Number to shift

  150. def sortedCIx: Frame[RX, CX, T]

    Create a new Frame whose cols are sorted according to the col index keys

  151. def sortedCIxReverse: Frame[RX, CX, T]

    Create a new Frame whose cols are sorted according to the reveverse of col index keys

  152. def sortedCols(locs: Int*)(implicit ev: ORD[T]): Frame[RX, CX, T]

    Create a new Frame whose cols are sorted primarily on the values in the first row specified in the argument list, and then on the values in the next row, etc.

    Create a new Frame whose cols are sorted primarily on the values in the first row specified in the argument list, and then on the values in the next row, etc.

    locs

    Location of rows containing values to sort on

  153. def sortedColsBy[Q](f: (Series[RX, T]) => Q)(implicit arg0: ORD[Q]): Frame[RX, CX, T]

    Create a new Frame whose cols are sorted by the result of a function acting on each col.

    Create a new Frame whose cols are sorted by the result of a function acting on each col.

    Q

    Result type of the function

    f

    Function from a single col (represented as series) to a value having an ordering

  154. def sortedRIx: Frame[RX, CX, T]

    Create a new Frame whose rows are sorted according to the row index keys

  155. def sortedRIxReverse: Frame[RX, CX, T]

    Create a new Frame whose rows are sorted according to the reverse of row index keys

  156. def sortedRows(locs: Int*)(implicit ev: ORD[T]): Frame[RX, CX, T]

    Create a new Frame whose rows are sorted primarily on the values in the first column specified in the argument list, and then on the values in the next column, etc.

    Create a new Frame whose rows are sorted primarily on the values in the first column specified in the argument list, and then on the values in the next column, etc.

    locs

    Location of columns containing values to sort on

  157. def sortedRowsBy[Q](f: (Series[CX, T]) => Q)(implicit arg0: ORD[Q]): Frame[RX, CX, T]

    Create a new Frame whose rows are sorted by the result of a function acting on each row.

    Create a new Frame whose rows are sorted by the result of a function acting on each row.

    Q

    Result type of the function

    f

    Function from a single row (represented as series) to a value having an ordering

  158. def squeeze: Frame[RX, CX, T]

    Drop all columns from the Frame which have nothing but NA values.

  159. def stack[O1, O2, V](implicit splt: Splitter[CX, O1, O2], stkr: Stacker[RX, O2, V], ord1: ORD[O1], ord2: ORD[O2], m1: ST[O1], m2: ST[O2]): Frame[V, O1, T]

    Stack pivots the innermost column labels to the innermost row labels.

    Stack pivots the innermost column labels to the innermost row labels. That is, it splits a col index of tuple keys of arity N into a new col index having arity N-1 and a remaining index C, and forms a new row index by stacking the existing row index with C. The resulting Frame has values as in the original Frame indexed by the corresponding keys. It does the reverse of unstack.

    O1

    The N-1 arity column index type

    O2

    The 1-arity type of split-out index C

    V

    The type of the stacked row index

    splt

    An implicit instance of Splitter to do the splitting

    stkr

    An implicit instance of Stacker to do the stacking

  160. def stringify(nrows: Int = 10, ncols: Int = 10): String

    Creates a string representation of Frame

    Creates a string representation of Frame

    nrows

    Max number of rows to include

    ncols

    Max number of rows to include

  161. def sum(implicit num: NUM[T]): Series[CX, T]

    Sum of the elements of each column, ignoring NA values

  162. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  163. def tail(n: Int): Frame[RX, CX, T]

    Extract last n rows

    Extract last n rows

    n

    number of rows to extract

  164. def tailCol(n: Int): Frame[RX, CX, T]

    Extract last n columns

    Extract last n columns

    n

    number of columns to extract

  165. def toColSeq: IndexedSeq[(CX, Series[RX, T])]

    Produce an indexed sequence of pairs of column index value and column Series.

  166. def toMat: Mat[T]

    Extract the Mat embodied in the values of the Frame (dropping any indexing information)

  167. def toRowSeq: IndexedSeq[(RX, Series[CX, T])]

    Produce an indexed sequence of pairs of row index value and row Series

  168. def toSeq: IndexedSeq[(RX, CX, T)]

    Produce an indexed sequence of triples of values in the Frame in row-major order.

  169. def toString(): String
    Definition Classes
    Frame → AnyRef → Any
  170. def transform[U, SX](f: (Series[RX, T]) => Series[SX, U])(implicit arg0: ST[U], arg1: ST[SX], arg2: ORD[SX]): Frame[SX, CX, U]

    Apply a function to each column series which results in another series (having possibly a different index); return new frame whose row index is the the full outer join of all the intermediately produced series (fast when all series have the same index), and having the original column index.

    Apply a function to each column series which results in another series (having possibly a different index); return new frame whose row index is the the full outer join of all the intermediately produced series (fast when all series have the same index), and having the original column index.

    U

    Type of values of result series of function

    SX

    Type of index of result series of function

    f

    Function to operate on each column as a series

  171. def unstack[O1, O2, V](implicit splt: Splitter[RX, O1, O2], stkr: Stacker[CX, O2, V], ord1: ORD[O1], ord2: ORD[O2], m1: ST[O1], m2: ST[O2]): Frame[O1, V, T]

    Unstack pivots the innermost row labels to the innermost col labels.

    Unstack pivots the innermost row labels to the innermost col labels. That is, it splits a row index of tuple keys of arity N into a new row index having arity N-1 and a remaining index R, and forms a new col index by stacking the existing col index with R. The resulting Frame has values as in the original Frame indexed by the corresponding keys.

    For example:

    scala> Frame(Series(Vec(1,2,3,4), Index(('a',1),('a',2),('b',1),('b',2))), Series(Vec(5,6,7,8), Index(('a',1),('a',2),('b',1),('b',2))))
    res1: org.saddle.Frame[(Char, Int),Int,Int] =
    [4 x 2]
            0  1
           -- --
    a 1 ->  1  5
      2 ->  2  6
    b 1 ->  3  7
      2 ->  4  8
    
    scala> res1.unstack
    res2: org.saddle.Frame[Char,(Int, Int),Int] =
    [2 x 4]
          0     1
          1  2  1  2
         -- -- -- --
    a ->  1  2  5  6
    b ->  3  4  7  8
    O1

    The N-1 arity row index type

    O2

    The 1-arity type of split-out index R

    V

    The type of the stacked col index

    splt

    An implicit instance of Splitter to do the splitting

    stkr

    An implicit instance of Stacker to do the stacking

  172. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  173. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  174. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  175. def where(pred: Vec[Boolean]): Frame[RX, CX, T]

    Create Frame whose rows satisfy the rule that their keys and values are chosen via a Vec[Boolean] or a Series[_, Boolean] predicate when the latter contains a true value.

    Create Frame whose rows satisfy the rule that their keys and values are chosen via a Vec[Boolean] or a Series[_, Boolean] predicate when the latter contains a true value.

    pred

    Series[_, Boolean] (or Vec[Boolean] which will implicitly convert)

  176. def where(pred: Series[_, Boolean]): Frame[RX, CX, T]

    Create Frame whose rows satisfy the rule that their keys and values are chosen via a Vec[Boolean] or a Series[_, Boolean] predicate when the latter contains a true value.

    Create Frame whose rows satisfy the rule that their keys and values are chosen via a Vec[Boolean] or a Series[_, Boolean] predicate when the latter contains a true value.

    pred

    Series[_, Boolean] (or Vec[Boolean] which will implicitly convert)

  177. def withColIndex(row1: Int, row2: Int)(implicit ordT: ORD[T]): Frame[RX, (T, T), T]

    Overloaded method to create hierarchical index from two rows.

  178. def withColIndex(row: Int)(implicit ordT: ORD[T]): Frame[RX, T, T]

    Create a new Frame using the current values but with the new col index specified by the row at a particular offset, and with that row removed from the frame data body.

  179. def withRowIndex(col1: Int, col2: Int)(implicit ordT: ORD[T]): Frame[(T, T), CX, T]

    Overloaded method to create hierarchical index from two cols.

  180. def withRowIndex(col: Int)(implicit ordT: ORD[T]): Frame[T, CX, T]

    Create a new Frame using the current values but with the new row index specified by the column at a particular offset, and with that column removed from the frame data body.

  181. def xor[B, That](other: B)(implicit op: BinOp[XorOp, Frame[RX, CX, T], B, That]): That

    Logical EXCLUSIVE OR

    Logical EXCLUSIVE OR

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  182. def |[B, That](other: B)(implicit op: BinOp[BitOr, Frame[RX, CX, T], B, That]): That

    Bit-wise OR

    Bit-wise OR

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps
  183. def ||[B, That](other: B)(implicit op: BinOp[OrOp, Frame[RX, CX, T], B, That]): That

    Logical OR

    Logical OR

    B

    type of the other operand

    That

    result type of operation

    other

    other operand instance

    op

    implicit evidence for operation between this and other

    Definition Classes
    NumericOps

Inherited from NumericOps[Frame[RX, CX, T]]

Inherited from AnyRef

Inherited from Any

Ungrouped