Класс scala.jdk.DoubleAccumulator

final class DoubleAccumulator extends Accumulator[Double, AnyAccumulator, DoubleAccumulator] with SeqOps[Double, AnyAccumulator, DoubleAccumulator] with Serializable

Специализированный Accumulator, хранящий Double без боксрования, см. Accumulator.

Конкретные методы

Исходный код

def addOne(a: Double): DoubleAccumulator

Добавляет элемент в этот DoubleAccumulator.

Исходный код

def apply(ix: Long): Double

Возвращает ix-й элемент.

Исходный код

def apply(i: Int): Double

Возвращает ix-й элемент, используя Int индекс.

Исходный код

override def clear(): Unit

Исходный код

def collect(pf: PartialFunction[Double, Double]): DoubleAccumulator

Исходный код

override def count(p: Double => Boolean): Int

Исходный код

def countLong(p: Double => Boolean): Long

Исходный код

def drain(that: DoubleAccumulator): Unit

Удаляет все элементы из that и добавляет их в этот DoubleAccumulator.

Исходный код

def efficientStepper[S <: Stepper[_]](implicit shape: StepperShape[Double, S]): S & EfficientSplit

Исходный код

override def empty: DoubleAccumulator

Исходный код

override def exists(p: Double => Boolean): Boolean

Исходный код

override def filter(pred: Double => Boolean): DoubleAccumulator

Исходный код

override def filterNot(pred: Double => Boolean): DoubleAccumulator

Исходный код

def flatMap(f: Double => IterableOnce[Double]): DoubleAccumulator

Исходный код

override def forall(p: Double => Boolean): Boolean

Исходный код

override def foreach[U](f: Double => U): Unit

Source

override def iterableFactory: SeqFactory[AnyAccumulator]

Source

def iterator: Iterator[Double]

Возвращает Iterator по содержимому этого DoubleAccumulator. Iterator не специализирована.

Source

def map(f: Double => Double): DoubleAccumulator

Source

override def result(): DoubleAccumulator

Результат коллекции, содержащий все добавленные до сих пор элементы.

Source

override def to[C1](factory: Factory[Double, C1]): C1

Копирует элементы из этого DoubleAccumulator в указанную коллекцию. Обратите внимание, что целевая коллекция не специализирована. Пример использования: acc.to(Vector)

Source

def toArray: Array[Double]

Копирует элементы из этого DoubleAccumulator в Array[Double].

Source

override def toList: List[Double]

Копирует элементы из этого DoubleAccumulator в List.

Source

def update(idx: Long, elem: Double): Unit

Source

def update(idx: Int, elem: Double): Unit

Наследованные методы

Source@inline

final def ++[B >: Double](suffix: IterableOnce[B]): AnyAccumulator[B]

Псевдоним для concat.

Source@inline

final override def ++:[B >: Double](prefix: IterableOnce[B]): AnyAccumulator[B]

Псевдоним для prependedAll.

Source@inline

final def ++=(xs: IterableOnce[Double]): DoubleAccumulator

Псевдоним для addAll.

Source@inline

final def +:[B >: Double](elem: B): AnyAccumulator[B]

Псевдоним для prepended.

Обратите внимание, что операторы с окончанием :- являются правоассоциативными (см. пример). Мемоническая подсказка для +: и :+ заключается в том, что двоеточие ставится со стороны коллекции.

Source@inline

final def +=(elem: Double): DoubleAccumulator

Псевдоним для addOne.

Source@inline

final def :+[B >: Double](elem: B): AnyAccumulator[B]

Псевдоним для appended.

Обратите внимание, что операторы с окончанием :- являются правоассоциативными (см. пример). Мемоническая подсказка для +: и :+ заключается в том, что двоеточие ставится со стороны коллекции.

Source@inline

final def :++[B >: Double](suffix: IterableOnce[B]): AnyAccumulator[B]

Псевдоним для appendedAll.

Source

def addAll(xs: IterableOnce[Double]): DoubleAccumulator

Добавляет все элементы, произведённые IterableOnce, в эту коллекцию, поддерживающую рост.

Source@inline

final def addString(b: StringBuilder): StringBuilder

Добавляет все элементы этой коллекции в строковый буфер. Записываемый текст состоит из строковых представлений (согласно методу toString) всех элементов этой коллекции без разделительной строки.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> val h = a.addString(b)
h: StringBuilder = 1234

Source@inline

final def addString(b: StringBuilder, sep: String): StringBuilder

Добавляет все элементы этого набора в строковый буфер с использованием разделителя. Записанный текст состоит из строковых представлений (относительно метода toString) всех элементов этого набора, разделенных строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b, ", ")
res0: StringBuilder = 1, 2, 3, 4

Источник

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

Добавляет все элементы этого набора в строковый буфер с использованием начальной, конечной и разделительной строк. Записанный текст начинается со строки start и заканчивается строкой end. Внутри строковые представления (относительно метода toString) всех элементов этого набора разделены строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b , "List(" , ", " , ")")
res5: StringBuilder = List(1, 2, 3, 4)

Источник

def andThen[C](k: PartialFunction[Double, C]): PartialFunction[Int, C]

Компонует эту частичную функцию с другой частичной функцией, которая применяется к результатам этой частичной функции.

Обратите внимание, что вызов isDefinedAt для полученной частичной функции может применить первую частичную функцию и выполнить её побочное действие. Для повышения эффективности рекомендуется вызывать applyOrElse вместо isDefinedAt или apply.

