BitVector

Instance Constructors

new BitVector(data: BitSet, length: Int, enforceLength: Boolean = true)

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 %[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpMod, That]): That

Alias for :%(b) when b is a scalar.
Alias for :%(b) when b is a scalar.

Definition Classes
NumericOps
final def %=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpMod]): BitVector

Alias for :%=(b) when b is a scalar.
Alias for :%=(b) when b is a scalar.

Definition Classes
NumericOps
final def &[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpAnd, That]): That

Alias for :&&(b) for all b.
Alias for :&&(b) for all b.

Definition Classes
NumericOps
final def &=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpAnd]): BitVector

Mutates this by element-wise and of this and b.
Mutates this by element-wise and of this and b.

Definition Classes
NumericOps
final def *[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpMulMatrix, That]): That

Matrix multiplication
Matrix multiplication

Definition Classes
NumericOps
final def *=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpMulScalar]): BitVector

Alias for :*=(b) when b is a scalar.
Alias for :*=(b) when b is a scalar.

Definition Classes
NumericOps
final def +[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpAdd, That]): That

Alias for :+(b) for all b.
Alias for :+(b) for all b.

Definition Classes
NumericOps
final def +=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpAdd]): BitVector

Alias for :+=(b) for all b.
Alias for :+=(b) for all b.

Definition Classes
NumericOps
final def -[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpSub, That]): That

Alias for :-(b) for all b.
Alias for :-(b) for all b.

Definition Classes
NumericOps
final def -=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpSub]): BitVector

Alias for :-=(b) for all b.
Alias for :-=(b) for all b.

Definition Classes
NumericOps
final def /[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpDiv, That]): That

Alias for :/(b) when b is a scalar.
Alias for :/(b) when b is a scalar.

Definition Classes
NumericOps
final def /=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpDiv]): BitVector

Alias for :/=(b) when b is a scalar.
Alias for :/=(b) when b is a scalar.

Definition Classes
NumericOps
final def :!=[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpNe, That]): That

Element-wise inequality comparator of this and b.
Element-wise inequality comparator of this and b.

Definition Classes
NumericOps
final def :%[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpMod, That]): That

Element-wise modulo of this and b.
Element-wise modulo of this and b.

Definition Classes
NumericOps
final def :%=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpMod]): BitVector

Mutates this by element-wise modulo of b into this.
Mutates this by element-wise modulo of b into this.

Definition Classes
NumericOps
final def :&[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpAnd, That]): That

Element-wise logical "and" operator -- returns true if corresponding elements are non-zero.
Element-wise logical "and" operator -- returns true if corresponding elements are non-zero.

Definition Classes
NumericOps
final def :&=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpAnd]): BitVector

Mutates this by element-wise and of this and b.
Mutates this by element-wise and of this and b.

Definition Classes
NumericOps
final def :*[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpMulScalar, That]): That

Element-wise product of this and b.
Element-wise product of this and b.

Definition Classes
NumericOps
final def :*=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpMulScalar]): BitVector

Mutates this by element-wise multiplication of b into this.
Mutates this by element-wise multiplication of b into this.

Definition Classes
NumericOps
final def :+[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpAdd, That]): That

Element-wise sum of this and b.
Element-wise sum of this and b.

Definition Classes
NumericOps
final def :+=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpAdd]): BitVector

Mutates this by element-wise addition of b into this.
Mutates this by element-wise addition of b into this.

Definition Classes
NumericOps
final def :-[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpSub, That]): That

Element-wise difference of this and b.
Element-wise difference of this and b.

Definition Classes
NumericOps
final def :-=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpSub]): BitVector

Mutates this by element-wise subtraction of b from this
Mutates this by element-wise subtraction of b from this

Definition Classes
NumericOps
final def :/[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpDiv, That]): That

Element-wise quotient of this and b.
Element-wise quotient of this and b.

Definition Classes
NumericOps
final def :/=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpDiv]): BitVector

Mutates this by element-wise division of b into this
Mutates this by element-wise division of b into this

Definition Classes
NumericOps
final def :<[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpLT, That]): That

Element-wise less=than comparator of this and b.
Element-wise less=than comparator of this and b.

Definition Classes
NumericOps
final def :<=[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpLTE, That]): That

Element-wise less-than-or-equal-to comparator of this and b.
Element-wise less-than-or-equal-to comparator of this and b.

Definition Classes
NumericOps
final def :=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpSet]): BitVector

Mutates this by element-wise assignment of b into this.
Mutates this by element-wise assignment of b into this.

Definition Classes
NumericOps
final def :==[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpEq, That]): That

Element-wise equality comparator of this and b.
Element-wise equality comparator of this and b.

Definition Classes
NumericOps
final def :>[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpGT, That]): That

Element-wise greater-than comparator of this and b.
Element-wise greater-than comparator of this and b.

