Returns the average of the elements in the array.

array : ^T[]

The input array.

Returns: ^T

The average of the elements in the array.

Example

 [| 1.0; 2.0; 6.0 |] |> Array.Parallel.average

Example

 [| |] |> Array.Parallel.average

Returns the average of the elements generated by applying the function to each element of the array.

projection : 'T -> ^U

The function to transform the array elements before averaging.

array : 'T[]

The input array.

Returns: ^U

The computed average.

Example

 type Foo = { Bar: float }

 let input = [| {Bar = 2.0}; {Bar = 4.0} |]

 input |> Array.Parallel.averageBy (fun foo -> foo.Bar)

Example

 type Foo = { Bar: float }

 let input : Foo[] = [| |]

 input |> Array.Parallel.averageBy (fun foo -> foo.Bar)

Apply the given function to each element of the array. Return the array comprised of the results x for each element where the function returns Some(x).

Performs the operation in parallel using Parallel.For. The order in which the given function is applied to elements of the input array is not specified.

chooser : 'T -> 'U option

The function to generate options from the elements.

array : 'T[]

The input array.

Returns: 'U[]

The array of results.

Example

 let input = [| Some 1; None; Some 2 |]

 input |> Array.Parallel.choose id

Example

 let input = [| 1; 2; 3 |]

 input |> Array.Parallel.choose (fun n -> if n % 2 = 0 then Some n else None)

For each element of the array, apply the given function. Concatenate all the results and return the combined array.

Performs the operation in parallel using Parallel.For. The order in which the given function is applied to elements of the input array is not specified.

mapping : 'T -> 'U[]

array : 'T[]

The input array.

Returns: 'U[]

'U[]

Example

 type Foo = { Bar: int[] }

 let input = [| {Bar = [| 1; 2 |]}; {Bar = [| 3; 4 |]} |]

 input |> Array.Parallel.collect (fun foo -> foo.Bar)

Example

 let input = [| [| 1; 2 |]; [| 3; 4 |] |]

 input |> Array.Parallel.collect id

Tests if any element of the array satisfies the given predicate.

The predicate is applied to the elements of the input array in parallel. If any application returns true then the overall result is true and testing of other elements in all threads is stopped at system's earliest convenience. Otherwise, false is returned.

predicate : 'T -> bool

The function to test the input elements.

array : 'T[]

The input array.

Returns: bool

True if any result from predicate is true.

Example

 let input = [| 1; 2; 3; 4; 5 |]

 input |> Array.Parallel.exists (fun elm -> elm % 4 = 0)

Example

 let input = [| 1; 2; 3; 4; 5 |]

 input |> Array.Parallel.exists (fun elm -> elm % 6 = 0)

Returns a new collection containing only the elements of the collection for which the given predicate returns true.

predicate : 'T -> bool

The function to test the input elements.

array : 'T[]

The input array.

Returns: 'T[]

An array containing the elements for which the given predicate returns true.

Example

 let inputs = [| 1; 2; 3; 4 |]

 inputs |> Array.Parallel.filter (fun elm -> elm % 2 = 0)

Tests if all elements of the array satisfy the given predicate.

The predicate is applied to the elements of the input collection in parallel. If any application returns false then the overall result is false and testing of other elements in all threads is stopped at system's earliest convenience. Otherwise, true is returned.

predicate : 'T -> bool

The function to test the input elements.

array : 'T[]

The input array.

Returns: bool

True if all of the array elements satisfy the predicate.

Example

 let isEven a = a % 2 = 0

 [2; 42] |> Array.Parallel.forall isEven // evaluates to true

 [1; 2] |> Array.Parallel.forall isEven // evaluates to false

Applies a key-generating function to each element of an array in parallel and yields an array of unique keys. Each unique key contains an array of all elements that match to this key.

Performs the operation in parallel using Parallel.For. The order in which the given function is applied to elements of the input array is not specified. The order of the keys and values in the result is also not specified

projection : 'T -> 'Key

A function that transforms an element of the array into a comparable key.

array : 'T[]

The input array.