Источник

override def andThen[C](k: Double => C): PartialFunction[Int, C]

Компонует эту частичную функцию с функцией преобразования, которая применяется к результатам этой частичной функции.

Если тип времени выполнения функции является PartialFunction, тогда используется другой andThen метод (обратите внимание на его предостережения).

Источник

def appended[B >: Double](elem: B): AnyAccumulator[B]

Копия этой последовательности с добавленным элементом.

Примечание: не будет завершаться для коллекций бесконечного размера.

Пример:

scala> val a = List(1)
a: List[Int] = List(1)

scala> val b = a :+ 2
b: List[Int] = List(1, 2)

scala> println(a)
List(1)

Источник

def appendedAll[B >: Double](suffix: IterableOnce[B]): AnyAccumulator[B]

Возвращает новую последовательность, содержащую элементы левого операнда, за которыми следуют элементы правого операнда. Тип элементов последовательности — самый специфичный суперкласс, охватывающий типы элементов двух операндов.

Источник

def applyOrElse[A1 <: Int, B1 >: Double](x: A1, default: A1 => B1): B1

Применяет эту частичную функцию к заданному аргументу, когда он содержится в области определения функции. Применяет функцию-обработчик, когда эта частичная функция не определена.

Обратите внимание, что выражение pf.applyOrElse(x, default) эквивалентно

if(pf isDefinedAt x) pf(x) else default(x)

за исключением того, что метод applyOrElse может быть реализован более эффективно. Для всех литералов частичных функций компилятор генерирует реализацию applyOrElse, которая избегает двойной оценки проверочных выражений и защитных условий. Это делает applyOrElse основой для эффективной реализации во многих операциях и сценариях, таких как:

- объединение частичных функций в цепочки orElse/andThen не приводит к чрезмерной оценке apply/isDefinedAt - lift и unlift не оценивают исходные функции дважды при каждом вызове - runWith позволяет эффективно объединять частичные функции в императивном стиле с условными действиями

Для классов частичных функций, отличных от литералов, с ненулевой функцией isDefinedAt рекомендуется переопределять applyOrElse с настраиваемой реализацией, которая избегает двойной оценки isDefinedAt. Это может привести к лучшей производительности и более предсказуемому поведению относительно побочных эффектов.

Источник

def canEqual(that: Any): Boolean

Источник

override def clone(): DoubleAccumulator

Источник

def collect[B](pf: PartialFunction[Double, B]): AnyAccumulator[B]

Source

def collectFirst[B](pf: PartialFunction[Double, B]): Option[B]

Находит первый элемент коллекции, для которого заданная частичная функция определена, и применяет частичную функцию к нему.

Примечание: может не завершиться для коллекций бесконечного размера.

Примечание: может возвращать разные результаты для разных запусков, если только тип коллекции не является упорядоченным.

Source

def combinations(n: Int): Iterator[DoubleAccumulator]

Итерируется по комбинациям. _Комбинация_ длины n — это подпоследовательность исходной последовательности, с элементами, взятыми в порядке. Таким образом, "xy" и "yy" — обе комбинации длины 2 исходной последовательности "xyy", но "yx" — нет. Если существует более одного способа генерации одной и той же подпоследовательности, будет возвращена только одна.

Например, "xyyy" имеет три различных способа сгенерировать "xy" в зависимости от того, был ли выбран первый, второй или третий "y". Однако, поскольку все они идентичны, будет выбран только один. Какой из трех будет выбран, является деталью реализации, которая не определена.

Примечание: даже при применении к представлению или ленивой коллекции элементы всегда будут форсированы.

Source

def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, Double]

Компонует другую частичную функцию k с этой частичной функцией таким образом, что эта частичная функция применяется к результатам k.

Обратите внимание, что вызов isDefinedAt для полученной частичной функции может применить первую частичную функцию и выполнить её побочный эффект. Для повышения эффективности рекомендуется использовать applyOrElse вместо isDefinedAt или apply.

Source@unspecialized

def compose[A](g: A => Int): A => Double

Компонует два экземпляра Function1 в новую Function1, с применением этой функции последней.

Source@inline

final override def concat[B >: Double](suffix: IterableOnce[B]): AnyAccumulator[B]

Source

def contains[A1 >: Double](elem: A1): Boolean

Проверяет, содержит ли эта последовательность заданное значение в качестве элемента.

Примечание: может не завершиться для коллекций бесконечного размера.

Source

def containsSlice[B >: Double](that: Seq[B]): Boolean

Проверяет, содержит ли эта последовательность заданную последовательность как срез.

Примечание: может не завершиться для коллекций бесконечного размера.

Source

def copyToArray[B >: Double](xs: Array[B], start: Int, len: Int): Int

Копирует элементы в массив, возвращая количество скопированных элементов.

Заполняет заданный массив xs начиная с индекса start не более чем len элементами этой коллекции.

Копирование остановится, как только будут скопированы все элементы этой коллекции, или будет достигнут конец массива, или будут скопированы len элементов.

Source@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

def copyToArray[B >: Double](xs: Array[B], start: Int): Int

Копирует элементы в массив, возвращая количество скопированных элементов.

Заполняет заданный массив xs начиная с индекса start значениями этой коллекции.

Копирование остановится, как только будут скопированы все элементы этой коллекции или будет достигнут конец массива.