Definition Classes
NumericOps
final def :>=[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpGTE, That]): That

Element-wise greater-than-or-equal-to comparator of this and b.
Element-wise greater-than-or-equal-to comparator of this and b.

Definition Classes
NumericOps
final def :^[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpPow, That]): That

Element-wise exponentiation of this and b.
Element-wise exponentiation of this and b.

Definition Classes
NumericOps
final def :^=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpPow]): BitVector

Mutates this by element-wise exponentiation of this by b.
Mutates this by element-wise exponentiation of this by b.

Definition Classes
NumericOps
final def :^^[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpXor, That]): That

Element-wise logical "xor" operator -- returns true if only one of the corresponding elements is non-zero.
Element-wise logical "xor" operator -- returns true if only one of the corresponding elements is non-zero.

Definition Classes
NumericOps
final def :^^=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpXor]): BitVector

Mutates this by element-wise xor of this and b.
Mutates this by element-wise xor of this and b.

Definition Classes
NumericOps
final def :|[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpOr, That]): That

Element-wise logical "or" operator -- returns true if either element is non-zero.
Element-wise logical "or" operator -- returns true if either element is non-zero.

Definition Classes
NumericOps
final def :|=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpOr]): BitVector

Mutates this by element-wise or of this and b.
Mutates this by element-wise or of this and b.

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

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

Definition Classes
Any
def \[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpSolveMatrixBy, That]): That

Shaped solve of this by b.
Shaped solve of this by b.

Definition Classes
NumericOps
final def ^^[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpXor, That]): That

Alias for :^^(b) for all b.
Alias for :^^(b) for all b.

Definition Classes
NumericOps
final def ^^=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpXor]): BitVector

Mutates this by element-wise xor of this and b.
Mutates this by element-wise xor of this and b.

Definition Classes
NumericOps
def active: TensorActive[Int, Boolean, BitVector]

Definition Classes
TensorLike
def activeIterator: Iterator[(Int, Boolean)]

Definition Classes
BitVector → QuasiTensor
def activeKeysIterator: Iterator[Int]

Definition Classes
BitVector → QuasiTensor
def activeSize: Int

Definition Classes
BitVector → TensorLike
def activeValuesIterator: Iterator[Boolean]

This will just be a bunch of true values.
This will just be a bunch of true values.

Definition Classes
BitVector → QuasiTensor
def all(implicit semi: Semiring[Boolean]): Boolean

Returns true if all elements are non-zero
Returns true if all elements are non-zero

Definition Classes
QuasiTensor
def any(implicit semi: Semiring[Boolean]): Boolean

Returns true if no elements are non-zero
Returns true if no elements are non-zero

Definition Classes
QuasiTensor
def apply(i: Int): Boolean

Definition Classes
BitVector → TensorLike → QuasiTensor
def apply[Slice1, Slice2, Result](slice1: Slice1, slice2: Slice2)(implicit canSlice: CanSlice2[BitVector, Slice1, Slice2, Result]): Result

Method for slicing that is tuned for Matrices.
Method for slicing that is tuned for Matrices.
returns

Definition Classes
TensorLike
def apply[Result](a: Int, slice: Int*)(implicit canSlice: CanSlice[BitVector, Seq[Int], Result]): Result

Slice a sequence of elements.
Slice a sequence of elements. Must be at least 2.
Result
a
slice
canSlice
returns

Definition Classes
TensorLike
def apply[Slice, Result](slice: Slice)(implicit canSlice: CanSlice[BitVector, Slice, Result]): Result

method for slicing a tensor.
method for slicing a tensor. For instance, DenseVectors support efficient slicing by a Range object.
returns

Definition Classes
TensorLike
def argmax(implicit ord: Ordering[Boolean]): Int

Definition Classes
QuasiTensor
def argmin(implicit ord: Ordering[Boolean]): Int

Definition Classes
QuasiTensor
def argsort(implicit ord: Ordering[Boolean]): IndexedSeq[Int]

Definition Classes
QuasiTensor
def argtopk(k: Int)(implicit ordering: Ordering[Boolean]): IndexedSeq[Int]

Returns the k indices with maximum value.
Returns the k indices with maximum value. (NOT absolute value.)
k
how many to return
ordering
returns

Definition Classes
QuasiTensor
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def copy: BitVector

Definition Classes
BitVector → VectorLike
val data: BitSet
final def dot[TT >: BitVector, B, BB >: B, That](b: B)(implicit op: BinaryOp[TT, BB, OpMulInner, That]): That

Inner product of this and b.
Inner product of this and b.

Definition Classes
NumericOps
val enforceLength: Boolean
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
Vector → AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def findAll(f: (Boolean) ⇒ Boolean): IndexedSeq[Int]

