org.saddle.Index

Abstract Value Members

abstract def argSort: Array[Int]

Returns offsets into index that would result in sorted index
abstract def concat[B, C](other: Index[B])(implicit p: Promoter[T, B, C], mc: ST[C], oc: ORD[C]): Index[C]

Concatenate two Index objects together
Concatenate two Index objects together
B
Type of other index
C
Result of promoting types A, B
other
Other index to concatenate
p
Implicit evidence of a Promoter which can send both T and B to C
mc
Implicit evidence of ST[C]
oc
Implicit evidence of ORD[C]
abstract def intersect(other: Index[T]): ReIndexer[T]

Produces a ReIndexer corresponding to the intersection of this Index with another.
Produces a ReIndexer corresponding to the intersection of this Index with another. Both indexes must have set semantics - ie, have no duplicates.
other
The other index
abstract def isContiguous: Boolean

Returns true if the index is either unique, or any two or more duplicate keys occur in consecutive locations in the index.
abstract def isMonotonic: Boolean

Returns true if the ordering of the elements of the Index is non-decreasing.
abstract def join(other: Index[T], how: JoinType = LeftJoin): ReIndexer[T]

Allows for the following SQL-style joins between this index and another:
Allows for the following SQL-style joins between this index and another:
- org.saddle.index.LeftJoin
- org.saddle.index.RightJoin
- org.saddle.index.InnerJoin
- org.saddle.index.OuterJoin
other
Another index
how
join type, see JoinType
abstract def length: Int

Number of elements in the index
abstract def locator: Locator[T]

Attributes
protected
abstract def lsearch(t: T): Int

Find the first location whereby inserting a key would maintain a sorted index.
Find the first location whereby inserting a key would maintain a sorted index. Index must already be sorted.
t
Key that would be inserted
abstract def map[B](f: (T) ⇒ B)(implicit arg0: ST[B], arg1: ORD[B]): Index[B]

Map over the elements in the Index, producing a new Index, similar to Map in the Scala collections.
Map over the elements in the Index, producing a new Index, similar to Map in the Scala collections.
B
Type of resulting elements
f
Function to map with
abstract def raw(loc: Int): T

Access an element directly within the index, without wrapping in a Scalar box.
Access an element directly within the index, without wrapping in a Scalar box.
loc
Offset into the index
abstract def reversed: Index[T]

Returns the index in reversed order
abstract def rsearch(t: T): Int

Find the last location whereby inserting a key would maintain a sorted index.
Find the last location whereby inserting a key would maintain a sorted index. Index must already be sorted.
t
Key that would be inserted
abstract def scalarTag: ScalarTag[T]

A ScalarTag representing the kind of Scalar found in this index.
abstract def slice(from: Int, until: Int, stride: Int = 1): Index[T]

Returns a slice of Index between two integers, including the from bound, and excluding the until bound.
Returns a slice of Index between two integers, including the from bound, and excluding the until bound.
from
Int, lower bound
until
Int, one past upper bound
stride
Default is 1, the step with which to advance over bound
abstract def take(locs: Array[Int]): Index[T]

Take values of the index at certain locations, returning a new Index consisting of those values.
Take values of the index at certain locations, returning a new Index consisting of those values.
See also org.saddle.array.take
locs
Locations to take
abstract def toVec: Vec[T]

Convert Index to a Vec
abstract def union(other: Index[T]): ReIndexer[T]

Produces a ReIndexer corresponding to the union of this Index with another.
Produces a ReIndexer corresponding to the union of this Index with another. Both indexes must have set semantics - ie, have no duplicates.
other
The other index
abstract def without(locs: Array[Int]): Index[T]

Complement of the take method; return a new Index whose values are those which do not occur at the specified locations.
Complement of the take method; return a new Index whose values are those which do not occur at the specified locations.
locs
Locations to omit

Concrete Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def apply(keys: Array[T]): Array[Int]

Given an array of keys, return the sequence of locations in the index at which those keys correspondingly occur, ignoring keys which do not exist.
Given an array of keys, return the sequence of locations in the index at which those keys correspondingly occur, ignoring keys which do not exist.
keys
Sequence of keys to find
def apply(keys: T*): Array[Int]

Given a sequence of keys, return the sequence of locations in the index at which those keys correspondingly occur, ignoring keys which do not exist.
Given a sequence of keys, return the sequence of locations in the index at which those keys correspondingly occur, ignoring keys which do not exist.
keys
Sequence of keys to find
final def asInstanceOf[T0]: T0

Definition Classes
Any
def at(locs: Int*): Index[T]

Retrieve several elements from the index at provided offsets
Retrieve several elements from the index at provided offsets
locs
A sequence of integer offsets
def at(locs: Array[Int]): Index[T]

