Series

Aligns this series with another series, returning the two series aligned to each others indexes according to the the provided parameter

Extract a Series corresponding to those keys provided. Returns a new Series whose key-value pairs maintain the original ordering.

Extract a Series corresponding to those keys provided. Returns a new Series whose key-value pairs maintain the original ordering.

Extract a Series whose keys respect the Slice provided. Returns a new Series whose key-value pairs maintain the original ordering.

Access a boxed element of a Series at a single location

Access multiple locations of a Series, returning a new Series comprising those locations

Access multiple locations of a Series, returning a new Series comprising those locations

Concatenate two Series instances together whose indexes share the same type of element, and where there exists some way to join the values of the Series. For instance, Series[X, Double] concat Series[X, Int] will promote Int to Double as a result of the implicit existence of a Promoter[Double, Int, Double] instance. The result Index will simply be the concatenation of the two input Indexes.

Returns true if the index of the Series contains the key

Return the series with the first occurence of each key

Creates a Series having the same values but excluding all key/value pairs in which the value is NA.

Compares the receiver object (this) with the argument object (that) for equivalence.

Any implementation of this method should be an equivalence relation:

• It is reflexive: for any instance x of type Any, x.equals(x) should return true.
• It is symmetric: for any instances x and y of type Any, x.equals(y) should return true if and only if y.equals(x) returns true.
• It is transitive: for any instances x, y, and z of type Any if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.

If you override this method, you should verify that your implementation remains an equivalence relation. Additionally, when overriding this method it is usually necessary to override hashCode to ensure that objects which are "equal" (o1.equals(o2) returns true) hash to the same scala.Int. (o1.hashCode.equals(o2.hashCode)).

Return true if there exists some element of the Series which satisfies the predicate function

Fill NA values by propagating defined values backward.

Fill NA values by propagating defined values forward.

Fill NA values in series with result of a function which acts on the index of the particular NA value found.

Fill NA values by propagating defined values.

Return Series whose values satisfy a predicate function

Return Series whose offets satisfy a predicate function

Return Series whose index keys satisfy a predicate function

Search for the int offsets where the values of the Series satisfy a predicate function.

Search for the keys of the Series index whose corresponding values satisfy a predicate function.

Find the first int offset (or -1 if none) where a value of the Series satisfies a predicate function.

Find the first key (or NA if none) where a value of the Series satisfies a predicate function.

Get the first value of the Series

Get the first value of the Series whose key matches that provided

Get the first key of the Series

Map and then flatten over the key-value pairs of the Series, resulting in a new Series.

Alias for first. If a key exists, get the value associated with the first occurrence of that key.

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

Construct a org.saddle.groupby.SeriesGrouper 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 Index; each unique result of calling the function on elements of the Index corresponds to a group.

Construct a org.saddle.groupby.SeriesGrouper 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.

Return true if there is at least one NA value in the Series

Calculate a hash code value for the object.

The default hashing algorithm is platform dependent.

Note that it is allowed for two objects to have identical hash codes (o1.hashCode.equals(o2.hashCode)) yet not be equal (o1.equals(o2) returns false). A degenerate implementation could always return 0. However, it is required that if two objects are equal (o1.equals(o2) returns true) that they have identical hash codes (o1.hashCode.equals(o2.hashCode)). Therefore, when overriding this method, be sure to verify that the behavior is consistent with the equals method.

Extract at most the first n elements of the Series

True if and only if number of elements is zero

Perform a join with another Series[X, T] according to its index. The how argument dictates how the join is to be performed:

• Left org.saddle.index.LeftJoin
• Right org.saddle.index.RightJoin
• Inner org.saddle.index.InnerJoin
• Outer org.saddle.index.OuterJoin

The result is a Frame whose index is the result of the join, and whose column index is {0, 1}, and whose values are sourced from the original Series.

Perform a join with a Frame[X, _, T] according to its row index. The values of the other Frame must have the same type as the Series. The result is a Frame whose row index is the result of the join, and whose column index is [0, N), corresponding to the number of columns of the frame plus 1, and whose values are sourced from the original Series and Frame.

Join two series on their index and apply a function to each paired value; when either value is NA, the result of the function is forced to be NA.

Access a boxed element of a Series index at a single location

Access a multiple locations of a Series index, returning a new Index

Access a multiple locations of a Series index, returning a new Index

Get the last value of the Series

Get the last value of the Series whose key matches that provided

Get the last key of the Series

The length shared by both the index and the values array

Map over the key-value pairs of the Series, resulting in a new Series. Applies a function to each pair of values in the series.

Map a function over the index, resulting in a new Series

Map over the values of the Series, resulting in a new Series. Applies a function to each (non-na) value in the series, returning a new series whose index remains the same.

Map a function over the contents, resulting in a new Series

Create a new Series that, wherever the mask Vec is true, is masked with NA

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

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

Return key corresponding to maximum value in series

Return key corresponding to minimum value in series

Pivot splits an index of tuple keys of arity N into a row index having arity N-1 and a column index, producing a 2D Frame whose values are from the original Series as indexed by the corresponding keys.

To recover the original Series, the melt method of Frame may be used.

For example, given:

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

the pivot command does the following:

 res0.pivot
 res1: org.saddle.Frame[Char,Int,Int] =
 [2 x 2]
         1  2
       -- --
   a =>  1  2
   b =>  3  4

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

Fill series NA's with values using a secondary series

Access an unboxed element of a Series at a single location

Create a new Series whose index is the provided argument, and whose values are derived from the original Series.

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

Create a new Series whose index is newIx and whose values are derived from the original Series. For keys in newIx not contained in this series's index, the associated values are derived based on the filling method fillMethod against this series. This series must be monotonic, othrwise IllegalArgumentException is thrown.

Create a new Series whose values are the same, but whose Index has been changed to the bound [0, length - 1), as in an array.

Create a new Series whose values and index keys are both in reversed order

Produce a Series whose values are the result of executing a function on a sliding window of the data.

Left scan over the values of the Series, as in scala collections library, but with the resulting series having the same index. Note, differs from standard left scan because initial value is not retained in result.

Create a new Series using the current values but with the new index. Positions of the values do not change.

Shift the sequence of values relative to the 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.

Creates a view into original Series from one int offset until (exclusive) another offset. Data is not copied.

Creates a view into original Series from one key up to (inclusive by default) another key. Data is not copied. Series index must be sorted.

Creates a view into original Series from one key through another key as specified in the bound argument. Data is not copied. Series index must be sorted.

Create a new Series whose key/value entries are sorted according to the values of the Series.

Create a new Series whose key/value entries are sorted according to the keys (index values).

Split Series into two series at position i

Split Series into two series at key x

Return a series with the current index as values and current values as index

Extract at most the last n elements of the Series

Given int offets to take, form a new series from the keys and values found at those offsets.

Converts to a single-column Frame

Convert Series to an indexed sequence of (key, value) pairs.

Returns a string representation of the object.

The default representation is platform dependent.

Convert Series to a Vec, by dropping the index.

Additive inverse of Series with numeric elements

Replaces all occurences of key with value, if present

If idx is not present then returns the same Series

Replaces all occurences of key with value, if present

If idx is not present then returns the same Series

Return Series whose keys and values are chosen via a Series[_, Boolean] where the latter contains a true value.

Return Series whose keys and values are chosen via a Vec[Boolean] or a Series[_, Boolean] where the latter contains a true value.

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