MatLong

Instance Constructors

new MatLong(r: Int, c: Int, values: Array[Long])

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
def %[B, That](other: B)(implicit op: BinOp[Mod, Mat[Long], 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
def &[B, That](other: B)(implicit op: BinOp[BitAnd, Mat[Long], 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
def &&[B, That](other: B)(implicit op: BinOp[AndOp, Mat[Long], 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
def *[B, That](other: B)(implicit op: BinOp[Multiply, Mat[Long], 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
def **[B, That](other: B)(implicit op: BinOp[Power, Mat[Long], 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
def +[B, That](other: B)(implicit op: BinOp[Add, Mat[Long], 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
def -[B, That](other: B)(implicit op: BinOp[Subtract, Mat[Long], 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
def /[B, That](other: B)(implicit op: BinOp[Divide, Mat[Long], 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
def <[B, That](other: B)(implicit op: BinOp[LtOp, Mat[Long], 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
def <<[B, That](other: B)(implicit op: BinOp[BitShl, Mat[Long], 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
def <=[B, That](other: B)(implicit op: BinOp[LteOp, Mat[Long], 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
def <>[B, That](other: B)(implicit op: BinOp[NeqOp, Mat[Long], 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
final def ==(arg0: AnyRef): Boolean

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

Definition Classes
Any
def =?[B, That](other: B)(implicit op: BinOp[EqOp, Mat[Long], 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
def >[B, That](other: B)(implicit op: BinOp[GtOp, Mat[Long], 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
def >=[B, That](other: B)(implicit op: BinOp[GteOp, Mat[Long], 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
def >>[B, That](other: B)(implicit op: BinOp[BitShr, Mat[Long], 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
def >>>[B, That](other: B)(implicit op: BinOp[BitUShr, Mat[Long], 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
def T: Mat[Long]

Transpose of original matrix
Transpose of original matrix

Definition Classes
Mat
def ^[B, That](other: B)(implicit op: BinOp[BitXor, Mat[Long], 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
final def asInstanceOf[T0]: T0

Definition Classes
Any
def at(r: Int, c: Int): Scalar[Long]

Return scalar value of matrix at at row/column
Return scalar value of matrix at at row/column
r
row index
c
col index

Definition Classes
Mat
def at(i: Int): Scalar[Long]

Return scalar value of matrix at offset from zero in row-major order
Return scalar value of matrix at offset from zero in row-major order
i
index

Definition Classes
Mat
lazy val cachedT: MatLong
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
def col(c: Int)(implicit ev: ST[Long]): Vec[Long]

Returns a specific column of the Mat as a Vec
Returns a specific column of the Mat as a Vec
c
Column index

Definition Classes
Mat
def cols()(implicit ev: ST[Long]): IndexedSeq[Vec[Long]]

Returns columns of matrix as an indexed sequence of Vec instances
Returns columns of matrix as an indexed sequence of Vec instances

Definition Classes
Mat
def colsWithNA(implicit ev: ST[Long]): Set[Int]

Yields column indices where column has some NA value
Yields column indices where column has some NA value

Definition Classes
Mat
def contents: Array[Long]

Returns (a copy of) the contents of matrix as a single array in row-major order
Returns (a copy of) the contents of matrix as a single array in row-major order

Definition Classes
Mat
def copy: Mat[Long]

Copy of original matrix
Copy of original matrix

Definition Classes
MatLong → Mat
def dot[B, That](other: B)(implicit op: BinOp[InnerProd, Mat[Long], 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
def dropColsWithNA(implicit ev: ST[Long]): Mat[Long]

Yields a matrix without those cols that have NA
Yields a matrix without those cols that have NA

Definition Classes
Mat
def dropRowsWithNA(implicit ev: ST[Long]): Mat[Long]

Yields a matrix without those rows that have NA
Yields a matrix without those rows that have NA

Definition Classes
Mat
final def eq(arg0: AnyRef): Boolean

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

Row-by-row equality check of all values.
Row-by-row equality check of all values.

Definition Classes
MatLong → Mat → AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
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
Mat → AnyRef → Any
def isEmpty: Boolean

Returns true if the matrix is empty
Returns true if the matrix is empty

Definition Classes
Mat
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isSquare: Boolean

Returns true if rows == cols
Returns true if rows == cols

Definition Classes
Mat
def length: Int

Returns total number of entries in the matrix
Returns total number of entries in the matrix

Definition Classes
Mat
def map[B](f: (Long) ⇒ B)(implicit arg0: ST[B]): Mat[B]

Maps a function over each element in the matrix
Maps a function over each element in the matrix

Definition Classes
MatLong → Mat
def mult[B](m: Mat[B])(implicit evA: NUM[Long], evB: NUM[B]): Mat[Double]

Multiplies this matrix against another
Multiplies this matrix against another

Definition Classes
Mat
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def numCols: Int

Returns number of columns in the matrix shape
Returns number of columns in the matrix shape

Definition Classes
MatLong → Mat
def numRows: Int

Returns number of rows in the matrix shape
Returns number of rows in the matrix shape

Definition Classes
MatLong → Mat
def outer[B, That](other: B)(implicit op: BinOp[OuterProd, Mat[Long], 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
def print(nrows: Int = 8, ncols: Int = 8, stream: OutputStream = System.out): Unit

Pretty-printer for Mat, which simply outputs the result of stringify.
Pretty-printer for Mat, which simply outputs the result of stringify.
nrows
Number of elements to display

Definition Classes
Mat
def raw(r: Int, c: Int): Long

Return unboxed value of matrix at row/column
Return unboxed value of matrix at row/column
r
row index
c
col index

Definition Classes
Mat
def raw(i: Int): Long

Return unboxed value of matrix at an offset from zero in row-major order
Return unboxed value of matrix at an offset from zero in row-major order
i
index

Definition Classes
Mat
def repr: MatLong
def reshape(r: Int, c: Int): Mat[Long]

Changes the shape of matrix without changing the underlying data
Changes the shape of matrix without changing the underlying data

Definition Classes
MatLong → Mat
def roundTo(sig: Int = 2)(implicit ev: NUM[Long]): Mat[Double]

Rounds elements in the matrix (which must be numeric) to a significance level
Rounds elements in the matrix (which must be numeric) to a significance level
sig
Significance level to round to (e.g., 2 decimal places)

Definition Classes
Mat
def row(r: Int)(implicit ev: ST[Long]): Vec[Long]

Returns a specific row of the Mat as a Vec
Returns a specific row of the Mat as a Vec
r
Row index

Definition Classes
Mat
def rows()(implicit ev: ST[Long]): IndexedSeq[Vec[Long]]

Returns rows of matrix as an indexed sequence of Vec instances
Returns rows of matrix as an indexed sequence of Vec instances

Definition Classes
Mat
def rowsWithNA(implicit ev: ST[Long]): Set[Int]

Yields row indices where row has some NA value
Yields row indices where row has some NA value

Definition Classes
Mat
def scalarTag: ScalarTagLong.type

Definition Classes
MatLong → Mat
def stringify(nrows: Int = 8, ncols: Int = 8): String

Creates a string representation of Mat
Creates a string representation of Mat
nrows
Max number of rows to include
ncols
Max number of cols to include

Definition Classes
Mat
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def takeCols(locs: Array[Int]): Mat[Long]

Create Mat comprised of same values in specified columns
Create Mat comprised of same values in specified columns

Definition Classes
Mat
def takeRows(locs: Array[Int]): Mat[Long]

Create Mat comprised of same values in specified rows
Create Mat comprised of same values in specified rows

Definition Classes
MatLong → Mat
def toString(): String

Definition Classes
Mat → AnyRef → Any
def toVec: VecLong

Concatenate all rows into a single row-wise Vec instance
Concatenate all rows into a single row-wise Vec instance

Definition Classes
MatLong → Mat
def transpose: MatLong

Transpose of original matrix
Transpose of original matrix

Definition Classes
MatLong → Mat
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()
def withoutCols(locs: Array[Int]): Mat[Long]

Create Mat comprised of same values without the specified columns
Create Mat comprised of same values without the specified columns
locs
Col locations to exclude

Definition Classes
Mat
def withoutRows(locs: Array[Int]): Mat[Long]

Create Mat comprised of same values without the specified rows
Create Mat comprised of same values without the specified rows
locs
Row locations to exclude

Definition Classes
MatLong → Mat
def xor[B, That](other: B)(implicit op: BinOp[XorOp, Mat[Long], 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
def |[B, That](other: B)(implicit op: BinOp[BitOr, Mat[Long], 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
def ||[B, That](other: B)(implicit op: BinOp[OrOp, Mat[Long], 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

class MatLong extends Mat[Long]

Instance Constructors

new MatLong(r: Int, c: Int, values: Array[Long])

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def %[B, That](other: B)(implicit op: BinOp[Mod, Mat[Long], B, That]): That

def &[B, That](other: B)(implicit op: BinOp[BitAnd, Mat[Long], B, That]): That

def &&[B, That](other: B)(implicit op: BinOp[AndOp, Mat[Long], B, That]): That

def *[B, That](other: B)(implicit op: BinOp[Multiply, Mat[Long], B, That]): That

def **[B, That](other: B)(implicit op: BinOp[Power, Mat[Long], B, That]): That

def +[B, That](other: B)(implicit op: BinOp[Add, Mat[Long], B, That]): That

def -[B, That](other: B)(implicit op: BinOp[Subtract, Mat[Long], B, That]): That

def /[B, That](other: B)(implicit op: BinOp[Divide, Mat[Long], B, That]): That

def <[B, That](other: B)(implicit op: BinOp[LtOp, Mat[Long], B, That]): That

def <<[B, That](other: B)(implicit op: BinOp[BitShl, Mat[Long], B, That]): That

def <=[B, That](other: B)(implicit op: BinOp[LteOp, Mat[Long], B, That]): That

def <>[B, That](other: B)(implicit op: BinOp[NeqOp, Mat[Long], B, That]): That

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def =?[B, That](other: B)(implicit op: BinOp[EqOp, Mat[Long], B, That]): That

def >[B, That](other: B)(implicit op: BinOp[GtOp, Mat[Long], B, That]): That

def >=[B, That](other: B)(implicit op: BinOp[GteOp, Mat[Long], B, That]): That

def >>[B, That](other: B)(implicit op: BinOp[BitShr, Mat[Long], B, That]): That

def >>>[B, That](other: B)(implicit op: BinOp[BitUShr, Mat[Long], B, That]): That

def T: Mat[Long]

def ^[B, That](other: B)(implicit op: BinOp[BitXor, Mat[Long], B, That]): That

final def asInstanceOf[T0]: T0

def at(r: Int, c: Int): Scalar[Long]

def at(i: Int): Scalar[Long]

lazy val cachedT: MatLong

def clone(): AnyRef

def col(c: Int)(implicit ev: ST[Long]): Vec[Long]

def cols()(implicit ev: ST[Long]): IndexedSeq[Vec[Long]]

def colsWithNA(implicit ev: ST[Long]): Set[Int]

def contents: Array[Long]

def copy: Mat[Long]

def dot[B, That](other: B)(implicit op: BinOp[InnerProd, Mat[Long], B, That]): That

def dropColsWithNA(implicit ev: ST[Long]): Mat[Long]

def dropRowsWithNA(implicit ev: ST[Long]): Mat[Long]

final def eq(arg0: AnyRef): Boolean

def equals(o: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def isSquare: Boolean

def length: Int

def map[B](f: (Long) ⇒ B)(implicit arg0: ST[B]): Mat[B]

def mult[B](m: Mat[B])(implicit evA: NUM[Long], evB: NUM[B]): Mat[Double]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def numCols: Int

def numRows: Int

def outer[B, That](other: B)(implicit op: BinOp[OuterProd, Mat[Long], B, That]): That

def print(nrows: Int = 8, ncols: Int = 8, stream: OutputStream = System.out): Unit

def raw(r: Int, c: Int): Long

def raw(i: Int): Long

def repr: MatLong

def reshape(r: Int, c: Int): Mat[Long]

def roundTo(sig: Int = 2)(implicit ev: NUM[Long]): Mat[Double]

def row(r: Int)(implicit ev: ST[Long]): Vec[Long]

def rows()(implicit ev: ST[Long]): IndexedSeq[Vec[Long]]

def rowsWithNA(implicit ev: ST[Long]): Set[Int]

def scalarTag: ScalarTagLong.type

def stringify(nrows: Int = 8, ncols: Int = 8): String

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

def takeCols(locs: Array[Int]): Mat[Long]

def takeRows(locs: Array[Int]): Mat[Long]

def toString(): String

def toVec: VecLong

def transpose: MatLong

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withoutCols(locs: Array[Int]): Mat[Long]