FSharp.PowerPack
Lookup or set the given element in the table. Set replaces all existing bindings for a value with a single
bindings. Raise <c>KeyNotFoundException</c> if the element is not found.
Lookup or set the given element in the table. Set replaces all existing bindings for a value with a single
bindings. Raise <c>KeyNotFoundException</c> if the element is not found.
The total number of keys in the hash table
Lookup the given element in the table, returning the result as an Option
Replace the latest binding (if any) for the given element.
Remove the latest binding (if any) for the given element from the table
Apply the given function to each binding in the hash table
Apply the given function to each element in the collection threading the accumulating parameter
through the sequence of function applications
Find all bindings for the given element in the table, if any
Make a shallow copy of the collection
Test if the collection contains any bindings for the given element
Clear all elements from the collection
Add a binding for the element to the table
Build a map that contains the bindings of the given IEnumerable
Create a new empty mutable HashMultiMap with an internal bucket array of the given approximate size
and with the given key hash/equality functions
Create a new empty mutable HashMultiMap with the given key hash/equality functions
Hash tables, by default based on F# structural "hash" and (=) functions.
The table may map a single key to multiple bindings.
The total number of elements in the set
Remove the given element from the set
Apply the given function to each binding in the hash table
Apply the given function to the set threading the accumulating parameter
through the sequence of function applications
Make a shallow copy of the set
Test if the set contains the given element
Clear all elements from the set
Add an element to the collection
Create a new mutable hash set with the given elements and using the given key hash/equality functions
Create a new empty mutable hash set with an internal bucket array of the given approximate size
and with the given key hash/equality functions
Create a new empty mutable hash set using the given key hash/equality functions
Mutable hash sets based by default on F# structural "hash" and (=) functions. Implemented via a hash table and/or Dictionary.
LazyLists are possibly-infinite, cached sequences. See also IEnumerable/Seq for
uncached sequences. LazyLists normally involve delayed computations without
side-effects. The results of these computations are cached and evaluations will be
performed only once for each element of the lazy list. In contrast, for sequences
(IEnumerable) recomputation happens each time an enumerator is created and the sequence
traversed.
LazyLists can represent cached, potentially-infinite computations. Because they are
cached they may cause memory leaks if some active code or data structure maintains a
live reference to the head of an infinite or very large lazy list while iterating it,
or if a reference is maintained after the list is no longer required.
Lazy lists may be matched using the LazyList.Cons and LazyList.Nil active patterns.
These may force the computation of elements of the list.
Build a new collection from the given enumerable object
Return a view of the collection as an enumerable object
Build a non-lazy list from the given collection. This function will eagerly evaluate all of the
list (and thus may not terminate).
Build a collection from the given list. This function will eagerly evaluate all of the
list (and thus may not terminate).
Build an array from the given collection
Build a collection from the given array. This function will eagerly evaluate all of the
list (and thus may not terminate).
Build a new collection whose elements are the results of applying the given function
to the corresponding elements of the two collections pairwise.
Build a new collection whose elements are the results of applying the given function
to each of the elements of the collection.
Return a new list consisting of the results of applying the given accumulating function
to successive elements of the list
Apply the given function to each element of the collection.
Return a new collection which on consumption will consist of only the elements of the collection
for which the given predicate returns "true"
Return the list which contains on demand the list of elements of the list of lazy lists.
Return the list which contains on demand the pair of elements of the first and second list
Return the list which contains on demand the elements of the first list followed
by the elements of the second list
Return a list that contains the elements returned by the given computation.
The given computation is not executed until the first element on the list is
consumed. The given argument is passed to the computation. Subsequent elements
in the list are generated by again applying the residual 'b to the computation.
Return a list that is in effect the list returned by the given computation.
The given computation is not executed until the first element on the list is
consumed.
Return the list which on consumption will consist of an infinite sequence of
the given item
Return a new list which on consumption contains the given item
followed by the list returned by the given computation. The
Return a new list which contains the given item followed by the
given list.
Return the length of the list
Evaluates to the list that contains no items
Return the first element for which the given function returns <c>true</c>.
Raise <c>KeyNotFoundException</c> if no such element exists.
Apply the given function to successive elements of the list, returning the first
result where function returns <c>Some(x)</c> for some x. If the function never returns
true, 'None' is returned.
Return the list which on consumption will skip the first 'n' elements of
the input list.
Return the list which on consumption will consist of at most 'n' elements of
the input list.
Get the first cell of the list.
Return the list corresponding to the remaining items in the sequence.
Forces the evaluation of the first cell of the list if it is not already evaluated.
Return the first element of the list. Forces the evaluation of
the first cell of the list if it is not already evaluated.
Test if a list is empty. Forces the evaluation of
the first element of the stream if it is not already evaluated.
Split an array of pairs into two arrays
Combine the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an <c>ArgumentException</c> is
raised..
Return the index of the first element in the array
that satisfies the given predicate.
Return the index of the first element in the array
that satisfies the given predicate.
Return an array containing the given element
Like <c>foldBack</c>, but return both the intermediary and final results
Like <c>fold</c>, but return the intermediary and final results
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.
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.
Return true if the given array is empty, otherwise false
Test elements of the two arrays pairwise to see if all pairs of elements satisfy the given predicate.
Raise ArgumentException if the arrays have different lengths.
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.
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.
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.
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.
Return the index of the first element in the array
that satisfies the given predicate. Raise <c>KeyNotFoundException</c> if
none of the elements satisfy the predicate.
Return the index of the first element in the array
that satisfies the given predicate. Raise <c>KeyNotFoundException</c> if
none of the elements satisfy the predicate.
Test elements of the two arrays pairwise to see if any pair of element satisfies the given predicate.
Raise ArgumentException if the arrays have different lengths.
Return a view of the array as an enumerable object
Build a ResizeArray from the given elements
Return a fixed-length array containing the elements of the input ResizeArray
Sort the elements using the key extractor and generic comparison on the keys
Sort the elements using the given comparison function
Return a new array with the elements in reverse order
Split a list of pairs into two lists
Combine the two arrays into an array of pairs. The two arrays must have equal lengths.
Apply the given function to successive elements, returning the first
result where function returns "Some(x)" for some x.
Return the first element for which the given function returns <c>true</c>.
Return None if no such element exists.
Return the first element for which the given function returns <c>true</c>.
Raise <c>KeyNotFoundException</c> if no such element exists.
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)
Split the collection into two collections, containing the
elements for which the given predicate returns <c>true</c> and <c>false</c>
respectively
Return a new collection containing only the elements of the collection
for which the given predicate returns <c>true</c>
Test if all elements of the array satisfy the given predicate.
If the input function is <c>f</c> and the elements are <c>i0...iN</c> and "j0...jN"
then computes <c>p i0 && ... && p iN</c>.
Test if any element of the array satisfies the given predicate.
If the input function is <c>f</c> and the elements are <c>i0...iN</c>
then computes <c>p i0 or ... or p iN</c>.
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.
Apply the given function to each element of the array. The integer passed to the
function indicates the index of element.
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.
Apply the given function to two arrays simultaneously. The
two arrays must have the same lengths, otherwise an Invalid_argument exception is
raised.
Build a new array whose elements are the results of applying the given function
to each of the elements of the array.
Apply the given function to each element of the array.
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>.
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>
Build and array from the given seq
Build an array from the given list
Build a list from the given array
Read a range of elements from the first array and write them into the second.
Fill a range of the collection with the given element
Build a new array that contains the elements of the given array
Build a new array that contains the given subrange specified by
starting index and length.
Build a new array that contains the elements of each of the given list of arrays
Build a new array that contains the elements of the first array followed by the elements of the second array
Create an array by calling the given generator on each index.
Create an array whose elements are all initially the given value.
Set the value of an element in the collection. You can also use the syntax <c>arr.[idx] <- e</c>.
Fetch an element from the collection. You can also use the syntax <c>arr.[idx]</c>.
Return the length of the collection. You can also use property <c>arr.Length</c>.
Generic operations on the type System.Collections.Generic.List, which is called ResizeArray in the F# libraries.
Lookup or set the given element in the table. Raise <c>KeyNotFoundException</c> if the element is not found.
Lookup or set the given element in the table. Raise <c>KeyNotFoundException</c> if the element is not found.
The number of bindings in the hash table
Lookup the given element in the table, returning the result as an Option
Replace the latest binding (if any) for the given element.
Remove the latest binding (if any) for the given element from the table
Apply the given function to each binding in the hash table
Apply the given function to each element in the collection threading the accumulating parameter
through the sequence of function applications
Find all bindings for the given element in the table, if any
Create a new empty mutable hash table with an internal bucket array of the given approximate size
and with the given key hash/equality functions
Make a shallow copy of the collection
Test if the collection contains any bindings for the given element
Test if the collection contains any bindings for the given element
Clear all elements from the collection
Add a binding for the element to the table
HashMultiMap, but where a constraint tag tracks information about the hash/equality functions used
for the hashing. When the tag is Tags.StructuralHash this is identical to HashMultiMap.
The number of elements in the set
Remove the given element from the set
Apply the given function to each binding in the hash table
Apply the given function to the set threading the accumulating parameter
through the sequence of function applications
Create a new empty mutable hash set with an internal bucket array of the given approximate size
and with the given key hash/equality functions
Make a shallow copy of the set
Test if the set contains the given element
Clear all elements from the set
Add an element to the collection
Mutable hash sets where a constraint tag tracks information about the hash/equality functions used
for the hashing. When the tag is Tags.StructuralHash this is identical to HashSet.
Lookup an element in the map. Raise <c>KeyNotFoundException</c> if no binding
exists in the map.
Gets a value indicating whether there are no bindings in the map.
The number of bindings in the map
Gets the comparer used for the map.
Lookup an element in the map, returning a <c>Some</c> value if the element is in the domain
of the map and <c>None</c> if not.
The elements of the set as a list.
The elements of the set as an array
Remove an element from the domain of the map. No exception is raised if the element is not present.
Build two new maps, one containing the bindings for which the given predicate returns 'true',
and the other the remaining bindings.
Build a new collection whose elements are the results of applying the given function
to each of the elements of the collection.
Build a new collection whose elements are the results of applying the given function
to each of the elements of the collection. The index passed to the
function indicates the index of element being transformed.
Apply the given function to each binding in the dictionary
Return true if the given predicate returns true for all of the
bindings in the map. Always returns true if the map is empty.
Given the start and end points of a key range,
Fold over the bindings in the map that are in the range,
and the end points are included if present (the range is considered a closed interval).
Fold over the bindings in the map.
Fold over the bindings in the map.
Search the map looking for the first element where the given function returns a <c>Some</c> value
Build a new map containing the bindings for which the given predicate returns 'true'.
Return true if the given predicate returns true for one of the
bindings in the map. Always returns false if the map is empty.
The empty map, and use the given comparer comparison function for all operations associated
with any maps built from this map.
Build a map that contains the bindings of the given IEnumerable
and where comparison of elements is based on the given comparison function
Test is an element is in the domain of the map
Return a new map with the binding added to the given map.
Immutable maps. Keys are ordered by construction function specified
when creating empty maps or by F# structural comparison if no
construction function is specified.
<performance>
Maps based on structural comparison are
efficient for small keys. They are not a suitable choice if keys are recursive data structures
or require non-structural comparison semantics.
</performance>
Immutable maps. A constraint tag carries information about the class of key-comparers being used.
Return a new set with the elements of the second set removed from the first.
Compute the union of the two sets.
Returns the lowest element in the set according to the ordering being used for the set
Returns the highest element in the set according to the ordering being used for the set
A useful shortcut for Set.isEmpty. See the Set module for further operations on sets.
Return the number of elements in the set
Gets the comparer used for the set.
The number of elements in the set
Compute the union of the two sets.
The elements of the set as a list.
The elements of the set as an array.
A singleton set based on the given comparison operator
A useful shortcut for Set.remove. Note this operation produces a new set
and does not mutate the original set. The new set will share many storage
nodes with the original. See the Set module for further operations on sets.
Build two new sets, one containing the elements for which the given predicate returns 'true',
and the other the remaining elements.
Apply the given function to each binding in the collection
Evaluates to "true" if all elements of the first set are in the second
Evaluates to "true" if all elements of the second set are in the first
Compute the intersection of the two sets.
Test if all elements of the collection satisfy the given predicate.
If the input function is <c>f</c> and the elements are <c>i0...iN</c> and <c>j0...jN</c> then
computes <c>p i0 && ... && p iN</c>.
Apply the given accumulating function to all the elements of the set
Return a new collection containing only the elements of the collection
for which the given predicate returns "true"
Test if any element of the collection satisfies the given predicate.
If the input function is <c>f</c> and the elements are <c>i0...iN</c> then computes
<c>p i0 or ... or p iN</c>.
Compares two sets and returns true if they are equal or false otherwise
The empty set based on the given comparer
Return a new set with the elements of the second set removed from the first.
A set based on the given comparer containing the given initial elements
A useful shortcut for Set.contains. See the Set module for further operations on sets.
Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b
A useful shortcut for Set.add. Note this operation prodcues a new set
and does not mutate the original set. The new set will share many storage
nodes with the original. See the Set module for further operations on sets.
Immutable sets based on binary trees, default tag
Immutable sets where a constraint tag carries information about the class of key-comparer being used.
Wait for the result and commit it
Record the result in the AsyncResultCell. Subsequent sets of the result are ignored.
This may result in the scheduled resumption of a waiting asynchronous operation
Create a new result cell
A helper type to store a single result from an asynchronous computation and asynchronously
access its result.
Create an async whose result depends on the value of an AsyncResult.
Represents the reified result of an asynchronous computation
An async that produces true if the reader is at the end of stream and false otherwise
Note that when the async is run it reflects the reader state at the time of running; multiple runs will
yield different results.
Creates an async that read all characters in the stream up to the end.
Note that when the async is run it reflects the reader state at the time of running; multiple runs will
yield different results.
Creates an async that reads next line from the stream
Note that when the async is run it reflects the reader state at the time of running; multiple runs will
yield different results.
Creates an async that reads exactly <c>count</c> characters from the stream unless end of stream is reached and puts them
into <c>buffer</c> starting at <c>index</c>. The async returns the number of characters that are read (if end-of-stream is not reached
that will be <c>count</c>
Note that when the async is run it reflects the reader state at the time of running; multiple runs will
yield different results.
Creates an async that reads all the charactes that are avilable in the stream up to <c>count</c characters and puts them
into <c>buffer</c> starting at <c>index</c>. The async returns the number of characters that are read.
Note that when the async is run it reflects the reader state at the time of running; multiple runs will
yield different results.
Creates an async that reads next character from the stream
Note that when the async is run it reflects the reader state at the time of running; multiple runs will
yield different results.
Creates an async that produces next character from the stream without advancing the stream
Note that when the async is run it reflects the reader state at the time of running; multiple runs will
yield different results.
. DiscardBufferedData tells StreamReader to throw away its internal
. buffer contents. This is useful if the user needs to seek on the
underlying stream to a known location then wants the StreamReader
to start reading from this new point. This method should be called
very sparingly, if ever, since it can lead to very poor performance.
However, it may be the only way of handling some scenarios where
users need to re-read the contents of a StreamReader a second time.
Creates a new AsyncStreamReader for the given stream. The
character encoding is set by encoding and the buffer size,
in number of 16-bit characters, is set by bufferSize.
Note that detectEncodingFromByteOrderMarks is a very
loose attempt at detecting the encoding by looking at the first
3 bytes of the stream. It will recognize UTF-8, little endian
unicode, and big endian unicode text, but that's it. If neither
of those three match, it will use the Encoding you provided.
Implements a TextReader-like API that asynchronously reads characters from
a byte stream in a particular encoding.
Create an async that opens a <c>System.IO.FileStream</c> on the specified path, via a fresh I/O thread.
Pass <c>options=FileOptions.Asynchronous</c> to enable further asynchronous read/write operations
on the FileStream.
Create an async that returns a <c>System.IO.StreamWriter</c> that appends UTF-8 text to an existing file, via a fresh I/O thread.
Create an async that opens an existing file writing, via a fresh I/O thread.
Create an async that opens a <c>System.IO.FileStream</c> on the specified path for read/write access, via a fresh I/O thread.
Create an async that opens an existing file for reading, via a fresh I/O thread.
Return an asynchronous computation that will read to the end of a stream via a fresh I/O thread.
See Lazy.Force
Return the given rational number
Return the negation of a rational number
Return the difference of two rational numbers
Return the product of two rational numbers
This operator is for use from other .NET languages
This operator is for use from other .NET languages
This operator is for use from other .NET languages
This operator is for use from other .NET languages
This operator is for use from other .NET languages
Return the result of converting the given rational number to an integer
Return the result of converting the given rational number to a big integer
Return the result of converting the given rational number to a floating point number
This operator is for use from other .NET languages
Return the ratio of two rational numbers
Return the sum of two rational numbers
Get zero as a rational number
Return the sign of a rational number; 0, +1 or -1
Get one as a rational number
Return the numerator of the normalized rational number
Return a boolean indicating if this rational number is strictly positive
Return a boolean indicating if this rational number is strictly negative
Return the denominator of the normalized rational number
Return the result of converting the given rational number to an integer
Return the result of converting the given rational number to a floating point number
Return the result of converting the given rational number to a big integer
Return the result of raising the given rational number to the given power
Return the result of converting the string to a rational number
Return the result of converting the given integer to a rational number
Return the result of converting the given big integer to a rational number
Return the absolute value of a rational number
The type of arbitrary-sized rational numbers
Unary negation of a complex number
Subtract one complex number from another
Multiply a complex number by a scalar
Multiply a scalar by a complex number
Multiply two complex numbers
Complex division of two complex numbers
Add two complex numbers
The real part of a complex number
The imaginary part of a complex number
The complex number 0+0i
The real part of a complex number
The polar-coordinate phase of a complex number
The complex number 0+1i
The complex number 1+0i
The polar-coordinate magnitude of a complex number
The imaginary part of a complex number
The conjugate of a complex number, i.e. x-yi
Create a complex number using magnitude/phase polar coordinates
Create a complex number x+ij using rectangular coordinates
Computes the absolute value of a complex number: e.g. Abs x+iy = sqrt(x**2.0 + y**2.0.)
Note: Complex.Abs(z) is the same as z.Magnitude
The type of complex numbers stored as pairs of 64-bit floating point numbers in rectangular coordinates
Get the item at the given position in a matrix
Prefix '+' operator. A nop.
Matrix negation.
Point-wise subtraction of two matrices. An InvalidArgument exception will be
raised if the dimensions do not match.
Multiply each element of a matrix by a scalar value
Multiply each element of a matrix by the given scalar value
Matrix-vector multiplication.
Matrix multiplication. An InvalidArgument exception will be
raised if the dimensions do not match.
Point-wise matrix multiplication. An InvalidArgument exception will be
raised if the dimensions do not match.
Point-wise addition of two matrices. An InvalidArgument exception will be
raised if the dimensions do not match.
Get the transpose of a matrix.
Get the number of rows in a matrix
Get the number of columns in a matrix
Returns sqrt(sum(norm(x)*(norm(x))) of all the elements of a matrix.
The element type of a matrix must have an associated instance of INormFloat<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)).
Return the non-zero entries of a sparse or dense matrix
Get the item at the given position in a matrix
Indicates if a matrix uses the sparse representation.
Indicates if a matrix uses the dense representation.
Get the internal array of values for a sparse matrix. This property
should only be used when interoperating with other matrix libraries.
Get the internal array of row offsets for a sparse matrix. This property
should only be used when interoperating with other matrix libraries.
Get the internal array of column values for a sparse matrix. This property
should only be used when interoperating with other matrix libraries.
Get the internal array of values for a dense matrix. This property
should only be used when interoperating with other matrix libraries.
Retrieve the dictionary of numeric operations associated with the element
type of this matrix. Accessing the property may raise an NotSupportedException if the element
type doesn't support any numeric operations. The object returned
may support additional numeric operations such as IFractional:
this can be determined by a dynamic type test against the object
returned.
Get the number of (rows,columns) in a matrix
Get the main diagonal of a matrix, as a vector
Convert a matrix to a column vector
Convert a matrix to a row vector
Return a new array containing the elements of a matrix
Supports the slicing syntax 'A.[idx1..idx2,idx1..idx2] <- B'
Select a range of rows from a matrix
Select a row from a matrix
Select a region from a matrix
Permutes the rows of a matrix.
Permutes the columns of a matrix.
Supports the slicing syntax 'A.[idx1..idx2,idx1..idx2]'
Return the nth diagonal of a matrix, as a vector. Diagonal 0 is the primary
diagonal, positive diagonals are further to the upper-right of a matrix.
Create a new matrix that is a copy of an array
Select a range of columns from a matrix
Select a column from a matrix
The type of matrices. The arithmetic operations on the element type are determined by inspection on the element type itself.
Two representations are supported: sparse and dense.
A permutation of a finite range of integers 0 .. N-1, represented by a mapping of index positions
Return a row vector, unchanged
Point-wise negation of a row vector
Point-wise subtraction of two row vectors
Multiply a scalar by a row vector
Multiply a row vector by a scalar
Multiply a row vector by a matrix
Multiply a row vector by a vector
Point-wise multiplication of two row vectors
Point-wise addition of two row vectors
Get the transpose of the row vector.
Get the underlying internal array of values for a vector. This property
should only be used when interoperating with other matrix libraries.
Return a new array containing a copy of the elements of a vector
Supports the slicing syntax 'rv.[idx1..idx2] <- rv2'
Permute the elements of the row vector.
Supports the slicing syntax 'rv.[idx1..idx2]'
Create a new matrix that is a copy of a array
The type of row vectors.
Gets an item from a vector
Return the input vector
Negate a vector
Subtract two vectors, pointwise
Multiply a vector by a scalar
Multiply a column vector and a row vector to produce a matrix
Multiply each element of a vector by a scalar value.
Point-wise multiplication of two vectors.
Add two vectors, pointwise
Get the transpose of a vector.
Gets the number of rows in a vector
Computes the 2-norm of a vector: sqrt(x.Transpose*x).
Gets the number of entries in a vector
Gets an item from a vector
Get the underlying internal array of values for a vector. This property
should only be used when interoperating with other matrix libraries.
Gets the element operations for the element type of a vector, if any
Return a new array containing a copy of the elements of a vector
Supports the slicing syntax 'v.[idx1..idx2] <- v2'
Permute the elements of a vector.
Supports the slicing syntax 'v.[idx1..idx2]'
Create a new matrix that is a copy of a array
The type of column vectors. The arithmetic operations on the element type are determined by inspection
on the element type itself
The type of complex numbers
The type of floating point matrices
The type of floating point row vectors
The type of floating point column vectors
Tagent
Cosine
Sine
sqrt(x) and 0 <= phase(x) < pi
log(x) is natural log (base e)
exp(x) = e^x
pi
Multiply a complex number by a scalar
Multiply a scalar by a complex number
Unary negation of a complex number
Complex division of two complex numbers
Multiply two complex numbers
Subtract one complex number from another
Add two complex numbers
The complex number 0+1i
The complex number 1+0i
The complex number 0+0i
The conjugate of a complex number, i.e. x-yi
A complex of magnitude 1 and the given phase and , i.e. cis x = mkPolar 1.0 x
Create a complex number using magnitude/phase polar coordinates
The imaginary part of a complex number
The real part of a complex number
The polar-coordinate phase of a complex number
The polar-coordinate magnitude of a complex number
Constructs a complex number from both the real and imaginary part.
Record an AppDomain-wide association between the given type and the given dictionary of
numeric operations. Raise an error if an existing association already exists.
Attempt to determine a numeric association for the given type, i.e. a registered dictionary of
numeric operations. The interface can be queried dynamically for additional functionality in the numerics
hierarchy.
Associations are a way of associating dictionaries of
operations with given types at runtime. Associations are global to a
.NET application domain. Once specified an association may not be deleted
or modified.
In this release the system of associations is simply
limited to a registry of types that support dictionaries (i.e. interface objects)
of numeric operations. The following types are pre-registered with associated numeric
operations: float, int32, int64, bigint, float32, Complex, bignum. Other types must be
registered explicitly by user code.
In-place subtraction, mutating the first matrix argument.
In-place addition, mutating the first matrix argument.
Create a new matrix that is a copy of the given array
Map the given indexed function over each element of a matrix, producing a new matrix
Map a function over each element of a matrix, producing a new matrix
Fold a function down a particular row of a matrix
Fold a function along a particular column of a matrix
Fold a function along each row of a matrix
Fold a function down each column of a matrix
Fold an indexed function over all elements of a matrix
Fold a function over all elements of a matrix
Check if a predicate holds for at least one element of a matrix
Check if a predicate holds for all elements of a matrix
Check if a predicate holds for at least one element of a matrix
Check if a predicate holds for all elements of a matrix
sqrt(sum(x*x)) of all the elements of a matrix
Multiply all the elements of a matrix
Sum all the elements of a matrix
Generate a new matrix of the same size as the input with random entries
drawn from the range 0..aij. Random numbers are generated using a globally
shared System.Random instance with the initial seed 99.
Sum of the diagonal elements of a matrix
Transpose of a matrix. Use also m.Transpose
Point-wise exponential of a matrix.
Dot product
Add two matrices (operator +)
Point-wise minimum element of two matrices
Point-wise maximum element of two matrices
Ensure that a matrix uses dense representation
Return the first column of a matrix
Return the first row of a matrix
Return the element at row 0, column 0 of a matrix
Create a matrix with one column from the given vector
Create a matrix with one row from the given row vector
Create a 1x1 matrix containing the given value
Return a new array containing the elements of the given matrix
Create a matrix from the given data
Create a matrix from the given data
Create a matrix from the given data
Create a square matrix with a vector lying on diagonal
Create a square matrix with the constant 1.0 lying on diagonal
Create a matrix with all entries zero
Create a sparse representation matrix with the given entries. Not all
operations are available for sparse matrices, and mutation is not permitted.
If an operation on sparse matrices raises a runtime exception then consider
converting to a dense matrix using to_dense.
Create a dense representation matrix with the given entries.
Create a matrix with all entries the given constant
Set an element of a matrix
Get an element of a matrix
Subtract the second matrix from the first, by mutating the first
Add the second matrix to the first by, mutating the first
Map the given position-indexed function over a matrix
Map a function over a matrix
Create a new matrix that is a copy of the given array
Return true if an indexed predicate returns true for some value in a matrix
Return true if an indexed predicate returns true for all values in a matrix
Return true if a predicate returns true for some value in a matrix
Return true if a predicate returns true for all values in a matrix
Fold an indexed function over all elements of a matrix
Fold a function over all elements of a matrix
Returns sqrt(sum(norm(x)*(norm(x))) of all the elements of a matrix.
The element type of a matrix must have an associated instance of INormFloat<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)).
Compute the product of the elements in a matrix
Compute the sum of the elements in a matrix
Compute the sum of the diagonal of a square matrix
Return a new matrix which is the transpose of the input matrix
Sum of the point-wise multiple of the two matrices.
The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)).
Take the pointwise maximum of two matrices
Take the pointwise maximum of two matrices
Create a matrix containing the given vector along the diagonal.
The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)).
Create a square matrix with the one for the element type lying on diagonal
The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)).
Create a matrix containing the zero element at each index.
The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)).
Create a matrix using a function to compute the item at each index.
The element type of a matrix must have an associated instance of INumeric<'T> (see <c>GlobalAssociations</c>) ((else NotSupportedException)).
The function is passed the dictionary of associated operations in addition to the index pair.
Create a matrix using a function to compute the item at each index.
Extract the first column of a matrix
Extract the first row of a matrix
Get the element at column zero, row zero
Create a matrix from a column vector
Create a matrix from a row vector
Create a 1x1 matrix containing the given value
Create a sparse matrix from the given sequence of elements
Create a dense matrix from the given sequence of elements
Create a matrix containing the given value at every element.
Return a new array containing the elements of the given matrix
Create a matrix from the given data
Create a matrix from the given data
Create a matrix from the given data
Set an element in a matrix. The indexes are given in row/column order.
Get an element from a matrix. The indexes are given in row/column order.
Operations to manipulate matrix types carrying
arbitrary element types. The names and types of the operations match those
in the containing module Math.Matrix.
The numeric operations on the element type (add, zero etc.) are inferred from the type
argument itself. That is, for some operations
the element type of a matrix must have an associated instance of INumeric<'T>
or some more specific numeric association (see <c>GlobalAssociations</c>) ((else NotSupportedException)).
Operations to manipulate floating
point matrices. The submodule <c>Matrix.Generic</c> contains a
matching set of operations to manipulate matrix types carrying
arbitrary element types.
Builds a (row) vector from a sequence of floats.
Builds a (column) vector from a sequence of floats.
Builds a matrix from a sequence of sequence of floats.
Version of System.Single.NaN that is generic in its units-of-measure
Version of System.Single.PositiveInfinity that is generic in its units-of-measure
Version of System.Double.NaN that is generic in its units-of-measure
Version of System.Double.PositiveInfinity that is generic in its units-of-measure
The identity permutation over any size
Return a permutation that rotates right by the given distance. If the distance
is negative then a left rotation results.
Return a permutation that, when applied, maps index 0 to size-1, size-1 to 0 etc.
Return a swaps the given two elements over any size
Create a permutation by specifying (source,destination) index pairs. For example,
Permutation(3,[ (0,2);(1,0); (2,1) ]) specifies a permutation that rotates
all elements left one place. Not all elements need be given, e.g.
Permutation(5,[ (1,2);(2,1) |]) specifies a permutation that swaps elements at indexes
1 and 2.
Create a permutation by specifying the result of permuting [| 0 .. n-1 |]. For example,
Permutation.ofArray [| 1;2;0 |] specifies a permutation that rotates all elements right one place.
Unified atomic mass unit
Electron volt
Stefan-Boltzmann constant
Boltzmann constant R/N_A
Molar gas constant
Faraday constant
Avogadro constant
Rydberg constant
Fine-structure constant
Proton mass
Electron mass
Conductance quantum 2e^2/h
Magnetic flux quantum h/2e
Elementary charge
Dirac constant, also known as the reduced Planck constant = h/2pi
Planck constant
Newtonian constant of gravitation
electric constant = 1/(mu0 c^2)
magnetic constant
speed of light in vacuum
Fundamental physical constants, with units-of-measure
Return a new array containing a copy of the elements of the given vector
Create a vector from an array of double precision floats
Create a vector from a sequence of numbers
Create a vector from a list of numbers
Return a vector of the given length where every entry is zero.
Create by comprehension
Create by constant initialization
Get the dimensions (number of rows) of a column rowvec.
Set an element of a column rowvec
Get an element of a column vector
Return a new array containing a copy of the elements of the given vector
Create a row vector from an array of elements
Create a row vector from a sequence of elements
Create a row vector from a list of elements
Return a vector of the given length where every entry is zero.
Create by constant initialization
Create by comprehension
Transpose the row vector
Get the number of rows in a column vector.
Set an element in a column vector.
Get an element from a column vector.
Operations to manipulate row vectors types carrying
arbitrary element types.
Operations to manipulate floating
point row vectors. These are included for completeness and are
nearly always transposed to column vectors.
Map an indexed function over each element of a vector
Map a function over each element of a vector
Copy a vector
Fold an indexed function over all elements of a vector
Fold a function over all elements of a vector
Return true if an indexed predicate returns true for some value in a vector
Return true if an indexed predicate returns true for all values in a vector
Return true if a predicate returns true for some value in a vector
Return true if a predicate returns true for all values in a vector
Computes the 2-norm of a vector: sqrt(x.Transpose*x).
Multiply all the elements of a matrix
Sum all the elements of a vector
Transpose of a matrix. Use also m.Transpose
Point-wise exponential of a vector.
Dot product
Create a vector that represents a integral mesh over the given range
e.g. range 1 5 = vector [ 1.;2.;3.;4.;5. ]
Create a vector that represents a mesh over the given range
e.g. rangef (-1.0) 0.5 1.0 = vector [ -1.0; -0.5; 0.0; 0.5; 1.0]
Return a vector of the given length where every entry is zero.
Generate a vector of the given length where each entry contains the given value
Create a 1-element vector
Return a new array containing a copy of the elements of the given vector
Create a vector from an array of double precision floats
Create a vector from a sequence of numbers
Create a vector from a list of numbers
Create a vector of a fixed length using a function to compute the initial element values
Get the dimensions (number of rows) of a column vector. Identical to <c>nrows</c>
Set an element of a column vector
Get an element of a column vector
Map an indexed function over each element of a vector
Map a function over each element of a vector
Copy the vector
Fold an indexed function over all elements of a vector
Fold a function over all elements of a vector
Return true if an indexed predicate returns true for some value in a vector
Return true if an indexed predicate returns true for all values in a vector
Return true if a predicate returns true for some value in a vector
Return true if a predicate returns true for all values in a vector
Computes the 2-norm of a vector: sqrt(x.Transpose*x).
Multiply all the elements of a matrix
Sum all the elements of a vector
Dot product
Take the pointwise minimum of two vectors
Take the pointwise maximum of two vectors
Return a vector of the given length where every entry is zero.
Generate a vector of the given length where each entry contains the given value
Return a new array containing a copy of the elements of the given vector
Create a vector from an array of elements
Create a 1-element vector
Create a vector from a sequence of numbers
Create a vector from a list of numbers
Creation: useful when the element type has associated operations.
Creation: general
Get the dimensions (number of rows) of a column vector. Identical to <c>nrows</c>
Set an element of a column vector
Get an element of a column vector
Operations to manipulate column vectors carrying
arbitrary element types.
Operations to manipulate floating
point column vectors. The submodule VectorOps.Generic contains a
matching set of operations to manipulate column vectors carrying
arbitrary element types.
See NativeArray2
Get or set an entry in the array
View a FortranMatrix as a CMatrix. Doesn't actually allocate
a new matirx - just gives a different label to the same bits, and swaps the
row/column count information associated with the bits.
Get or set an entry in the array
This type wraps a pointer to a blob of unmanaged memory assumed to contain
a Fortran-style column major two-dimensional matrix of items compatible with the (presumably blittable)
type 'T. The blob of memory must be allocated and managed externally,
e.g. by a computation routine written in C.
All operations on this type are marked inlined
because the code used to implement the operations is not verifiable.
Any code that uses these operations will be unverifiable and may
cause memory corruption if not used with extreme care.
Get or set an entry in the array
Pointer to the C-style row major two-dimensional array
Get the number of rows of the native array
Get the number of columns of the native array
View a CMatrix as a FortranMatrix. Doesn't actually allocate
a new matirx - just gives a different label to the same bits, and swaps the
row/column count information associated with the bits.
Get or set an entry in the array
Creates a C-style row major two-dimensional array from a native pointer, the number of rows and the number of columns.
Nothing is actually copied.
This type wraps a pointer to a blob of unmanaged memory assumed to contain
a C-style row major two-dimensional matrix of items compatible with the (presumably blittable)
type 'T. The blob of memory must be allocated and managed externally,
e.g. by a computation routine written in C.
All operations on this type are marked inlined
because the code used to implement the operations is not verifiable.
Any code that uses these operations will be unverifiable and may
cause memory corruption if not used with extreme care.
Get or set an entry in the array
Pointer to the C-style one-dimensional array
Length of the C-style one-dimensional array
Get or set an entry in the array
Creates a C-style one dimensional array from a native pointer and the length of the array
Nothing is actually copied.
This type wraps a pointer to a blob of unmanaged memory assumed to contain
a C-style one-dimensional array of items compatible with the (presumably blittable)
type 'T. The blob of memory must be allocated and managed externally,
e.g. by a computation routine written in C.
All operations on this type are marked inlined
because the code used to implement the operations is not verifiable.
Any code that uses these operations will be unverifiable and may
cause memory corruption if not used with extreme care.
For native interop. Pin the given object
For native interop. Pin the given object
Represents a pinned handle to a structure with an underlying 2D array, i.e. an underlying NativeArray2.
Used when interfacing with native code math libraries such as LAPACK.
For native interop. Pin the given object
Represents a pinned handle to a structure with an underlying 1D array, i.e. an underlying NativeArray.
Used when interfacing with native code math libraries such as LAPACK.
For native interop. Pin the given object
For native interop. Pin the given object
For native interop. Pin the given object
Pin the given ref for the duration of a single call to the given function. A native pointer to
the contents of the ref is passed to the given function. Cleanup the GCHandle associated with the
pin when the function completes, even if an exception is raised.
Return the name of the argument
Return the usage help associated with the argument
Return the argument type and action of the argument
Prints the help for each argument.
Parse some of the arguments given by 'argv', starting at the given position
Parse the arguments given by System.Environment.GetEnvironmentVariables()
according to the argument processing specifications "specs".
Args begin with "-". Non-arguments are passed to "f" in
order. "use" is printed as part of the usage line if an error occurs.
The spec value describes the action of the argument,
and whether it expects a following parameter.
Interpret tables for a unicode lexer generated by fslex.
Interpret tables for a unicode lexer generated by fslex, processing input asynchronously
The type of tables for an unicode lexer generated by fslex.
Interpret tables for an ascii lexer generated by fslex.
Interpret tables for an ascii lexer generated by fslex, processing input asynchronously
The type of tables for an ascii lexer generated by fslex.
The start position for the lexeme
True if the refill of the buffer ever failed , or if explicitly set to true.
The end position for the lexeme
The start position for the lexeme
The length of the matched string
The matched string
True if the refill of the buffer ever failed , or if explicitly set to true.
The end position for the lexeme
Dynamically typed, non-lexically scoped parameter table
Fast helper to turn the matched characters into a string, avoiding an intermediate array
Fetch a particular character in the matched string
Create a lex buffer suitable for use with a Unicode lexer that reads character inputs from the given text reader
Create a lex buffer suitable for Unicode lexing that reads characters from the given string
Create a lex buffer that reads character or byte inputs by using the given function
Create a lex buffer suitable for Unicode lexing that reads characters from the given array
Create a lex buffer suitable for byte lexing that reads characters from the given array
Create a lex buffer suitable for use with ASCII byte lexing that reads byte inputs from the given binary reader
Create a lex buffer that asynchronously reads character or byte inputs by using the given function
Remove all input, though don't discard the current lexeme
Input buffers consumed by lexers generated by <c>fslex.exe </c>
The absolute offset of the column for the position
The absolute offset of the beginning of the line
The line number for the position
The file name for the position
Return absolute offset of the start of the line marked by the position
The line number in the input stream, assuming fresh positions have been updated
using AsNewLinePos() and by modifying the EndPos property of the LexBuffer.
The file name associated with the input stream.
Get an arbitrary position, with the empty string as filename, and
Return the column number marked by the position, i.e. the difference between the AbsoluteOffset and the StartOfLineAbsoluteOffset
The character number in the input stream
Gives a position shifted by specified number of characters
Get a position corresponding to the first line (line number 1) in a given file
Given a position at the start of a token of length n, return a position just beyond the end of the token
Position information stored for lexing tokens
Indicates a parse error has occured and parse recovery is in progress
Indicates an accept action has occured
The tag of the error terminal
The total number of terminals
This function is used to hold the user specified "parse_error" or "parse_error_rich" functions
This table is logically part of the Goto table
The sparse table offsets for the productions active for each state
The sparse table for the productions active for each state
The sparse goto table row offsets
The sparse goto table
The immediate action table
The number of symbols for each reduction
The sparse action table row offsets
The sparse action table elements
A function to compute the data carried by a token
A function to compute the tag of a token
The token number indicating the end of input
The reduction table
Interpret the parser table taking input from the given lexer, using the given lex buffer, and the given start state.
Returns an object indicating the final synthesized value for the parse.
Tables generated by fsyacc
The type of the tables contained in a file produced by the fsyacc.exe parser generator.
The stack of state indexes active at the parse error
The token that would cause a shift at the parse error
The stack of productions that would be reduced at the parse error
The tokens that would cause a reduction at the parse error
The state active at the parse error
The message associated with the parse error
The token that caused the parse error
The context provided when a parse error occurs
Get the full range of positions matched by the production
Get the store of local values associated with this parser
Raise an error in this parse context
Get the start position for the terminal or non-terminal at a given index matched by the production
Get the start and end position for the terminal or non-terminal at a given index matched by the production
Get the end position for the terminal or non-terminal at a given index matched by the production
Get the value produced by the terminal or non-terminal at the given position
The information accessible via the <c>parseState</c> value within parser actions.
The default implementation of the parse_error function
The default implementation of the parse_error_rich function
Helpers used by generated parsers.
A record of options to control structural formatting.
For F# Interactive properties matching those of this value can be accessed via the 'fsi'
value.
Floating Point format given in the same format accepted by System.Double.ToString,
e.g. f6 or g15.
If ShowProperties is set the printing process will evaluate properties of the values being
displayed. This may cause additional computation.
The ShowIEnumerable is set the printing process will force the evalution of IEnumerable objects
to a small, finite depth, as determined by the printing parameters.
This may lead to additional computation being performed during printing.
<example>
From F# Interactive the default settings can be adjusted using, for example,
<pre>
open Microsoft.FSharp.Compiler.Interactive.Settings;;
setPrintWidth 120;;
</pre>
</example>
The maximum number of rows for which to generate layout for table-like
structures. -1 if no maximum.
The maximum number of elements for which to generate layout for
list-like structures, or columns in table-like
structures. -1 if no maximum.
Return to the layout-generation
environment to layout any otherwise uninterpreted object
Data representing structured layouts of terms. The representation
of this data type is only for the consumption of formatting engines.
Data representing joints in structured layouts of terms. The representation
of this data type is only for the consumption of formatting engines.
Convert any value to a layout using the given formatting options. The
layout can then be processed using formatting display engines such as
those in the LayoutOps module. any_to_string and output_any are
built using any_to_layout with default format options.
Ouput any value to a channel using the same set of formatting rules
as any_to_string
Convert any value to a string using a standard formatter
Data is typically formatted in a structured format, e.g.
lists are formatted using the "[1;2]" notation.
The details of the format are not specified and may change
from version to version and according to the flags given
to the F# compiler. The format is intended to be human-readable,
not machine readable. If alternative generic formats are required
you should develop your own formatter, using the code in the
implementation of this file as a starting point.
Data from other .NET languages is formatted using a virtual
call to Object.ToString() on the boxed version of the input.
For limitting layout of list-like sequences (lists,arrays,etc).
unfold a list of items using (project and z) making layout list via itemL.
If reach maxLength (before exhausting) then truncate.
See tagL
Layout like an F# list.
Layout like an F# option.
Layout list vertically.
Layout two vertically.
Form tuple of layouts.
Wrap braces around layout.
Wrap square brackets around layout.
Wrap round brackets around Layout.
Join layouts into a list separated using the given Layout.
Join layouts into a semi-colon separated list.
Join layouts into a space separated list.
Join layouts into a comma separated list.
Join broken with ident=2
Join broken with ident=1
Join broken with ident=0
Join, possible break with indent=2
Join, possible break with indent=1
Join, possible break with indent=0
Join, unbreakable.
An string which is left parenthesis (no space on the right).
An string which is right parenthesis (no space on the left).
An string which requires no spaces either side.
An string leaf
An uninterpreted leaf, to be interpreted into a string
by the layout engine. This allows leaf layouts for numbers, strings and
other atoms to be customized according to culture.
Is it the empty layout?
The empty layout
A layout is a sequence of strings which have been joined together.
The strings are classified as words, separators and left and right parenthesis.
This classification determines where spaces are inserted.
A joint is either unbreakable, breakable or broken.
If a joint is broken the RHS layout occurs on the next line with optional indentation.
A layout can be squashed to for given width which forces breaks as required.