ArrayFun
Static members
| Static member | Description |
AllEqual(...)
Signature: (array0:'T0 [] * array1:'T1 [] * item0_item1_equalFun:Func<'T0,'T1,bool>) -> bool
Type parameters: 'T0, 'T1 |
|
Apply(self, element_fun)
Signature: (self:'T [] * element_fun:Func<'T,'T>) -> 'T []
Type parameters: 'T |
Apply the supplied transformation function to each element of the array. |
Apply(self, count, element_fun)
Signature: (self:'T [] * count:int64 * element_fun:Func<'T,'T>) -> 'T []
Type parameters: 'T |
Apply the supplied transformation function to the first count elements of the array. |
Apply(self, start, count, element_fun)
Signature: (self:'T [] * start:int64 * count:int64 * element_fun:Func<'T,'T>) -> 'T []
Type parameters: 'T |
Apply the supplied transformation function to count elements of the array, starting at the supplied start index. |
Apply(self, element_index_fun)
Signature: (self:'T [] * element_index_fun:Func<'T,int64,'T>) -> 'T []
Type parameters: 'T |
|
Apply(self, count, element_index_fun)
Signature: (self:'T [] * count:int64 * element_index_fun:Func<'T,int64,'T>) -> 'T []
Type parameters: 'T |
Apply the supplied transformation function to the first count elements of the array. |
Apply(...)
Signature: (self:'T [] * start:int64 * count:int64 * element_index_fun:Func<'T,int64,'T>) -> 'T []
Type parameters: 'T |
Apply the supplied transformation function to count elements of the array, starting at the supplied start index. |
Apply(array, fun, funT1ofT0, funT0ofT1)
Signature: (array:Array * fun:Func<'T1,'T1> * funT1ofT0:Func<'T0,'T1> * funT0ofT1:Func<'T1,'T0>) -> Array
Type parameters: 'T0, 'T1 |
Apply a supplied function to each element of an array, with supplied conversion functions if the array is of a different type. |
BackMappedCopy(array, backMap, count)
Signature: (array:'T [] * backMap:int [] * count:int) -> 'T []
Type parameters: 'T |
Returns a copy of this array that is created by copying the elements at the positions specified in the supplied backward map. An optional count argument is used for the size of the resulting array. |
BackMappedCopy(...)
Signature: (array:'T [] * backMap:int [] * fun:Func<'T,'Tr> * count:int) -> 'Tr []
Type parameters: 'T, 'Tr |
Returns a copy of this array that is created by copying the elements at the positions specified in the supplied backward map and applying a function to each element. An optional count argument is used for the size of the resulting array. |
BackMappedCopy(array, backMap, count)
Signature: (array:'T [] * backMap:int64 [] * count:int64) -> 'T []
Type parameters: 'T |
Returns a copy of this array that is created by copying the elements at the positions specified in the supplied backward map. An optional count argument is used for the size of the resulting array. |
BackMappedCopy(...)
Signature: (array:'T [] * backMap:int64 [] * fun:Func<'T,'Tr> * count:int64) -> 'Tr []
Type parameters: 'T, 'Tr |
Returns a copy of this array that is created by copying the elements at the positions specified in the supplied backward map and applying a function to each element. An optional count argument is used for the size of the resulting array. |
BackMappedCopy(...)
Signature: (array:'T [] * indexArray:int [] * backMap:int [] * count:int) -> 'T []
Type parameters: 'T |
Returns a copy of this array that is created by copying the elements at the positions specified in the index array of the supplied backward map. If the index array is null only the backward map is used to compute the position. An optional count argument is used for the size of the resulting array. |
BackMappedCopy(...)
Signature: (array:'T [] * indexArray:int [] * backMap:int [] * fun:Func<'T,'Tr> * count:int) -> 'Tr []
Type parameters: 'T, 'Tr |
Returns a copy of this array that is created by copying the elements at the positions specified in the index array of the supplied backward map and applying a function to each element. If the index array is null only the backward map is used to compute the position. An optional count argument is used for the size of the resulting array. |
BackMappedCopy(source, backMap, count)
Signature: (source:Array * backMap:int [] * count:int) -> Array
|
|
BackMappedCopy(...)
Signature: (source:Array * indexArray:int [] * backMap:int [] * count:int) -> Array
|
|
BackMappedCopyFrom(...)
Signature: (targetArray:'T [] * sourceArrays:'T [] [] * backwardMaps:int [] []) -> 'T []
Type parameters: 'T |
copies all srcArrays into this array indexed by an inversed indexMap returns itself |
BackMappedCopyFromIndexArrays(...)
Signature: (targetArray:int [] * sourceArrays:int [] [] * backwardMaps:int [] []) -> int [] []
|
copies all srcIndexArrays to this indexArray over iaIndexMaps and returns aIndexMaps for copying the arrays that are indexed by srcIndexArrays |
BackMappedCopyIndexArrayTo(...)
Signature: (sourceArray:int [] * targetArray:int [] * backwardMap:int [] * targetOffest:int) -> int []
|
Copies this index array to the target array over iaIndexMap at position diaOffset and returns aIndexMap for copying the arrays that are indexed by sourceIndexArray !! destinationIndexArray has to be initialized with -1 |
BackMappedCopyIndexArrayTo(...)
Signature: (sourceArray:int [] * targetArray:byref<int []> * backwardMap:int []) -> int []
|
copies from this indexArray to destinationIndexArray over iaIndexMap and returns aIndexMap for copying the arrays that are indexed by sourceIndexArray |
BackMappedCopySafe(...)
Signature: (array:'T [] * backMap:int [] * defaultValue:'T * count:int) -> 'T []
Type parameters: 'T |
Returns a copy of this array that is created by copying the elements at the positions specified in the supplied backward map. An optional count argument is used for the size of the resulting array. |
BackMappedCopyTo(...)
Signature: (source:'T [] * target:'T [] * backMap:int [] * offset:int) -> unit
Type parameters: 'T |
Copies from this array into the target array starting at the supplied offset using the supplied backward map that contains the source index for each index of the target array. |
BackMappedCopyTo(...)
Signature: (source:'T [] * target:'T [] * backMap:int64 [] * offset:int64) -> unit
Type parameters: 'T |
Copies from this array into the target array starting at the supplied offset using the supplied backward map that contains the source index for each index of the target array. |
BackMappedCopyTo(...)
Signature: (source:Array * backwardMap:int [] * target:Array * offset:int) -> Array
|
|
BackMappedGroupCopyTo(...)
Signature: (source:'T [] * groupBackMap:int [] * groupCount:int * fia:int [] * target:'T [] * start:int) -> unit
Type parameters: 'T |
|
BackMappedGroupCopyTo(...)
Signature: (source:int [] * groupBackMap:int [] * groupCount:int * fia:int [] * elementForwardMap:int [] * target:int [] * start:int) -> unit
|
|
BackMappedGroupCopyTo(...)
Signature: (source:Array * faceBackMap:int [] * faceCount:int * fia:int [] * target:Array * offset:int) -> unit
|
|
BinarySearch(self, item, comparer)
Signature: (self:'T [] * item:'T * comparer:Func<'T,'T,int>) -> int
Type parameters: 'T |
|
Copy(array)
Signature: (array:'T []) -> 'T []
Type parameters: 'T |
Use this instead of Clone() in order to get a typed array back. |
Copy(array, count)
Signature: (array:'T [] * count:int64) -> 'T []
Type parameters: 'T |
Create a copy of the specified length. If the copy is longer it is filled with default elements. |
Copy(array, start, count)
Signature: (array:'T [] * start:int64 * count:int64) -> 'T []
Type parameters: 'T |
Create a copy of the specified length starting at the specified start. If the copy is longer it is filled with default elements. |
Copy(array, element_fun)
Signature: (array:'T [] * element_fun:Func<'T,'Tr>) -> 'Tr []
Type parameters: 'T, 'Tr |
|
Copy(array, element_index_fun)
Signature: (array:'T [] * element_index_fun:Func<'T,int64,'Tr>) -> 'Tr []
Type parameters: 'T, 'Tr |
|
Copy(array, count, element_fun)
Signature: (array:'T [] * count:int64 * element_fun:Func<'T,'Tr>) -> 'Tr []
Type parameters: 'T, 'Tr |
|
Copy(array, count, element_index_fun)
Signature: (array:'T [] * count:int64 * element_index_fun:Func<'T,int64,'Tr>) -> 'Tr []
Type parameters: 'T, 'Tr |
|
Copy(array, start, count, element_fun)
Signature: (array:'T [] * start:int64 * count:int64 * element_fun:Func<'T,'Tr>) -> 'Tr []
Type parameters: 'T, 'Tr |
|
Copy(...)
Signature: (array:'T [] * start:int64 * count:int64 * element_index_fun:Func<'T,int64,'Tr>) -> 'Tr []
Type parameters: 'T, 'Tr |
|
Copy(array)
Signature: array:Array -> Array
|
|
Copy(...)
Signature: (array:Array * funOfElementTypeToElementType:Func<'T,'T> * defaultFun:Func<Array,Array>) -> Array
Type parameters: 'T |
|
CopyAndConvert(array, convert)
Signature: (array:Array * convert:Func<'T0,'T1>) -> 'T1 []
Type parameters: 'T0, 'T1 |
|
CopyAndConvert(array, convert, fun)
Signature: (array:Array * convert:Func<'T0,'T1> * fun:Func<'T1,'Tr>) -> 'Tr []
Type parameters: 'T0, 'T1, 'Tr |
|
CopyRange(...)
Signature: (array:'T [] * start:int64 * count:int64 * targetStart:int64) -> unit
Type parameters: 'T |
Copies the specified range of elements to the specified destination within the same array. |
CopyReversed(array)
Signature: (array:'T []) -> 'T []
Type parameters: 'T |
Create a copy with the elements reversed. |
CopyTo(...)
Signature: (array:'T [] * count:int64 * target:'T [] * targetStart:int64) -> unit
Type parameters: 'T |
Copy a range of elements to the target array. |
CopyTo(...)
Signature: (array:'T [] * start:int64 * count:int64 * target:'T [] * targetStart:int64) -> unit
Type parameters: 'T |
Copy a range of elements to the target array. |
CopyTo(input, offset, length, target)
Signature: (input:Array * offset:int * length:int * target:nativeint) -> unit
|
Copies the specified part of an array to the target-pointer. NOTE: May cause AccessViolationException if the target-pointer is not sufficiently allocated. |
CopyTo(input, length, target)
Signature: (input:Array * length:int * target:nativeint) -> unit
|
|
CopyTo(input, target)
Signature: (input:Array * target:nativeint) -> unit
|
|
CopyTo(input, target, offset, length)
Signature: (input:nativeint * target:Array * offset:int * length:int) -> unit
|
|
CopyTo(input, target, length)
Signature: (input:nativeint * target:Array * length:int) -> unit
|
|
CopyTo(input, target)
Signature: (input:nativeint * target:Array) -> unit
|
|
CopyTo(input, target, size)
Signature: (input:nativeint * target:nativeint * size:int) -> unit
|
|
CopyToList(array)
Signature: (array:'T []) -> List<'T>
Type parameters: 'T |
Copies the array into a list. |
CopyToList(array, element_fun)
Signature: (array:'T [] * element_fun:Func<'T,'Tr>) -> List<'Tr>
Type parameters: 'T, 'Tr |
|
CopyToList(array, item_index_fun)
Signature: (array:'T [] * item_index_fun:Func<'T,int64,'Tr>) -> List<'Tr>
Type parameters: 'T, 'Tr |
|
CreateBackMap(forwardMap)
Signature: (forwardMap:int []) -> int []
|
returns the inverse of the given indexMap (be carefull with inversing inversedIndexMaps => can be to short! fix if needed: use inverseIndexMap(int[] indexMap, int size) instead) |
CreateBackMap(forwardMap, resultLength)
Signature: (forwardMap:int [] * resultLength:int) -> int []
|
returns the backward map in the given size of the given forward map |
CreateBackMap(...)
Signature: (forwardMap:int [] * resultLength:int * offset:int) -> int []
|
|
CreateBackToFirstMap(...)
Signature: (forwardMap:int [] * resultLength:int) -> int []
|
|
DenseCount(...)
Signature: (indexArray:int [] * indexCount:int * maxIndex:int) -> int
|
Count the indices in an index array that are actually used. |
DenseForwardMap(...)
Signature: (indexArray:int [] * indexCount:int * maxIndex:int * denseCount:byref<int>) -> int []
|
Create a forward map from an index array that contains new indices in such a way, that no index is unused. |
DenseForwardMap(...)
Signature: (indexArray:int [] * groupSelectionArray:int [] * groupSize:int * denseCount:byref<int>) -> int []
|
|
Elements(array, first, count)
Signature: (array:'T [] * first:int64 * count:int64) -> IEnumerable<'T>
Type parameters: 'T |
|
Elements(array, convert)
Signature: (array:Array * convert:Func<'T0,'T1>) -> IEnumerable<'T1>
Type parameters: 'T0, 'T1 |
|
ElementsWhere(...)
Signature: (array:'T [] * first:int * count:int * predicate:Func<'T,bool>) -> IEnumerable<'T>
Type parameters: 'T |
|
ElementsWhere(...)
Signature: (array:'T [] * first:int64 * count:int64 * predicate:Func<'T,bool>) -> IEnumerable<'T>
Type parameters: 'T |
|
FlatCopy(array)
Signature: (array:'T [] []) -> 'T []
Type parameters: 'T |
|
FlatCopy(array)
Signature: (array:'T [] [] []) -> 'T []
Type parameters: 'T |
|
FlatCopyTo(array, target, start)
Signature: (array:'T [] [] * target:'T [] * start:int64) -> unit
Type parameters: 'T |
|
FlatCopyTo(array, target, start)
Signature: (array:'T [] [] [] * target:'T [] * start:int64) -> unit
Type parameters: 'T |
|
FlatCount(array)
Signature: (array:'T [] []) -> int64
Type parameters: 'T |
|
FlatCount(array)
Signature: (array:'T [] [] []) -> int64
Type parameters: 'T |
|
FoldLeft(array, seed, sum_item_fun)
Signature: (array:'TVal [] * seed:'TSum * sum_item_fun:Func<'TSum,'TVal,'TSum>) -> 'TSum
Type parameters: 'TVal, 'TSum |
Performs an aggregation of all items in an array with the supplied aggregation function starting from the left and with the supplied seed, and returns the aggregated result. |
FoldLeft(...)
Signature: (array:'TVal [] * start:int64 * count:int64 * seed:'TSum * sum_item_fun:Func<'TSum,'TVal,'TSum>) -> 'TSum
Type parameters: 'TVal, 'TSum |
Performs an aggregation of the specified slice of items in an array with the supplied aggregation function starting from the left and with the initial supplied left sum, and returns the aggregated result. |
FoldLeft2(...)
Signature: (array0:'T0 [] * array1:'T1 [] * seed:'TSum * sum_item0_item1_fun:Func<'TSum,'T0,'T1,'TSum>) -> 'TSum
Type parameters: 'T0, 'T1, 'TSum |
Performs an aggregation of all corresponding pairs of items of the supplied arrays with the supplied aggregation function starting from the left and with the supplied seed, and returns the aggregated result. |
FoldLeft3(...)
Signature: (array0:'T0 [] * array1:'T1 [] * array2:'T2 [] * seed:'TSum * sum_item0_item1_item2_fun:Func<'TSum,'T0,'T1,'T2,'TSum>) -> 'TSum
Type parameters: 'T0, 'T1, 'T2, 'TSum |
Performs an aggregation of all corresponding triples of items of the supplied arrays with the supplied aggregation function starting from the left and with the supplied seed, and returns the aggregated result. |
FoldRight(array, item_sum_fun, seed)
Signature: (array:'TVal [] * item_sum_fun:Func<'TVal,'TSum,'TSum> * seed:'TSum) -> 'TSum
Type parameters: 'TVal, 'TSum |
Performs an aggregation of all items in an array with the supplied aggregation function starting from the right and with the supplied seed, and returns the aggregated result. |
FoldRight(...)
Signature: (array:'TVal [] * start:int64 * count:int64 * item_sum_fun:Func<'TVal,'TSum,'TSum> * seed:'TSum) -> 'TSum
Type parameters: 'TVal, 'TSum |
Performs an aggregation of the specified slice of items in an array with the supplied aggregation function starting from the right and with the initial supplied right sum, and returns the aggregated result. |
FoldRight2(...)
Signature: (array0:'T0 [] * array1:'T1 [] * item0_item1_sum_fun:Func<'T0,'T1,'TSum,'TSum> * seed:'TSum) -> 'TSum
Type parameters: 'T0, 'T1, 'TSum |
Performs an aggregation of all corresponding pairs of items of the supplied arrays with the supplied aggregation function starting from the rigth and with the supplied seed, and returns the aggregated result. |
FoldRight3(...)
Signature: (array0:'T0 [] * array1:'T1 [] * array2:'T2 [] * item0_item1_item2_sum_fun:Func<'T0,'T1,'T2,'TSum,'TSum> * seed:'TSum) -> 'TSum
Type parameters: 'T0, 'T1, 'T2, 'TSum |
Performs an aggregation of all corresponding triples of items of the supplied arrays with the supplied aggregation function starting from the rigth and with the supplied seed, and returns the aggregated result. |
ForwardMapAdd(...)
Signature: (forwardMap:int [] * index:int * forwardCount:byref<int>) -> int
|
|
ForwardMapAdd(...)
Signature: (forwardMap:int [] * forwardCount:int * indexArray:int [] * indexCount:int) -> int
|
|
ForwardMappedCopy(...)
Signature: (sourceArray:'T [] * forwardMap:int []) -> 'T []
Type parameters: 'T |
Returns a copy of this array by placing each element at a new position specified by the supplied forward map. The forward map may contain negative values for elements that should not be copied. The length of the result is computed to hold all forward mapped elements of the soruce array. |
ForwardMappedCopy(...)
Signature: (sourceArray:'T [] * forwardMap:int [] * targetLength:int) -> 'T []
Type parameters: 'T |
Returns a copy of this array by placing each element at a new position specified by the supplied forward map. The forward map may contain negative values for elements that should not be copied. The length of the result needs to be supplied as a parameter. |
ForwardMappedCopyFrom(...)
Signature: (targetArray:'T [] * sourceArrays:'T [] [] * forwardMaps:int [] []) -> 'T []
Type parameters: 'T |
Copies all source arrays into this array, using the supplied array of forward maps. |
ForwardMappedCopyFromIndexArrays(...)
Signature: (targetArray:int [] * sourceArrays:int [] [] * forwardMaps:int [] []) -> int [] []
|
copies all srcIndexArrays to this indexArray over iaIndexMaps and returns aIndexMaps for copying the arrays that are indexed by srcIndexArrays |
ForwardMappedCopyIndexArrayTo(...)
Signature: (sourceArray:int [] * targetArray:int [] * forwardMap:int [] * targetOffset:int) -> int []
|
copies this indexArray to destinationIndexArray over iaIndexMap at position diaOffset and returns aIndexMap for copying the arrays that are indexed by sourceIndexArray !! destinationIndexArray has to be initialized with -1 |
ForwardMappedCopyIndexArrayTo(...)
Signature: (sourceArray:int [] * targetArray:byref<int []> * forwardMap:int []) -> int []
|
copies from this indexArray to destinationIndexArray over iaIndexMap and returns aIndexMap for copying the arrays that are indexed by sourceIndexArray |
ForwardMappedCopyTo(...)
Signature: (sourceArray:'T [] * targetArray:'T [] * forwardMap:int [] * offset:int) -> unit
Type parameters: 'T |
Copies from this array into the target array starting at the supplied offset and using the supplied forward map that specifies the new index for each element. The forward map may contain negative values for elements to be skipped. |
GetTypeIdUncached()
Signature: unit -> nativeint
Type parameters: 'T |
|
GroupReversedCopy(...)
Signature: (array:'T [] * groupFirstIndices:int [] * groupCount:int * reverseMap:Func<int,bool>) -> 'T []
Type parameters: 'T |
Return an array with reversed groups. The specified first group indices array defines which consecutive elements constitute a group, and the reverse map function specifies wich of these groups should actually be reversed. |
GroupReversedCopy(...)
Signature: (array:Array * groupArray:int [] * groupCount:int * reverseMap:Func<int,bool>) -> Array
|
|
IndexOfMax(a)
Signature: (a:'T []) -> int
Type parameters: 'T |
|
IndexOfMax(a, start, count)
Signature: (a:'T [] * start:int * count:int) -> int
Type parameters: 'T |
|
IndexOfMax(a, compare)
Signature: (a:'T [] * compare:Func<'T,'T,int>) -> int
Type parameters: 'T |
|
IndexOfMin(a)
Signature: (a:'T []) -> int
Type parameters: 'T |
|
IndexOfMin(a, start, count)
Signature: (a:'T [] * start:int * count:int) -> int
Type parameters: 'T |
|
IndexOfMin(a, compare)
Signature: (a:'T [] * compare:Func<'T,'T,int>) -> int
Type parameters: 'T |
|
IndexOfNLargest(a, n)
Signature: (a:'T [] * n:int) -> int
Type parameters: 'T |
|
IndexOfNSmallest(a, n)
Signature: (a:'T [] * n:int) -> int
Type parameters: 'T |
|
InnerProduct(...)
Signature: (array:'T1 [] * other:'T2 [] * count:int64 * mulFun:Func<'T1,'T2,'TMul> * seed:'TSum * addFun:Func<'TSum,'TMul,'TSum>) -> 'TSum
Type parameters: 'T1, 'T2, 'TMul, 'TSum |
Apply the supplied mulFun to the first count corresponding pairs of elements from the supplied arrays. Aggregate the results starting with the supplied seed and the supplied addFun. |
InnerProduct(...)
Signature: (array:'T1 [] * other:'T2 [] * count:int64 * mulFun:Func<'T1,'T2,'TMul> * seed:'TSum * addFun:Func<'TSum,'TMul,'TSum> * sum_exitIfTrueFun:Func<'TSum,bool>) -> 'TSum
Type parameters: 'T1, 'T2, 'TMul, 'TSum |
Apply the supplied mulFun to the first count corresponding pairs of elements from the supplied arrays. Aggregate the results starting with the supplied seed and the supplied addFun. |
InnerProduct(...)
Signature: (array0:'T1 [] * array1:'T2 [] * item0_item1_productFun:Func<'T1,'T2,'TProduct> * seed:'TSum * sum_product_sumFun:Func<'TSum,'TProduct,'TSum>) -> 'TSum
Type parameters: 'T1, 'T2, 'TProduct, 'TSum |
Apply the supplied productFun to corresponding pairs of elements from supplied arrays. Aggregate the results starting with the supplied seed and the supplied sumFun. |
InnerProduct(...)
Signature: (array0:'T1 [] * array1:'T2 [] * item0_item1_productFun:Func<'T1,'T2,'TProduct> * seed:'TSum * sum_product_sumFun:Func<'TSum,'TProduct,'TSum> * sum_exitIfTrueFun:Func<'TSum,bool>) -> 'TSum
Type parameters: 'T1, 'T2, 'TProduct, 'TSum |
Apply the supplied productFun to corresponding pairs of elements from supplied arrays. Aggregate the results starting with the supplied seed and the supplied sumFun. |
Integrate(array, sum)
Signature: (array:int [] * sum:int) -> int
|
Converts an array that contains the number of elements at each index into an array that holds the indices of the first element if the elements are stored in consecutive order. Returns the sum of all elements. |
Integrate(array, sum)
Signature: (array:int64 [] * sum:int64) -> int64
|
Converts an array that contains the number of elements at each index into an array that holds the indices of the first element if the elements are stored in consecutive order. Returns the sum of all elements. |
Integrate(array, sum)
Signature: (array:float [] * sum:float) -> float
|
Integrates the array and returns the sum. Note that the value of the starting element will be the supplied initial sum value after the operation. |
JaggedCopy(array)
Signature: (array:'T [] []) -> 'T [] []
Type parameters: 'T |
Use this instead of Clone() or Copy() in order to get a full copy of the jagged array back. |
JaggedCopy(array)
Signature: (array:'T [] [] []) -> 'T [] [] []
Type parameters: 'T |
|
LongIndexOfMax(a)
Signature: (a:'T []) -> int64
Type parameters: 'T |
|
LongIndexOfMax(a, compare)
Signature: (a:'T [] * compare:Func<'T,'T,int>) -> int64
Type parameters: 'T |
|
LongIndexOfMin(a)
Signature: (a:'T []) -> int64
Type parameters: 'T |
|
LongIndexOfMin(a, compare)
Signature: (a:'T [] * compare:Func<'T,'T,int>) -> int64
Type parameters: 'T |
|
LongSum(array, selector)
Signature: (array:'T [] * selector:Func<'T,int64>) -> int64
Type parameters: 'T |
|
Map(array, item_fun)
Signature: (array:'T [] * item_fun:Func<'T,'Tr>) -> 'Tr []
Type parameters: 'T, 'Tr |
Create a copy with the elements piped through a function. |
Map(array, item_index_fun)
Signature: (array:'T [] * item_index_fun:Func<'T,int64,'Tr>) -> 'Tr []
Type parameters: 'T, 'Tr |
Create a copy with the elements piped through a function. The function gets the index of the element as a second argument. |
Map(array, count, element_fun)
Signature: (array:'T [] * count:int64 * element_fun:Func<'T,'Tr>) -> 'Tr []
Type parameters: 'T, 'Tr |
Create a copy of count elements with the elements piped through a function. count may be longer than the array, in this case the result array has default elements at the end. |
Map(array, count, element_index_fun)
Signature: (array:'T [] * count:int64 * element_index_fun:Func<'T,int64,'Tr>) -> 'Tr []
Type parameters: 'T, 'Tr |
Create a copy of count elements with the elements piped through a function. count may be longer than the array, in this case the result array has default elements at the end. The function gets the index of the element as a second argument. |
Map(array, start, count, element_fun)
Signature: (array:'T [] * start:int64 * count:int64 * element_fun:Func<'T,'Tr>) -> 'Tr []
Type parameters: 'T, 'Tr |
Create a copy of specified length starting at the specified offset with the elements piped through a function. |
Map(...)
Signature: (array:'T [] * start:int64 * count:int64 * element_index_fun:Func<'T,int64,'Tr>) -> 'Tr []
Type parameters: 'T, 'Tr |
Create a copy of specified length starting at the specified offset with the elements piped through a function. The function gets the target index of the element as a second argument. |
Map2(array0, array1, item0_item1_fun)
Signature: (array0:'T0 [] * array1:'T1 [] * item0_item1_fun:Func<'T0,'T1,'Tr>) -> 'Tr []
Type parameters: 'T0, 'T1, 'Tr |
Create an array of reulting items by applying a supplied binary function to corresponding pairs of the supplied arrays. |
Map2(...)
Signature: (array0:'T0 [] * array1:'T1 [] * item0_item1_index_fun:Func<'T0,'T1,int64,'Tr>) -> 'Tr []
Type parameters: 'T0, 'T1, 'Tr |
|
Map3(...)
Signature: (array0:'T0 [] * array1:'T1 [] * array2:'T2 [] * item0_item1_item2_fun:Func<'T0,'T1,'T2,'Tr>) -> 'Tr []
Type parameters: 'T0, 'T1, 'T2, 'Tr |
Create an array of resulting items by applying a supplied ternary function to corresponding triples of the supplied arrays. |
Map3(...)
Signature: (array0:'T0 [] * array1:'T1 [] * array2:'T2 [] * item0_item1_item2_index_fun:Func<'T0,'T1,'T2,int64,'Tr>) -> 'Tr []
Type parameters: 'T0, 'T1, 'T2, 'Tr |
|
MapToList(array, element_fun)
Signature: (array:'T [] * element_fun:Func<'T,'Tr>) -> List<'Tr>
Type parameters: 'T, 'Tr |
|
MapToList(array, item_index_fun)
Signature: (array:'T [] * item_index_fun:Func<'T,int64,'Tr>) -> List<'Tr>
Type parameters: 'T, 'Tr |
|
Merge(array, left, right, comparer)
Signature: (array:'T [] * left:'T [] * right:'T [] * comparer:Func<'T,'T,int>) -> unit
Type parameters: 'T |
Merges two already sorted arrays. |
MergeSorted(a0, a1)
Signature: (a0:'T [] * a1:'T []) -> 'T []
Type parameters: 'T |
|
Move(self, sourceIndex, targetIndex)
Signature: (self:'T [] * sourceIndex:int64 * targetIndex:int64) -> unit
Type parameters: 'T |
Move an element from a given source index to a destination index, and shift all elements in between by one. |
ProductArray(...)
Signature: (array0:'T0 [] * array1:'T1 [] * item0_item1_productFun:Func<'T0,'T1,'TProduct>) -> 'TProduct []
Type parameters: 'T0, 'T1, 'TProduct |
|
ProductArray(...)
Signature: (array0:'T0 [] * array1:'T1 [] * count:int64 * item0_item1_productFun:Func<'T0,'T1,'TProduct>) -> 'TProduct []
Type parameters: 'T0, 'T1, 'TProduct |
|
ProductArray(...)
Signature: (array0:'T0 [] * array1:'T1 [] * item0_item1_index_productFun:Func<'T0,'T1,int64,'TProduct>) -> 'TProduct []
Type parameters: 'T0, 'T1, 'TProduct |
|
ProductArray(...)
Signature: (array0:'T0 [] * array1:'T1 [] * count:int64 * item0_item1_index_productFun:Func<'T0,'T1,int64,'TProduct>) -> 'TProduct []
Type parameters: 'T0, 'T1, 'TProduct |
|
Resized(array, newSize)
Signature: (array:'T [] * newSize:int) -> 'T []
Type parameters: 'T |
|
Resized(array, newSize)
Signature: (array:'T [] * newSize:int64) -> 'T []
Type parameters: 'T |
|
Resized(array, size)
Signature: (array:Array * size:int) -> Array
|
|
ReverseGroups(...)
Signature: (array:'T [] * groupFirstIndices:int [] * groupCount:int * reverseMap:Func<int,bool>) -> unit
Type parameters: 'T |
|
ReverseGroups(...)
Signature: (array:Array * groupArray:int [] * groupCount:int * reverseMap:Func<int,bool>) -> unit
|
|
ReverseRange(a, lo, hi)
Signature: (a:'T [] * lo:int64 * hi:int64) -> unit
Type parameters: 'T |
Reverse the order of elements in the supplied range [lo, hi[. |
Revert(array)
Signature: (array:'T []) -> unit
Type parameters: 'T |
|
ScanLeft(array, leftSum, sum_val_addFun)
Signature: (array:'TVal [] * leftSum:'TSum * sum_val_addFun:Func<'TSum,'TVal,'TSum>) -> 'TSum []
Type parameters: 'TVal, 'TSum |
Performs an aggregation of all elements in an array with the supplied aggregation function starting from the left and with the initial supplied left sum. All intermediate results are returned as an array with the same length as the original. |
ScanLeft(...)
Signature: (array:'TVal [] * leftSum:'TSum * sum_val_index_addFun:Func<'TSum,'TVal,int64,'TSum>) -> 'TSum []
Type parameters: 'TVal, 'TSum |
Performs an aggregation of all elements in an array with the supplied aggregation function starting from the left and with the initial supplied left sum. All intermediate results are returned as an array with the same length as the original. |
ScanLeft(...)
Signature: (array:'TVal [] * start:int64 * count:int64 * leftSum:'TSum * sum_val_addFun:Func<'TSum,'TVal,'TSum>) -> 'TSum []
Type parameters: 'TVal, 'TSum |
Performs an aggregation of the specified slice of elements in an array with the supplied aggregation function starting from the left and with the initial supplied left sum. All intermediate results are returned as an array with the given count as length. |
ScanLeft(...)
Signature: (array:'TVal [] * start:int64 * count:int64 * leftSum:'TSum * sum_val_index_addFun:Func<'TSum,'TVal,int64,'TSum>) -> 'TSum []
Type parameters: 'TVal, 'TSum |
Performs an aggregation of the specified slice of elements in an array with the supplied aggregation function starting from the left and with the initial supplied left sum. All intermediate results are returned as an array with the given count as length. |
ScanRight(...)
Signature: (array:'TVal [] * val_sum_addFun:Func<'TVal,'TSum,'TSum> * rightSum:'TSum) -> 'TSum []
Type parameters: 'TVal, 'TSum |
Performs an aggregation of all elements in an array with the supplied aggregation function starting from the right and with the initial supplied right sum. All intermediate results are returned as an array with the same length as the original. |
ScanRight(...)
Signature: (array:'TVal [] * val_index_sum_addFun:Func<'TVal,int64,'TSum,'TSum> * rightSum:'TSum) -> 'TSum []
Type parameters: 'TVal, 'TSum |
Performs an aggregation of all elements in an array with the supplied aggregation function starting from the right and with the initial supplied right sum. All intermediate results are returned as an array with the same length as the original. |
ScanRight(...)
Signature: (array:'TVal [] * start:int64 * count:int64 * val_sum_addFun:Func<'TVal,'TSum,'TSum> * rightSum:'TSum) -> 'TSum []
Type parameters: 'TVal, 'TSum |
Performs an aggregation of the specified slice of elements in an array with the supplied aggregation function starting from the right and with the initial supplied right sum. All intermediate results are returned as an array with the given count as length. |
ScanRight(...)
Signature: (array:'TVal [] * start:int64 * count:int64 * val_index_sum_addFun:Func<'TVal,int64,'TSum,'TSum> * rightSum:'TSum) -> 'TSum []
Type parameters: 'TVal, 'TSum |
Performs an aggregation of the specified slice of elements in an array with the supplied aggregation function starting from the right and with the initial supplied right sum. All intermediate results are returned as an array with the given count as length. |
Set(self, value)
Signature: (self:'T [] * value:'T) -> 'T []
Type parameters: 'T |
Set all elements to the same supplied value. |
Set(self, count, value)
Signature: (self:'T [] * count:int64 * value:'T) -> 'T []
Type parameters: 'T |
Set count elements to the same supplied value. |
Set(self, start, count, value)
Signature: (self:'T [] * start:int64 * count:int64 * value:'T) -> 'T []
Type parameters: 'T |
Set count elements starting at the supplied index to the same supplied value. |
Set(self, array)
Signature: (self:'T [] * array:'T []) -> 'T []
Type parameters: 'T |
Set all elements to the elements of the supplied array. |
Set(self, value)
Signature: (self:'T [,] * value:'T) -> 'T [,]
Type parameters: 'T |
Set all elements to the same supplied value. |
SetByIndex(self, index_fun)
Signature: (self:'T [] * index_fun:Func<int,'T>) -> 'T []
Type parameters: 'T |
Set all elements to a function of the element index. |
SetByIndex(self, count, index_fun)
Signature: (self:'T [] * count:int * index_fun:Func<int,'T>) -> 'T []
Type parameters: 'T |
Set count elements to a function of the element index. |
SetByIndex(...)
Signature: (self:'T [] * start:int * count:int * index_fun:Func<int,'T>) -> 'T []
Type parameters: 'T |
Set count elements starting at the supplied index to a function of the element index. |
SetByIndex(self, fun)
Signature: (self:'T [,] * fun:Func<int,int,'T>) -> 'T [,]
Type parameters: 'T |
Set all elements to a function of the element index. |
SetByIndex(self, fun)
Signature: (self:'T [,,] * fun:Func<int,int,int,'T>) -> 'T [,,]
Type parameters: 'T |
Set all elements to a function of the element index. |
SetByIndexLong(self, index_fun)
Signature: (self:'T [] * index_fun:Func<int64,'T>) -> 'T []
Type parameters: 'T |
Set all elements to a function of the element index. |
SetByIndexLong(self, count, index_fun)
Signature: (self:'T [] * count:int64 * index_fun:Func<int64,'T>) -> 'T []
Type parameters: 'T |
Set count elements to a function of the element index. |
SetByIndexLong(...)
Signature: (self:'T [] * start:int64 * count:int64 * index_fun:Func<int64,'T>) -> 'T []
Type parameters: 'T |
Set count elements starting at the supplied index to a function of the element index. |
SetByIndexLong(self, fun)
Signature: (self:'T [,] * fun:Func<int64,int64,'T>) -> 'T [,]
Type parameters: 'T |
Set all elements to a function of the element index. |
SetByIndexLong(self, fun)
Signature: (self:'T [,,] * fun:Func<int64,int64,int64,'T>) -> 'T [,,]
Type parameters: 'T |
Set all elements to a function of the element index. |
SetMap(array, array0, item0_fun)
Signature: (array:'T [] * array0:'T0 [] * item0_fun:Func<'T0,'T>) -> unit
Type parameters: 'T, 'T0 |
Sets the array items to a mapped version of the items of array0. |
SetMap2(...)
Signature: (array:'T [] * array0:'T0 [] * array1:'T1 [] * item0_item1_fun:Func<'T0,'T1,'T>) -> unit
Type parameters: 'T, 'T0, 'T1 |
Sets the array items to a mapped version of corresponding pairs of items of array0 and array1. |
SetMap3(...)
Signature: (array:'T [] * array0:'T0 [] * array1:'T1 [] * array2:'T2 [] * item0_item1_item2_fun:Func<'T0,'T1,'T2,'T>) -> unit
Type parameters: 'T, 'T0, 'T1, 'T2 |
Sets the array items to a mapped version of corresponding triples of items of array0, array1, and array2. |
SkipLast(array, count)
Signature: (array:'T [] * count:int64) -> IEnumerable<'T>
Type parameters: 'T |
Enumerate all but last elements of an array. The number of elements to omit is supplied as a parameter and defaults to 1. |
Swap(self, i, j)
Signature: (self:'T [] * i:int * j:int) -> unit
Type parameters: 'T |
Swap the two elements specified by their indices. |
Swap(self, i, j)
Signature: (self:'T [] * i:int64 * j:int64) -> unit
Type parameters: 'T |
Swap the two elements specified by their indices. |
Swap(array, i, j)
Signature: (array:Array * i:int64 * j:int64) -> unit
|
|
TakeFraction(array, fraction)
Signature: (array:'T [] * fraction:float) -> IEnumerable<'T>
Type parameters: 'T |
Enumerates the given fraction of the array elements from the beginning of the array. E.g. TakeFraction(0.1) would enumerate the first 1/10 of the array elements. Fraction must be in range [0.0, 1.0]. |
ToList(array, fun)
Signature: (array:'T [] * fun:Func<'T,'Tr>) -> List<'Tr>
Type parameters: 'T, 'Tr |
|
UnsafeCoerce(input)
Signature: input:Array -> 'TR []
Type parameters: 'TR |
Reinterprets an array as one of a different type Both types must be structs and you may cause memory leaks when the array-byte-sizes are not multiple of each other WARNING: destroys the original array |
UnsafeCoercedApply(input, action)
Signature: (input:Array * action:Action<'TR []>) -> unit
Type parameters: 'TR |
|
With(array, index, item)
Signature: (array:'T [] * index:int * item:'T) -> 'T []
Type parameters: 'T |
Returns a copy of the array with the specified item replaced. |
WithAdded(array, item)
Signature: (array:'T [] * item:'T) -> 'T []
Type parameters: 'T |
Synonym for WithAppended(). |
WithAppended(array, item)
Signature: (array:'T [] * item:'T) -> 'T []
Type parameters: 'T |
Returns a copy of the array with the specified item appended at the end. If the item is already contained in the array, the original array is returned. |
WithPrepended(array, item)
Signature: (array:'T [] * item:'T) -> 'T []
Type parameters: 'T |
Returns a copy of the array with the specified item prepended to the front. If the item is already contained in the array, the original array is returned. |
WithRemoved(array, item)
Signature: (array:'T [] * item:'T) -> 'T []
Type parameters: 'T |
Returns a copy of the item with the specified item removed. If the item is not contained in the array, the original array is returned. |
