Трейт scala.collection.parallel.ParSet

Проверка двух объектов на неравенство.

Эквивалентно x.hashCode за исключением упакованных числовых типов и null. Для числовых типов возвращает значение хеша, согласованное с равенством значений: если два экземпляра типа значения сравниваются как true, то ## будет генерировать одинаковое значение хеша для каждого из них. Для null возвращает хешкод, где null.hashCode выбрасывает NullPointerException.

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

Примечание: То же самое, что и intersect.

Разность этого множества и другого множества.

Примечание: То же самое, что и diff.

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

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

Примечание: /: — альтернативный синтаксис для foldLeft; z /: xs — то же самое, что и xs foldLeft z.

Примеры:

Обратите внимание, что функция сворачивания, используемая для вычисления b, эквивалентна той, которая используется для вычисления c.

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

scala> val b = (5 /: a)(_+_)
b: Int = 15

scala> val c = (5 /: a)((x,y) => x + y)
c: Int = 15

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

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

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

Примечание: :\ — это альтернативная синтаксическая конструкция для foldRight; xs :\ z эквивалентно xs foldRight z.

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

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

Примеры:

Обратите внимание, что функция сворачивания, используемая для вычисления b, эквивалентна функции, используемой для вычисления c.

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

scala> val b = (a :\ 5)(_+_)
b: Int = 15

scala> val c = (a :\ 5)((x,y) => x + y)
c: Int = 15

Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

Агрегирует результаты применения оператора к последующим элементам.

Это более общий вид fold и reduce. Он имеет аналогичную семантику, но не требует, чтобы результат был супертипом типа элемента. Он последовательно проходит по элементам в разных разделах, используя seqop для обновления результата, а затем применяет combop к результатам из разных разделов. Реализация этой операции может работать с произвольным количеством разделов коллекции, поэтому combop может вызываться произвольное количество раз.

Например, можно обработать некоторые элементы и затем создать Set. В этом случае seqop будет обрабатывать элемент и добавлять его в множество, а combop будет конкатенировать два множества из разных разделов вместе. Начальное значение z будет пустым множеством.

pc.aggregate(Set[Int]())(_ += process(_), _ ++ _)

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

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

Проверяет, содержится ли какой-либо элемент в этом множестве.

Этот метод эквивалентен contains. Он позволяет интерпретировать множества как предикаты.

Приводит объект-приемник к типу T0.

Обратите внимание, что успех приведения типов во время выполнения зависит от семантики стирания Scala. Поэтому выражение 1.asInstanceOf[String] выбросит ClassCastException во время выполнения, в то время как выражение List(1).asInstanceOf[List[String]] этого не сделает. В последнем примере, поскольку аргумент типа стирается в ходе компиляции, проверить, соответствуют ли содержимое списка запрошенному типу, невозможно.

Создаёт копию объекта-приёмника.

По умолчанию реализация метода clone зависит от платформы.

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

на которых она определена.

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

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

Фабричный объект-компаньон, который создаёт экземпляры класса ParSet. (или его Iterable суперкласс, где класс ParSet не является Seq.)

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

Копирует элементы этого параллельного множества в массив. Заполняет заданный массив xs не более чем len элементами этого параллельного множества, начиная с позиции start. Копирование прекратится, как только будет достигнут конец текущего параллельного множества, или конец целевого массива, или len элементов будут скопированы.

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

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

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

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

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

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

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

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

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

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

Этот метод будет использовать indexFlag возможности сигнализации. Это означает, что разделители могут устанавливать и считывать состояние indexFlag. Флаг индекса изначально устанавливается в максимальное значение целого числа.

Проверяет, является ли аргумент (that) ссылкой на объект-получатель (this).

Метод eq реализует отношение эквивалентности на непустых экземплярах AnyRef, и имеет три дополнительных свойства:

Он согласован: для любых непустых экземпляров x и y типа AnyRef, многократные вызовы x.eq(y) последовательно возвращают true или последовательно возвращают false.Для любого непустого экземпляра x типа AnyRef, x.eq(null) и null.eq(x) возвращает false. null.eq(null) возвращает true.

