Value Members

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

   Definition Classes

   Any

2.  final def ##(): Int

   Definition Classes

   Any

3.  def ++(that: ofDouble): ofDouble
4.  final def ==(arg0: Any): Boolean

   Definition Classes

   Any

5.  def ===(that: ofDouble): 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[Double, A])(implicit A: ClassTag[A]): Array[A]

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

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

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

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

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

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

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

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

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

13.  def collectFirst[A](f: PartialFunction[Double, A])(implicit A: ClassTag[A]): Option[A]
14.  def collectFirstBoolean(f: PartialFunction[Double, Boolean]): Option[Boolean]
15.  def collectFirstByte(f: PartialFunction[Double, Byte]): Option[Byte]
16.  def collectFirstChar(f: PartialFunction[Double, Char]): Option[Char]
17.  def collectFirstDouble(f: PartialFunction[Double, Double]): Option[Double]
18.  def collectFirstFloat(f: PartialFunction[Double, Float]): Option[Float]
19.  def collectFirstInt(f: PartialFunction[Double, Int]): Option[Int]
20.  def collectFirstLong(f: PartialFunction[Double, Long]): Option[Long]
21.  def collectFirstRef[Y <: AnyRef](f: PartialFunction[Double, Y])(implicit arg0: ClassTag[Y]): Option[Y]
22.  def collectFirstShort(f: PartialFunction[Double, Short]): Option[Short]
23.  def collectFloat(f: PartialFunction[Double, Float]): ofFloat

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

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

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

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

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

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

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

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

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