Retrieve several elements from the index at provided offets
Retrieve several elements from the index at provided offets
locs
An array of integer offsets
def at(loc: Int): Scalar[T]

Retrieve an element of the index at a particular offset
Retrieve an element of the index at a particular offset
loc
Offset into index
def clone(): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def contains(key: T): Boolean

Returns true if the index contains at least one entry equal to the provided key
Returns true if the index contains at least one entry equal to the provided key
key
Key to query
def count(key: T): Int

Return the number of times the key occurs in the index
Return the number of times the key occurs in the index
key
The key to query
def counts: Array[Int]

Returns an array whose entries represent the number of times the corresponding entry in uniques occurs within the index.
def dropLevel[U, _](implicit ev: org.saddle.index.Splitter[T, U, _]): Index[U]

For an index which contains Tuples, drop the right-most element of each tuple, resulting in a new index.
For an index which contains Tuples, drop the right-most element of each tuple, resulting in a new index.
U
Type of elements of result index
ev
Implicit evidence of a Splitter instance that takes T (of arity N) to U (of arity N-1)
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(o: Any): Boolean

Default equality does an iterative, element-wise equality check of all values.
Default equality does an iterative, element-wise equality check of all values.

Definition Classes
Index → AnyRef → Any
def exists(pred: (T) ⇒ Boolean): Boolean

Returns true if there is an element which satisfies the predicate function,
Returns true if there is an element which satisfies the predicate function,
pred
Function from T => Boolean
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def findOne(pred: (T) ⇒ Boolean): Int

Returns the int location of the first element of the index to satisfy the predicate function, or -1 if no element satisfies the function.
Returns the int location of the first element of the index to satisfy the predicate function, or -1 if no element satisfies the function.
pred
Function from T => Boolean
def first: Scalar[T]

Returns the first element of the Index, or NA if there is none
def get(key: T): Array[Int]

Get location offsets within Index given a particular key
Get location offsets within Index given a particular key
key
Key with which to search
final def getClass(): java.lang.Class[_]

Definition Classes
AnyRef → Any
def getFirst(key: T): Int

Get first integer offset of a key
Get first integer offset of a key
key
Key to find in index
def getIndexer(other: Index[T]): Option[Array[Int]]

Generates offsets into current index given another index for the purposes of re-indexing.
Generates offsets into current index given another index for the purposes of re-indexing. For more on reindexing, see ReIndexer. If the current and other indexes are equal, a value of None is returned.
other
The other index with which to generate offsets
def getLast(key: T): Int

Get last integer offset of a key
Get last integer offset of a key
key
Key to find in index
def hashCode(): Int

Default hashcode is simple rolling prime multiplication of sums of hashcodes for all values.
Default hashcode is simple rolling prime multiplication of sums of hashcodes for all values.

Definition Classes
Index → AnyRef → Any
def head(n: Int): Index[T]

Returns a slice comprised of at most the first n elements of the Index
Returns a slice comprised of at most the first n elements of the Index
n
Number of elements to slice
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isUnique: Boolean

Returns true if there are no duplicate keys in the Index
def last: Scalar[T]

Returns the last element of the Index, or NA if there is none
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def next(current: Scalar[T]): Scalar[T]

Given a key, return the next value in the Index (in the natural, ie supplied, order).
Given a key, return the next value in the Index (in the natural, ie supplied, order). The Index must at least be contiguous, if not unique.
current
Key value to find
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def prev(current: Scalar[T]): Scalar[T]

Given a key, return the previous value in the Index (in the natural, ie supplied, order).
Given a key, return the previous value in the Index (in the natural, ie supplied, order). The Index must at least be contiguous, if not unique.
current
Key value to find
def print(len: Int = 10, stream: OutputStream = System.out): Unit

Pretty-printer for Index, which simply outputs the result of stringify.
Pretty-printer for Index, which simply outputs the result of stringify.
len
Number of elements to display
def sliceBy(rng: Slice[T]): Index[T]

Returns a slice of Index between two keys, including both the lower and upper keys.
Returns a slice of Index between two keys, including both the lower and upper keys.
rng
An instance of
def sliceBy(from: T, to: T, inclusive: Boolean = true): Index[T]

Returns a slice of an index between two keys; if inclusive is false, then exclude the upper bound.
Returns a slice of an index between two keys; if inclusive is false, then exclude the upper bound. Index must be sorted, as this method relies on lsearch and rsearch.
from
Key lower bound
to
Key upper bound
inclusive
If true (default), include upper bound in slice
def sorted: Index[T]

Returns the index in sorted (ascending) order
def split[O1, O2](implicit ev: Splitter[T, O1, O2]): (Index[O1], Index[O2])

