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

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)

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)

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

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)

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)

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

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)

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)

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

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

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)

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)

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

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)

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

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)

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)

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)

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

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

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)

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)

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

array : 'T[]

The input array.

Example

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

 Array.sortInPlace 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.

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)

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

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

array : ^T[]

The input array.

Returns: ^T

The resulting sum.

Example

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

 input |> Array.Parallel.sum

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)

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)

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)

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)

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