Returns: ('Key * 'T[])[]

The result array.

Example

 let inputs = [| 1; 2; 3; 4; 5 |]

 inputs |> Array.Parallel.groupBy (fun n -> n % 2)

Create an array given the dimension and a generator function to compute the elements.

Performs the operation in parallel using Parallel.For. The order in which the given function is applied to indices is not specified.

count : int

initializer : int -> 'T

Returns: 'T[]

The array of results.

Example

 Array.Parallel.init 4 (fun v -> v + 5)

Apply the given function to each element of the array.

Performs the operation in parallel using Parallel.For. The order in which the given function is applied to elements of the input array is not specified.

action : 'T -> unit

array : 'T[]

The input array.

Example

 let inputs = [| "a"; "b"; "c" |]

 inputs |> Array.Parallel.iter (printfn "%s")

 a
 c
 b

Apply the given function to each element of the array. The integer passed to the function indicates the index of element.

Performs the operation in parallel using Parallel.For. The order in which the given function is applied to elements of the input array is not specified.

action : int -> 'T -> unit

array : 'T[]

The input array.

Example

 let inputs = [| "a"; "b"; "c" |]

 inputs |> Array.Parallel.iteri (fun i v -> printfn "{i}: {v}")

 0: a
 2: c
 1: b

Build a new array whose elements are the results of applying the given function to each of the elements of the array.

Performs the operation in parallel using Parallel.For. The order in which the given function is applied to elements of the input array is not specified.

mapping : 'T -> 'U

array : 'T[]

The input array.

Returns: 'U[]

The array of results.

Example

 let inputs = [| "a"; "bbb"; "cc" |]

 inputs |> Array.Parallel.map (fun x -> x.Length)

Build a new array whose elements are the results of applying the given function to each of the elements of the array. The integer index passed to the function indicates the index of element being transformed.

Performs the operation in parallel using Parallel.For. The order in which the given function is applied to elements of the input array is not specified.

mapping : int -> 'T -> 'U

array : 'T[]

The input array.

Returns: 'U[]

The array of results.

Example

 let inputs = [| 10; 10; 10 |]

 inputs |> Array.Parallel.mapi (fun i x -> i + x)

Returns the greatest of all elements of the array, compared via Operators.max.

Throws ArgumentException for empty arrays.

array : 'T[]

The input array.

Returns: 'T

The maximum element.

Example

 let inputs = [| 10; 12; 11 |]

 inputs |> Array.Parallel.max

Example

 let inputs: int[]= [| |]

 inputs |> Array.Parallel.max

Returns the greatest of all elements of the array, compared via Operators.max on the function result.

Throws ArgumentException for empty arrays.

projection : 'T -> 'U

The function to transform the elements into a type supporting comparison.

array : 'T[]

The input array.

Returns: 'T

The maximum element.

Example

 let inputs = [| "aaa"; "b"; "cccc" |]

 inputs |> Array.Parallel.maxBy (fun s -> s.Length)

Example

 let inputs: string[]= [| |]

 inputs |> Array.Parallel.maxBy (fun s -> s.Length)

Returns the smallest of all elements of the array, compared via Operators.min.

Throws ArgumentException for empty arrays

array : 'T[]

The input array.

Returns: 'T

The minimum element.

Example

 let inputs = [| 10; 12; 11 |]

 inputs |> Array.Parallel.min

Example

 let inputs: int[]= [| |]

 inputs |> Array.Parallel.min

Returns the lowest of all elements of the array, compared via Operators.min on the function result.

Throws ArgumentException for empty arrays.

projection : 'T -> 'U

The function to transform the elements into a type supporting comparison.

array : 'T[]

The input array.

Returns: 'T

The minimum element.

Example

 let inputs = [| "aaa"; "b"; "cccc" |]

 inputs |> Array.Parallel.minBy (fun s -> s.Length)

Example

 let inputs: string[]= [| |]

 inputs |> Array.Parallel.minBy (fun s -> s.Length)

Split the collection into two collections, containing the elements for which the given predicate returns "true" and "false" respectively