При переопределении методов equals или hashCode важно обеспечить, чтобы их поведение соответствовало равенству ссылок. Поэтому, если два объекта являются ссылками друг на друга (o1 eq o2), они должны быть равны друг другу (o1 == o2) и должны хэшироваться к одному значению (o1.hashCode == o2.hashCode).

Сравнивает этот набор с другим объектом на равенство.

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

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

Этот метод будет использовать abort возможности передачи сигналов. Это означает, что разделители могут отправлять и читать abort сигналы.

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

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

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

Детали времени и условий вызова метода finalize, а также взаимодействия между finalize и нелокальными возвратами и исключениями зависят от платформы.

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

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

Этот метод будет использовать abort возможности сигнализации. Это означает, что разделители могут отправлять и читать abort сигналы.

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

и используя элементы полученных коллекций.

Например:

def getWords(lines: Seq[String]): Seq[String] = lines flatMap (line => line split "\\W+")

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

// lettersOf will return a Seq[Char] of likely repeated letters, instead of a Set
def lettersOf(words: Seq[String]) = words flatMap (word => word.toSet)

// lettersOf will return a Set[Char], not a Seq
def lettersOf(words: Seq[String]) = words.toSet flatMap (word => word.toSeq)

// xs will be an Iterable[Int]
val xs = Map("a" -> List(11,111), "b" -> List(22,222)).flatMap(_._2)

// ys will be a Map[Int, Int]
val ys = Map("a" -> List(1 -> 11,1 -> 111), "b" -> List(2 -> 22,2 -> 222)).flatMap(_._2)

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

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

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

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

Обратите внимание, что подпись этого метода отличается от подписей методов foldLeft и foldRight в тракте Traversable. Результат слияния может быть только супертипом параметра типа этой параллельной коллекции T.

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

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

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

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

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

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

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

Этот метод будет использовать abort возможности сигнализации. Это означает, что разделители могут отправлять и читать abort сигналы.

Применяет функцию f ко всем элементам параллельного итерируемого объекта в неопределенном порядке.

Возвращает строку, отформатированную в соответствии с заданной format строкой. Форматные строки аналогичны String.format (@см java.lang.String.format).

Обобщенный билдер, который создаёт экземпляры Traversable произвольных типов элементов.

Возвращает представление класса объекта во время выполнения.

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

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

Проверяет, известно ли, что у этого параллельного итерируемого множества конечный размер. Все строгие коллекции известны как имеющие конечный размер. Для нестрогой коллекции, такой как Stream, предикат возвращает true если все элементы были вычислены. Он возвращает false если поток еще не был оценен до конца. Непустые итераторы обычно возвращают false даже если они были созданы из коллекции с известным конечным размером.

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

Метод hashCode для ссылочных типов. См. hashCode в scala.Any.

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

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

Выбирает первый элемент, если он существует.

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

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

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

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

Проверяет, пусто ли параллельное итерируемое множество.

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

Проверяет, соответствует ли динамический тип объекта-получателя типу T0.

Обратите внимание, что результат проверки зависит от семантики стирания Scala. Поэтому выражение 1.isInstanceOf[String] вернет false, а выражение List(1).isInstanceOf[List[String]] вернет true. В последнем примере, поскольку аргумент типа стирается во время компиляции, проверить, относятся ли содержимое списка к указанному типу, невозможно.

Указывает, имеет ли данная параллельная коллекция строгие разделители.

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

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

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

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

По умолчанию этот метод реализован через защищённый метод splitter.

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

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

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

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

Строит новую коллекцию, применяя функцию ко всем элементам этого параллельного множества.

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

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

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

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

Отображает все элементы этого параллельного итерируемого объекта в строке.

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

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

Эквивалентно !(this eq that).

Библиотека для построения экземпляров типа Traversable[A]

Проверяет, не пуст ли параллельный итерируемый объект.

Разбуживает единственную нить, ожидающую монитора объекта-получателя.

Разбуживает все нити, ожидающие монитора объекта-получателя.