Given this index contains tuples of arity N > 1, split will result in a pair of index instances; the left will have elements of arity N-1, and the right arity 1.
Given this index contains tuples of arity N > 1, split will result in a pair of index instances; the left will have elements of arity N-1, and the right arity 1.
O1
Left index type (of arity N-1)
O2
Right index type (of arity 1)
ev
Implicit evidence of an instance of Splitter
def stack[U, V](other: Index[U])(implicit ev: Stacker[T, U, V]): Index[V]

Given this index whose elements have arity N and another index of arity 1, form a result index whose entries are tuples of arity N+1 reflecting the Cartesian product of the two, in the provided order.
Given this index whose elements have arity N and another index of arity 1, form a result index whose entries are tuples of arity N+1 reflecting the Cartesian product of the two, in the provided order. See Stacker for more details.
U
The input type, of arity 1
V
The result type, of arity N+1
other
Another Index
ev
Implicit evidence of a Stacker
def stringify(len: Int = 10): String

Creates a string representation of Index
Creates a string representation of Index
len
Max number of elements to include
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail(n: Int): Index[T]

Returns a slice comprised of at most the last n elements of the Index
Returns a slice comprised of at most the last n elements of the Index
n
Number of elements to slice
def toSeq: IndexedSeq[T]

Convert Index elements to an IndexedSeq.
def toString(): String

Definition Classes
Index → AnyRef → Any
def uniques(implicit ord: ORD[T], tag: ST[T]): Index[T]

Returns an array of unique keys in the Index, in the order in which they originally appeared in the backing Vec.
Returns an array of unique keys in the Index, in the order in which they originally appeared in the backing Vec.
ord
Implicit ORD for instances of type T
tag
Implicit ST for instances of type T
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws()

Index

trait Index[T] extends Serializable

Abstract Value Members

abstract def argSort: Array[Int]

abstract def concat[B, C](other: Index[B])(implicit p: Promoter[T, B, C], mc: ST[C], oc: ORD[C]): Index[C]

abstract def intersect(other: Index[T]): ReIndexer[T]

abstract def isContiguous: Boolean

abstract def isMonotonic: Boolean

abstract def join(other: Index[T], how: JoinType = LeftJoin): ReIndexer[T]

abstract def length: Int

abstract def locator: Locator[T]

abstract def lsearch(t: T): Int

abstract def map[B](f: (T) ⇒ B)(implicit arg0: ST[B], arg1: ORD[B]): Index[B]

abstract def raw(loc: Int): T

abstract def reversed: Index[T]

abstract def rsearch(t: T): Int

abstract def scalarTag: ScalarTag[T]

abstract def slice(from: Int, until: Int, stride: Int = 1): Index[T]

abstract def take(locs: Array[Int]): Index[T]

abstract def toVec: Vec[T]

abstract def union(other: Index[T]): ReIndexer[T]

abstract def without(locs: Array[Int]): Index[T]

Concrete Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def apply(keys: Array[T]): Array[Int]

def apply(keys: T*): Array[Int]

final def asInstanceOf[T0]: T0

def at(locs: Int*): Index[T]

def at(locs: Array[Int]): Index[T]

def at(loc: Int): Scalar[T]

def clone(): AnyRef

def contains(key: T): Boolean

def count(key: T): Int

def counts: Array[Int]

def dropLevel[U, _](implicit ev: org.saddle.index.Splitter[T, U, _]): Index[U]

final def eq(arg0: AnyRef): Boolean

def equals(o: Any): Boolean

def exists(pred: (T) ⇒ Boolean): Boolean

def finalize(): Unit

def findOne(pred: (T) ⇒ Boolean): Int

def first: Scalar[T]

def get(key: T): Array[Int]

final def getClass(): java.lang.Class[_]

def getFirst(key: T): Int

def getIndexer(other: Index[T]): Option[Array[Int]]

def getLast(key: T): Int

def hashCode(): Int

def head(n: Int): Index[T]

final def isInstanceOf[T0]: Boolean

def isUnique: Boolean

def last: Scalar[T]

final def ne(arg0: AnyRef): Boolean

def next(current: Scalar[T]): Scalar[T]

final def notify(): Unit

final def notifyAll(): Unit

def prev(current: Scalar[T]): Scalar[T]

def print(len: Int = 10, stream: OutputStream = System.out): Unit

def sliceBy(rng: Slice[T]): Index[T]

def sliceBy(from: T, to: T, inclusive: Boolean = true): Index[T]

def sorted: Index[T]

def split[O1, O2](implicit ev: Splitter[T, O1, O2]): (Index[O1], Index[O2])

def stack[U, V](other: Index[U])(implicit ev: Stacker[T, U, V]): Index[V]

def stringify(len: Int = 10): String

final def synchronized[T0](arg0: ⇒ T0): T0

def tail(n: Int): Index[T]

def toSeq: IndexedSeq[T]

def toString(): String

def uniques(implicit ord: ORD[T], tag: ST[T]): Index[T]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any