Источник@deprecatedOverriding("Это всегда должно пересылать 3-аргументную версию этого метода", since = "2.13.4")

def copyToArray[B >: Double](xs: Array[B]): Int

Копирует элементы в массив, возвращая количество скопированных элементов.

Заполняет заданный массив xs начиная с индекса start значениями этого набора.

Копирование прекратится, как только будут скопированы все элементы этого набора или будет достигнут конец массива.

Источник

def corresponds[B](that: Seq[B])(p: (Double, B) => Boolean): Boolean

Проверяет, соответствуют ли каждый элемент этой последовательности соответствующему элементу другой последовательности, удовлетворяя предикату проверки.

Источник

def corresponds[B](that: IterableOnce[B])(p: (Double, B) => Boolean): Boolean

Проверяет, соответствует ли каждый элемент итератора этого набора соответствующему элементу другого набора, удовлетворяя предикату проверки.

Примечание: не будет завершаться для коллекций бесконечного размера.

Источник

def diff[B >: Double](that: Seq[B]): DoubleAccumulator

Вычисляет разность мультимножеств между этой последовательностью и другой последовательностью.

Источник

def distinct: DoubleAccumulator

Выбирает все элементы этой последовательности, игнорируя дубликаты.

Источник

def distinctBy[B](f: Double => B): DoubleAccumulator

Выбирает все элементы этой последовательности, игнорируя дубликаты, определяемые по == после применения преобразующей функции f.

Источник

def drop(n: Int): DoubleAccumulator

Источник

def dropRight(n: Int): DoubleAccumulator

Выбирает все элементы, кроме последних n.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не упорядочен.

Источник

def dropWhile(p: Double => Boolean): DoubleAccumulator

Источник

def elementWise: ElementWiseExtractor[Int, Double]

Возвращает объект-экстрактор с методом unapplySeq, который извлекает каждый элемент данных последовательности.

val firstChar: String => Option[Char] = _.headOption
Seq("foo", "bar", "baz") match {
  case firstChar.unlift.elementWise(c0, c1, c2) =>
    println(s"$c0, $c1, $c2") // Output: f, b, b
}

Источник

def endsWith[B >: Double](that: Iterable[B]): Boolean

Проверяет, заканчивается ли эта последовательность заданной последовательностью.

Примечание: не будет завершаться для бесконечных коллекций.

Источник

override def equals(o: Any): Boolean

Source

def find(p: Double => Boolean): Option[Double]

Находит первый элемент в коллекции, удовлетворяющий предикату, если такой есть.

Примечание: может не завершиться для коллекций бесконечного размера.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не упорядочен.

Source

def findLast(p: Double => Boolean): Option[Double]

Находит последний элемент последовательности, удовлетворяющий предикату, если такой есть.

Примечание: не завершится для коллекций бесконечного размера.

Source

def flatMap[B](f: Double => IterableOnce[B]): AnyAccumulator[B]

Source

def flatten[B](implicit asIterable: Double => IterableOnce[B]): AnyAccumulator[B]

Source

def fold[A1 >: Double](z: A1)(op: (A1, A1) => A1): A1

Выполняет свертку элементов этой коллекции с помощью указанного ассоциативного бинарного оператора. Реализация по умолчанию в IterableOnce эквивалентна foldLeft, но может быть переопределена для более эффективного порядка обхода.

Порядок выполнения операций над элементами не определен и может быть не детерминированным.

Примечание: не завершится для коллекций бесконечного размера.

Source

def foldLeft[B](z: B)(op: (B, Double) => B): B

Применяет бинарный оператор к начальному значению и всем элементам этой коллекции слева направо.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции упорядочен или оператор является ассоциативным и коммутативным.

Source

def foldRight[B](z: B)(op: (Double, B) => B): B

Применяет бинарный оператор ко всем элементам этой коллекции и начальному значению, двигаясь справа налево.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции упорядочен или оператор является ассоциативным и коммутативным.

Source

def groupBy[K](f: Double => K): Map[K, DoubleAccumulator]

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций в соответствии с функцией-дискриминатором.

Примечание: даже при применении к представлению или ленивой коллекции элементы будут всегда принудительно вычисляться.

(xs groupBy f)(k) = xs filter (x => f(x) == k)

Source

def groupMap[K, B](key: Double => K)(f: Double => B): Map[K, AnyAccumulator[B]]

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций в соответствии с функцией-дискриминатором key. Каждый элемент в группе преобразуется в значение типа B с помощью функции value.

Эквивалентно groupBy(key).mapValues(_.map(f)), но более эффективно.

case class User(name: String, age: Int)

def namesByAge(users: Seq[User]): Map[Int, Seq[String]] =
  users.groupMap(_.age)(_.name)

Примечание: даже при применении к представлению или ленивой коллекции элементы будут всегда принудительно вычисляться.

Source

def groupMapReduce[K, B](key: Double => K)(f: Double => B)(reduce: (B, B) => B): Map[K, B]

Разделяет эту итерируемую коллекцию на карту в соответствии с функцией-дискриминатором key. Все значения, имеющие одинаковый дискриминатор, затем преобразуются функцией f и затем сводятся к одному значению с помощью функции reduce.

Эквивалентно groupBy(key).mapValues(_.map(f).reduce(reduce)), но более эффективно.

def occurrences[A](as: Seq[A]): Map[A, Int] =
  as.groupMapReduce(identity)(_ => 1)(_ + _)

