saddle-core/org.saddle.ops/BinOps

BinOps

object BinOps extends BinOpMat with BinOpMatInPlace with BinOpVec with BinOpVecInPlace with BinOpFrame with BinOpSeries

Contains implementations of primitive binary ops that are NA-aware

Double primitive has NA bit pattern baked into its representation, but for others we must check for the appropriate sentinel value.

Note scala.Function2 is not specialized on Boolean inputs, only output

trait BinOpVec
trait BinOpMat
class Object
trait Matchable
class Any
BinOps.type

Type members

Inherited classlikes

final class FrFrEOp[OP <: ScalarOp, X, Y, A, B, C](opv: BinOp[OP, Vec[A], Vec[B], Vec[C]])(implicit evidence$2: ScalarTag[X], evidence$3: Order[X], evidence$4: ScalarTag[Y], evidence$5: Order[Y], evidence$6: ScalarTag[B], evidence$7: ScalarTag[C]) extends BinOp[OP, Frame[X, Y, A], Frame[X, Y, B], Frame[X, Y, C]]
Inherited from:
BinOpFrame
final class FrScEOp[OP <: ScalarOp, X, Y, A, B, C](opv: BinOp[OP, Vec[A], B, Vec[C]])(implicit evidence$1: ScalarTag[C]) extends BinOp[OP, Frame[X, Y, A], B, Frame[X, Y, C]]
Inherited from:
BinOpFrame
final class MatMatElemOp[OP <: ScalarOp, @specialized(Int, Long, Double) A, @specialized(Int, Long, Double) B, @specialized(Int, Long, Double) C](op: BinOp[OP, A, B, C])(implicit evidence$2: ScalarTag[C]) extends BinOp[OP, Mat[A], Mat[B], Mat[C]]

Binary element-wise operation on two Mats

Binary element-wise operation on two Mats

Broadcasts according to the following rules (same as numpy). If any of the pairs of dimensions are the same, or one of the pair is size 1, then the dimensions are compatible. If the compatible dimension is size 1, then it is virtually expanded to match the size of the corresponding dimension of the other operand.

Inherited from:
BinOpMat
final class MatMatElemOpIp[OP <: ScalarOp, @specialized(Int, Long, Double) A, @specialized(Int, Long, Double) B](op: BinOp[OP, A, B, A]) extends BinOpInPlace[OP, Mat[A], Mat[B]]
Inherited from:
BinOpMatInPlace
final class MatSclrElemOp[OP <: ScalarOp, @specialized(Boolean, Int, Long, Double) A, @specialized(Boolean, Int, Long, Double) B, @specialized(Boolean, Int, Long, Double) C](val op: BinOp[OP, A, B, C])(implicit evidence$1: ScalarTag[C]) extends BinOp[OP, Mat[A], B, Mat[C]]
Inherited from:
BinOpMat
final class MatSclrElemOpIp[OP <: ScalarOp, @specialized(Int, Long, Double) A, @specialized(Int, Long, Double) B](val op: BinOp[OP, A, B, A]) extends BinOpInPlace[OP, Mat[A], B]
Inherited from:
BinOpMatInPlace
final class SrScEOp[OP <: ScalarOp, X, A, B, C](op: BinOp[OP, Vec[A], B, Vec[C]])(implicit evidence$1: ScalarTag[X], evidence$2: Order[X], evidence$3: ScalarTag[C]) extends BinOp[OP, Series[X, A], B, Series[X, C]]
Inherited from:
BinOpSeries
final class SrSrEOp[OP <: ScalarOp, X, A, B, C](opv: BinOp[OP, Vec[A], Vec[B], Vec[C]])(implicit evidence$4: ScalarTag[X], evidence$5: Order[X], evidence$6: ScalarTag[C]) extends BinOp[OP, Series[X, A], Series[X, B], Series[X, C]]
Inherited from:
BinOpSeries
final class VecSclrElemOp[OP <: ScalarOp, @specialized(Boolean, Int, Long, Double) A, @specialized(Boolean, Int, Long, Double) B, @specialized(Boolean, Int, Long, Double) C](val op: BinOp[OP, A, B, C])(implicit evidence$1: ScalarTag[C]) extends BinOp[OP, Vec[A], B, Vec[C]]
Inherited from:
BinOpVec
final class VecSclrElemOpIp[OP <: ScalarOp, @specialized(Boolean, Int, Long, Double) A, @specialized(Boolean, Int, Long, Double) B](val op: BinOp[OP, A, B, A]) extends BinOpInPlace[OP, Vec[A], B]
Inherited from:
BinOpVecInPlace
final class VecVecDot[@specialized(Int, Long, Double) A, @specialized(Int, Long, Double) B, @specialized(Int, Long, Double) C](opadd: BinOp[Add, C, C, C], opmul: BinOp[Multiply, A, B, C])(implicit evidence$3: ScalarTag[C], evidence$4: Numeric[C]) extends BinOp[InnerProd, Vec[A], Vec[B], C]
Inherited from:
BinOpVec
final class VecVecElemOp[OP <: ScalarOp, @specialized(Boolean, Int, Long, Double) A, @specialized(Boolean, Int, Long, Double) B, @specialized(Boolean, Int, Long, Double) C](op: BinOp[OP, A, B, C])(implicit evidence$2: ScalarTag[C]) extends BinOp[OP, Vec[A], Vec[B], Vec[C]]
Inherited from:
BinOpVec
final class VecVecElemOpIp[OP <: ScalarOp, @specialized(Boolean, Int, Long, Double) A, @specialized(Boolean, Int, Long, Double) B](op: BinOp[OP, A, B, A]) extends BinOpInPlace[OP, Vec[A], Vec[B]]
Inherited from:
BinOpVecInPlace
final class VecVecOuter[@specialized(Int, Long, Double) A, @specialized(Int, Long, Double) B, @specialized(Int, Long, Double) C](opmul: BinOp[Multiply, A, B, C])(implicit evidence$5: ScalarTag[C]) extends BinOp[OuterProd, Vec[A], Vec[B], Mat[C]]
Inherited from:
BinOpVec

Implicits

Implicits

