csharpfftfsharpintegrationinterpolationlinear-algebramathdifferentiationmatrixnumericsrandomregressionstatisticsmathnet
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
463 lines
26 KiB
463 lines
26 KiB
//=========================================================================
|
|
// (c) Microsoft Corporation 2005-2009.
|
|
//=========================================================================
|
|
|
|
namespace Microsoft.FSharp.Collections
|
|
|
|
open System
|
|
open Microsoft.FSharp.Core
|
|
open Microsoft.FSharp.Collections
|
|
open System.Collections.Generic
|
|
|
|
/// Basic operations on arrays
|
|
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
|
|
[<RequireQualifiedAccess>]
|
|
module Array =
|
|
|
|
/// Build a new array that contains the elements of the first array followed by the elements of the second array
|
|
val append: array1:array<'T> -> array2:array<'T> -> array<'T>
|
|
|
|
/// Return the average of the elements in the array. If the array is empty an ArgumentException is thrown.
|
|
val inline average : array:^T array -> ^T
|
|
when ^T : (static member ( + ) : ^T * ^T -> ^T)
|
|
and ^T : (static member DivideByInt : ^T*int -> ^T)
|
|
and ^T : (static member Zero : ^T)
|
|
|
|
|
|
/// Return the average of the elements generated by applying the function to each element of the array.
|
|
/// If the array is empty an ArgumentException is thrown.
|
|
val inline averageBy : projection:('T -> ^U) -> array:array<'T> -> ^U
|
|
when ^U : (static member ( + ) : ^U * ^U -> ^U)
|
|
and ^U : (static member DivideByInt : ^U*int -> ^U)
|
|
and ^U : (static member Zero : ^U)
|
|
|
|
/// Read a range of elements from the first array and write them into the second.
|
|
val blit: source:array<'T> -> sourceIndex:int -> target:array<'T> -> targetIndex:int -> count:int -> unit
|
|
|
|
/// For each element of the array, apply the given function. Concatenate all the results and return the combined array.
|
|
val collect : mapping:('T -> array<'U>) -> array:array<'T> -> array<'U>
|
|
|
|
/// Build a new array that contains the elements of each of the given sequence of arrays
|
|
val concat: arrays:seq<array<'T>> -> array<'T>
|
|
|
|
/// Build a new array that contains the elements of the given array
|
|
val copy: array:array<'T> -> array<'T>
|
|
|
|
/// Create an array whose elements are all initially the given value.
|
|
val create: count:int -> value:'T -> array<'T>
|
|
|
|
/// Apply the given function to successive elements, returning the first
|
|
/// result where function returns <c>Some(x)</c> for some <c>x</c>. If the function
|
|
/// never returns <c>Some(x)</c> then <c>None</c> is returned.
|
|
val tryPick: chooser:('T -> 'U option) -> array:array<'T> -> 'U option
|
|
|
|
/// Fill a range of elements of the array with the given value.
|
|
val fill: target:array<'T> -> targetIndex:int -> count:int -> value:'T -> unit
|
|
|
|
/// Apply the given function to successive elements, returning the first
|
|
/// result where function returns <c>Some(x)</c> for some <c>x</c>. If the function
|
|
/// never returns <c>Some(x)</c> then <c>KeyNotFoundException</c> is raised.
|
|
val pick: chooser:('T -> 'U option) -> array:array<'T> -> 'U
|
|
|
|
/// 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)
|
|
val choose: chooser:('T -> 'U option) -> array:array<'T> -> 'U array
|
|
|
|
/// Return an empty array of the given type
|
|
[<GeneralizableValue>]
|
|
val empty<'T> : array<'T>
|
|
|
|
/// Test if any element of the array satisfies the given predicate.
|
|
///
|
|
/// The predicate is applied to the elements of the input array. If any application
|
|
/// returns true then the overall result is true and no further elements are tested.
|
|
/// Otherwise, false is returned.
|
|
val exists: predicate:('T -> bool) -> array:array<'T> -> bool
|
|
|
|
/// Test if any pair of corresponding elements of the arrays satisfies the given predicate.
|
|
///
|
|
/// The predicate is applied to matching elements in the two collections up to the lesser of the
|
|
/// two lengths of the collections. If any application returns true then the overall result is
|
|
/// true and no further elements are tested. Otherwise, if one collections is longer
|
|
/// than the other then the <c>ArgumentException</c> exception is raised.
|
|
/// Otherwise, false is returned.
|
|
val exists2: predicate:('T1 -> 'T2 -> bool) -> array1:'T1 array -> array2:'T2 array -> bool
|
|
|
|
/// Return a new collection containing only the elements of the collection
|
|
/// for which the given predicate returns "true"
|
|
val filter: predicate:('T -> bool) -> array:array<'T> -> array<'T>
|
|
|
|
/// Return the first element for which the given function returns 'true'.
|
|
/// Raise <c>KeyNotFoundException</c> if no such element exists.
|
|
val find: predicate:('T -> bool) -> array:array<'T> -> 'T
|
|
|
|
/// Return the index of the first element in the array
|
|
/// that satisfies the given predicate. Raise <c>KeyNotFoundException</c> if
|
|
/// none of the elements satisy the predicate.
|
|
val findIndex: predicate:('T -> bool) -> array:array<'T> -> int
|
|
|
|
/// Test if all elements of the array satisfy the given predicate.
|
|
///
|
|
/// The predicate is applied to the elements of the input collection. If any application
|
|
/// returns false then the overall result is false and no further elements are tested.
|
|
/// Otherwise, true is returned.
|
|
val forall: predicate:('T -> bool) -> array:array<'T> -> bool
|
|
|
|
|
|
/// Test if all corresponding elements of the array satisfy the given predicate pairwise.
|
|
///
|
|
/// The predicate is applied to matching elements in the two collections up to the lesser of the
|
|
/// two lengths of the collections. If any application returns false then the overall result is
|
|
/// false and no further elements are tested. Otherwise, if one collection is longer
|
|
/// than the other then the <c>ArgumentException</c> exception is raised.
|
|
/// Otherwise, true is returned.
|
|
val forall2: predicate:('T1 -> 'T2 -> bool) -> array1:'T1 array -> array2:'T2 array -> bool
|
|
|
|
/// Apply a function to each element of the collection, threading an accumulator argument
|
|
/// through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> then computes
|
|
/// <c>f (... (f s i0)...) iN</c>
|
|
val fold: folder:('State -> 'T -> 'State) -> state:'State -> array: array<'T> -> 'State
|
|
|
|
/// Apply a function to each element of the array, threading an accumulator argument
|
|
/// through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> then computes
|
|
/// <c>f i0 (...(f iN s))</c>
|
|
val foldBack: folder:('T -> 'State -> 'State) -> array:array<'T> -> state:'State -> 'State
|
|
|
|
/// Apply a function to pairs of elements drawn from the two collections,
|
|
/// left-to-right, threading an accumulator argument
|
|
/// through the computation. The two input
|
|
/// arrays must have the same lengths, otherwise an <c>ArgumentException</c> is
|
|
/// raised.
|
|
val fold2: folder:('State -> 'T1 -> 'T2 -> 'State) -> state:'State -> array1:'T1 array -> array2:'T2 array -> 'State
|
|
|
|
/// Apply a function to pairs of elements drawn from the two collections, right-to-left,
|
|
/// threading an accumulator argument through the computation. The two input
|
|
/// arrays must have the same lengths, otherwise an <c>ArgumentException</c> is
|
|
/// raised.
|
|
val foldBack2: folder:('T1 -> 'T2 -> 'State -> 'State) -> array1:'T1 array -> array2:'T2 array -> state:'State -> 'State
|
|
|
|
/// Get an element from an array
|
|
val get: array:array<'T> -> index:int -> 'T
|
|
|
|
/// Create an array given the dimension and a generator function to compute the elements.
|
|
val init: count:int -> initializer:(int -> 'T) -> array<'T>
|
|
|
|
/// Create an array where the entries are initially the default value Unchecked.defaultof<'T>.
|
|
val zeroCreate: count:int -> array<'T>
|
|
|
|
/// Return true if the given array is empty, otherwise false
|
|
val isEmpty: array:array<'T> -> bool
|
|
|
|
/// Apply the given function to each element of the array.
|
|
val iter: action:('T -> unit) -> array:array<'T> -> unit
|
|
|
|
/// Apply the given function to pair of elements drawn from matching indices in two arrays. The
|
|
/// two arrays must have the same lengths, otherwise an <c>ArgumentException</c> is
|
|
/// raised.
|
|
val iter2: action:('T1 -> 'T2 -> unit) -> array1:'T1 array -> array2:'T2 array -> unit
|
|
|
|
/// Apply the given function to each element of the array. The integer passed to the
|
|
/// function indicates the index of element.
|
|
val iteri: action:(int -> 'T -> unit) -> array:array<'T> -> unit
|
|
|
|
/// Apply the given function to pair of elements drawn from matching indices in two arrays,
|
|
/// also passing the index of the elements. The two arrays must have the same lengths,
|
|
/// otherwise an <c>ArgumentException</c> is raised.
|
|
val iteri2: action:(int -> 'T1 -> 'T2 -> unit) -> array1:'T1 array -> array2:'T2 array -> unit
|
|
|
|
/// Return the length of an array. You can also use property arr.Length.
|
|
val length: array:array<'T> -> int
|
|
|
|
/// Build a new array whose elements are the results of applying the given function
|
|
/// to each of the elements of the array.
|
|
val map: mapping:('T -> 'U) -> array:array<'T> -> 'U array
|
|
|
|
/// Build a new collection whose elements are the results of applying the given function
|
|
/// to the corresponding elements of the two collections pairwise. The two input
|
|
/// arrays must have the same lengths, otherwise an <c>ArgumentException</c> is
|
|
/// raised.
|
|
val map2: mapping:('T1 -> 'T2 -> 'U) -> array1:'T1 array -> array2:'T2 array -> 'U array
|
|
|
|
/// Build a new collection whose elements are the results of applying the given function
|
|
/// to the corresponding elements of the two collections pairwise, also passing the index of
|
|
/// the elements. The two input arrays must have the same lengths, otherwise an <c>ArgumentException</c> is
|
|
/// raised.
|
|
val mapi2: mapping:(int -> 'T1 -> 'T2 -> 'U) -> array1:'T1 array -> array2:'T2 array -> 'U array
|
|
|
|
/// 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.
|
|
val mapi: mapping:(int -> 'T -> 'U) -> array:array<'T> -> 'U array
|
|
|
|
/// Return the greatest of all elements of the array, compared via Operators.max on the function result
|
|
val max : array:array<'T> -> 'T
|
|
|
|
/// Return the greatest of all elements of the array, compared via Operators.max on the function result
|
|
val maxBy : projection:('T -> 'U) -> array:array<'T> -> 'T
|
|
|
|
/// Return the lowest of all elements of the array, compared via Operators.min
|
|
val min : array:array<'T> -> 'T
|
|
|
|
/// Return the lowest of all elements of the array, compared via Operators.min on the function result
|
|
val minBy : projection:('T -> 'U) -> array:array<'T> -> 'T
|
|
|
|
/// Build an array from the given list
|
|
val of_list: elements:'T list -> array<'T>
|
|
|
|
/// Build a new array from the given enumerable object
|
|
val of_seq: elements:seq<'T> -> array<'T>
|
|
|
|
/// Split the collection into two collections, containing the
|
|
/// elements for which the given predicate returns "true" and "false"
|
|
/// respectively
|
|
val partition: predicate:('T -> bool) -> array:array<'T> -> array<'T> * array<'T>
|
|
|
|
/// Returns an array with all elements permuted according to the
|
|
/// specified permutation
|
|
val permute : indexMap:(int -> int) -> array:array<'T> -> array<'T>
|
|
|
|
/// Apply a function to each element of the array, threading an accumulator argument
|
|
/// through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c>
|
|
/// then computes <c>f (... (f i0 i1)...) iN</c>.
|
|
/// Raises ArgumentException if the array has size zero.
|
|
val reduce: reduction:('T -> 'T -> 'T) -> array:array<'T> -> 'T
|
|
|
|
/// Apply a function to each element of the array, threading an accumulator argument
|
|
/// through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c>
|
|
/// then computes <c>f i0 (...(f iN-1 iN))</c>.
|
|
/// Raises ArgumentException if the array has size zero.
|
|
val reduceBack: reduction:('T -> 'T -> 'T) -> array:array<'T> -> 'T
|
|
|
|
/// Return a new array with the elements in reverse order
|
|
val rev: array:array<'T> -> array<'T>
|
|
|
|
/// Like <c>fold_left</c>, but return the intermediary and final results
|
|
val scan : folder:('State -> 'T -> 'State) -> state:'State -> array:array<'T> -> 'State array
|
|
|
|
/// Like <c>fold_right</c>, but return both the intermediary and final results
|
|
val scanBack : folder:('T -> 'State -> 'State) -> array:array<'T> -> state:'State -> 'State array
|
|
|
|
/// Set an element of an array
|
|
val set: array:array<'T> -> index:int -> value:'T -> unit
|
|
|
|
/// Build a new array that contains the given subrange specified by
|
|
/// starting index and length.
|
|
val sub: array:array<'T> -> startIndex:int -> count:int -> array<'T>
|
|
|
|
/// Sort the elements of an array, returning a new array. Elements are compared using Operators.compare.
|
|
val sort: array:array<'T> -> array<'T>
|
|
|
|
/// Sort the elements of an array, using the given projection for the keys and returning a new array. Elements are compared using Operators.compare.
|
|
val sortBy: projection:('T -> 'U) -> array:array<'T> -> array<'T>
|
|
|
|
/// Sort the elements of an array, using the given comparison function as the order, returning a new array
|
|
val sortWith: comparer:('T -> 'T -> int) -> array:array<'T> -> array<'T>
|
|
|
|
/// Sort the elements of an array by mutating the array in-place, using the given projection for the keys. Elements are compared using Operators.compare.
|
|
val sortInPlaceBy: projection:('T -> 'U) -> array:array<'T> -> unit
|
|
|
|
|
|
/// Sort the elements of an array by mutating the array in-place, using the given comparison function as the order
|
|
val sortInPlaceWith: comparer:('T -> 'T -> int) -> array:array<'T> -> unit
|
|
|
|
/// Sort the elements of an array by mutating the array in-place, using the given comparison function. Elements are compared using Operators.compare.
|
|
val sortInPlace: array:array<'T> -> unit
|
|
|
|
/// Return the sum of the elements in the array
|
|
val inline sum : array: ^T array -> ^T
|
|
when ^T : (static member ( + ) : ^T * ^T -> ^T)
|
|
and ^T : (static member Zero : ^T)
|
|
|
|
|
|
/// Return the sum of the results generated by applying the function to each element of the array.
|
|
val inline sumBy : projection:('T -> ^U) -> array:array<'T> -> ^U
|
|
when ^U : (static member ( + ) : ^U * ^U -> ^U)
|
|
and ^U : (static member Zero : ^U)
|
|
|
|
/// Build a list from the given array
|
|
val to_list: array:array<'T> -> 'T list
|
|
|
|
/// View the given array as a sequence
|
|
val to_seq: array:array<'T> -> seq<'T>
|
|
|
|
/// Return the first element for which the given function returns <c>true</c>.
|
|
/// Return <c>None</c> if no such element exists.
|
|
val tryFind: predicate:('T -> bool) -> array:array<'T> -> 'T option
|
|
|
|
/// Return the index of the first element in the array
|
|
/// that satisfies the given predicate.
|
|
val tryFindIndex : predicate:('T -> bool) -> array:array<'T> -> int option
|
|
|
|
/// Split an array of pairs into two arrays
|
|
val unzip: array:('T1 * 'T2) array -> ('T1 array * 'T2 array)
|
|
|
|
/// Split an array of triples into three arrays
|
|
val unzip3: array:('T1 * 'T2 * 'T3) array -> ('T1 array * 'T2 array * 'T3 array)
|
|
|
|
/// Combine the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an <c>ArgumentException</c> is
|
|
/// raised.
|
|
val zip: array1:'T1 array -> array2:'T2 array -> ('T1 * 'T2) array
|
|
|
|
/// Combine three arrays into an array of pairs. The three arrays must have equal lengths, otherwise an <c>ArgumentException</c> is
|
|
/// raised.
|
|
val zip3: array1:'T1 array -> array2:'T2 array -> array3:'T3 array -> ('T1 * 'T2 * 'T3) array
|
|
|
|
#if FX_ATLEAST_40
|
|
/// Provides parallel operations on arrays
|
|
module Parallel =
|
|
|
|
/// 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 System.Threading.Parallel.For.
|
|
/// The order in which the given function is applied to elements of the input array is not specified.
|
|
val choose: chooser:('T -> 'U option) -> array:'T array -> 'U array
|
|
|
|
/// 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 System.Threading.Parallel.For.
|
|
/// The order in which the given function is applied to elements of the input array is not specified.
|
|
val collect : mapping:('T -> array<'U>) -> array:array<'T> -> array<'U>
|
|
|
|
/// 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 System.Threading.Parallel.For.
|
|
/// The order in which the given function is applied to elements of the input array is not specified.
|
|
val map : mapping:('T -> 'U) -> array:array<'T> -> array<'U>
|
|
|
|
/// 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 System.Threading.Parallel.For.
|
|
/// The order in which the given function is applied to elements of the input array is not specified.
|
|
val mapi: mapping:(int -> 'T -> 'U) -> array:'T array -> 'U array
|
|
|
|
/// Apply the given function to each element of the array.
|
|
///
|
|
/// Performs the operation in parallel using System.Threading.Parallel.For.
|
|
/// The order in which the given function is applied to elements of the input array is not specified.
|
|
val iter : action:('T -> unit) -> array:array<'T> -> unit
|
|
|
|
/// 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 System.Threading.Parallel.For.
|
|
/// The order in which the given function is applied to elements of the input array is not specified.
|
|
val iteri: action:(int -> 'T -> unit) -> array:'T array -> unit
|
|
|
|
/// Create an array given the dimension and a generator function to compute the elements.
|
|
///
|
|
/// Performs the operation in parallel using System.Threading.Parallel.For.
|
|
/// The order in which the given function is applied to indicies is not specified.
|
|
val init : count:int -> initializer:(int -> 'T) -> array<'T>
|
|
|
|
/// 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 System.Threading.Parallel.For.
|
|
/// The order in which the given function is applied to indicies is not specified.
|
|
val partition : predicate:('T -> bool) -> array:array<'T> -> array<'T> * array<'T>
|
|
#endif
|
|
|
|
#if DONT_INCLUDE_DEPRECATED
|
|
#else
|
|
[<OCamlCompatibility("This F# library function has been renamed. Use 'zip' instead")>]
|
|
val combine: array1:'T1 array -> array2:'T2 array -> ('T1 * 'T2) array
|
|
|
|
[<OCamlCompatibility("This F# library function has been renamed. Use 'unzip' instead")>]
|
|
val split: array:('T1 * 'T2) array -> ('T1 array * 'T2 array)
|
|
|
|
[<Obsolete("This F# library function has been renamed. Use 'averageBy' instead")>]
|
|
val inline average_by : projection:('T -> ^U) -> array:array<'T> -> ^U
|
|
when ^U : (static member ( + ) : ^U * ^U -> ^U)
|
|
and ^U : (static member DivideByInt : ^U*int -> ^U)
|
|
and ^U : (static member Zero : ^U)
|
|
|
|
[<Obsolete("This F# library function has been renamed. Use 'findIndex' instead")>]
|
|
val find_index: predicate:('T -> bool) -> array:array<'T> -> int
|
|
|
|
[<OCamlCompatibility("This F# library function has been renamed. Use 'forall' instead")>]
|
|
val for_all: predicate:('T -> bool) -> array:array<'T> -> bool
|
|
|
|
[<OCamlCompatibility("This F# library function has been renamed. Use 'create' instead")>]
|
|
val make: count:int -> value:'T -> array<'T>
|
|
|
|
[<Obsolete("This F# library function has been renamed. Use 'tryPick' instead")>]
|
|
val first: chooser:('T -> 'U option) -> array:array<'T> -> 'U option
|
|
|
|
[<Obsolete("This F# library function has been renamed. Use 'forall2' instead")>]
|
|
val for_all2: predicate:('T1 -> 'T2 -> bool) -> array1:'T1 array -> array2:'T2 array -> bool
|
|
|
|
[<OCamlCompatibility("This F# library function has been renamed. Use 'fold' instead")>]
|
|
val fold_left: folder:('State -> 'T -> 'State) -> state:'State -> array: array<'T> -> 'State
|
|
|
|
/// Apply a function to each element of the array, threading an accumulator argument
|
|
/// through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c>
|
|
/// then computes <c>f i0 (...(f iN s))</c>
|
|
[<OCamlCompatibility("This F# library function has been renamed. Use 'foldBack' instead")>]
|
|
val fold_right: folder:('T -> 'State -> 'State) -> array:array<'T> -> state:'State -> 'State
|
|
|
|
/// Apply a function to pairs of elements drawn from the two collections,
|
|
/// left-to-right, threading an accumulator argument
|
|
/// through the computation. The two input
|
|
/// arrays must have the same lengths, otherwise an <c>ArgumentException</c> is
|
|
/// raised.
|
|
[<Obsolete("This F# library function has been renamed. Use 'fold2' instead")>]
|
|
val fold_left2: folder:('State -> 'T1 -> 'T2 -> 'State) -> state:'State -> array1:'T1 array -> array2:'T2 array -> 'State
|
|
|
|
[<Obsolete("This F# library function has been renamed. Use 'foldBack2' instead")>]
|
|
val fold_right2: folder:('T1 -> 'T2 -> 'State -> 'State) -> array1:'T1 array -> array2:'T2 array -> state:'State -> 'State
|
|
|
|
/// Create an array where the entries are initially the default value Unchecked.defaultof<'T>.
|
|
[<Obsolete("This F# library function has been renamed. Use 'zeroCreate' instead")>]
|
|
val zero_create: count:int -> array<'T>
|
|
|
|
[<Obsolete("This F# library function has been renamed. Use 'isEmpty' instead")>]
|
|
val is_empty: array:array<'T> -> bool
|
|
|
|
[<Obsolete("This F# library function has been renamed. Use 'maxBy' instead")>]
|
|
val max_by : projection:('T -> 'U) -> array:array<'T> -> 'T
|
|
|
|
[<Obsolete("This F# library function has been renamed. Use 'minBy' instead")>]
|
|
val min_by : projection:('T -> 'U) -> array:array<'T> -> 'T
|
|
|
|
[<Obsolete("This F# library function has been renamed. Use 'reduce' instead")>]
|
|
val reduce_left: reduction:('T -> 'T -> 'T) -> array:array<'T> -> 'T
|
|
|
|
[<Obsolete("This F# library function has been renamed. Use 'reduceBack' instead")>]
|
|
val reduce_right: reduction:('T -> 'T -> 'T) -> array:array<'T> -> 'T
|
|
|
|
[<Obsolete("This F# library function has been renamed. Use 'scan' instead")>]
|
|
val scan_left : folder:('State -> 'T -> 'State) -> state:'State -> array:array<'T> -> 'State array
|
|
|
|
[<Obsolete("This F# library function has been renamed. Use 'scanBack' instead")>]
|
|
val scan_right : folder:('T -> 'State -> 'State) -> array:array<'T> -> state:'State -> 'State array
|
|
|
|
/// Sort the elements of an array, using the given projection for the keys. Elements are compared using Operators.compare.
|
|
[<Obsolete("This F# library function has been renamed. Use 'sortInPlaceBy' instead")>]
|
|
val sort_by: projection:('T -> 'U) -> array:array<'T> -> unit
|
|
|
|
[<Obsolete("This F# library function has been renamed. Use 'sumBy' instead")>]
|
|
val inline sum_by : projection:('T -> ^U) -> array:array<'T> -> ^U
|
|
when ^U : (static member ( + ) : ^U * ^U -> ^U)
|
|
and ^U : (static member Zero : ^U)
|
|
|
|
|
|
[<Obsolete("This F# library function has been renamed. Use 'tryFind' instead")>]
|
|
val tryfind: predicate:('T -> bool) -> array:array<'T> -> 'T option
|
|
|
|
[<Obsolete("This F# library function has been renamed. Use 'tryFindIndex' instead")>]
|
|
val tryfind_index: predicate:('T -> bool) -> array:array<'T> -> int option
|
|
|
|
[<Obsolete("This function will be removed from the F# library. Replacement functions 'tryPick' and 'tryFindIndex' are now provided")>]
|
|
val tryfind_indexi: predicate:(int -> 'T -> bool) -> array:array<'T> -> int option
|
|
|
|
[<Obsolete("This function will be removed from the F# library. Replacement functions 'pick' and 'findIndex' are now provided")>]
|
|
val find_indexi: predicate:(int -> 'T -> bool) -> array:array<'T> -> int
|
|
|
|
#endif
|
|
|