Примечание: даже при применении к представлению или ленивой коллекции элементы будут всегда принудительно вычисляться.

Source

def grouped(size: Int): Iterator[DoubleAccumulator]

Разделяет элементы на итерируемые коллекции фиксированного размера.

Source

override def hashCode(): Int

Source

def head: Double

Выбирает первый элемент этой итерируемой коллекции.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не является упорядоченным.

Source

def headOption: Option[Double]

Необязательно выбирает первый элемент.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не является упорядоченным.

Source@deprecatedOverriding("Override indexOf(elem, from) instead - indexOf(elem) calls indexOf(elem, 0)", "2.13.0")

def indexOf[B >: Double](elem: B): Int

Находит индекс первого вхождения некоторого значения в эту последовательность.

Source

def indexOf[B >: Double](elem: B, from: Int): Int

Находит индекс первого вхождения некоторого значения в эту последовательность после или в указанном начальном индексе.

Source@deprecatedOverriding("Override indexOfSlice(that, from) instead - indexOfSlice(that) calls indexOfSlice(that, 0)", "2.13.0")

def indexOfSlice[B >: Double](that: Seq[B]): Int

Находит первый индекс, где эта последовательность содержит заданную последовательность в виде фрагмента.

Примечание: может не завершаться для коллекций бесконечного размера.

Источник

def indexOfSlice[B >: Double](that: Seq[B], from: Int): Int

Находит первый индекс после или на стартовом индексе, где эта последовательность содержит заданную последовательность как срез.

Примечание: для коллекций бесконечного размера может не завершаться.

Источник@deprecatedOverriding("Override indexWhere(p, from) instead - indexWhere(p) calls indexWhere(p, 0)", "2.13.0")

def indexWhere(p: Double => Boolean): Int

Находит индекс первого элемента, удовлетворяющего некоторому предикату.

Примечание: для коллекций бесконечного размера может не завершаться.

Источник

def indexWhere(p: Double => Boolean, from: Int): Int

Находит индекс первого элемента, удовлетворяющего некоторому предикату после или на определенном стартовом индексе.

Примечание: для коллекций бесконечного размера может не завершаться.

Источник

def indices: Range

Создает диапазон всех индексов этой последовательности.

Примечание: даже при применении к представлению или ленивой коллекции элементы всегда будут принудительно вычисляться.

Источник

def init: DoubleAccumulator

Начальная часть коллекции без её последнего элемента.

Примечание: даже при применении к представлению или ленивой коллекции элементы всегда будут принудительно вычисляться.

Source

def inits: Iterator[DoubleAccumulator]

Итерирует по начальным фрагментам (inits) этого итерируемого набора. Первое значение будет этим итерируемым набором, а последнее — пустым итерируемым набором, а промежуточные значения — результатами последовательных применений init.

Примечание: даже при применении к представлению или ленивому набору элементы всегда будут принудительно вычислены.

Source

def intersect[B >: Double](that: Seq[B]): DoubleAccumulator

Вычисляет пересечение множеств (включая множественности элементов) между этой последовательностью и другой последовательностью.

Source

def isDefinedAt(idx: Int): Boolean

Проверяет, содержит ли эта последовательность указанный индекс.

Реализации методов apply и isDefinedAt преобразуют Seq[A] в PartialFunction[Int, A].

Source

override def isEmpty: Boolean

Source

override def isTraversableAgain: Boolean

Source

final override def knownSize: Int

Source

def last: Double

Выбирает последний элемент.

Примечание: может возвращать разные результаты для разных запусков, если тип базового набора не упорядочен.

Source

def lastIndexOf[B >: Double](elem: B, end: Int): Int

Находит индекс последнего вхождения некоторого значения в эту последовательность до или на заданном индексе конца.

Примечание: не будет завершаться для коллекций бесконечного размера.

Source@deprecatedOverriding("Override lastIndexOfSlice(that, end) instead - lastIndexOfSlice(that) calls lastIndexOfSlice(that, Int.MaxValue)", "2.13.0")

def lastIndexOfSlice[B >: Double](that: Seq[B]): Int

Находит последний индекс, где эта последовательность содержит заданную последовательность в качестве среза.

Примечание: не будет завершаться для коллекций бесконечного размера.

Source

def lastIndexOfSlice[B >: Double](that: Seq[B], end: Int): Int

Находит последний индекс перед или на заданном индексе конца, где эта последовательность содержит заданную последовательность в качестве среза.

Примечание: не будет завершаться для коллекций бесконечного размера.

Source@deprecatedOverriding("Override lastIndexWhere(p, end) instead - lastIndexWhere(p) calls lastIndexWhere(p, Int.MaxValue)", "2.13.0")

def lastIndexWhere(p: Double => Boolean): Int

Находит индекс последнего элемента, удовлетворяющего некоторому предикату.

Примечание: не будет завершаться для коллекций бесконечного размера.

Source

def lastIndexWhere(p: Double => Boolean, end: Int): Int

Находит индекс последнего элемента, удовлетворяющего некоторому предикату до или на заданном индексе конца.

Примечание: не будет завершаться для коллекций бесконечного размера.

Source

def lastOption: Option[Double]

Возвращает последнее значение.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не упорядочен.

Source

def lazyZip[B](that: Iterable[B]): LazyZip2[Double, B, DoubleAccumulator]

Аналогично zip , но элементы каждой коллекции не потребляются до вызова строгой операции над возвращаемым LazyZip2 декоратором.