Returns all indices k whose value satisfies a predicate.
Returns all indices k whose value satisfies a predicate.

Definition Classes
QuasiTensor
def forall(fn: (Int, Boolean) ⇒ Boolean): Boolean

Returns true if and only if the given predicate is true for all elements.
Returns true if and only if the given predicate is true for all elements.

Definition Classes
TensorLike
def forallValues(fn: (Boolean) ⇒ Boolean): Boolean

Returns true if and only if the given predicate is true for all elements.
Returns true if and only if the given predicate is true for all elements.

Definition Classes
TensorLike
def foreach[U](fn: (Boolean) ⇒ U): Unit

Definition Classes
VectorLike
def foreachKey[U](fn: (Int) ⇒ U): Unit

Applies the given function to each key in the tensor.
Applies the given function to each key in the tensor.

Definition Classes
TensorLike
def foreachPair[U](fn: (Int, Boolean) ⇒ U): Unit

Applies the given function to each key and its corresponding value.
Applies the given function to each key and its corresponding value.

Definition Classes
TensorLike
def foreachValue[U](fn: (Boolean) ⇒ U): Unit

Applies the given function to each value in the map (one for each element of the domain, including zeros).
Applies the given function to each value in the map (one for each element of the domain, including zeros).

Definition Classes
TensorLike
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterator: Iterator[(Int, Boolean)]

Definition Classes
Vector → QuasiTensor
def keySet: Set[Int]

returns
the set of keys in this vector (0 until length)

Definition Classes
Vector → QuasiTensor
def keys: TensorKeys[Int, Boolean, BitVector]

Definition Classes
TensorLike
def keysIterator: Iterator[Int]

Definition Classes
Vector → QuasiTensor
val length: Int

Definition Classes
BitVector → Vector
def lengthsMatch(other: Vector[_]): Boolean
def map[E2, That](fn: (Boolean) ⇒ E2)(implicit canMapValues: CanMapValues[BitVector, Boolean, E2, That]): That

Definition Classes
VectorLike
def mapActivePairs[TT >: BitVector, O, That](f: (Int, Boolean) ⇒ O)(implicit bf: CanMapKeyValuePairs[TT, Int, Boolean, O, That]): That

Maps all active key-value pairs values.
Maps all active key-value pairs values.

Definition Classes
TensorLike
def mapActiveValues[TT >: BitVector, O, That](f: (Boolean) ⇒ O)(implicit bf: CanMapValues[TT, Boolean, O, That]): That

Maps all non-zero values.
Maps all non-zero values.

Definition Classes
TensorLike
def mapPairs[TT >: BitVector, O, That](f: (Int, Boolean) ⇒ O)(implicit bf: CanMapKeyValuePairs[TT, Int, Boolean, O, That]): That

Creates a new map containing a transformed copy of this map.
Creates a new map containing a transformed copy of this map.

Definition Classes
TensorLike
def mapValues[TT >: BitVector, O, That](f: (Boolean) ⇒ O)(implicit bf: CanMapValues[TT, Boolean, O, That]): That

Creates a new map containing a transformed copy of this map.
Creates a new map containing a transformed copy of this map.

Definition Classes
TensorLike
def max(implicit ord: Ordering[Boolean]): Boolean

Definition Classes
QuasiTensor
def min(implicit ord: Ordering[Boolean]): Boolean

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

Definition Classes
AnyRef
def norm(n: Double)(implicit ring: Ring[Boolean]): Double

Returns the k-norm of this Vector.
Returns the k-norm of this Vector.

Definition Classes
Vector
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def pairs: TensorPairs[Int, Boolean, BitVector]

Definition Classes
TensorLike
def repr: BitVector

Definition Classes
BitVector → NumericOps
def size: Int

Definition Classes
Vector → TensorLike
def sum(implicit num: Numeric[Boolean]): Boolean

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

Definition Classes
AnyRef
final def t[TT >: BitVector, That, Slice1, Slice2, Result](a: Slice1, b: Slice2)(implicit op: CanTranspose[TT, That], canSlice: CanSlice2[That, Slice1, Slice2, Result]): Result

A transposed view of this object, followed by a slice.
A transposed view of this object, followed by a slice. Sadly frequently necessary.

Definition Classes
NumericOps
final def t[TT >: BitVector, That](implicit op: CanTranspose[TT, That]): That

A transposed view of this object.
A transposed view of this object.

Definition Classes
NumericOps
def toArray(implicit cm: ClassTag[Boolean]): Array[Boolean]

Definition Classes
Vector
def toDenseVector(implicit cm: ClassTag[Boolean]): DenseVector[Boolean]

Definition Classes
Vector
def toString(): String

Definition Classes
BitVector → AnyRef → Any
final def unary_![TT >: BitVector, That](implicit op: UnaryOp[TT, OpNot, That]): That

