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. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

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

  100. def length: Int

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

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

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

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

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

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

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

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

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

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

  111. def max: Option[Float]

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

  113. def min: Option[Float]

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

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

  116. def mkString: String

  117. def mkString(sep: String): String

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

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

  120. def product: Float

  121. def productDouble: Double

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

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

  124. def reverse: ofFloat

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  158. val self: Array[Float]

  159. def size: Int

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

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

    Annotations
    @throws( ... )

  162. def sorted: ofFloat

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

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

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

  166. def sum: Float

  167. def tailOption: Option[ofFloat]

  168. def tails: Iterator[ofFloat]

  169. def take(n: Int): ofFloat

  170. def takeRight(n: Int): ofFloat

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

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

  173. def toString(): String

    Definition Classes
    ofFloat → Any

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

    Annotations
    @throws( ... )

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

Inherited from AnyVal

Inherited from Any

Ungrouped