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

   Annotations

   @inline()

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(scala.this.throws.<init>$default$1[IllegalArgumentException])

95.  def indexOf(elem: Float): Option[Int]
96.  def initOption: Option[ofFloat]
97.  def inits: Iterator[ofFloat]
98.  def interleave(that: ofFloat): ofFloat
99.  def intersperse(a: Float): ofFloat
100.  final def isInstanceOf[T0]: Boolean

     Definition Classes

     Any

101.  def lastIndexOf(elem: Float): Option[Int]
102.  def length: Int

     Annotations

     @inline()

103.  def map[A](f: (Float) => A)(implicit A: ClassTag[A]): Array[A]
104.  def mapBoolean(f: (Float) => Boolean): ofBoolean
105.  def mapByte(f: (Float) => Byte): ofByte
106.  def mapChar(f: (Float) => Char): ofChar
107.  def mapDouble(f: (Float) => Double): ofDouble
108.  def mapFloat(f: (Float) => Float): ofFloat
109.  def mapInt(f: (Float) => Int): ofInt
110.  def mapLong(f: (Float) => Long): ofLong
111.  def mapRef[Y <: AnyRef](f: (Float) => Y)(implicit arg0: ClassTag[Y]): ofRef[Y]
112.  def mapShort(f: (Float) => Short): ofShort
113.  def max: Option[Float]
114.  def maxBy[A](f: (Float) => A)(implicit A: Ordering[A]): Option[Float]
115.  def min: Option[Float]
116.  def minBy[A](f: (Float) => A)(implicit A: Ordering[A]): Option[Float]
117.  def minmax: Option[(Float, Float)]
118.  def mkString: String
119.  def mkString(sep: String): String
120.  def mkString(start: String, sep: String, end: String): String
121.  def partition(f: (Float) => Boolean): (ofFloat, ofFloat)
122.  def product: Float
123.  def productDouble: Double
124.  def reduceLeftOption(f: (Float, Float) => Float): Option[Float]
125.  def reduceRightOption(f: (Float, Float) => Float): Option[Float]
126.  def reverse: ofFloat
127.  def reverseMap[A](f: (Float) => A)(implicit A: ClassTag[A]): Array[A]
128.  def reverseMapBoolean(f: (Float) => Boolean): ofBoolean
129.  def reverseMapByte(f: (Float) => Byte): ofByte
130.  def reverseMapChar(f: (Float) => Char): ofChar
131.  def reverseMapDouble(f: (Float) => Double): ofDouble
132.  def reverseMapFloat(f: (Float) => Float): ofFloat
133.  def reverseMapInt(f: (Float) => Int): ofInt
134.  def reverseMapLong(f: (Float) => Long): ofLong
135.  def reverseMapRef[Y <: AnyRef](f: (Float) => Y)(implicit arg0: ClassTag[Y]): ofRef[Y]
136.  def reverseMapShort(f: (Float) => Short): ofShort
137.  def reverse_:::(prefix: ofFloat): ofFloat
138.  def scanLeft[A](z: A)(f: (A, Float) => A)(implicit A: ClassTag[A]): Array[A]
139.  def scanLeft1(f: (Float, Float) => Float): ofFloat
140.  def scanLeftBoolean(z: Boolean)(f: (Boolean, Float) => Boolean): ofBoolean
141.  def scanLeftByte(z: Byte)(f: (Byte, Float) => Byte): ofByte
142.  def scanLeftChar(z: Char)(f: (Char, Float) => Char): ofChar
143.  def scanLeftDouble(z: Double)(f: (Double, Float) => Double): ofDouble
144.  def scanLeftFloat(z: Float)(f: (Float, Float) => Float): ofFloat
145.  def scanLeftInt(z: Int)(f: (Int, Float) => Int): ofInt
146.  def scanLeftLong(z: Long)(f: (Long, Float) => Long): ofLong
147.  def scanLeftRef[Y <: AnyRef](z: Y)(f: (Y, Float) => Y)(implicit arg0: ClassTag[Y]): ofRef[Y]
148.  def scanLeftShort(z: Short)(f: (Short, Float) => Short): ofShort
149.  def scanRight[A](z: A)(f: (Float, A) => A)(implicit A: ClassTag[A]): Array[A]
150.  def scanRight1(f: (Float, Float) => Float): ofFloat
151.  def scanRightBoolean(z: Boolean)(f: (Float, Boolean) => Boolean): ofBoolean
152.  def scanRightByte(z: Byte)(f: (Float, Byte) => Byte): ofByte
153.  def scanRightChar(z: Char)(f: (Float, Char) => Char): ofChar
154.  def scanRightDouble(z: Double)(f: (Float, Double) => Double): ofDouble
155.  def scanRightFloat(z: Float)(f: (Float, Float) => Float): ofFloat
156.  def scanRightInt(z: Int)(f: (Float, Int) => Int): ofInt
157.  def scanRightLong(z: Long)(f: (Float, Long) => Long): ofLong
158.  def scanRightRef[Y <: AnyRef](z: Y)(f: (Float, Y) => Y)(implicit arg0: ClassTag[Y]): ofRef[Y]
159.  def scanRightShort(z: Short)(f: (Float, Short) => Short): ofShort
160.  val self: Array[Float]
161.  def size: Int

     Annotations

     @inline()

162.  def slice(from: Int, until: Int): ofFloat
163.  def sliding(_size: Int, step: Int = 1): Iterator[ofFloat]

     Annotations

     @throws(scala.this.throws.<init>$default$1[IllegalArgumentException])

164.  def sorted: ofFloat
165.  def span(f: (Float) => Boolean): (ofFloat, ofFloat)
166.  def splitAt(n: Int): (ofFloat, ofFloat)
167.  def startsWith(that: Array[Float], offset: Int = 0): Boolean
168.  def sum: Float
169.  def tailOption: Option[ofFloat]
170.  def tails: Iterator[ofFloat]
171.  def take(n: Int): ofFloat
172.  def takeRight(n: Int): ofFloat
173.  def takeWhile(f: (Float) => Boolean): ofFloat
174.  def takeWhileR(f: (Float) => Boolean): ofFloat
175.  def toArray: Array[Float]
176.  def toList: List[Float]
177.  def toString(): String

     Definition Classes

     ofFloat → Any

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

     Annotations

     @throws(scala.this.throws.<init>$default$1[IndexOutOfBoundsException])

179.  def withFilter(f: (Float) => Boolean): WithFilterFloat