Definition Classes
NumericOps
final def unary_-[TT >: BitVector, That](implicit op: UnaryOp[TT, OpNeg, That]): That

Definition Classes
NumericOps
def update(i: Int, v: Boolean): Unit

Definition Classes
BitVector → TensorLike → QuasiTensor
def ureduce[A](f: URFunc[Boolean, A]): A

Definition Classes
QuasiTensor
def values: TensorValues[Int, Boolean, BitVector]

Definition Classes
TensorLike
def valuesIterator: Iterator[Boolean]

Definition Classes
Vector → QuasiTensor
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( ... )
final def |[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpOr, That]): That

Alias for :||(b) for all b.
Alias for :||(b) for all b.

Definition Classes
NumericOps
final def |=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpOr]): BitVector

Mutates this by element-wise or of this and b.
Mutates this by element-wise or of this and b.

Definition Classes
NumericOps

class BitVector extends Vector[Boolean] with VectorLike[Boolean, BitVector]

Instance Constructors

new BitVector(data: BitSet, length: Int, enforceLength: Boolean = true)

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def %[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpMod, That]): That

final def %=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpMod]): BitVector

final def &[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpAnd, That]): That

final def &=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpAnd]): BitVector

final def *[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpMulMatrix, That]): That

final def *=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpMulScalar]): BitVector

final def +[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpAdd, That]): That

final def +=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpAdd]): BitVector

final def -[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpSub, That]): That

final def -=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpSub]): BitVector

final def /[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpDiv, That]): That

final def /=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpDiv]): BitVector

final def :!=[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpNe, That]): That

final def :%[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpMod, That]): That

final def :%=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpMod]): BitVector

final def :&[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpAnd, That]): That

final def :&=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpAnd]): BitVector

final def :*[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpMulScalar, That]): That

final def :*=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpMulScalar]): BitVector

final def :+[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpAdd, That]): That

final def :+=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpAdd]): BitVector

final def :-[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpSub, That]): That

final def :-=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpSub]): BitVector

final def :/[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpDiv, That]): That

final def :/=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpDiv]): BitVector

final def :<[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpLT, That]): That

final def :<=[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpLTE, That]): That

final def :=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpSet]): BitVector

final def :==[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpEq, That]): That

final def :>[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpGT, That]): That

final def :>=[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpGTE, That]): That

final def :^[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpPow, That]): That

final def :^=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpPow]): BitVector

final def :^^[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpXor, That]): That

final def :^^=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpXor]): BitVector

final def :|[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpOr, That]): That

final def :|=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpOr]): BitVector

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def \[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpSolveMatrixBy, That]): That

final def ^^[TT >: BitVector, B, That](b: B)(implicit op: BinaryOp[TT, B, OpXor, That]): That

final def ^^=[TT >: BitVector, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpXor]): BitVector

def active: TensorActive[Int, Boolean, BitVector]

def activeIterator: Iterator[(Int, Boolean)]

def activeKeysIterator: Iterator[Int]

def activeSize: Int

def activeValuesIterator: Iterator[Boolean]

def all(implicit semi: Semiring[Boolean]): Boolean

def any(implicit semi: Semiring[Boolean]): Boolean

def apply(i: Int): Boolean

def apply[Slice1, Slice2, Result](slice1: Slice1, slice2: Slice2)(implicit canSlice: CanSlice2[BitVector, Slice1, Slice2, Result]): Result

def apply[Result](a: Int, slice: Int*)(implicit canSlice: CanSlice[BitVector, Seq[Int], Result]): Result

def apply[Slice, Result](slice: Slice)(implicit canSlice: CanSlice[BitVector, Slice, Result]): Result

def argmax(implicit ord: Ordering[Boolean]): Int

def argmin(implicit ord: Ordering[Boolean]): Int

def argsort(implicit ord: Ordering[Boolean]): IndexedSeq[Int]

def argtopk(k: Int)(implicit ordering: Ordering[Boolean]): IndexedSeq[Int]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def copy: BitVector

val data: BitSet

final def dot[TT >: BitVector, B, BB >: B, That](b: B)(implicit op: BinaryOp[TT, BB, OpMulInner, That]): That

val enforceLength: Boolean

final def eq(arg0: AnyRef): Boolean

def equals(p1: Any): Boolean

def finalize(): Unit

def findAll(f: (Boolean) ⇒ Boolean): IndexedSeq[Int]

def forall(fn: (Int, Boolean) ⇒ Boolean): Boolean

def forallValues(fn: (Boolean) ⇒ Boolean): Boolean

def foreach[U](fn: (Boolean) ⇒ U): Unit

def foreachKey[U](fn: (Int) ⇒ U): Unit

def foreachPair[U](fn: (Int, Boolean) ⇒ U): Unit