Performs the operation in parallel using Parallel.For. The order in which the given function is applied to indices is not specified.

predicate : 'T -> bool

The function to test the input elements.

array : 'T[]

The input array.

Returns: 'T[] * 'T[]

The two arrays of results.

Example

 let inputs = [| 1; 2; 3; 4 |]

 inputs |> Array.Parallel.partition (fun x -> x % 2 = 0)

Applies a function to each element of the array in parallel, threading an accumulator argument through the computation for each thread involved in the computation. After processing entire input, results from all threads are reduced together. Raises ArgumentException if the array is empty.

The order of processing is not guaranteed. For that reason, the 'reduce' function argument should be commutative. (That is, changing the order of execution must not affect the result) Also, compared to the non-parallel version of Array.reduce, the 'reduce' function may be invoked more times due to the resulting reduction from participating threads.

reduction : 'T -> 'T -> 'T

The function to reduce a pair of elements to a single element.

array : 'T[]

The input array.

Returns: 'T

Result of the reductions.

Example

 let inputs = [| 1; 3; 4; 2 |]

 inputs |> Array.Parallel.reduce (fun a b -> a + b)

Applies a projection function to each element of the array in parallel, reducing elements in each thread with a dedicated 'reduction' function. After processing entire input, results from all threads are reduced together. Raises ArgumentException if the array is empty.

The order of processing is not guaranteed. For that reason, the 'reduction' function argument should be commutative. (That is, changing the order of execution must not affect the result)

projection : 'T -> 'U

The function to project from elements of the input array

reduction : 'U -> 'U -> 'U

The function to reduce a pair of projected elements to a single element.

array : 'T[]

The input array.

Returns: 'U

The final result of the reductions.

Example

 let inputs = [| "1"; "3"; "4"; "2" |]

 inputs |> Array.Parallel.reduceBy  (fun x -> int x) (+)

Sorts the elements of an array in parallel, returning a new array. Elements are compared using Operators.compare.

This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using Seq.Sort.

array : 'T[]

The input array.

Returns: 'T[]

The sorted array.

Example

 let input = [| 8; 4; 3; 1; 6; 1 |]

 Array.Parallel.sort input

Sorts the elements of an array in parallel, using the given projection for the keys and returning a new array. Elements are compared using Operators.compare.

This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using Seq.Sort.

projection : 'T -> 'Key

The function to transform array elements into the type that is compared.

array : 'T[]

The input array.

Returns: 'T[]

The sorted array.

Example

 let input = [| "a"; "bbb"; "cccc"; "dd" |]

 input |> Array.Parallel.sortBy (fun s -> s.Length)

Sorts the elements of an array in parallel, in descending order, using the given projection for the keys and returning a new array. Elements are compared using Operators.compare.

This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using Seq.Sort.

projection : 'T -> 'Key

The function to transform array elements into the type that is compared.

array : 'T[]

The input array.

Returns: 'T[]

The sorted array.

Example

 let input = [| "a"; "bbb"; "cccc"; "dd" |]

 input |> Array.Parallel.sortByDescending (fun s -> s.Length)

Sorts the elements of an array in parallel, in descending order, returning a new array. Elements are compared using Operators.compare.

This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using Seq.Sort.

array : 'T[]

The input array.

Returns: 'T[]

The sorted array.

Example

 let input = [| 8; 4; 3; 1; 6; 1 |]

 input |> Array.Parallel.sortDescending

Sorts the elements of an array by mutating the array in-place in parallel, using the given comparison function. Elements are compared using Operators.compare.

array : 'T[]

The input array.

Example

 let array = [| 8; 4; 3; 1; 6; 1 |]

 Array.sortInPlace array

Sorts the elements of an array by mutating the array in-place in parallel, using the given projection for the keys. Elements are compared using Operators.compare.

This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using Seq.Sort.

projection : 'T -> 'Key

The function to transform array elements into the type that is compared.

array : 'T[]

The input array.

Example

 let array = [| "a"; "bbb"; "cccc"; "dd" |]

 array |> Array.Parallel.sortInPlaceBy (fun s -> s.Length)

