Frame

The transpose of the frame (swapping the axes)

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

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.

See addCol, operates row-wise.

See addRow; operates row-wise.

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

Slice frame by row and column slice specifiers

Slice frame by row slice and array of column keys

Slice frame by array of row keys and a col slice

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

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

Access a slice of the Frame by integer offsets

Access a slice of the Frame by integer offsets

Access a slice of the Frame by integer offsets

Access a slice of the Frame by Slice parameters

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

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

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

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

Access frame column at a particular integer offset

Access frame columns at a particular integer offsets

Access frame columns at a particular integer offsets

Access frame columns specified by a slice

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

Slice out a set of columns from the frame

Split Frame into two frames at column position c

Split Frame into two frames at column key k

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

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

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

Count of the elements of each column, ignoring NA values

See shift; operates col-wise

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

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

Return empty series of type equivalent to a column of frame

Return empty series of type equivalent to a row of frame

Fill NAs with a defined value.

Fill NA values by propagating defined values column-wise.

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

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

Extract first row matching a particular key

Extract first col matching a particular key

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

Return scalar of first row and column found

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.

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.

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.

Extract first n rows

Extract first n columns

Returns true if there are no values in the Frame

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.

Extract last row matching a particular key

Extract first col matching a particular key

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

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

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

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

Map a function over the rows, resulting in a new 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.

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

Create a new Frame that, whenever the mask predicate function evaluates to true on a 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

Max of the elements of each column, ignoring NA values

Mean of each column

Median of each column

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

Min of the elements of each column, ignoring NA values

Number of cols in the Frame

Number of rows in the Frame

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

Product of the elements of each column, ignoring NA values

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

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

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

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

See dropNA; operates row-wise

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

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.

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 row index is formed of the provided argument, and whose values are derived from the original Frame.

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.

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.

See filter; operates row-wise

See filterAt; operates row-wise

See filterIx; operates row-wise

See mapVec; operates row-wise

See mask; operates row-wise

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

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.

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

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

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

Access frame row at a particular integer offset

Access frame rows at a particular integer offsets

Access frame rows at a particular integer offsets

Access frame rows specified by a slice

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

Slice out a set of rows from the frame

Split Frame into two frames at row position r

Split Frame into two frames at row key k

See reduce; operates row-wise

See squeeze; operates row-wise

See transform; operates row-wise

See where; operates row-wise

See where; operates row-wise

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.

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.

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.

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

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

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 by the result of a function acting on each col.

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

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

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 by the result of a function acting on each row.

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

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.

Creates a string representation of Frame

Sum of the elements of each column, ignoring NA values

Extract last n rows

Extract last n columns

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

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

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

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

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.

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

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.

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.

Overloaded method to create hierarchical index from two rows.

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.

Overloaded method to create hierarchical index from two cols.

Integer modulus of division

Bit-wise AND

Logical AND

Multiplication

Exponentiation

Addition

Subtraction

Division

Less-than comparison operator

Bit-shift left

Less-than-or-equal-to comparison operator

Element-wise inequality operator

Element-wise equality operator

Greater-than comparison operator

Greater-than-or-equal-to comparison operator

Bit-shift right (arithmetic)

Bit-shift right (logical)

Bit-wise EXCLUSIVE OR

Dot (inner) product

Outer product

Logical EXCLUSIVE OR

Bit-wise OR

Logical OR