Возвращает параллельную реализацию этого набора.

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

Определённые наборы (например, ParArray или mutable.ParHashMap) переопределяют это поведение по умолчанию, создавая параллельный набор, который разделяет тот же базовый набор данных. Для этих наборов par занимает постоянное или подлинейное время.

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

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

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

Производит произведение элементов этого набора.

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

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

Обратите внимание, что у этого метода другой тип, чем у методов reduceLeft и reduceRight в трайте Traversable. Результатом уменьшения может быть только супертип параметра типа этого параллельного набора T.

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

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

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

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

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

Обратите внимание, что у этого метода другой сигнатура, чем у методов reduceLeftOption и reduceRightOption трейта Traversable. Результатом сокращения может быть только супертип параметра типа этого параллельного набора T.

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

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

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

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

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

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

Необязательно использует существующий комбинирователь для повышения производительности. По умолчанию не использует - подклассы могут переопределить это поведение. Предоставленный комбинирователь oldc, который потенциально может быть повторно использован, будет либо некоторым комбинирователем из предыдущей вычислительной задачи, либо None, если не было предыдущей фазы (в этом случае этот метод должен вернуть newc).

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

Размер этой коллекции или итератора, если он может быть легко вычислен

Выбирает интервал элементов. Результирующая коллекция состоит из всех элементов x, которые удовлетворяют инварианту:

from <= indexOf(x) < until

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

Разделяет этот параллельный итерируемый объект на пару префикс/суффикс в соответствии с предикатом.

Этот метод будет использовать indexFlag возможности сигнализации. Это означает, что разделители могут устанавливать и считывать indexFlag состояние. Флаг индекса изначально устанавливается в максимальное целочисленное значение.

Разделяет этот параллельный итерируемый объект на два по заданной позиции. Примечание: c splitAt n эквивалентно (но, возможно, более эффективно, чем) (c take n, c drop n).

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

Определяет префикс представления этого объекта в строковом toString формате.

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

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

Возвращает все элементы, кроме первого.

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

Возвращает первые n элементов.

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

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

Этот метод будет использовать возможности indexFlag сигнализации. Это означает, что разделители могут устанавливать и читать состояние indexFlag. Флаг индекса первоначально устанавливается в максимальное целочисленное значение.

Объект поддержки задач, отвечающий за планирование и балансировку нагрузки задач для процессоров.

Изменяет объект поддержки задач, отвечающий за планирование и балансировку нагрузки задач для процессоров.

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

Вот как можно изменить поддержку задач параллельной коллекции:

import scala.collection.parallel._
val pc = mutable.ParArray(1, 2, 3)
pc.tasksupport = new ForkJoinTaskSupport(
  new java.util.concurrent.ForkJoinPool(2))

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

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

Преобразует это параллельное множество в массив.

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

Использует содержимое этого параллельного итерируемого объекта для создания нового изменяемого буфера.

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

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

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

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

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

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

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

Преобразует это параллельное итерируемое в список.

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

Преобразует это параллельное множество в карту. Этот метод недоступен, если элементы не являются членами Tuple2, при этом каждый ((T, U)) становится парой ключ-значение в карте. Повторные ключи будут перезаписаны последующими ключами: если это неупорядоченная коллекция, то ключ, который находится в результирующей карте, не определен.

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

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

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

Преобразует это параллельное множество в множество.

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

Преобразует это параллельное множество в поток.

Создаёт строковое представление этого объекта. По умолчанию представление зависит от платформы. На платформе Java это конкатенация имени класса, "@", и хэш-кода объекта в шестнадцатеричном формате.

Преобразует это параллельное множество в неспецифицируемое множество. Возвращает ту же самую коллекцию, если этот экземпляр уже является множеством.

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

Преобразует это параллельное множество в вектор.

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

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

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

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))

Вычисляет объединение множества с другим множеством.

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

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

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

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

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

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

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

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

Объединяет это параллельное множество со своими индексами.

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

Вычисляет объединение этого множества и другого множества.

Примечание: То же, что и union.