Вызовы lazyZip могут быть объединены для поддержки более высоких арностей (до 4) без затрат на создание и деструкцию промежуточных кортежей.

val xs = List(1, 2, 3)
val res = (xs lazyZip xs lazyZip xs lazyZip xs).map((a, b, c, d) => a + b + c + d)
// res == List(4, 8, 12)

Source

final override def length: Int

Source

def lengthCompare(that: Iterable[_]): Int

Сравнивает длину этой последовательности с размером другого Iterable.

x <  0       if this.length <  that.size
x == 0       if this.length == that.size
x >  0       if this.length >  that.size

Source

def lengthCompare(len: Int): Int

Сравнивает длину этой последовательности со значением-тестом.

x <  0       if this.length <  len
x == 0       if this.length == len
x >  0       if this.length >  len

Source@inline

final def lengthIs: SizeCompareOps

Возвращает значение класса, содержащего операции для сравнения длины этой последовательности со значением-тестом.

Эти операции реализованы в терминах lengthCompare(Int), и позволяют использовать следующие более читабельные варианты:

this.lengthIs < len     // this.lengthCompare(len) < 0
this.lengthIs <= len    // this.lengthCompare(len) <= 0
this.lengthIs == len    // this.lengthCompare(len) == 0
this.lengthIs != len    // this.lengthCompare(len) != 0
this.lengthIs >= len    // this.lengthCompare(len) >= 0
this.lengthIs > len     // this.lengthCompare(len) > 0

Source

def lift: Int => Option[Double]

Преобразует данную частичную функцию в обычную функцию, возвращающую результат Option.

Source

def map[B](f: Double => B): AnyAccumulator[B]

Source

def mapResult[NewTo](f: DoubleAccumulator => NewTo): Builder[Double, NewTo]

Сборщик, полученный из этого сборщика путём отображения результата с помощью f.

Source

def max[B >: Double](implicit ord: Ordering[B]): Double

Находит максимальный элемент.

Примечание: не завершится для бесконечно больших коллекций.

Source

def maxBy[B](f: Double => B)(implicit cmp: Ordering[B]): Double

Находит первый элемент, который даёт наибольшее значение, измеренное функцией f.

Примечание: не завершится для бесконечно больших коллекций.

Source

def maxByOption[B](f: Double => B)(implicit cmp: Ordering[B]): Option[Double]

Находит первый элемент, который даёт наибольшее значение, измеренное функцией f.

Примечание: не завершится для бесконечно больших коллекций.

Источник

def maxOption[B >: Double](implicit ord: Ordering[B]): Option[Double]

Находит наибольший элемент.

Примечание: не завершится для коллекций бесконечного размера.

Источник

def min[B >: Double](implicit ord: Ordering[B]): Double

Находит наименьший элемент.

Примечание: не завершится для коллекций бесконечного размера.

Источник

def minBy[B](f: Double => B)(implicit cmp: Ordering[B]): Double

Находит первый элемент, который дает наименьшее значение, измеренное функцией f.

Примечание: не завершится для коллекций бесконечного размера.

Источник

def minByOption[B](f: Double => B)(implicit cmp: Ordering[B]): Option[Double]

Находит первый элемент, который дает наименьшее значение, измеренное функцией f.

Примечание: не завершится для коллекций бесконечного размера.

Источник

def minOption[B >: Double](implicit ord: Ordering[B]): Option[Double]

Находит наименьший элемент.

Примечание: не будет завершаться для коллекций бесконечного размера.

Источник@inline

final def mkString: String

Отображает все элементы этой коллекции в строке.

Делегирует addString, который можно переопределить.

Источник@inline

final def mkString(sep: String): String

Отображает все элементы этой коллекции в строке с использованием разделительной строки.

Делегирует addString, который можно переопределить.

Источник

final def mkString(start: String, sep: String, end: String): String

Отображает все элементы этой коллекции в строке с использованием начальной, конечной и разделительных строк.

Делегирует addString, который можно переопределить.

Источник@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

Проверяет, не пуста ли коллекция.

Источник