28.  def contains(elem: Double): Boolean
29.  def count(f: (Double) ⇒ Boolean): Int
30.  def deleteFirst(elem: Double): ofDouble
31.  def drop(n: Int): ofDouble
32.  def dropRight(n: Int): ofDouble
33.  def dropWhile(f: (Double) ⇒ Boolean): ofDouble
34.  def dropWhileR(f: (Double) ⇒ Boolean): ofDouble
35.  def endsWith(that: Array[Double]): Boolean
36.  def exists(f: (Double) ⇒ Boolean): Boolean
37.  def filter(f: (Double) ⇒ Boolean): ofDouble
38.  def filterNot(f: (Double) ⇒ Boolean): ofDouble
39.  def find(f: (Double) ⇒ Boolean): Option[Double]
40.  def flatMap[A](f: (Double) ⇒ Array[A])(implicit A: ClassTag[A]): Array[A]
41.  def flatMapBoolean(f: (Double) ⇒ Array[Boolean]): ofBoolean
42.  def flatMapByte(f: (Double) ⇒ Array[Byte]): ofByte
43.  def flatMapChar(f: (Double) ⇒ Array[Char]): ofChar
44.  def flatMapDouble(f: (Double) ⇒ Array[Double]): ofDouble
45.  def flatMapFloat(f: (Double) ⇒ Array[Float]): ofFloat
46.  def flatMapInt(f: (Double) ⇒ Array[Int]): ofInt
47.  def flatMapLong(f: (Double) ⇒ Array[Long]): ofLong
48.  def flatMapRef[Y <: AnyRef](f: (Double) ⇒ Array[Y])(implicit arg0: ClassTag[Y]): ofRef[Y]
49.  def flatMapShort(f: (Double) ⇒ Array[Short]): ofShort
50.  def foldLeft[A](z: A)(f: (A, Double) ⇒ A)(implicit A: ClassTag[A]): A
51.  def foldLeftBoolean(z: Boolean)(f: (Boolean, Double) ⇒ Boolean): Boolean
52.  def foldLeftByte(z: Byte)(f: (Byte, Double) ⇒ Byte): Byte
53.  def foldLeftChar(z: Char)(f: (Char, Double) ⇒ Char): Char
54.  def foldLeftDouble(z: Double)(f: (Double, Double) ⇒ Double): Double
55.  def foldLeftFloat(z: Float)(f: (Float, Double) ⇒ Float): Float
56.  def foldLeftInt(z: Int)(f: (Int, Double) ⇒ Int): Int
57.  def foldLeftLong(z: Long)(f: (Long, Double) ⇒ Long): Long
58.  def foldLeftRef[Y](z: Y)(f: (Y, Double) ⇒ Y): Y
59.  def foldLeftShort(z: Short)(f: (Short, Double) ⇒ Short): Short
60.  def foldMapLeft1[A](z: (Double) ⇒ A)(f: (A, Double) ⇒ A)(implicit A: ClassTag[A]): Option[A]
61.  def foldMapLeft1Boolean(z: (Double) ⇒ Boolean)(f: (Boolean, Double) ⇒ Boolean): Option[Boolean]
62.  def foldMapLeft1Byte(z: (Double) ⇒ Byte)(f: (Byte, Double) ⇒ Byte): Option[Byte]
63.  def foldMapLeft1Char(z: (Double) ⇒ Char)(f: (Char, Double) ⇒ Char): Option[Char]
64.  def foldMapLeft1Double(z: (Double) ⇒ Double)(f: (Double, Double) ⇒ Double): Option[Double]
65.  def foldMapLeft1Float(z: (Double) ⇒ Float)(f: (Float, Double) ⇒ Float): Option[Float]
66.  def foldMapLeft1Int(z: (Double) ⇒ Int)(f: (Int, Double) ⇒ Int): Option[Int]
67.  def foldMapLeft1Long(z: (Double) ⇒ Long)(f: (Long, Double) ⇒ Long): Option[Long]
68.  def foldMapLeft1Ref[Y](z: (Double) ⇒ Y)(f: (Y, Double) ⇒ Y): Option[Y]
69.  def foldMapLeft1Short(z: (Double) ⇒ Short)(f: (Short, Double) ⇒ Short): Option[Short]
70.  def foldMapRight1[A](z: (Double) ⇒ A)(f: (Double, A) ⇒ A)(implicit A: ClassTag[A]): Option[A]
71.  def foldMapRight1Boolean(z: (Double) ⇒ Boolean)(f: (Double, Boolean) ⇒ Boolean): Option[Boolean]
72.  def foldMapRight1Byte(z: (Double) ⇒ Byte)(f: (Double, Byte) ⇒ Byte): Option[Byte]
73.  def foldMapRight1Char(z: (Double) ⇒ Char)(f: (Double, Char) ⇒ Char): Option[Char]
74.  def foldMapRight1Double(z: (Double) ⇒ Double)(f: (Double, Double) ⇒ Double): Option[Double]
75.  def foldMapRight1Float(z: (Double) ⇒ Float)(f: (Double, Float) ⇒ Float): Option[Float]
76.  def foldMapRight1Int(z: (Double) ⇒ Int)(f: (Double, Int) ⇒ Int): Option[Int]
77.  def foldMapRight1Long(z: (Double) ⇒ Long)(f: (Double, Long) ⇒ Long): Option[Long]
78.  def foldMapRight1Ref[Y](z: (Double) ⇒ Y)(f: (Double, Y) ⇒ Y): Option[Y]
79.  def foldMapRight1Short(z: (Double) ⇒ Short)(f: (Double, Short) ⇒ Short): Option[Short]
80.  def foldRight[A](z: A)(f: (Double, A) ⇒ A)(implicit A: ClassTag[A]): A
81.  def foldRightBoolean(z: Boolean)(f: (Double, Boolean) ⇒ Boolean): Boolean
82.  def foldRightByte(z: Byte)(f: (Double, Byte) ⇒ Byte): Byte
83.  def foldRightChar(z: Char)(f: (Double, Char) ⇒ Char): Char
84.  def foldRightDouble(z: Double)(f: (Double, Double) ⇒ Double): Double
85.  def foldRightFloat(z: Float)(f: (Double, Float) ⇒ Float): Float
86.  def foldRightInt(z: Int)(f: (Double, Int) ⇒ Int): Int
87.  def foldRightLong(z: Long)(f: (Double, Long) ⇒ Long): Long
88.  def foldRightRef[Y](z: Y)(f: (Double, Y) ⇒ Y): Y
89.  def foldRightShort(z: Short)(f: (Double, Short) ⇒ Short): Short
90.  def forall(f: (Double) ⇒ Boolean): Boolean
91.  def foreach[U](f: (Double) ⇒ U): Unit
92.  def getClass(): Class[_ <: AnyVal]

    Definition Classes

    AnyVal → Any

93.  def groupBy[A](f: (Double) ⇒ A): Map[A, ofDouble]
94.  def grouped(n: Int): Iterator[ofDouble]

    Annotations

    @throws( ... )

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

     Definition Classes

     Any

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

     Annotations

     @inline()

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

     Annotations

     @inline()

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

     Annotations

     @throws( ... )

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

     Definition Classes

     ofDouble → Any

177.  def updated(index: Int, elem: Double): ofDouble

     Annotations

     @throws( ... )

178.  def withFilter(f: (Double) ⇒ Boolean): WithFilterDouble