implicit val addDD: BinOp[Add, Double, Double, Double]
implicit val addDI: BinOp[Add, Double, Int, Double]
implicit val addDL: BinOp[Add, Double, Long, Double]
implicit val addID: BinOp[Add, Int, Double, Double]
implicit val addII: BinOp[Add, Int, Int, Int]
implicit val addIL: BinOp[Add, Int, Long, Long]
implicit val addLD: BinOp[Add, Long, Double, Double]
implicit val addLI: BinOp[Add, Long, Int, Long]
implicit val addLL: BinOp[Add, Long, Long, Long]
implicit val andBB: BinOp[AndOp, Boolean, Boolean, Boolean]
implicit val andII: BinOp[BitAnd, Int, Int, Int]
implicit val andIL: BinOp[BitAnd, Int, Long, Long]
implicit val andLI: BinOp[BitAnd, Long, Int, Long]
implicit val andLL: BinOp[BitAnd, Long, Long, Long]
implicit val divDD: BinOp[Divide, Double, Double, Double]
implicit val divDI: BinOp[Divide, Double, Int, Double]
implicit val divDL: BinOp[Divide, Double, Long, Double]
implicit val divID: BinOp[Divide, Int, Double, Double]
implicit val divII: BinOp[Divide, Int, Int, Int]
implicit val divIL: BinOp[Divide, Int, Long, Long]
implicit val divLD: BinOp[Divide, Long, Double, Double]
implicit val divLI: BinOp[Divide, Long, Int, Long]
implicit val divLL: BinOp[Divide, Long, Long, Long]
implicit val eqBB: BinOp[EqOp, Boolean, Boolean, Boolean]
implicit val eqDD: BinOp[EqOp, Double, Double, Boolean]
implicit val eqDI: BinOp[EqOp, Double, Int, Boolean]
implicit val eqDL: BinOp[EqOp, Double, Long, Boolean]
implicit val eqID: BinOp[EqOp, Int, Double, Boolean]
implicit val eqII: BinOp[EqOp, Int, Int, Boolean]
implicit val eqLD: BinOp[EqOp, Long, Double, Boolean]
implicit val eqLI: BinOp[EqOp, Long, Int, Boolean]
implicit val eqLL: BinOp[EqOp, Long, Long, Boolean]
implicit val gtBB: BinOp[GtOp, Boolean, Boolean, Boolean]
implicit val gtDD: BinOp[GtOp, Double, Double, Boolean]
implicit val gtDI: BinOp[GtOp, Double, Int, Boolean]
implicit val gtDL: BinOp[GtOp, Double, Long, Boolean]
implicit val gtID: BinOp[GtOp, Int, Double, Boolean]
implicit val gtII: BinOp[GtOp, Int, Int, Boolean]
implicit val gtLD: BinOp[GtOp, Long, Double, Boolean]
implicit val gtLI: BinOp[GtOp, Long, Int, Boolean]
implicit val gtLL: BinOp[GtOp, Long, Long, Boolean]
implicit val gteBB: BinOp[GteOp, Boolean, Boolean, Boolean]
implicit val gteDD: BinOp[GteOp, Double, Double, Boolean]
implicit val gteDI: BinOp[GteOp, Double, Int, Boolean]
implicit val gteDL: BinOp[GteOp, Double, Long, Boolean]
implicit val gteID: BinOp[GteOp, Int, Double, Boolean]
implicit val gteII: BinOp[GteOp, Int, Int, Boolean]
implicit val gteLD: BinOp[GteOp, Long, Double, Boolean]
implicit val gteLI: BinOp[GteOp, Long, Int, Boolean]
implicit val gteLL: BinOp[GteOp, Long, Long, Boolean]
implicit val ltBB: BinOp[LtOp, Boolean, Boolean, Boolean]
implicit val ltDD: BinOp[LtOp, Double, Double, Boolean]
implicit val ltDI: BinOp[LtOp, Double, Int, Boolean]
implicit val ltDL: BinOp[LtOp, Double, Long, Boolean]
implicit val ltID: BinOp[LtOp, Int, Double, Boolean]
implicit val ltII: BinOp[LtOp, Int, Int, Boolean]
implicit val ltLD: BinOp[LtOp, Long, Double, Boolean]
implicit val ltLI: BinOp[LtOp, Long, Int, Boolean]
implicit val ltLL: BinOp[LtOp, Long, Long, Boolean]
implicit val lteBB: BinOp[LteOp, Boolean, Boolean, Boolean]
implicit val lteDD: BinOp[LteOp, Double, Double, Boolean]
implicit val lteDI: BinOp[LteOp, Double, Int, Boolean]
implicit val lteDL: BinOp[LteOp, Double, Long, Boolean]
implicit val lteID: BinOp[LteOp, Int, Double, Boolean]
implicit val lteII: BinOp[LteOp, Int, Int, Boolean]
implicit val lteLD: BinOp[LteOp, Long, Double, Boolean]
implicit val lteLI: BinOp[LteOp, Long, Int, Boolean]
implicit val lteLL: BinOp[LteOp, Long, Long, Boolean]
implicit val modDD: BinOp[Mod, Double, Double, Double]
implicit val modDI: BinOp[Mod, Double, Int, Double]
implicit val modDL: BinOp[Mod, Double, Long, Double]
implicit val modID: BinOp[Mod, Int, Double, Double]
implicit val modII: BinOp[Mod, Int, Int, Int]
implicit val modIL: BinOp[Mod, Int, Long, Long]
implicit val modLD: BinOp[Mod, Long, Double, Double]
implicit val modLI: BinOp[Mod, Long, Int, Long]
implicit val modLL: BinOp[Mod, Long, Long, Long]
implicit val mulDD: BinOp[Multiply, Double, Double, Double]
implicit val mulDI: BinOp[Multiply, Double, Int, Double]
implicit val mulDL: BinOp[Multiply, Double, Long, Double]
implicit val mulID: BinOp[Multiply, Int, Double, Double]
implicit val mulII: BinOp[Multiply, Int, Int, Int]
implicit val mulIL: BinOp[Multiply, Int, Long, Long]
implicit val mulLD: BinOp[Multiply, Long, Double, Double]
implicit val mulLI: BinOp[Multiply, Long, Int, Long]
implicit val mulLL: BinOp[Multiply, Long, Long, Long]
implicit val neqBB: BinOp[NeqOp, Boolean, Boolean, Boolean]
implicit val neqDD: BinOp[NeqOp, Double, Double, Boolean]
implicit val neqDI: BinOp[NeqOp, Double, Int, Boolean]
implicit val neqDL: BinOp[NeqOp, Double, Long, Boolean]
implicit val neqID: BinOp[NeqOp, Int, Double, Boolean]
implicit val neqII: BinOp[NeqOp, Int, Int, Boolean]
implicit val neqLD: BinOp[NeqOp, Long, Double, Boolean]
implicit val neqLI: BinOp[NeqOp, Long, Int, Boolean]
implicit val neqLL: BinOp[NeqOp, Long, Long, Boolean]
implicit val orBB: BinOp[OrOp, Boolean, Boolean, Boolean]
implicit val orII: BinOp[BitOr, Int, Int, Int]
implicit val orIL: BinOp[BitOr, Int, Long, Long]
implicit val orLI: BinOp[BitOr, Long, Int, Long]
implicit val orLL: BinOp[BitOr, Long, Long, Long]
implicit val powDD: BinOp[Power, Double, Double, Double]
implicit val powDI: BinOp[Power, Double, Int, Double]
implicit val powDL: BinOp[Power, Double, Long, Double]
implicit val powID: BinOp[Power, Int, Double, Double]
implicit val powII: BinOp[Power, Int, Int, Int]
implicit val powIL: BinOp[Power, Int, Long, Long]
implicit val powLD: BinOp[Power, Long, Double, Double]
implicit val powLI: BinOp[Power, Long, Int, Long]
implicit val powLL: BinOp[Power, Long, Long, Long]
implicit val shlII: BinOp[BitShl, Int, Int, Int]
implicit val shrII: BinOp[BitShr, Int, Int, Int]
implicit val subDD: BinOp[Subtract, Double, Double, Double]
implicit val subDI: BinOp[Subtract, Double, Int, Double]
implicit val subDL: BinOp[Subtract, Double, Long, Double]
implicit val subID: BinOp[Subtract, Int, Double, Double]
implicit val subII: BinOp[Subtract, Int, Int, Int]
implicit val subIL: BinOp[Subtract, Int, Long, Long]
implicit val subLD: BinOp[Subtract, Long, Double, Double]
implicit val subLI: BinOp[Subtract, Long, Int, Long]
implicit val subLL: BinOp[Subtract, Long, Long, Long]
implicit val ushrII: BinOp[BitUShr, Int, Int, Int]
implicit val xorBB: BinOp[XorOp, Boolean, Boolean, Boolean]
implicit val xorII: BinOp[BitXor, Int, Int, Int]
implicit val xorIL: BinOp[BitXor, Int, Long, Long]
implicit val xorLI: BinOp[BitXor, Long, Int, Long]
implicit val xorLL: BinOp[BitXor, Long, Long, Long]