def orElse[A1 <: Int, B1 >: Double](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

Комбинирует эту частичную функцию с резервной частичной функцией, которая применяется там, где эта частичная функция не определена.

Исходный код

def padTo[B >: Double](len: Int, elem: B): AnyAccumulator[B]

Копия этой последовательности с добавленным элементом до тех пор, пока не будет достигнута заданная длина.

Исходный код

def partition(p: Double => Boolean): (DoubleAccumulator, DoubleAccumulator)

Пара, состоящая из, во-первых, всех элементов, удовлетворяющих предикату p, и, во-вторых, всех элементов, которые этому предикату не удовлетворяют. Интересно, потому что разделяет коллекцию на две части.

Указанная здесь реализация требует два прохода по коллекции. Строгие коллекции имеют переопределённый метод partition в StrictOptimizedIterableOps, который требует только одного прохода.

Исходный код

def partitionMap[A1, A2](f: Double => Either[A1, A2]): (AnyAccumulator[A1], AnyAccumulator[A2])

Применяет функцию f к каждому элементу итерационной коллекции и возвращает пару итерационных коллекций: первая содержит значения, возвращаемые f, которые были обернуты в scala.util.Left, а вторая — те, что были обернуты в scala.util.Right.

Пример:

val xs = Iterable(1, "one", 2, "two", 3, "three") partitionMap {
 case i: Int => Left(i)
 case s: String => Right(s)
}
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

Исходный код

def patch[B >: Double](from: Int, other: IterableOnce[B], replaced: Int): AnyAccumulator[B]

Создаёт новую последовательность, в которой срез элементов этой последовательности заменяется другой последовательностью.

Замена по отрицательным индексам эквивалентна замене с начала. Замена по индексам, равным или большим длины исходной последовательности, добавляет замену в конец. Если заменяемых значений больше, чем существует, избыток игнорируется.

Исходный код

def permutations: Iterator[DoubleAccumulator]

Итерируется по различным перестановкам.

Примечание: даже когда применяется к представлению или ленивой коллекции, элементы всегда будут принудительно вычисляться.

Исходный код

def prepended[B >: Double](elem: B): AnyAccumulator[B]

Копия последовательности с добавленным элементом в начало.

Кроме того, исходная последовательность не изменяется, поэтому вам нужно будет сохранить результат.

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = 2 +: x
y: List[Int] = List(2, 1)

scala> println(x)
List(1)

Исходный код

def prependedAll[B >: Double](prefix: IterableOnce[B]): AnyAccumulator[B]

Аналогично :++, возвращает новую коллекцию, содержащую элементы левого операнда, за которыми следуют элементы правого операнда.

Отличается от :++ тем, что тип результирующей коллекции определяется правым операндом, а не левым. Мемоническое правило: двоеточие стоит со стороны нового типа коллекции.

Исходный код

def product[B >: Double](implicit num: Numeric[B]): B

Умножает элементы этой коллекции.

Примечание: не будет завершаться для бесконечных коллекций.

Исходный код

def reduce[B >: Double](op: (B, B) => B): B

Сокращает элементы этой коллекции с помощью указанного ассоциативного бинарного оператора.

Порядок выполнения операций над элементами не определён и может быть не детерминированным.

Источник

def reduceLeft[B >: Double](op: (B, Double) => B): B

Применяет бинарный оператор ко всем элементам этой коллекции слева направо.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не упорядочен или оператор не является ассоциативным и коммутативным.

Источник

def reduceLeftOption[B >: Double](op: (B, Double) => B): Option[B]

Необязательно применяет бинарный оператор ко всем элементам этой коллекции слева направо.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не упорядочен или оператор не является ассоциативным и коммутативным.

Источник

def reduceOption[B >: Double](op: (B, B) => B): Option[B]

Сводит элементы этой коллекции, если таковые имеются, используя указанный ассоциативный бинарный оператор.

Порядок выполнения операций над элементами не определен и может быть не детерминированным.

Источник

def reduceRight[B >: Double](op: (Double, B) => B): B

Применяет бинарный оператор ко всем элементам этой коллекции справа налево.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не упорядочен или оператор не является ассоциативным и коммутативным.

Источник

def reduceRightOption[B >: Double](op: (Double, B) => B): Option[B]

Необязательно применяет бинарный оператор ко всем элементам этой коллекции справа налево.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не упорядочен или оператор не является ассоциативным и коммутативным.

Источник

def reverse: DoubleAccumulator

Возвращает новую последовательность с элементами в обратном порядке.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: Даже при применении к представлению или ленивой коллекции, элементы всегда будут принудительно вычислены.

Источник

def reverseIterator: Iterator[Double]

Итератор, возвращающий элементы в обратном порядке.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: xs.reverseIterator эквивалентно xs.reverse.iterator, но может быть более эффективным.

Источник

protected def reversed: Iterable[Double]

Источник

def runWith[U](action: Double => U): Int => Boolean

Комбинирует эту частичную функцию с функцией действия, которая применяется к результатам этой частичной функции. Функция действия вызывается только для своих побочных эффектов; её результат игнорируется.

Обратите внимание, что выражение pf.runWith(action)(x) эквивалентно

if(pf isDefinedAt x) { action(pf(x)); true } else false

за исключением того, что runWith реализовано через applyOrElse и, следовательно, потенциально более эффективно. Использование runWith позволяет избежать двойного вычисления обработчиков шаблонов и условий для литералов частичных функций.

Источник

def sameElements[B >: Double](that: IterableOnce[B]): Boolean

Являются ли элементы этой коллекции такими же (и в том же порядке), как элементы that?

Исходный код

def scan[B >: Double](z: B)(op: (B, B) => B): AnyAccumulator[B]

Вычисляет префиксное сканирование элементов коллекции.

Примечание: нейтральный элемент z может быть применён более одного раза.

Исходный код

def scanLeft[B](z: B)(op: (B, Double) => B): AnyAccumulator[B]

Исходный код

def scanRight[B](z: B)(op: (Double, B) => B): AnyAccumulator[B]

Создаёт коллекцию, содержащую кумулятивные результаты применения оператора справа налево. Голова коллекции — последний кумулятивный результат.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: может возвращать разные результаты для разных запусков, если тип базовой коллекции не упорядочен.

Примечание: даже при применении к представлению или ленивой коллекции элементы всегда будут вынужденно использоваться.

Пример:

List(1, 2, 3, 4).scanRight(0)(_ + _) == List(10, 9, 7, 4, 0)

Исходный код

def search[B >: Double](elem: B, from: Int, to: Int)(implicit ord: Ordering[B]): SearchResult

Поиск элемента в заданном интервале в этой отсортированной последовательности. Если эта последовательность является IndexedSeq, используется двоичный поиск. В противном случае используется линейный поиск.

Последовательность должна быть отсортирована с использованием того же Ordering перед вызовом; в противном случае результаты не определены.

Исходный код

def search[B >: Double](elem: B)(implicit ord: Ordering[B]): SearchResult

Ищет этот отсортированный массив для определённого элемента. Если последовательность является IndexedSeq, используется двоичный поиск. В противном случае используется линейный поиск.

Последовательность должна быть отсортирована с использованием того же Ordering перед вызовом; в противном случае результаты не определены.

Исходный код

def segmentLength(p: Double => Boolean, from: Int): Int

Вычисляет длину самой длинной последовательности, начинающейся с определённого индекса, элементы которой удовлетворяют некоторому предикату.

Примечание: может не завершиться для коллекций бесконечного размера.

Исходный код

final def segmentLength(p: Double => Boolean): Int

Вычисляет длину самой длинной последовательности, начинающейся с первого элемента, элементы которой удовлетворяют некоторому предикату.

Примечание: может не завершиться для коллекций бесконечного размера.

Исходный код

final override def size: Int

Исходный код

final override def sizeCompare(that: Iterable[_]): Int

Исходный код

final override def sizeCompare(otherSize: Int): Int

Исходный код

final def sizeHint(coll: IterableOnce[_], delta: Int): Unit

Предполагает, что размер этого билдера будет таким же, как и заданной коллекции, плюс некоторая разница. Это будет указано только в том случае, если коллекция имеет известный размер. Некоторые классы билдеров оптимизируют своё представление на основе этого предположения. Тем не менее, реализации билдеров должны работать правильно, даже если предположение неверно, то есть добавлено другое количество элементов.

Исходный код

def sizeHint(size: Int): Unit

Указывает предполагаемое количество элементов, которые будут добавлены при вызове следующего result. Некоторые классы билдеров оптимизируют своё представление на основе этой подсказки. Однако реализации билдеров всё равно должны работать корректно, даже если подсказка неверна, то есть если добавлено другое количество элементов.

Исходный код

final def sizeHintBounded(size: Int, boundingColl: Iterable[_]): Unit

Указывает предполагаемое количество элементов, которые будут добавлены при вызове следующего result, вместе с верхней границей, заданной размером другой коллекции. Некоторые классы билдеров оптимизируют своё представление на основе этой подсказки. Однако реализации билдеров всё равно должны работать корректно, даже если подсказка неверна, то есть если добавлено другое количество элементов.

Исходный код@inline

final def sizeIs: SizeCompareOps

Возвращает значение класса, содержащего операции для сравнения размера этой итерируемой коллекции со значением-тестом.

Эти операции реализуются с использованием sizeCompare(Int) и позволяют использовать следующие более читаемые варианты:

this.sizeIs < size     // this.sizeCompare(size) < 0
this.sizeIs <= size    // this.sizeCompare(size) <= 0
this.sizeIs == size    // this.sizeCompare(size) == 0
this.sizeIs != size    // this.sizeCompare(size) != 0
this.sizeIs >= size    // this.sizeCompare(size) >= 0
this.sizeIs > size     // this.sizeCompare(size) > 0

Исходный код

final def sizeLong: Long

Размер накопленной коллекции, как Long

Исходный код

def slice(from: Int, until: Int): DoubleAccumulator

Исходный код

def sliding(size: Int, step: Int): Iterator[DoubleAccumulator]

Группирует элементы в блоки фиксированного размера, перемещая "скользящее окно" по ним (в отличие от разбиения, как в grouped.)

Возвращаемый итератор будет пустым при вызове для пустой коллекции. Последний элемент, который генерирует итератор, может быть меньше размера окна, если исходная коллекция не исчерпана окном до конца, и последний элемент не пропущен шагом до него.

Исходный код

def sliding(size: Int): Iterator[DoubleAccumulator]

Группирует элементы в блоки фиксированного размера, перемещая "скользящее окно" по ним (в отличие от разбиения, как в grouped.)

Пустая коллекция возвращает пустой итератор, а непустая коллекция, содержащая меньше элементов, чем размер окна, возвращает итератор, который будет генерировать исходную коллекцию как единственный элемент.

Исходный код

def sortBy[B](f: Double => B)(implicit ord: Ordering[B]): DoubleAccumulator

Сортирует эту последовательность в соответствии с упорядочением, полученным путём преобразования неявно заданного упорядочения с помощью функции преобразования.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: даже при применении к представлению или ленивой коллекции, элементы всегда будут форсироваться.

Сортировка устойчивая. То есть элементы, которые равны (как определено ord.compare), появляются в отсортированной последовательности в том же порядке, что и в исходной.

val words = "The quick brown fox jumped over the lazy dog".split(' ')
// this works because scala.Ordering will implicitly provide an Ordering[Tuple2[Int, Char]]
words.sortBy(x => (x.length, x.head))
res0: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped)

