nobox

ofFloat

final class ofFloat extends AnyVal

Linear Supertypes
AnyVal, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. ofFloat
  2. AnyVal
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new ofFloat(self: Array[Float])

Value Members

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

    Definition Classes
    Any

  2. final def ##(): Int

    Definition Classes
    Any

  3. def ++(that: ofFloat): ofFloat

  4. final def ==(arg0: Any): Boolean

    Definition Classes
    Any

  5. def ===(that: ofFloat): Boolean

  6. def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

  7. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  8. def collect[A](f: PartialFunction[Float, A])(implicit A: ClassTag[A]): Array[A]

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  9. def collectBoolean(f: PartialFunction[Float, Boolean]): ofBoolean

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  10. def collectByte(f: PartialFunction[Float, Byte]): ofByte

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  11. def collectChar(f: PartialFunction[Float, Char]): ofChar

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  12. def collectDouble(f: PartialFunction[Float, Double]): ofDouble

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  13. def collectFirst[A](f: PartialFunction[Float, A])(implicit A: ClassTag[A]): Option[A]

  14. def collectFirstBoolean(f: PartialFunction[Float, Boolean]): Option[Boolean]

  15. def collectFirstByte(f: PartialFunction[Float, Byte]): Option[Byte]

  16. def collectFirstChar(f: PartialFunction[Float, Char]): Option[Char]

  17. def collectFirstDouble(f: PartialFunction[Float, Double]): Option[Double]

  18. def collectFirstFloat(f: PartialFunction[Float, Float]): Option[Float]

  19. def collectFirstInt(f: PartialFunction[Float, Int]): Option[Int]

  20. def collectFirstLong(f: PartialFunction[Float, Long]): Option[Long]

  21. def collectFirstRef[Y <: AnyRef](f: PartialFunction[Float, Y])(implicit arg0: ClassTag[Y]): Option[Y]

  22. def collectFirstShort(f: PartialFunction[Float, Short]): Option[Short]

  23. def collectFloat(f: PartialFunction[Float, Float]): ofFloat

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  24. def collectInt(f: PartialFunction[Float, Int]): ofInt

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  25. def collectLong(f: PartialFunction[Float, Long]): ofLong

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  26. def collectRef[Y <: AnyRef](f: PartialFunction[Float, Y])(implicit arg0: ClassTag[Y]): ofRef[Y]

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  27. def collectShort(f: PartialFunction[Float, Short]): ofShort

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  28. def contains(elem: Float): Boolean

  29. def count(f: (Float) ⇒ Boolean): Int

  30. def deleteFirst(elem: Float): ofFloat

  31. def drop(n: Int): ofFloat

  32. def dropRight(n: Int): ofFloat

  33. def dropWhile(f: (Float) ⇒ Boolean): ofFloat

  34. def dropWhileR(f: (Float) ⇒ Boolean): ofFloat

  35. def endsWith(that: Array[Float]): Boolean

  36. def exists(f: (Float) ⇒ Boolean): Boolean

  37. def filter(f: (Float) ⇒ Boolean): ofFloat

  38. def filterNot(f: (Float) ⇒ Boolean): ofFloat

  39. def find(f: (Float) ⇒ Boolean): Option[Float]

  40. def flatMap[A](f: (Float) ⇒ Array[A])(implicit A: ClassTag[A]): Array[A]

  41. def flatMapBoolean(f: (Float) ⇒ Array[Boolean]): ofBoolean

  42. def flatMapByte(f: (Float) ⇒ Array[Byte]): ofByte

  43. def flatMapChar(f: (Float) ⇒ Array[Char]): ofChar

  44. def flatMapDouble(f: (Float) ⇒ Array[Double]): ofDouble

  45. def flatMapFloat(f: (Float) ⇒ Array[Float]): ofFloat

  46. def flatMapInt(f: (Float) ⇒ Array[Int]): ofInt

  47. def flatMapLong(f: (Float) ⇒ Array[Long]): ofLong

  48. def flatMapRef[Y <: AnyRef](f: (Float) ⇒ Array[Y])(implicit arg0: ClassTag[Y]): ofRef[Y]

  49. def flatMapShort(f: (Float) ⇒ Array[Short]): ofShort

  50. def foldLeft[A](z: A)(f: (A, Float) ⇒ A)(implicit A: ClassTag[A]): A

  51. def foldLeftBoolean(z: Boolean)(f: (Boolean, Float) ⇒ Boolean): Boolean

  52. def foldLeftByte(z: Byte)(f: (Byte, Float) ⇒ Byte): Byte

  53. def foldLeftChar(z: Char)(f: (Char, Float) ⇒ Char): Char

  54. def foldLeftDouble(z: Double)(f: (Double, Float) ⇒ Double): Double

  55. def foldLeftFloat(z: Float)(f: (Float, Float) ⇒ Float): Float

  56. def foldLeftInt(z: Int)(f: (Int, Float) ⇒ Int): Int

  57. def foldLeftLong(z: Long)(f: (Long, Float) ⇒ Long): Long

  58. def foldLeftRef[Y](z: Y)(f: (Y, Float) ⇒ Y): Y

  59. def foldLeftShort(z: Short)(f: (Short, Float) ⇒ Short): Short

  60. def foldMapLeft1[A](z: (Float) ⇒ A)(f: (A, Float) ⇒ A)(implicit A: ClassTag[A]): Option[A]

  61. def foldMapLeft1Boolean(z: (Float) ⇒ Boolean)(f: (Boolean, Float) ⇒ Boolean): Option[Boolean]

  62. def foldMapLeft1Byte(z: (Float) ⇒ Byte)(f: (Byte, Float) ⇒ Byte): Option[Byte]

  63. def foldMapLeft1Char(z: (Float) ⇒ Char)(f: (Char, Float) ⇒ Char): Option[Char]

  64. def foldMapLeft1Double(z: (Float) ⇒ Double)(f: (Double, Float) ⇒ Double): Option[Double]

  65. def foldMapLeft1Float(z: (Float) ⇒ Float)(f: (Float, Float) ⇒ Float): Option[Float]

  66. def foldMapLeft1Int(z: (Float) ⇒ Int)(f: (Int, Float) ⇒ Int): Option[Int]

  67. def foldMapLeft1Long(z: (Float) ⇒ Long)(f: (Long, Float) ⇒ Long): Option[Long]

  68. def foldMapLeft1Ref[Y](z: (Float) ⇒ Y)(f: (Y, Float) ⇒ Y): Option[Y]

  69. def foldMapLeft1Short(z: (Float) ⇒ Short)(f: (Short, Float) ⇒ Short): Option[Short]

  70. def foldMapRight1[A](z: (Float) ⇒ A)(f: (Float, A) ⇒ A)(implicit A: ClassTag[A]): Option[A]

  71. def foldMapRight1Boolean(z: (Float) ⇒ Boolean)(f: (Float, Boolean) ⇒ Boolean): Option[Boolean]

  72. def foldMapRight1Byte(z: (Float) ⇒ Byte)(f: (Float, Byte) ⇒ Byte): Option[Byte]

  73. def foldMapRight1Char(z: (Float) ⇒ Char)(f: (Float, Char) ⇒ Char): Option[Char]

  74. def foldMapRight1Double(z: (Float) ⇒ Double)(f: (Float, Double) ⇒ Double): Option[Double]

  75. def foldMapRight1Float(z: (Float) ⇒ Float)(f: (Float, Float) ⇒ Float): Option[Float]

  76. def foldMapRight1Int(z: (Float) ⇒ Int)(f: (Float, Int) ⇒ Int): Option[Int]

  77. def foldMapRight1Long(z: (Float) ⇒ Long)(f: (Float, Long) ⇒ Long): Option[Long]

  78. def foldMapRight1Ref[Y](z: (Float) ⇒ Y)(f: (Float, Y) ⇒ Y): Option[Y]

  79. def foldMapRight1Short(z: (Float) ⇒ Short)(f: (Float, Short) ⇒ Short): Option[Short]

  80. def foldRight[A](z: A)(f: (Float, A) ⇒ A)(implicit A: ClassTag[A]): A

  81. def foldRightBoolean(z: Boolean)(f: (Float, Boolean) ⇒ Boolean): Boolean

  82. def foldRightByte(z: Byte)(f: (Float, Byte) ⇒ Byte): Byte

  83. def foldRightChar(z: Char)(f: (Float, Char) ⇒ Char): Char

  84. def foldRightDouble(z: Double)(f: (Float, Double) ⇒ Double): Double

  85. def foldRightFloat(z: Float)(f: (Float, Float) ⇒ Float): Float

  86. def foldRightInt(z: Int)(f: (Float, Int) ⇒ Int): Int

  87. def foldRightLong(z: Long)(f: (Float, Long) ⇒ Long): Long

  88. def foldRightRef[Y](z: Y)(f: (Float, Y) ⇒ Y): Y

  89. def foldRightShort(z: Short)(f: (Float, Short) ⇒ Short): Short

  90. def forall(f: (Float) ⇒ Boolean): Boolean

  91. def foreach[U](f: (Float) ⇒ U): Unit

  92. def getClass(): Class[_ <: AnyVal]

    Definition Classes
    AnyVal → Any

  93. def groupBy[A](f: (Float) ⇒ A): Map[A, ofFloat]

  94. def grouped(n: Int): Iterator[ofFloat]

    Annotations
    @throws( ... )

  95. def indexOf(elem: Float): Option[Int]

  96. def initOption: Option[ofFloat]

  97. def inits: Iterator[ofFloat]

  98. def intersperse(a: Float): ofFloat

  99. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  100. def lastIndexOf(elem: Float): Option[Int]

  101. def length: Int

  102. def map[A](f: (Float) ⇒ A)(implicit A: ClassTag[A]): Array[A]

  103. def mapBoolean(f: (Float) ⇒ Boolean): ofBoolean

  104. def mapByte(f: (Float) ⇒ Byte): ofByte

  105. def mapChar(f: (Float) ⇒ Char): ofChar

  106. def mapDouble(f: (Float) ⇒ Double): ofDouble

  107. def mapFloat(f: (Float) ⇒ Float): ofFloat

  108. def mapInt(f: (Float) ⇒ Int): ofInt

  109. def mapLong(f: (Float) ⇒ Long): ofLong

  110. def mapRef[Y <: AnyRef](f: (Float) ⇒ Y)(implicit arg0: ClassTag[Y]): ofRef[Y]

  111. def mapShort(f: (Float) ⇒ Short): ofShort

  112. def max: Option[Float]

  113. def maxBy[A](f: (Float) ⇒ A)(implicit A: Ordering[A]): Option[Float]

  114. def min: Option[Float]

  115. def minBy[A](f: (Float) ⇒ A)(implicit A: Ordering[A]): Option[Float]

  116. def minmax: Option[(Float, Float)]

  117. def mkString: String

  118. def mkString(sep: String): String

  119. def mkString(start: String, sep: String, end: String): String

  120. def partition(f: (Float) ⇒ Boolean): (ofFloat, ofFloat)

  121. def product: Float

  122. def productDouble: Double

  123. def reduceLeftOption(f: (Float, Float) ⇒ Float): Option[Float]

  124. def reduceRightOption(f: (Float, Float) ⇒ Float): Option[Float]

  125. def reverse: ofFloat

  126. def reverseMap[A](f: (Float) ⇒ A)(implicit A: ClassTag[A]): Array[A]

  127. def reverseMapBoolean(f: (Float) ⇒ Boolean): ofBoolean

  128. def reverseMapByte(f: (Float) ⇒ Byte): ofByte

  129. def reverseMapChar(f: (Float) ⇒ Char): ofChar

  130. def reverseMapDouble(f: (Float) ⇒ Double): ofDouble

  131. def reverseMapFloat(f: (Float) ⇒ Float): ofFloat

  132. def reverseMapInt(f: (Float) ⇒ Int): ofInt

  133. def reverseMapLong(f: (Float) ⇒ Long): ofLong

  134. def reverseMapRef[Y <: AnyRef](f: (Float) ⇒ Y)(implicit arg0: ClassTag[Y]): ofRef[Y]

  135. def reverseMapShort(f: (Float) ⇒ Short): ofShort

  136. def reverse_:::(prefix: ofFloat): ofFloat

  137. def scanLeft[A](z: A)(f: (A, Float) ⇒ A)(implicit A: ClassTag[A]): Array[A]

  138. def scanLeft1(f: (Float, Float) ⇒ Float): ofFloat

  139. def scanLeftBoolean(z: Boolean)(f: (Boolean, Float) ⇒ Boolean): ofBoolean

  140. def scanLeftByte(z: Byte)(f: (Byte, Float) ⇒ Byte): ofByte

  141. def scanLeftChar(z: Char)(f: (Char, Float) ⇒ Char): ofChar

  142. def scanLeftDouble(z: Double)(f: (Double, Float) ⇒ Double): ofDouble

  143. def scanLeftFloat(z: Float)(f: (Float, Float) ⇒ Float): ofFloat

  144. def scanLeftInt(z: Int)(f: (Int, Float) ⇒ Int): ofInt

  145. def scanLeftLong(z: Long)(f: (Long, Float) ⇒ Long): ofLong

  146. def scanLeftRef[Y <: AnyRef](z: Y)(f: (Y, Float) ⇒ Y)(implicit arg0: ClassTag[Y]): ofRef[Y]

  147. def scanLeftShort(z: Short)(f: (Short, Float) ⇒ Short): ofShort

  148. def scanRight[A](z: A)(f: (Float, A) ⇒ A)(implicit A: ClassTag[A]): Array[A]

  149. def scanRight1(f: (Float, Float) ⇒ Float): ofFloat

  150. def scanRightBoolean(z: Boolean)(f: (Float, Boolean) ⇒ Boolean): ofBoolean

  151. def scanRightByte(z: Byte)(f: (Float, Byte) ⇒ Byte): ofByte

  152. def scanRightChar(z: Char)(f: (Float, Char) ⇒ Char): ofChar

  153. def scanRightDouble(z: Double)(f: (Float, Double) ⇒ Double): ofDouble

  154. def scanRightFloat(z: Float)(f: (Float, Float) ⇒ Float): ofFloat

  155. def scanRightInt(z: Int)(f: (Float, Int) ⇒ Int): ofInt

  156. def scanRightLong(z: Long)(f: (Float, Long) ⇒ Long): ofLong

  157. def scanRightRef[Y <: AnyRef](z: Y)(f: (Float, Y) ⇒ Y)(implicit arg0: ClassTag[Y]): ofRef[Y]

  158. def scanRightShort(z: Short)(f: (Float, Short) ⇒ Short): ofShort

  159. val self: Array[Float]

  160. def size: Int

  161. def slice(from: Int, until: Int): ofFloat

  162. def sliding(_size: Int, step: Int = 1): Iterator[ofFloat]

    Annotations
    @throws( ... )

  163. def sorted: ofFloat

  164. def span(f: (Float) ⇒ Boolean): (ofFloat, ofFloat)

  165. def splitAt(n: Int): (ofFloat, ofFloat)

  166. def startsWith(that: Array[Float], offset: Int = 0): Boolean

  167. def sum: Float

  168. def tailOption: Option[ofFloat]

  169. def tails: Iterator[ofFloat]

  170. def take(n: Int): ofFloat

  171. def takeRight(n: Int): ofFloat

  172. def takeWhile(f: (Float) ⇒ Boolean): ofFloat

  173. def takeWhileR(f: (Float) ⇒ Boolean): ofFloat

  174. def toString(): String

    Definition Classes
    ofFloat → Any

  175. def updated(index: Int, elem: Float): ofFloat

    Annotations
    @throws( ... )

  176. def withFilter(f: (Float) ⇒ Boolean): WithFilterFloat

Inherited from AnyVal

Inherited from Any

Ungrouped