object BinOp extends AnyRef

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

Linear Supertypes
AnyRef, Any
  1. Alphabetic
  2. By inheritance
  1. Hide All
  2. Show all
  1. BinOp
  2. AnyRef
  3. Any
  1. Public
  2. All

Type Members

  1. type BDDD[T <: OpType] = BinOp[T, Double, Double, Double]

  2. type BDID[T <: OpType] = BinOp[T, Double, Int, Double]

  3. type BDLD[T <: OpType] = BinOp[T, Double, Long, Double]

  4. type BIDD[T <: OpType] = BinOp[T, Int, Double, Double]

  5. type BIII[T <: OpType] = BinOp[T, Int, Int, Int]

  6. type BILL[T <: OpType] = BinOp[T, Int, Long, Long]

  7. type BLDD[T <: OpType] = BinOp[T, Long, Double, Double]

  8. type BLIL[T <: OpType] = BinOp[T, Long, Int, Long]

  9. type BLLL[T <: OpType] = BinOp[T, Long, Long, Long]

Value Members

  1. final def !=(arg0: AnyRef): Boolean

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

    Definition Classes
  3. final def ##(): Int

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

    Definition Classes
  5. final def ==(arg0: Any): Boolean

    Definition Classes
  6. implicit val addDD: BDDD[Add]

  7. implicit val addDI: BIDD[Add]

  8. implicit val addDL: BDLD[Add]

  9. implicit val addID: BDID[Add]

  10. implicit val addII: BIII[Add]

  11. implicit val addIL: BILL[Add]

  12. implicit val addLD: BLDD[Add]

  13. implicit val addLI: BLIL[Add]

  14. implicit val addLL: BLLL[Add]

  15. implicit val andBB: BinOp[AndOp, Boolean, Boolean, Boolean]

  16. implicit val andII: BIII[BitAnd]

  17. implicit val andIL: BILL[BitAnd]

  18. implicit val andLI: BLIL[BitAnd]

  19. implicit val andLL: BLLL[BitAnd]

  20. final def asInstanceOf[T0]: T0

    Definition Classes
  21. def clone(): AnyRef

    Definition Classes
  22. implicit val divDD: BDDD[Divide]

  23. implicit val divDI: BIDD[Divide]

  24. implicit val divDL: BDLD[Divide]

  25. implicit val divID: BDID[Divide]

  26. implicit val divII: BIII[Divide]

  27. implicit val divIL: BILL[Divide]

  28. implicit val divLD: BLDD[Divide]

  29. implicit val divLI: BLIL[Divide]

  30. implicit val divLL: BLLL[Divide]

  31. final def eq(arg0: AnyRef): Boolean

    Definition Classes
  32. implicit val eqBB: BinOp[EqOp, Boolean, Boolean, Boolean]

  33. implicit val eqDD: BinOp[EqOp, Double, Double, Boolean]

  34. implicit val eqDI: BinOp[EqOp, Double, Int, Boolean]

  35. implicit val eqDL: BinOp[EqOp, Double, Long, Boolean]

  36. implicit val eqID: BinOp[EqOp, Int, Double, Boolean]

  37. implicit val eqII: BinOp[EqOp, Int, Int, Boolean]

  38. implicit val eqIL: BinOp[EqOp, Int, Long, Boolean]

  39. implicit val eqLD: BinOp[EqOp, Long, Double, Boolean]

  40. implicit val eqLI: BinOp[EqOp, Long, Int, Boolean]

  41. implicit val eqLL: BinOp[EqOp, Long, Long, Boolean]

  42. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  43. def finalize(): Unit

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

    Definition Classes
    AnyRef → Any
  45. implicit val gtBB: BinOp[GtOp, Boolean, Boolean, Boolean]

  46. implicit val gtDD: BinOp[GtOp, Double, Double, Boolean]

  47. implicit val gtDI: BinOp[GtOp, Double, Int, Boolean]

  48. implicit val gtDL: BinOp[GtOp, Double, Long, Boolean]

  49. implicit val gtID: BinOp[GtOp, Int, Double, Boolean]

  50. implicit val gtII: BinOp[GtOp, Int, Int, Boolean]

  51. implicit val gtIL: BinOp[GtOp, Int, Long, Boolean]

  52. implicit val gtLD: BinOp[GtOp, Long, Double, Boolean]

  53. implicit val gtLI: BinOp[GtOp, Long, Int, Boolean]

  54. implicit val gtLL: BinOp[GtOp, Long, Long, Boolean]

  55. implicit val gteBB: BinOp[GteOp, Boolean, Boolean, Boolean]

  56. implicit val gteDD: BinOp[GteOp, Double, Double, Boolean]

  57. implicit val gteDI: BinOp[GteOp, Double, Int, Boolean]

  58. implicit val gteDL: BinOp[GteOp, Double, Long, Boolean]

  59. implicit val gteID: BinOp[GteOp, Int, Double, Boolean]

  60. implicit val gteII: BinOp[GteOp, Int, Int, Boolean]

  61. implicit val gteIL: BinOp[GteOp, Int, Long, Boolean]

  62. implicit val gteLD: BinOp[GteOp, Long, Double, Boolean]

  63. implicit val gteLI: BinOp[GteOp, Long, Int, Boolean]

  64. implicit val gteLL: BinOp[GteOp, Long, Long, Boolean]

  65. def hashCode(): Int

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

    Definition Classes
  67. implicit val ltBB: BinOp[LtOp, Boolean, Boolean, Boolean]

  68. implicit val ltDD: BinOp[LtOp, Double, Double, Boolean]

  69. implicit val ltDI: BinOp[LtOp, Double, Int, Boolean]

  70. implicit val ltDL: BinOp[LtOp, Double, Long, Boolean]

  71. implicit val ltID: BinOp[LtOp, Int, Double, Boolean]

  72. implicit val ltII: BinOp[LtOp, Int, Int, Boolean]

  73. implicit val ltIL: BinOp[LtOp, Int, Long, Boolean]

  74. implicit val ltLD: BinOp[LtOp, Long, Double, Boolean]

  75. implicit val ltLI: BinOp[LtOp, Long, Int, Boolean]

  76. implicit val ltLL: BinOp[LtOp, Long, Long, Boolean]

  77. implicit val lteBB: BinOp[LteOp, Boolean, Boolean, Boolean]

  78. implicit val lteDD: BinOp[LteOp, Double, Double, Boolean]

  79. implicit val lteDI: BinOp[LteOp, Double, Int, Boolean]

  80. implicit val lteDL: BinOp[LteOp, Double, Long, Boolean]

  81. implicit val lteID: BinOp[LteOp, Int, Double, Boolean]

  82. implicit val lteII: BinOp[LteOp, Int, Int, Boolean]

  83. implicit val lteIL: BinOp[LteOp, Int, Long, Boolean]

  84. implicit val lteLD: BinOp[LteOp, Long, Double, Boolean]

  85. implicit val lteLI: BinOp[LteOp, Long, Int, Boolean]

  86. implicit val lteLL: BinOp[LteOp, Long, Long, Boolean]

  87. implicit val modDD: BDDD[Mod]

  88. implicit val modDI: BIDD[Mod]

  89. implicit val modDL: BDLD[Mod]

  90. implicit val modID: BDID[Mod]

  91. implicit val modII: BIII[Mod]

  92. implicit val modIL: BILL[Mod]

  93. implicit val modLD: BLDD[Mod]

  94. implicit val modLI: BLIL[Mod]

  95. implicit val modLL: BLLL[Mod]

  96. implicit val mulDD: BDDD[Multiply]

  97. implicit val mulDI: BIDD[Multiply]

  98. implicit val mulDL: BDLD[Multiply]

  99. implicit val mulID: BDID[Multiply]

  100. implicit val mulII: BIII[Multiply]

  101. implicit val mulIL: BILL[Multiply]

  102. implicit val mulLD: BLDD[Multiply]

  103. implicit val mulLI: BLIL[Multiply]

  104. implicit val mulLL: BLLL[Multiply]

  105. final def ne(arg0: AnyRef): Boolean

    Definition Classes
  106. implicit val neqBB: BinOp[NeqOp, Boolean, Boolean, Boolean]

  107. implicit val neqDD: BinOp[NeqOp, Double, Double, Boolean]

  108. implicit val neqDI: BinOp[NeqOp, Double, Int, Boolean]

  109. implicit val neqDL: BinOp[NeqOp, Double, Long, Boolean]

  110. implicit val neqID: BinOp[NeqOp, Int, Double, Boolean]

  111. implicit val neqII: BinOp[NeqOp, Int, Int, Boolean]

  112. implicit val neqIL: BinOp[NeqOp, Int, Long, Boolean]

  113. implicit val neqLD: BinOp[NeqOp, Long, Double, Boolean]

  114. implicit val neqLI: BinOp[NeqOp, Long, Int, Boolean]

  115. implicit val neqLL: BinOp[NeqOp, Long, Long, Boolean]

  116. final def notify(): Unit

    Definition Classes
  117. final def notifyAll(): Unit

    Definition Classes
  118. implicit val orBB: BinOp[OrOp, Boolean, Boolean, Boolean]

  119. implicit val orII: BIII[BitOr]

  120. implicit val orIL: BILL[BitOr]

  121. implicit val orLI: BLIL[BitOr]

  122. implicit val orLL: BLLL[BitOr]

  123. implicit val powDD: BDDD[Power]

  124. implicit val powDI: BIDD[Power]

  125. implicit val powDL: BDLD[Power]

  126. implicit val powID: BDID[Power]

  127. implicit val powII: BIII[Power]

  128. implicit val powIL: BILL[Power]

  129. implicit val powLD: BLDD[Power]

  130. implicit val powLI: BLIL[Power]

  131. implicit val powLL: BLLL[Power]

  132. implicit val shlII: BIII[BitShl]

  133. implicit val shlIL: BILL[BitShl]

  134. implicit val shlLI: BLIL[BitShl]

  135. implicit val shrII: BIII[BitShr]

  136. implicit val shrIL: BILL[BitShr]

  137. implicit val shrLI: BLIL[BitShr]

  138. implicit val subDD: BDDD[Subtract]

  139. implicit val subDI: BIDD[Subtract]

  140. implicit val subDL: BDLD[Subtract]

  141. implicit val subID: BDID[Subtract]

  142. implicit val subII: BIII[Subtract]

  143. implicit val subIL: BILL[Subtract]

  144. implicit val subLD: BLDD[Subtract]

  145. implicit val subLI: BLIL[Subtract]

  146. implicit val subLL: BLLL[Subtract]

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

    Definition Classes
  148. def toString(): String

    Definition Classes
    AnyRef → Any
  149. implicit val ushII: BIII[BitUShr]

  150. implicit val ushIL: BILL[BitUShr]

  151. implicit val ushLI: BLIL[BitUShr]

  152. final def wait(): Unit

    Definition Classes
  153. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
  154. final def wait(arg0: Long): Unit

    Definition Classes
  155. implicit val xorBB: BinOp[XorOp, Boolean, Boolean, Boolean]

  156. implicit val xorII: BIII[BitXor]

  157. implicit val xorIL: BILL[BitXor]

  158. implicit val xorLI: BLIL[BitXor]

  159. implicit val xorLL: BLLL[BitXor]

Inherited from AnyRef

Inherited from Any