object Frame extends BinOpFrame
- Alphabetic
- By Inheritance
- Frame
- BinOpFrame
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- implicit def FrFrEOpBBB[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Boolean], Vec[Boolean], Vec[Boolean]]): FrFrEOp[Op, X, Y, Boolean, Boolean, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpDDB[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Double], Vec[Double], Vec[Boolean]]): FrFrEOp[Op, X, Y, Double, Double, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpDDD[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Double], Vec[Double], Vec[Double]]): FrFrEOp[Op, X, Y, Double, Double, Double]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpDIB[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Double], Vec[Int], Vec[Boolean]]): FrFrEOp[Op, X, Y, Double, Int, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpDID[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Double], Vec[Int], Vec[Double]]): FrFrEOp[Op, X, Y, Double, Int, Double]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpDLB[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Double], Vec[Long], Vec[Boolean]]): FrFrEOp[Op, X, Y, Double, Long, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpDLD[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Double], Vec[Long], Vec[Double]]): FrFrEOp[Op, X, Y, Double, Long, Double]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpIDB[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Int], Vec[Double], Vec[Boolean]]): FrFrEOp[Op, X, Y, Int, Double, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpIDD[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Int], Vec[Double], Vec[Double]]): FrFrEOp[Op, X, Y, Int, Double, Double]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpIIB[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Int], Vec[Int], Vec[Boolean]]): FrFrEOp[Op, X, Y, Int, Int, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpIII[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Int], Vec[Int], Vec[Int]]): FrFrEOp[Op, X, Y, Int, Int, Int]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpILB[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Int], Vec[Long], Vec[Boolean]]): FrFrEOp[Op, X, Y, Int, Long, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpILL[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Int], Vec[Long], Vec[Long]]): FrFrEOp[Op, X, Y, Int, Long, Long]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpLDB[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Long], Vec[Double], Vec[Boolean]]): FrFrEOp[Op, X, Y, Long, Double, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpLDD[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Long], Vec[Double], Vec[Double]]): FrFrEOp[Op, X, Y, Long, Double, Double]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpLIB[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Long], Vec[Int], Vec[Boolean]]): FrFrEOp[Op, X, Y, Long, Int, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpLIL[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Long], Vec[Int], Vec[Long]]): FrFrEOp[Op, X, Y, Long, Int, Long]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpLLB[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Long], Vec[Long], Vec[Boolean]]): FrFrEOp[Op, X, Y, Long, Long, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrFrEOpLLL[Op <: ScalarOp, X, Y](implicit cm: ST[X], cmp: ORD[X], my: ST[Y], cmpY: ORD[Y], opv: BinOp[Op, Vec[Long], Vec[Long], Vec[Long]]): FrFrEOp[Op, X, Y, Long, Long, Long]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpBBB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Boolean], Boolean, Vec[Boolean]]): FrScEOp[Op, X, Y, Boolean, Boolean, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpDDB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Double, Vec[Boolean]]): FrScEOp[Op, X, Y, Double, Double, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpDDD[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Double, Vec[Double]]): FrScEOp[Op, X, Y, Double, Double, Double]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpDIB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Int, Vec[Boolean]]): FrScEOp[Op, X, Y, Double, Int, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpDID[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Int, Vec[Double]]): FrScEOp[Op, X, Y, Double, Int, Double]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpDLB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Long, Vec[Boolean]]): FrScEOp[Op, X, Y, Double, Long, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpDLD[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Long, Vec[Double]]): FrScEOp[Op, X, Y, Double, Long, Double]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpIDB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Double, Vec[Boolean]]): FrScEOp[Op, X, Y, Int, Double, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpIDD[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Double, Vec[Double]]): FrScEOp[Op, X, Y, Int, Double, Double]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpIIB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Int, Vec[Boolean]]): FrScEOp[Op, X, Y, Int, Int, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpIII[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Int, Vec[Int]]): FrScEOp[Op, X, Y, Int, Int, Int]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpILB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Long, Vec[Boolean]]): FrScEOp[Op, X, Y, Int, Long, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpILL[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Long, Vec[Long]]): FrScEOp[Op, X, Y, Int, Long, Long]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpLDB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Double, Vec[Boolean]]): FrScEOp[Op, X, Y, Long, Double, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpLDD[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Double, Vec[Double]]): FrScEOp[Op, X, Y, Long, Double, Double]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpLIB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Int, Vec[Boolean]]): FrScEOp[Op, X, Y, Long, Int, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpLIL[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Int, Vec[Long]]): FrScEOp[Op, X, Y, Long, Int, Long]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpLLB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Long, Vec[Boolean]]): FrScEOp[Op, X, Y, Long, Long, Boolean]
- Definition Classes
- BinOpFrame
- implicit def FrScEOpLLL[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Long, Vec[Long]]): FrScEOp[Op, X, Y, Long, Long, Long]
- Definition Classes
- BinOpFrame
- def apply[RX, CX, T](mat: Mat[T], rowIx: Index[RX], colIx: Index[CX])(implicit arg0: ST[RX], arg1: ORD[RX], arg2: ST[CX], arg3: ORD[CX], arg4: ST[T]): Frame[RX, CX, T]
Build a Frame from a provided Mat, row index, and col index
- def apply[T](values: Mat[T])(implicit arg0: ST[T]): Frame[Int, Int, T]
Build a Frame from a provided Mat
- def apply[RX, CX, T](values: (CX, Series[RX, T])*)(implicit arg0: ST[RX], arg1: ORD[RX], arg2: ST[CX], arg3: ORD[CX], arg4: ST[T]): Frame[RX, CX, T]
Factory method to create a Frame from a sequence of tuples, where the first element of the tuple is a column label, and the second a series of values.
Factory method to create a Frame from a sequence of tuples, where the first element of the tuple is a column label, and the second a series of values. The row labels of the result are the outer join of the indexes of the series provided.
This method repeatedly joins the rows indices. Mind the combinatorial semantics of joins, if the indices contain duplicates, the resulting Frame can grow quickly. An alternative is Frame.fromCols.
- def apply[RX, CX, T](values: Seq[Series[RX, T]], colIx: Index[CX])(implicit arg0: ST[RX], arg1: ORD[RX], arg2: ST[CX], arg3: ORD[CX], arg4: ST[T]): Frame[RX, CX, T]
Factory method to create a Frame from a sequence of series, also specifying the column index to use.
Factory method to create a Frame from a sequence of series, also specifying the column index to use. The row labels of the result are the outer join of the indexes of the series provided.
This method repeatedly joins the rows indices. Mind the combinatorial semantics of joins, if the indices contain duplicates, the resulting Frame can grow quickly. An alternative is Frame.fromCols.
- def apply[RX, T](values: Series[RX, T]*)(implicit arg0: ST[RX], arg1: ORD[RX], arg2: ST[T], arg3: ID[T]): Frame[RX, Int, T]
Factory method to create a Frame from a sequence of Series.
Factory method to create a Frame from a sequence of Series. The row labels of the result are the outer join of the indexes of the series provided.
This method repeatedly joins the rows indices. Mind the combinatorial semantics of joins, if the indices contain duplicates, the resulting Frame can grow quickly. An alternative is Frame.fromCols.
- Annotations
- @nowarn()
- def apply[CX, T](values: (CX, Vec[T])*)(implicit arg0: ST[CX], arg1: ORD[CX], arg2: ST[T]): Frame[Int, CX, T]
Factory method to create a Frame from tuples whose first element is the column label and the second is a Vec of values.
- def apply[CX, T](values: Seq[Vec[T]], colIx: Index[CX])(implicit arg0: ST[CX], arg1: ORD[CX], arg2: ST[T]): Frame[Int, CX, T]
Factory method to create a Frame from a sequence of Vec objects and a column index.
- def apply[RX, CX, T](values: Vec[Vec[T]], rowIx: Index[RX], colIx: Index[CX])(implicit arg0: ST[RX], arg1: ORD[RX], arg2: ST[CX], arg3: ORD[CX], arg4: ST[T]): Frame[RX, CX, T]
- def apply[RX, CX, T](values: Seq[Vec[T]], rowIx: Index[RX], colIx: Index[CX])(implicit arg0: ST[RX], arg1: ORD[RX], arg2: ST[CX], arg3: ORD[CX], arg4: ST[T]): Frame[RX, CX, T]
Factory method to create a Frame from a sequence of Vec objects, a row index, and a column index.
- def apply[T](values: Vec[T]*)(implicit arg0: ST[T]): Frame[Int, Int, T]
Factory method to create a Frame from a sequence of Vec objects
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def empty[RX, CX, T](implicit arg0: ST[RX], arg1: ORD[RX], arg2: ST[CX], arg3: ORD[CX], arg4: ST[T]): Frame[RX, CX, T]
Factory method to create an empty Frame
Factory method to create an empty Frame
- RX
Type of row keys
- CX
Type of col keys
- T
Type of values
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def fromCols[RX, CX, T](values: (CX, Series[RX, T])*)(implicit arg0: ST[RX], arg1: ORD[RX], arg2: ST[CX], arg3: ORD[CX], arg4: ST[T]): Frame[RX, CX, T]
Factory method to create a Frame from a sequence of tuples, where the first element of the tuple is a column label, and the second a series of values.
Factory method to create a Frame from a sequence of tuples, where the first element of the tuple is a column label, and the second a series of values. The row labels of the result are the outer join of the indexes of the series provided.
Row indices are disambiguated before the join via the Index.makeUnique method which turns each row index into a unique index resolving ties.
This methods avoids a combinatorial increase in the resulting row count in case of duplicate elements in the row indices, however the join of rows with the same index is arbitrary. Alternatively see Frame.apply .
- def fromCols[RX, CX, T](values: Seq[Series[RX, T]], colIx: Index[CX])(implicit arg0: ST[RX], arg1: ORD[RX], arg2: ST[CX], arg3: ORD[CX], arg4: ST[T]): Frame[RX, CX, T]
Factory method to create a Frame from a sequence of series, also specifying the column index to use.
Factory method to create a Frame from a sequence of series, also specifying the column index to use. The row labels of the result are the outer join of the indexes of the series provided.
Row indices are disambiguated before the join via the Index.makeUnique method which turns each row index into a unique index resolving ties.
This methods avoids a combinatorial increase in the resulting row count in case of duplicate elements in the row indices, however the join of rows with the same index is arbitrary. Alternatively see Frame.apply .
- def fromCols[RX, T](values: Series[RX, T]*)(implicit arg0: ST[RX], arg1: ORD[RX], arg2: ST[T]): Frame[RX, Int, T]
Factory method to create a Frame from a sequence of Series.
Factory method to create a Frame from a sequence of Series. The row labels of the result are the outer join of the indexes of the series provided.
Row indices are disambiguated before the join via the Index.makeUnique method which turns each row index into a unique index resolving ties.
This methods avoids a combinatorial increase in the resulting row count in case of duplicate elements in the row indices, however the join of rows with the same index is arbitrary. Alternatively see Frame.apply .
- Annotations
- @nowarn()
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def table[RX, CX](values: Vec[(RX, CX)])(implicit arg0: ST[RX], arg1: ORD[RX], arg2: ST[CX], arg3: ORD[CX]): Frame[RX, CX, Int]
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()