Исходный код

def sortWith(lt: (Double, Double) => Boolean): DoubleAccumulator

Сортирует эту последовательность в соответствии с функцией сравнения.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: даже при применении к представлению или ленивой коллекции, элементы всегда будут форсироваться.

Сортировка устойчивая. То есть элементы, которые равны (как определено lt), появляются в отсортированной последовательности в том же порядке, что и в исходной.

List("Steve", "Tom", "John", "Bob").sortWith(_.compareTo(_) < 0) =
List("Bob", "John", "Steve", "Tom")

Исходный код

def sorted[B >: Double](implicit ord: Ordering[B]): DoubleAccumulator

Сортирует эту последовательность в соответствии с упорядочением.

Сортировка устойчивая. То есть элементы, которые равны (как определено ord.compare), появляются в отсортированной последовательности в том же порядке, что и в исходной.

Источник

def span(p: Double => Boolean): (DoubleAccumulator, DoubleAccumulator)

Источник

override def splitAt(n: Int): (DoubleAccumulator, DoubleAccumulator)

Источник

def startsWith[B >: Double](that: IterableOnce[B], offset: Int): Boolean

Проверяет, содержит ли эта последовательность заданную последовательность в заданном индексе.

Примечание: если оба объекта получателя this и аргумент that являются бесконечными последовательностями, этот метод может не завершиться.