Inherited implicits

implicit def FrFrEOpBBB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Boolean], Vec[Boolean], Vec[Boolean]]): FrFrEOp[Op, X, Y, Boolean, Boolean, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpDDB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Double], Vec[Double], Vec[Boolean]]): FrFrEOp[Op, X, Y, Double, Double, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpDDD[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Double], Vec[Double], Vec[Double]]): FrFrEOp[Op, X, Y, Double, Double, Double]
Inherited from:
BinOpFrame
implicit def FrFrEOpDIB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Double], Vec[Int], Vec[Boolean]]): FrFrEOp[Op, X, Y, Double, Int, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpDID[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Double], Vec[Int], Vec[Double]]): FrFrEOp[Op, X, Y, Double, Int, Double]
Inherited from:
BinOpFrame
implicit def FrFrEOpDLB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Double], Vec[Long], Vec[Boolean]]): FrFrEOp[Op, X, Y, Double, Long, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpDLD[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Double], Vec[Long], Vec[Double]]): FrFrEOp[Op, X, Y, Double, Long, Double]
Inherited from:
BinOpFrame
implicit def FrFrEOpIDB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Int], Vec[Double], Vec[Boolean]]): FrFrEOp[Op, X, Y, Int, Double, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpIDD[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Int], Vec[Double], Vec[Double]]): FrFrEOp[Op, X, Y, Int, Double, Double]
Inherited from:
BinOpFrame
implicit def FrFrEOpIIB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Int], Vec[Int], Vec[Boolean]]): FrFrEOp[Op, X, Y, Int, Int, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpIII[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Int], Vec[Int], Vec[Int]]): FrFrEOp[Op, X, Y, Int, Int, Int]
Inherited from:
BinOpFrame
implicit def FrFrEOpILB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Int], Vec[Long], Vec[Boolean]]): FrFrEOp[Op, X, Y, Int, Long, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpILL[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Int], Vec[Long], Vec[Long]]): FrFrEOp[Op, X, Y, Int, Long, Long]
Inherited from:
BinOpFrame
implicit def FrFrEOpLDB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Long], Vec[Double], Vec[Boolean]]): FrFrEOp[Op, X, Y, Long, Double, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpLDD[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Long], Vec[Double], Vec[Double]]): FrFrEOp[Op, X, Y, Long, Double, Double]
Inherited from:
BinOpFrame
implicit def FrFrEOpLIB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Long], Vec[Int], Vec[Boolean]]): FrFrEOp[Op, X, Y, Long, Int, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpLIL[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Long], Vec[Int], Vec[Long]]): FrFrEOp[Op, X, Y, Long, Int, Long]
Inherited from:
BinOpFrame
implicit def FrFrEOpLLB[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Long], Vec[Long], Vec[Boolean]]): FrFrEOp[Op, X, Y, Long, Long, Boolean]
Inherited from:
BinOpFrame
implicit def FrFrEOpLLL[Op <: ScalarOp, X, Y](implicit cm: ScalarTag[X], cmp: Order[X], my: ScalarTag[Y], cmpY: Order[Y], opv: BinOp[Op, Vec[Long], Vec[Long], Vec[Long]]): FrFrEOp[Op, X, Y, Long, Long, Long]
Inherited from:
BinOpFrame
implicit def FrScEOpBBB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Boolean], Boolean, Vec[Boolean]]): FrScEOp[Op, X, Y, Boolean, Boolean, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpDDB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Double, Vec[Boolean]]): FrScEOp[Op, X, Y, Double, Double, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpDDD[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Double, Vec[Double]]): FrScEOp[Op, X, Y, Double, Double, Double]
Inherited from:
BinOpFrame
implicit def FrScEOpDIB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Int, Vec[Boolean]]): FrScEOp[Op, X, Y, Double, Int, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpDID[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Int, Vec[Double]]): FrScEOp[Op, X, Y, Double, Int, Double]
Inherited from:
BinOpFrame
implicit def FrScEOpDLB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Long, Vec[Boolean]]): FrScEOp[Op, X, Y, Double, Long, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpDLD[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Double], Long, Vec[Double]]): FrScEOp[Op, X, Y, Double, Long, Double]
Inherited from:
BinOpFrame
implicit def FrScEOpIDB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Double, Vec[Boolean]]): FrScEOp[Op, X, Y, Int, Double, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpIDD[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Double, Vec[Double]]): FrScEOp[Op, X, Y, Int, Double, Double]
Inherited from:
BinOpFrame
implicit def FrScEOpIIB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Int, Vec[Boolean]]): FrScEOp[Op, X, Y, Int, Int, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpIII[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Int, Vec[Int]]): FrScEOp[Op, X, Y, Int, Int, Int]
Inherited from:
BinOpFrame
implicit def FrScEOpILB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Long, Vec[Boolean]]): FrScEOp[Op, X, Y, Int, Long, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpILL[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Int], Long, Vec[Long]]): FrScEOp[Op, X, Y, Int, Long, Long]
Inherited from:
BinOpFrame
implicit def FrScEOpLDB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Double, Vec[Boolean]]): FrScEOp[Op, X, Y, Long, Double, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpLDD[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Double, Vec[Double]]): FrScEOp[Op, X, Y, Long, Double, Double]
Inherited from:
BinOpFrame
implicit def FrScEOpLIB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Int, Vec[Boolean]]): FrScEOp[Op, X, Y, Long, Int, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpLIL[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Int, Vec[Long]]): FrScEOp[Op, X, Y, Long, Int, Long]
Inherited from:
BinOpFrame
implicit def FrScEOpLLB[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Long, Vec[Boolean]]): FrScEOp[Op, X, Y, Long, Long, Boolean]
Inherited from:
BinOpFrame
implicit def FrScEOpLLL[Op <: ScalarOp, X, Y](implicit opv: BinOp[Op, Vec[Long], Long, Vec[Long]]): FrScEOp[Op, X, Y, Long, Long, Long]
Inherited from:
BinOpFrame
implicit def MatMatElemOpDDD[Op <: ScalarOp](implicit op: BinOp[Op, Double, Double, Double]): MatMatElemOp[Op, Double, Double, Double]
Inherited from:
BinOpMat
implicit def MatMatElemOpDID[Op <: ScalarOp](implicit op: BinOp[Op, Double, Int, Double]): MatMatElemOp[Op, Double, Int, Double]
Inherited from:
BinOpMat
implicit def MatMatElemOpDLD[Op <: ScalarOp](implicit op: BinOp[Op, Double, Long, Double]): MatMatElemOp[Op, Double, Long, Double]
Inherited from:
BinOpMat
implicit def MatMatElemOpIDD[Op <: ScalarOp](implicit op: BinOp[Op, Int, Double, Double]): MatMatElemOp[Op, Int, Double, Double]
Inherited from:
BinOpMat
implicit def MatMatElemOpIII[Op <: ScalarOp](implicit op: BinOp[Op, Int, Int, Int]): MatMatElemOp[Op, Int, Int, Int]
Inherited from:
BinOpMat
implicit def MatMatElemOpILL[Op <: ScalarOp](implicit op: BinOp[Op, Int, Long, Long]): MatMatElemOp[Op, Int, Long, Long]
Inherited from:
BinOpMat
implicit def MatMatElemOpIpDDD[Op <: ScalarOp](implicit op: BinOp[Op, Double, Double, Double]): MatMatElemOpIp[Op, Double, Double]
Inherited from:
BinOpMatInPlace
implicit def MatMatElemOpIpDID[Op <: ScalarOp](implicit op: BinOp[Op, Double, Int, Double]): MatMatElemOpIp[Op, Double, Int]
Inherited from:
BinOpMatInPlace
implicit def MatMatElemOpIpDLD[Op <: ScalarOp](implicit op: BinOp[Op, Double, Long, Double]): MatMatElemOpIp[Op, Double, Long]
Inherited from:
BinOpMatInPlace
implicit def MatMatElemOpIpIII[Op <: ScalarOp](implicit op: BinOp[Op, Int, Int, Int]): MatMatElemOpIp[Op, Int, Int]
Inherited from:
BinOpMatInPlace
implicit def MatMatElemOpIpLIL[Op <: ScalarOp](implicit op: BinOp[Op, Long, Int, Long]): MatMatElemOpIp[Op, Long, Int]
Inherited from:
BinOpMatInPlace
implicit def MatMatElemOpIpLLL[Op <: ScalarOp](implicit op: BinOp[Op, Long, Long, Long]): MatMatElemOpIp[Op, Long, Long]
Inherited from:
BinOpMatInPlace
implicit def MatMatElemOpLDD[Op <: ScalarOp](implicit op: BinOp[Op, Long, Double, Double]): MatMatElemOp[Op, Long, Double, Double]
Inherited from:
BinOpMat
implicit def MatMatElemOpLIL[Op <: ScalarOp](implicit op: BinOp[Op, Long, Int, Long]): MatMatElemOp[Op, Long, Int, Long]
Inherited from:
BinOpMat
implicit def MatMatElemOpLLL[Op <: ScalarOp](implicit op: BinOp[Op, Long, Long, Long]): MatMatElemOp[Op, Long, Long, Long]
Inherited from:
BinOpMat
implicit def MatSclrElmOpBBB[Op <: ScalarOp](implicit op: BinOp[Op, Boolean, Boolean, Boolean]): MatSclrElemOp[Op, Boolean, Boolean, Boolean]
Inherited from:
BinOpMat
implicit def MatSclrElmOpDDB[Op <: ScalarOp](implicit op: BinOp[Op, Double, Double, Boolean]): MatSclrElemOp[Op, Double, Double, Boolean]
Inherited from:
BinOpMat
implicit def MatSclrElmOpDDD[Op <: ScalarOp](implicit op: BinOp[Op, Double, Double, Double]): MatSclrElemOp[Op, Double, Double, Double]
Inherited from:
BinOpMat
implicit def MatSclrElmOpDIB[Op <: ScalarOp](implicit op: BinOp[Op, Double, Int, Boolean]): MatSclrElemOp[Op, Double, Int, Boolean]
Inherited from:
BinOpMat
implicit def MatSclrElmOpDID[Op <: ScalarOp](implicit op: BinOp[Op, Double, Int, Double]): MatSclrElemOp[Op, Double, Int, Double]
Inherited from:
BinOpMat
implicit def MatSclrElmOpDLB[Op <: ScalarOp](implicit op: BinOp[Op, Double, Long, Boolean]): MatSclrElemOp[Op, Double, Long, Boolean]
Inherited from:
BinOpMat
implicit def MatSclrElmOpDLD[Op <: ScalarOp](implicit op: BinOp[Op, Double, Long, Double]): MatSclrElemOp[Op, Double, Long, Double]
Inherited from:
BinOpMat
implicit def MatSclrElmOpIDB[Op <: ScalarOp](implicit op: BinOp[Op, Int, Double, Boolean]): MatSclrElemOp[Op, Int, Double, Boolean]
Inherited from:
BinOpMat
implicit def MatSclrElmOpIDD[Op <: ScalarOp](implicit op: BinOp[Op, Int, Double, Double]): MatSclrElemOp[Op, Int, Double, Double]
Inherited from:
BinOpMat
implicit def MatSclrElmOpIIB[Op <: ScalarOp](implicit op: BinOp[Op, Int, Int, Boolean]): MatSclrElemOp[Op, Int, Int, Boolean]
Inherited from:
BinOpMat
implicit def MatSclrElmOpIII[Op <: ScalarOp](implicit op: BinOp[Op, Int, Int, Int]): MatSclrElemOp[Op, Int, Int, Int]
Inherited from:
BinOpMat
implicit def MatSclrElmOpILL[Op <: ScalarOp](implicit op: BinOp[Op, Int, Long, Long]): MatSclrElemOp[Op, Int, Long, Long]
Inherited from:
BinOpMat
implicit def MatSclrElmOpIpDDD[Op <: ScalarOp](implicit op: BinOp[Op, Double, Double, Double]): MatSclrElemOpIp[Op, Double, Double]
Inherited from:
BinOpMatInPlace
implicit def MatSclrElmOpIpDID[Op <: ScalarOp](implicit op: BinOp[Op, Double, Int, Double]): MatSclrElemOpIp[Op, Double, Int]
Inherited from:
BinOpMatInPlace
implicit def MatSclrElmOpIpDLD[Op <: ScalarOp](implicit op: BinOp[Op, Double, Long, Double]): MatSclrElemOpIp[Op, Double, Long]
Inherited from:
BinOpMatInPlace
implicit def MatSclrElmOpIpIII[Op <: ScalarOp](implicit op: BinOp[Op, Int, Int, Int]): MatSclrElemOpIp[Op, Int, Int]
Inherited from:
BinOpMatInPlace
implicit def MatSclrElmOpIpLIL[Op <: ScalarOp](implicit op: BinOp[Op, Long, Int, Long]): MatSclrElemOpIp[Op, Long, Int]
Inherited from:
BinOpMatInPlace
implicit def MatSclrElmOpIpLLL[Op <: ScalarOp](implicit op: BinOp[Op, Long, Long, Long]): MatSclrElemOpIp[Op, Long, Long]
Inherited from:
BinOpMatInPlace
implicit def MatSclrElmOpLDB[Op <: ScalarOp](implicit op: BinOp[Op, Long, Double, Boolean]): MatSclrElemOp[Op, Long, Double, Boolean]
Inherited from:
BinOpMat
implicit def MatSclrElmOpLDD[Op <: ScalarOp](implicit op: BinOp[Op, Long, Double, Double]): MatSclrElemOp[Op, Long, Double, Double]
Inherited from:
BinOpMat
implicit def MatSclrElmOpLIB[Op <: ScalarOp](implicit op: BinOp[Op, Long, Int, Boolean]): MatSclrElemOp[Op, Long, Int, Boolean]
Inherited from:
BinOpMat
implicit def MatSclrElmOpLIL[Op <: ScalarOp](implicit op: BinOp[Op, Long, Int, Long]): MatSclrElemOp[Op, Long, Int, Long]
Inherited from:
BinOpMat
implicit def MatSclrElmOpLLB[Op <: ScalarOp](implicit op: BinOp[Op, Long, Long, Boolean]): MatSclrElemOp[Op, Long, Long, Boolean]
Inherited from:
BinOpMat
implicit def MatSclrElmOpLLL[Op <: ScalarOp](implicit op: BinOp[Op, Long, Long, Long]): MatSclrElemOp[Op, Long, Long, Long]
Inherited from:
BinOpMat
implicit def SrScEOpBBB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Boolean], Boolean, Vec[Boolean]]): SrScEOp[Op, X, Boolean, Boolean, Boolean]
Inherited from:
BinOpSeries
implicit def SrScEOpDDB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Double], Double, Vec[Boolean]]): SrScEOp[Op, X, Double, Double, Boolean]
Inherited from:
BinOpSeries
implicit def SrScEOpDDD[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Double], Double, Vec[Double]]): SrScEOp[Op, X, Double, Double, Double]
Inherited from:
BinOpSeries
implicit def SrScEOpDIB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Double], Int, Vec[Boolean]]): SrScEOp[Op, X, Double, Int, Boolean]
Inherited from:
BinOpSeries
implicit def SrScEOpDID[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Double], Int, Vec[Double]]): SrScEOp[Op, X, Double, Int, Double]
Inherited from:
BinOpSeries
implicit def SrScEOpDLB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Double], Long, Vec[Boolean]]): SrScEOp[Op, X, Double, Long, Boolean]
Inherited from:
BinOpSeries
implicit def SrScEOpDLD[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Double], Long, Vec[Double]]): SrScEOp[Op, X, Double, Long, Double]
Inherited from:
BinOpSeries
implicit def SrScEOpIDB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Int], Double, Vec[Boolean]]): SrScEOp[Op, X, Int, Double, Boolean]
Inherited from:
BinOpSeries
implicit def SrScEOpIDD[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Int], Double, Vec[Double]]): SrScEOp[Op, X, Int, Double, Double]
Inherited from:
BinOpSeries
implicit def SrScEOpIIB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Int], Int, Vec[Boolean]]): SrScEOp[Op, X, Int, Int, Boolean]
Inherited from:
BinOpSeries
implicit def SrScEOpIII[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Int], Int, Vec[Int]]): SrScEOp[Op, X, Int, Int, Int]
Inherited from:
BinOpSeries
implicit def SrScEOpILB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Int], Long, Vec[Boolean]]): SrScEOp[Op, X, Int, Long, Boolean]
Inherited from:
BinOpSeries
implicit def SrScEOpILL[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Int], Long, Vec[Long]]): SrScEOp[Op, X, Int, Long, Long]
Inherited from:
BinOpSeries
implicit def SrScEOpLDB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Long], Double, Vec[Boolean]]): SrScEOp[Op, X, Long, Double, Boolean]
Inherited from:
BinOpSeries
implicit def SrScEOpLDD[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Long], Double, Vec[Double]]): SrScEOp[Op, X, Long, Double, Double]
Inherited from:
BinOpSeries
implicit def SrScEOpLIB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Long], Int, Vec[Boolean]]): SrScEOp[Op, X, Long, Int, Boolean]
Inherited from:
BinOpSeries
implicit def SrScEOpLIL[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Long], Int, Vec[Long]]): SrScEOp[Op, X, Long, Int, Long]
Inherited from:
BinOpSeries
implicit def SrScEOpLLB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Long], Long, Vec[Boolean]]): SrScEOp[Op, X, Long, Long, Boolean]
Inherited from:
BinOpSeries
implicit def SrScEOpLLL[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Long], Long, Vec[Long]]): SrScEOp[Op, X, Long, Long, Long]
Inherited from:
BinOpSeries
implicit def SrSrEOpBBB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Boolean], Vec[Boolean], Vec[Boolean]]): SrSrEOp[Op, X, Boolean, Boolean, Boolean]
Inherited from:
BinOpSeries
implicit def SrSrEOpDDB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Double], Vec[Double], Vec[Boolean]]): SrSrEOp[Op, X, Double, Double, Boolean]
Inherited from:
BinOpSeries
implicit def SrSrEOpDDD[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Double], Vec[Double], Vec[Double]]): SrSrEOp[Op, X, Double, Double, Double]
Inherited from:
BinOpSeries
implicit def SrSrEOpDIB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Double], Vec[Int], Vec[Boolean]]): SrSrEOp[Op, X, Double, Int, Boolean]
Inherited from:
BinOpSeries
implicit def SrSrEOpDID[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Double], Vec[Int], Vec[Double]]): SrSrEOp[Op, X, Double, Int, Double]
Inherited from:
BinOpSeries
implicit def SrSrEOpDLB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Double], Vec[Long], Vec[Boolean]]): SrSrEOp[Op, X, Double, Long, Boolean]
Inherited from:
BinOpSeries
implicit def SrSrEOpDLD[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Double], Vec[Long], Vec[Double]]): SrSrEOp[Op, X, Double, Long, Double]
Inherited from:
BinOpSeries
implicit def SrSrEOpIDB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Int], Vec[Double], Vec[Boolean]]): SrSrEOp[Op, X, Int, Double, Boolean]
Inherited from:
BinOpSeries
implicit def SrSrEOpIDD[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Int], Vec[Double], Vec[Double]]): SrSrEOp[Op, X, Int, Double, Double]
Inherited from:
BinOpSeries
implicit def SrSrEOpIIB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Int], Vec[Int], Vec[Boolean]]): SrSrEOp[Op, X, Int, Int, Boolean]
Inherited from:
BinOpSeries
implicit def SrSrEOpIII[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Int], Vec[Int], Vec[Int]]): SrSrEOp[Op, X, Int, Int, Int]
Inherited from:
BinOpSeries
implicit def SrSrEOpILB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Int], Vec[Long], Vec[Boolean]]): SrSrEOp[Op, X, Int, Long, Boolean]
Inherited from:
BinOpSeries
implicit def SrSrEOpILL[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Int], Vec[Long], Vec[Long]]): SrSrEOp[Op, X, Int, Long, Long]
Inherited from:
BinOpSeries
implicit def SrSrEOpLDB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Long], Vec[Double], Vec[Boolean]]): SrSrEOp[Op, X, Long, Double, Boolean]
Inherited from:
BinOpSeries
implicit def SrSrEOpLDD[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Long], Vec[Double], Vec[Double]]): SrSrEOp[Op, X, Long, Double, Double]
Inherited from:
BinOpSeries
implicit def SrSrEOpLIB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Long], Vec[Int], Vec[Boolean]]): SrSrEOp[Op, X, Long, Int, Boolean]
Inherited from:
BinOpSeries
implicit def SrSrEOpLIL[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Long], Vec[Int], Vec[Long]]): SrSrEOp[Op, X, Long, Int, Long]
Inherited from:
BinOpSeries
implicit def SrSrEOpLLB[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Long], Vec[Long], Vec[Boolean]]): SrSrEOp[Op, X, Long, Long, Boolean]
Inherited from:
BinOpSeries
implicit def SrSrEOpLLL[Op <: ScalarOp, X](implicit cm: ScalarTag[X], cmp: Order[X], opv: BinOp[Op, Vec[Long], Vec[Long], Vec[Long]]): SrSrEOp[Op, X, Long, Long, Long]
Inherited from:
BinOpSeries
implicit def VecSclrElmOpBBB[Op <: ScalarOp](implicit op: BinOp[Op, Boolean, Boolean, Boolean]): VecSclrElemOp[Op, Boolean, Boolean, Boolean]
Inherited from:
BinOpVec
implicit def VecSclrElmOpBBBIp[Op <: ScalarOp](implicit op: BinOp[Op, Boolean, Boolean, Boolean]): VecSclrElemOpIp[Op, Boolean, Boolean]
Inherited from:
BinOpVecInPlace
implicit def VecSclrElmOpDDB[Op <: ScalarOp](implicit op: BinOp[Op, Double, Double, Boolean]): VecSclrElemOp[Op, Double, Double, Boolean]
Inherited from:
BinOpVec
implicit def VecSclrElmOpDDD[Op <: ScalarOp](implicit op: BinOp[Op, Double, Double, Double]): VecSclrElemOp[Op, Double, Double, Double]
Inherited from:
BinOpVec
implicit def VecSclrElmOpDDDIp[Op <: ScalarOp](implicit op: BinOp[Op, Double, Double, Double]): VecSclrElemOpIp[Op, Double, Double]
Inherited from:
BinOpVecInPlace
implicit def VecSclrElmOpDIB[Op <: ScalarOp](implicit op: BinOp[Op, Double, Int, Boolean]): VecSclrElemOp[Op, Double, Int, Boolean]
Inherited from:
BinOpVec
implicit def VecSclrElmOpDID[Op <: ScalarOp](implicit op: BinOp[Op, Double, Int, Double]): VecSclrElemOp[Op, Double, Int, Double]
Inherited from:
BinOpVec
implicit def VecSclrElmOpDIDIp[Op <: ScalarOp](implicit op: BinOp[Op, Double, Int, Double]): VecSclrElemOpIp[Op, Double, Int]
Inherited from:
BinOpVecInPlace
implicit def VecSclrElmOpDLB[Op <: ScalarOp](implicit op: BinOp[Op, Double, Long, Boolean]): VecSclrElemOp[Op, Double, Long, Boolean]
Inherited from:
BinOpVec
implicit def VecSclrElmOpDLD[Op <: ScalarOp](implicit op: BinOp[Op, Double, Long, Double]): VecSclrElemOp[Op, Double, Long, Double]
Inherited from:
BinOpVec
implicit def VecSclrElmOpDLDIp[Op <: ScalarOp](implicit op: BinOp[Op, Double, Long, Double]): VecSclrElemOpIp[Op, Double, Long]
Inherited from:
BinOpVecInPlace
implicit def VecSclrElmOpIDB[Op <: ScalarOp](implicit op: BinOp[Op, Int, Double, Boolean]): VecSclrElemOp[Op, Int, Double, Boolean]
Inherited from:
BinOpVec
implicit def VecSclrElmOpIDD[Op <: ScalarOp](implicit op: BinOp[Op, Int, Double, Double]): VecSclrElemOp[Op, Int, Double, Double]
Inherited from:
BinOpVec
implicit def VecSclrElmOpIIB[Op <: ScalarOp](implicit op: BinOp[Op, Int, Int, Boolean]): VecSclrElemOp[Op, Int, Int, Boolean]
Inherited from:
BinOpVec
implicit def VecSclrElmOpIII[Op <: ScalarOp](implicit op: BinOp[Op, Int, Int, Int]): VecSclrElemOp[Op, Int, Int, Int]
Inherited from:
BinOpVec
implicit def VecSclrElmOpIIIIp[Op <: ScalarOp](implicit op: BinOp[Op, Int, Int, Int]): VecSclrElemOpIp[Op, Int, Int]
Inherited from:
BinOpVecInPlace
implicit def VecSclrElmOpILB[Op <: ScalarOp](implicit op: BinOp[Op, Int, Long, Boolean]): VecSclrElemOp[Op, Int, Long, Boolean]
Inherited from:
BinOpVec
implicit def VecSclrElmOpILL[Op <: ScalarOp](implicit op: BinOp[Op, Int, Long, Long]): VecSclrElemOp[Op, Int, Long, Long]
Inherited from:
BinOpVec
implicit def VecSclrElmOpLDB[Op <: ScalarOp](implicit op: BinOp[Op, Long, Double, Boolean]): VecSclrElemOp[Op, Long, Double, Boolean]
Inherited from:
BinOpVec
implicit def VecSclrElmOpLDD[Op <: ScalarOp](implicit op: BinOp[Op, Long, Double, Double]): VecSclrElemOp[Op, Long, Double, Double]
Inherited from:
BinOpVec
implicit def VecSclrElmOpLIB[Op <: ScalarOp](implicit op: BinOp[Op, Long, Int, Boolean]): VecSclrElemOp[Op, Long, Int, Boolean]
Inherited from:
BinOpVec
implicit def VecSclrElmOpLIL[Op <: ScalarOp](implicit op: BinOp[Op, Long, Int, Long]): VecSclrElemOp[Op, Long, Int, Long]
Inherited from:
BinOpVec
implicit def VecSclrElmOpLILIp[Op <: ScalarOp](implicit op: BinOp[Op, Long, Int, Long]): VecSclrElemOpIp[Op, Long, Int]
Inherited from:
BinOpVecInPlace
implicit def VecSclrElmOpLLB[Op <: ScalarOp](implicit op: BinOp[Op, Long, Long, Boolean]): VecSclrElemOp[Op, Long, Long, Boolean]
Inherited from:
BinOpVec
implicit def VecSclrElmOpLLL[Op <: ScalarOp](implicit op: BinOp[Op, Long, Long, Long]): VecSclrElemOp[Op, Long, Long, Long]
Inherited from:
BinOpVec
implicit def VecSclrElmOpLLLIp[Op <: ScalarOp](implicit op: BinOp[Op, Long, Long, Long]): VecSclrElemOpIp[Op, Long, Long]
Inherited from:
BinOpVecInPlace
implicit def VecVecDotOpDDD(implicit opA: BinOp[Add, Double, Double, Double], opM: BinOp[Multiply, Double, Double, Double]): VecVecDot[Double, Double, Double]
Inherited from:
BinOpVec
implicit def VecVecDotOpDID(implicit opA: BinOp[Add, Double, Double, Double], opM: BinOp[Multiply, Double, Int, Double]): VecVecDot[Double, Int, Double]
Inherited from:
BinOpVec
implicit def VecVecDotOpDLD(implicit opA: BinOp[Add, Double, Double, Double], opM: BinOp[Multiply, Double, Long, Double]): VecVecDot[Double, Long, Double]
Inherited from:
BinOpVec
implicit def VecVecDotOpIDD(implicit opA: BinOp[Add, Double, Double, Double], opM: BinOp[Multiply, Int, Double, Double]): VecVecDot[Int, Double, Double]
Inherited from:
BinOpVec
implicit def VecVecDotOpIII(implicit opA: BinOp[Add, Int, Int, Int], opM: BinOp[Multiply, Int, Int, Int]): VecVecDot[Int, Int, Int]
Inherited from:
BinOpVec
implicit def VecVecDotOpILL(implicit opA: BinOp[Add, Long, Long, Long], opM: BinOp[Multiply, Int, Long, Long]): VecVecDot[Int, Long, Long]
Inherited from:
BinOpVec
implicit def VecVecDotOpLDD(implicit opA: BinOp[Add, Double, Double, Double], opM: BinOp[Multiply, Long, Double, Double]): VecVecDot[Long, Double, Double]
Inherited from:
BinOpVec
implicit def VecVecDotOpLIL(implicit opA: BinOp[Add, Long, Long, Long], opM: BinOp[Multiply, Long, Int, Long]): VecVecDot[Long, Int, Long]
Inherited from:
BinOpVec
implicit def VecVecDotOpLLL(implicit opA: BinOp[Add, Long, Long, Long], opM: BinOp[Multiply, Long, Long, Long]): VecVecDot[Long, Long, Long]
Inherited from:
BinOpVec
implicit def VecVecElemOpBBB[Op <: ScalarOp](implicit op: BinOp[Op, Boolean, Boolean, Boolean]): VecVecElemOp[Op, Boolean, Boolean, Boolean]
Inherited from:
BinOpVec
implicit def VecVecElemOpBBBIp[Op <: ScalarOp](implicit op: BinOp[Op, Boolean, Boolean, Boolean]): VecVecElemOpIp[Op, Boolean, Boolean]
Inherited from:
BinOpVecInPlace
implicit def VecVecElemOpDDB[Op <: ScalarOp](implicit op: BinOp[Op, Double, Double, Boolean]): VecVecElemOp[Op, Double, Double, Boolean]
Inherited from:
BinOpVec
implicit def VecVecElemOpDIB[Op <: ScalarOp](implicit op: BinOp[Op, Double, Int, Boolean]): VecVecElemOp[Op, Double, Int, Boolean]
Inherited from:
BinOpVec
implicit def VecVecElemOpDLB[Op <: ScalarOp](implicit op: BinOp[Op, Double, Long, Boolean]): VecVecElemOp[Op, Double, Long, Boolean]
Inherited from:
BinOpVec
implicit def VecVecElemOpIDB[Op <: ScalarOp](implicit op: BinOp[Op, Int, Double, Boolean]): VecVecElemOp[Op, Int, Double, Boolean]
Inherited from:
BinOpVec
implicit def VecVecElemOpIIB[Op <: ScalarOp](implicit op: BinOp[Op, Int, Int, Boolean]): VecVecElemOp[Op, Int, Int, Boolean]
Inherited from:
BinOpVec
implicit def VecVecElemOpILB[Op <: ScalarOp](implicit op: BinOp[Op, Int, Long, Boolean]): VecVecElemOp[Op, Int, Long, Boolean]
Inherited from:
BinOpVec
implicit def VecVecElemOpLDB[Op <: ScalarOp](implicit op: BinOp[Op, Long, Double, Boolean]): VecVecElemOp[Op, Long, Double, Boolean]
Inherited from:
BinOpVec
implicit def VecVecElemOpLIB[Op <: ScalarOp](implicit op: BinOp[Op, Long, Int, Boolean]): VecVecElemOp[Op, Long, Int, Boolean]
Inherited from:
BinOpVec
implicit def VecVecElemOpLLB[Op <: ScalarOp](implicit op: BinOp[Op, Long, Long, Boolean]): VecVecElemOp[Op, Long, Long, Boolean]
Inherited from:
BinOpVec
implicit def VecVecOuterOpDDD(implicit opM: BinOp[Multiply, Double, Double, Double]): VecVecOuter[Double, Double, Double]
Inherited from:
BinOpVec
implicit def VecVecOuterOpDID(implicit opM: BinOp[Multiply, Double, Int, Double]): VecVecOuter[Double, Int, Double]
Inherited from:
BinOpVec
implicit def VecVecOuterOpDLD(implicit opM: BinOp[Multiply, Double, Long, Double]): VecVecOuter[Double, Long, Double]
Inherited from:
BinOpVec
implicit def VecVecOuterOpIDD(implicit opM: BinOp[Multiply, Int, Double, Double]): VecVecOuter[Int, Double, Double]
Inherited from:
BinOpVec
implicit def VecVecOuterOpIII(implicit opM: BinOp[Multiply, Int, Int, Int]): VecVecOuter[Int, Int, Int]
Inherited from:
BinOpVec
implicit def VecVecOuterOpILL(implicit opM: BinOp[Multiply, Int, Long, Long]): VecVecOuter[Int, Long, Long]
Inherited from:
BinOpVec
implicit def VecVecOuterOpLDD(implicit opM: BinOp[Multiply, Long, Double, Double]): VecVecOuter[Long, Double, Double]
Inherited from:
BinOpVec
implicit def VecVecOuterOpLIL(implicit opM: BinOp[Multiply, Long, Int, Long]): VecVecOuter[Long, Int, Long]
Inherited from:
BinOpVec
implicit def VecVecOuterOpLLL(implicit opM: BinOp[Multiply, Long, Long, Long]): VecVecOuter[Long, Long, Long]
Inherited from:
BinOpVec
implicit def VecVelElemOpDDD[Op <: ScalarOp](implicit op: BinOp[Op, Double, Double, Double]): VecVecElemOp[Op, Double, Double, Double]
Inherited from:
BinOpVec
implicit def VecVelElemOpDDDIp[Op <: ScalarOp](implicit op: BinOp[Op, Double, Double, Double]): VecVecElemOpIp[Op, Double, Double]
Inherited from:
BinOpVecInPlace
implicit def VecVelElemOpDID[Op <: ScalarOp](implicit op: BinOp[Op, Double, Int, Double]): VecVecElemOp[Op, Double, Int, Double]
Inherited from:
BinOpVec
implicit def VecVelElemOpDIDIp[Op <: ScalarOp](implicit op: BinOp[Op, Double, Int, Double]): VecVecElemOpIp[Op, Double, Int]
Inherited from:
BinOpVecInPlace
implicit def VecVelElemOpDLD[Op <: ScalarOp](implicit op: BinOp[Op, Double, Long, Double]): VecVecElemOp[Op, Double, Long, Double]
Inherited from:
BinOpVec
implicit def VecVelElemOpDLDIp[Op <: ScalarOp](implicit op: BinOp[Op, Double, Long, Double]): VecVecElemOpIp[Op, Double, Long]
Inherited from:
BinOpVecInPlace
implicit def VecVelElemOpIDD[Op <: ScalarOp](implicit op: BinOp[Op, Int, Double, Double]): VecVecElemOp[Op, Int, Double, Double]
Inherited from:
BinOpVec
implicit def VecVelElemOpIII[Op <: ScalarOp](implicit op: BinOp[Op, Int, Int, Int]): VecVecElemOp[Op, Int, Int, Int]
Inherited from:
BinOpVec
implicit def VecVelElemOpIIIIp[Op <: ScalarOp](implicit op: BinOp[Op, Int, Int, Int]): VecVecElemOpIp[Op, Int, Int]
Inherited from:
BinOpVecInPlace
implicit def VecVelElemOpILL[Op <: ScalarOp](implicit op: BinOp[Op, Int, Long, Long]): VecVecElemOp[Op, Int, Long, Long]
Inherited from:
BinOpVec
implicit def VecVelElemOpLDD[Op <: ScalarOp](implicit op: BinOp[Op, Long, Double, Double]): VecVecElemOp[Op, Long, Double, Double]
Inherited from:
BinOpVec
implicit def VecVelElemOpLIL[Op <: ScalarOp](implicit op: BinOp[Op, Long, Int, Long]): VecVecElemOp[Op, Long, Int, Long]
Inherited from:
BinOpVec
implicit def VecVelElemOpLILIp[Op <: ScalarOp](implicit op: BinOp[Op, Long, Int, Long]): VecVecElemOpIp[Op, Long, Int]
Inherited from:
BinOpVecInPlace
implicit def VecVelElemOpLLL[Op <: ScalarOp](implicit op: BinOp[Op, Long, Long, Long]): VecVecElemOp[Op, Long, Long, Long]
Inherited from:
BinOpVec
implicit def VecVelElemOpLLLIp[Op <: ScalarOp](implicit op: BinOp[Op, Long, Long, Long]): VecVecElemOpIp[Op, Long, Long]
Inherited from:
BinOpVecInPlace