Sorts the elements of an array by mutating the array in-place in parallel, using the given comparison function as the order.

comparer : 'T -> 'T -> int

The function to compare pairs of array elements.

array : 'T[]

The input array.

Example

The following sorts entries using a comparison function that compares string lengths then index numbers:

 let compareEntries (n1: int, s1: string) (n2: int, s2: string) =
     let c = compare s1.Length s2.Length
     if c <> 0 then c else
     compare n1 n2

 let array = [| (0,"aa"); (1,"bbb"); (2,"cc"); (3,"dd") |]

 array |> Array.Parallel.sortInPlaceWith compareEntries

Sorts the elements of an array in parallel, using the given comparison function as the order, returning a new array.

This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using Seq.Sort.

comparer : 'T -> 'T -> int

The function to compare pairs of array elements.

array : 'T[]

The input array.

Returns: 'T[]

The sorted array.

Example

Sort an array of pairs using a comparison function that compares string lengths then index numbers:

 let compareEntries (n1: int, s1: string) (n2: int, s2: string) =
     let c = compare s1.Length s2.Length
     if c <> 0 then c else
     compare n1 n2

 let input = [| (0,"aa"); (1,"bbb"); (2,"cc"); (3,"dd") |]

 input |> Array.Parallel.sortWith compareEntries

Returns the sum of the elements in the array.

array : ^T[]

The input array.

Returns: ^T

The resulting sum.

Example

 let input = [| 1; 5; 3; 2 |]

 input |> Array.Parallel.sum

Returns the sum of the results generated by applying the function to each element of the array.

projection : 'T -> ^U

The function to transform the array elements into the type to be summed.

array : 'T[]

The input array.

Returns: ^U

The resulting sum.

Example

 let input = [| "aa"; "bbb"; "cc" |]

 input |> Array.Parallel.sumBy (fun s -> s.Length)

Returns the first element for which the given function returns True. Returns None if no such element exists.

predicate : 'T -> bool

The function to test the input elements.

array : 'T[]

The input array.

Returns: 'T option

The first element that satisfies the predicate, or None.

Example

Try to find the first even number:

 let inputs = [| 1; 2; 3 |]

 inputs |> Array.Parallel.tryFind (fun elm -> elm % 2 = 0)

Example

Try to find the first even number:

 let inputs = [| 1; 5; 3 |]

 inputs |> Array.Parallel.tryFind (fun elm -> elm % 2 = 0)

Returns the index of the first element in the array that satisfies the given predicate. Returns None if no such element exists.

predicate : 'T -> bool

The function to test the input elements.

array : 'T[]

The input array.

Returns: int option

The index of the first element that satisfies the predicate, or None.

Example

Try to find the index of the first even number:

 let inputs = [| 1; 2; 3; 4; 5 |]

 inputs |> Array.Parallel.tryFindIndex (fun elm -> elm % 2 = 0)

Example

Try to find the index of the first even number:

 let inputs = [| 1; 3; 5; 7 |]

 inputs |> Array.Parallel.tryFindIndex (fun elm -> elm % 2 = 0)

Applies the given function to successive elements, returning the first result where the function returns Some(x) for some x. If the function never returns Some(x) then None is returned.

chooser : 'T -> 'U option

The function to transform the array elements into options.

array : 'T[]

The input array.

Returns: 'U option

The first transformed element that is Some(x).

Example

 let input = [| 1; 2; 3 |]

 input |> Array.Parallel.tryPick (fun n -> if n % 2 = 0 then Some (string n) else None)

Example

 let input = [| 1; 2; 3 |]

 input |> Array.Parallel.tryPick (fun n -> if n > 3 = 0 then Some (string n) else None)

Combines the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an ArgumentException is raised.

array1 : 'T1[]

The first input array.

array2 : 'T2[]

The second input array.

Returns: ('T1 * 'T2)[]

The array of tupled elements.

Example

 let numbers = [|1; 2|]
 let names = [|"one"; "two"|]

 Array.Parallel.zip numbers names