Источник

final override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Double, S]): S & EfficientSplit

Источник

def sum[B >: Double](implicit num: Numeric[B]): B

Суммирует элементы этой коллекции.

Примечание: не будет завершаться для коллекций бесконечного размера.

Источник

def tail: DoubleAccumulator

Остальная часть коллекции без ее первого элемента.

Источник

def tails: Iterator[DoubleAccumulator]

Итерируется по хвостам этой итерируемой коллекции. Первое значение будет этой итерируемой коллекцией, а последнее — пустой итерируемой коллекцией, промежуточные значения — результаты последовательных применений tail.

Источник

def take(n: Int): DoubleAccumulator

Источник

def takeRight(n: Int): DoubleAccumulator

Выбирает последние n элементов.

Примечание: может возвращать разные результаты для разных запусков, если тип базовой коллекции не упорядочен.

Источник

def takeWhile(p: Double => Boolean): DoubleAccumulator

Берет самую длинную префиксную часть элементов, которые удовлетворяют предикату.

Примечание: может возвращать разные результаты для разных запусков, если тип базовой коллекции не упорядочен.

Источник

override def tapEach[U](f: Double => U): DoubleAccumulator

Источник

def toArray[B >: Double : ClassTag]: Array[B]

Преобразовать коллекцию в массив.

Примечание реализации: НЕ вызывайте Array.from из этого метода.

Источник@inline

final def toBuffer[B >: Double]: Buffer[B]

Источник

def toIndexedSeq: IndexedSeq[Double]

Источник

def toMap[K, V](implicit ev: Double <:< (K, V)): Map[K, V]

Исходный код

def toSeq: Seq[Double]

Исходный код

def toSet[B >: Double]: Set[B]

Исходный код

override def toString(): String

Исходный код

def toVector: Vector[Double]

Исходный код

def transpose[B](implicit asIterable: Double => Iterable[B]): AnyAccumulator[AnyAccumulator[B]]

Транспонирует эту итерируемую коллекцию коллекций в итерируемую коллекцию коллекций.

Тип результирующей коллекции будет определяться статическим типом итерируемой коллекции. Например:

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

Примечание: Даже при применении к представлению или ленивой коллекции элементы всегда будут принудительно вычисляться.

Исходный код

def unapply(a: Int): Option[Double]

Попытка извлечь B из A в выражении сопоставления с образцом.

Исходный код

def unzip[A1, A2](implicit asPair: Double => (A1, A2)): (AnyAccumulator[A1], AnyAccumulator[A2])

Преобразует эту итерируемую коллекцию пар в две коллекции первой и второй половины каждой пары. Если одна из двух коллекций длиннее другой, оставшиеся элементы игнорируются.

val xs = Iterable(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

Исходный код

def unzip3[A1, A2, A3](implicit asTriple: Double => (A1, A2, A3)): (AnyAccumulator[A1], AnyAccumulator[A2], AnyAccumulator[A3])

Преобразует эту итерируемую коллекцию троек в три коллекции первого, второго и третьего элемента каждой тройки.

val xs = Iterable(
           (1, "one", '1'),
           (2, "two", '2'),
           (3, "three", '3')).unzip3
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three),
//        Iterable(1, 2, 3))

Исходный код

def updated[B >: Double](index: Int, elem: B): AnyAccumulator[B]

Копия этого последовательности с одним заменённым элементом.

Исходный код

override def view: SeqView[Double]

Исходный код

def withFilter(p: Double => Boolean): WithFilter[Double, AnyAccumulator]

Создаёт нестрогий фильтр этой итерируемой коллекции.

Примечание: разница между c filter p и c withFilter p в том, что первый создаёт новую коллекцию, а второй только ограничивает область последующих map, flatMap, foreach, и withFilter операций.

Примечание: может возвращать разные результаты для разных запусков, если тип базовой коллекции не упорядочен.

Исходный код

def zip[B](that: IterableOnce[B]): AnyAccumulator[(Double, B)]

Возвращает итерируемую коллекцию, образованную из этой итерируемой коллекции и другой итерируемой коллекции, комбинируя соответствующие элементы парами. Если одна из двух коллекций длиннее другой, её оставшиеся элементы игнорируются.

Источник

def zipAll[A1 >: Double, B](that: Iterable[B], thisElem: A1, thatElem: B): AnyAccumulator[(A1, B)]

Возвращает итерируемый набор, сформированный из этого итерируемого набора и другого итерируемого набора путем объединения соответствующих элементов в пары. Если один из двух наборов короче другого, используется элемент-заполнитель для расширения более короткого набора до длины более длинного.

Источник

def zipWithIndex: AnyAccumulator[(Double, Int)]