# Aardvark.Base

## Aardvark.Base Namespace

Type | Description | ||

Aardvark | |||

AbstractGraph<'TVertex, 'TCost> | |||

ActionRef1<'T0> | |||

ActionRef1<'T0, 'T1> | |||

ActionRef1<'T0, 'T1, 'T2> | |||

ActionRef1<'T0, 'T1, 'T2, 'T3> | |||

ActionRef1<'T0, 'T1, 'T2, 'T3, 'T4> | |||

ActionRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5> | |||

ActionRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6> | |||

ActionRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> | |||

ActionRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8> | |||

ActionRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9> | |||

ActionRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10> | |||

ActionRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11> | |||

ActionRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12> | |||

ActionRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13> | |||

ActionRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14> | |||

ActionRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15> | |||

ActionRef2<'T0, 'T1> | |||

ActionRef2<'T0, 'T1, 'T2> | |||

ActionRef2<'T0, 'T1, 'T2, 'T3> | |||

ActionRef2<'T0, 'T1, 'T2, 'T3, 'T4> | |||

ActionRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5> | |||

ActionRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6> | |||

ActionRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> | |||

ActionRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8> | |||

ActionRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9> | |||

ActionRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10> | |||

ActionRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11> | |||

ActionRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12> | |||

ActionRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13> | |||

ActionRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14> | |||

ActionRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15> | |||

ActionRef3<'T0, 'T1, 'T2> | |||

ActionRef3<'T0, 'T1, 'T2, 'T3> | |||

ActionRef3<'T0, 'T1, 'T2, 'T3, 'T4> | |||

ActionRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5> | |||

ActionRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6> | |||

ActionRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> | |||

ActionRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8> | |||

ActionRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9> | |||

ActionRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10> | |||

ActionRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11> | |||

ActionRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12> | |||

ActionRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13> | |||

ActionRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14> | |||

ActionRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15> | |||

ActionRef4<'T0, 'T1, 'T2, 'T3> | |||

ActionRef4<'T0, 'T1, 'T2, 'T3, 'T4> | |||

ActionRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5> | |||

ActionRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6> | |||

ActionRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> | |||

ActionRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8> | |||

ActionRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9> | |||

ActionRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10> | |||

ActionRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11> | |||

ActionRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12> | |||

ActionRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13> | |||

ActionRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14> | |||

ActionRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15> | |||

ActionRef5<'T0, 'T1, 'T2, 'T3, 'T4> | |||

ActionRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5> | |||

ActionRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6> | |||

ActionRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> | |||

ActionRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8> | |||

ActionRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9> | |||

ActionRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10> | |||

ActionRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11> | |||

ActionRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12> | |||

ActionRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13> | |||

ActionRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14> | |||

ActionRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15> | |||

ActionRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5> | |||

ActionRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6> | |||

ActionRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> | |||

ActionRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8> | |||

ActionRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9> | |||

ActionRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10> | |||

ActionRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11> | |||

ActionRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12> | |||

ActionRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13> | |||

ActionRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14> | |||

ActionRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15> | |||

ActionRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6> | |||

ActionRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> | |||

ActionRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8> | |||

ActionRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9> | |||

ActionRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10> | |||

ActionRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11> | |||

ActionRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12> | |||

ActionRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13> | |||

ActionRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14> | |||

ActionRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15> | |||

ActionRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> | |||

ActionRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8> | |||

ActionRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9> | |||

ActionRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10> | |||

ActionRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11> | |||

ActionRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12> | |||

ActionRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13> | |||

ActionRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14> | |||

ActionRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15> | |||

ActionRefValVal<'T0, 'T1, 'T2> | |||

ActionTable<'T> | |||

ActionValRef<'T0, 'T1> | |||

AdaBoost | Adaptive boosting creates a strong binary classifier out of an ensemble of weak classifiers. |
||

Adler32 | Computes Adler32 checksum for a stream of data. An Adler32 checksum is not as reliable as a CRC32 checksum, but a lot faster to compute. The specification for Adler32 may be found in RFC 1950. From that document: "ADLER32 (Adler-32 checksum) This contains a checksum value of the uncompressed data (excluding any dictionary data) computed according to Adler-32 algorithm. This algorithm is a 32-bit extension and improvement of the Fletcher algorithm, used in the ITU-T X.224 / ISO 8073 standard. Adler-32 is composed of two sums accumulated per byte: s1 is the sum of all bytes, s2 is the sum of all s1 values. Both sums are done modulo 65521. s1 is initialized to 1, s2 to zero. The Adler-32 checksum is stored as s2*65536 + s1 in most- significant-byte first (network) order." "8.2. The Adler-32 algorithm The Adler-32 algorithm is much faster than the CRC32 algorithm yet still provides an extremely low probability of undetected errors. The modulo on unsigned long accumulators can be delayed for 5552 bytes, so the modulo operation time is negligible. If the bytes are a, b, c, the second sum is 3a + 2b + c + 3, and so is position and order sensitive, unlike the first sum, which is just a checksum. That 65521 is prime is important to avoid a possible large class of two-byte errors that leave the check unchanged. (The Fletcher checksum uses 255, which is not prime and which also makes the Fletcher check insensitive to single byte changes 0 - 255.) The sum s1 is initialized to 1 instead of zero to make the length of the sequence part of s2, so that the length does not have to be checked separately. (Any sequence of zeroes has a Fletcher checksum of zero.)" |
||

ArrayFun | |||

ArrayVectorExtensions | |||

AverageWindow | Represents a moving average window of a sequence. It builds the average of the last N inserted values. |
||

BigDict<'TKey, 'TValue> | A BigDict is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

BigDictIEq<'TKey, 'TValue> | A BigDictIEq is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

BigDictSet<'TKey> | A BigDictSet is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

BigDictSetIEq<'TKey> | A BigDictSetIEq is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

Border2i | Specifies an image boder, all entries should be positive values. |
||

Border2l | Specifies an image boder, all entries should be positive values. |
||

BorderMatrixAndVolumeExtensions | |||

Box | |||

Box2d | |||

Box2dExtensions | |||

Box2f | |||

Box2i | |||

Box2l | |||

Box3d | |||

Box3dAndFlags | |||

Box3dExtensions | |||

Box3f | |||

Box3i | |||

Box3l | |||

BoxFun | |||

C3b | |||

C3d | |||

C3f | |||

C3ui | |||

C3us | |||

C4b | |||

C4d | |||

C4f | |||

C4ui | |||

C4us | |||

CIeLuvf | |||

CMYKf | |||

CSharpStringTextParserExtension | |||

CameraExtrinsics | |||

CameraIntrinsics | |||

Capsule3d | |||

Case<'TPar, 'TNode> | Case represents a state transition of a generic recursive descent parser. |
||

Cases<'TPar, 'TNode> | The Cases class makes it possible to build a single state transition table by combining already defined case arrays. This makes it possible to avoid re-specifying cases that appear in multiple states. |
||

CastExtensions | |||

CharFun | |||

CieLabf | |||

CieXYZf | This structure holds Cie XYZ colors where Y should be in the range [0,100] for reflective color values. |
||

CieYxyf | |||

Circle2d | A two dimensional circle represented by center and radius. |
||

Circle3d | A circle in 3-space represented by its center, normal (normalized), and a radius. |
||

Col | A static container class that provides functionality for dealing with colors. It is intentionally named Col in order to avoid a collision with the system provided Color class. |
||

ColFun | |||

ColorConversion | |||

ComparableIndexedValue<'T> | |||

ComplexD | |||

ComplexF | |||

ConcurrentBigDict<'TKey, 'TValue> | A ConcurrentBigDict is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

ConcurrentBigDictIEq<'TKey, 'TValue> | A ConcurrentBigDictIEq is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

ConcurrentBigDictSet<'TKey> | A ConcurrentBigDictSet is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

ConcurrentBigDictSetIEq<'TKey> | A ConcurrentBigDictSetIEq is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

ConcurrentDataModifiedException | |||

ConcurrentDict<'TKey, 'TValue> | A ConcurrentDict is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

ConcurrentDictIEq<'TKey, 'TValue> | A ConcurrentDictIEq is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

ConcurrentDictSet<'TKey> | A ConcurrentDictSet is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

ConcurrentDictSetIEq<'TKey> | A ConcurrentDictSetIEq is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

ConcurrentIntDict<'TValue> | A ConcurrentIntDict is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

ConcurrentIntSet | A ConcurrentIntSet is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

ConcurrentLongDict<'TValue> | A ConcurrentLongDict is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

ConcurrentLongSet | A ConcurrentLongSet is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

ConcurrentSymbolDict<'TValue> | A ConcurrentSymbolDict is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

ConcurrentSymbolSet | A ConcurrentSymbolSet is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

Cone3d | |||

Conic2d | WARNING: Sektch! Defines the conic section CXX x^2 + CYY y^2 + CZZ z^2 + CXY xy + CYZ yz + CYZ yz = 0 with (x,y,z) being homogenous coordinates. |
||

Constant<'T> | |||

Constant | Mathematical constants. |
||

ControlFun | |||

Conversion | Conversion routines. |
||

CoordTransforms | Various coordinate transformations. Abbreviations: ll = lower left, lr = lower right, ul = upper left, ur = upper right 2D: Normalized Image Pos: Our coord-exchange format; Independent of reolution. (0,0)=ul edge of sensor = ul edge of ul pixel, (1,1) = lr edge of sensor = lr edge of lr pixel. Pixel Center: (0,0)=center of ul pixel, (w-1, h-1)=center of lr pixel. Pixel Edge: (0,0)=ul edge of ul pixel, (w-1, h-1)= lr edge of lr pixel. |
||

CoordinateSystem | |||

CubeSide | |||

CurvePoints<'T> | |||

Cylinder3d | |||

DeltaDict<'TKey, 'TValue> | A Dict that overrides all values contained in a delta Dict with respect to a supplied base Dict. |
||

DeltaSymbolDict<'TValue> | A SymbolDict that overrides all values contained in a delta SymbolDict with respect to a supplied base SymbolDict. |
||

DenseGraph<'TVertex, 'TCost> | |||

Dict<'TKey, 'TValue> | A Dict is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

DictConstant | |||

DictFun | |||

DictIEq<'TKey, 'TValue> | A DictIEq is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

DictReport | |||

DictSet<'TKey> | A DictSet is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

DictSetIEq<'TKey> | A DictSetIEq is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

DictionaryFun | |||

Dir | |||

EdgeDirection | |||

EdgeFilter | |||

Ellipse2d | A 2D ellipse is defined by its center and two half-axes. Note that in principle any two conjugate half-diameters can be used as axes, however some algorithms require that the major and minor half axes are known. By convention in this case, axis0 is the major half axis. |
||

Ellipse3d | A 3D ellipse is defined by its center, its plane normal, and two half-axes. Note that in principle any two conjugate half-diameters can be used as axes, however some algorithms require that the major and minor half axes are known. By convention in this case, axis0 is the major half axis. |
||

Ensures | "Design by contract" helpers for post-conditions. |
||

EnumHelpers | |||

EnumerableEx | |||

EnumerableUtils | |||

Euclidean2d | Represents a Rigid Transformation (or Rigid Body Transformation) in 2D that is composed of a 2D rotation Rot and a subsequent translation by a 2D vector Trans. This is also called an Euclidean Transformation and is a length preserving Transformation. |
||

Euclidean2f | Represents a Rigid Transformation (or Rigid Body Transformation) in 2D that is composed of a 2D rotation Rot and a subsequent translation by a 2D vector Trans. This is also called an Euclidean Transformation and is a length preserving Transformation. |
||

Euclidean3d | Represents a Rigid Transformation (or Rigid Body Transformation) in 3D that is composed of a 3D rotation Rot and a subsequent translation by a 3D vector Trans. This is also called an Euclidean Transformation and is a length preserving Transformation. |
||

Euclidean3f | Represents a Rigid Transformation (or Rigid Body Transformation) in 3D that is composed of a 3D rotation Rot and a subsequent translation by a 3D vector Trans. This is also called an Euclidean Transformation and is a length preserving Transformation. |
||

EventHandlerExtensions | |||

Extremum<'T> | A structure that maintains the extreme Value and an associated Data field as each value/data pair is added. |
||

FastConcurrentBigDict<'TKey, 'TValue> | A FastConcurrentBigDict is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

FastConcurrentBigDictIEq<'TKey, 'TValue> | A FastConcurrentBigDictIEq is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

FastConcurrentBigDictSet<'TKey> | A FastConcurrentBigDictSet is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

FastConcurrentBigDictSetIEq<'TKey> | A FastConcurrentBigDictSetIEq is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

FastConcurrentDict<'TKey, 'TValue> | A FastConcurrentDict is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

FastConcurrentDictIEq<'TKey, 'TValue> | A FastConcurrentDictIEq is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

FastConcurrentDictSet<'TKey> | A FastConcurrentDictSet is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

FastConcurrentDictSetIEq<'TKey> | A FastConcurrentDictSetIEq is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

FastConcurrentIntDict<'TValue> | A FastConcurrentIntDict is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

FastConcurrentIntSet | A FastConcurrentIntSet is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

FastConcurrentLongDict<'TValue> | A FastConcurrentLongDict is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

FastConcurrentLongSet | A FastConcurrentLongSet is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

FastConcurrentSymbolDict<'TValue> | A FastConcurrentSymbolDict is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

FastConcurrentSymbolSet | A FastConcurrentSymbolSet is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

FastHull3d | A fast hull is a set of planes bounding a convex polyhedron, that can be quickly tested against intersection of an axis- aligned bounding box. |
||

FastRay2d | A fast ray contains a ray and a number of precomputed flags and fields for fast intersection computation with bounding boxes and other axis-aligned sturctures such as kd-Trees. |
||

FastRay3d | A fast ray contains a ray and a number of precomputed flags and fields for fast intersection computation with bounding boxes and other axis-aligned sturctures such as kd-Trees. |
||

FileImage | |||

FileVolume | |||

FilterKernel | Convolution filter kernels. |
||

FilterKernelFun | |||

FilterLogTarget | A filtering log target that only records messages for which the filter function supplied in the constructor returns true. |
||

Fraction | Represents an integral fraction. |
||

Fun | |||

FuncActionExtensions | |||

FuncOfT2Bool<'T> | |||

FuncOut1<'T0, 'TRes> | |||

FuncOut1<'T0, 'T1, 'TRes> | |||

FuncOut1<'T0, 'T1, 'T2, 'TRes> | |||

FuncOut1<'T0, 'T1, 'T2, 'T3, 'TRes> | |||

FuncOut1<'T0, 'T1, 'T2, 'T3, 'T4, 'TRes> | |||

FuncOut1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'TRes> | |||

FuncOut1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TRes> | |||

FuncOut1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncOut1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncOut1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncOut1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncOut1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncOut1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncOut1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncOut1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncOut1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

FuncOut2<'T0, 'T1, 'TRes> | |||

FuncOut2<'T0, 'T1, 'T2, 'TRes> | |||

FuncOut2<'T0, 'T1, 'T2, 'T3, 'TRes> | |||

FuncOut2<'T0, 'T1, 'T2, 'T3, 'T4, 'TRes> | |||

FuncOut2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'TRes> | |||

FuncOut2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TRes> | |||

FuncOut2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncOut2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncOut2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncOut2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncOut2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncOut2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncOut2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncOut2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncOut2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

FuncOut3<'T0, 'T1, 'T2, 'TRes> | |||

FuncOut3<'T0, 'T1, 'T2, 'T3, 'TRes> | |||

FuncOut3<'T0, 'T1, 'T2, 'T3, 'T4, 'TRes> | |||

FuncOut3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'TRes> | |||

FuncOut3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TRes> | |||

FuncOut3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncOut3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncOut3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncOut3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncOut3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncOut3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncOut3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncOut3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncOut3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

FuncOut4<'T0, 'T1, 'T2, 'T3, 'TRes> | |||

FuncOut4<'T0, 'T1, 'T2, 'T3, 'T4, 'TRes> | |||

FuncOut4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'TRes> | |||

FuncOut4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TRes> | |||

FuncOut4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncOut4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncOut4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncOut4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncOut4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncOut4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncOut4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncOut4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncOut4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

FuncOut5<'T0, 'T1, 'T2, 'T3, 'T4, 'TRes> | |||

FuncOut5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'TRes> | |||

FuncOut5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TRes> | |||

FuncOut5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncOut5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncOut5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncOut5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncOut5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncOut5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncOut5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncOut5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncOut5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

FuncOut6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'TRes> | |||

FuncOut6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TRes> | |||

FuncOut6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncOut6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncOut6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncOut6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncOut6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncOut6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncOut6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncOut6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncOut6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

FuncOut7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TRes> | |||

FuncOut7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncOut7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncOut7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncOut7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncOut7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncOut7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncOut7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncOut7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncOut7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

FuncOut8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncOut8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncOut8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncOut8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncOut8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncOut8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncOut8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncOut8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncOut8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

FuncRef1<'T0, 'TRes> | |||

FuncRef1<'T0, 'T1, 'TRes> | |||

FuncRef1<'T0, 'T1, 'T2, 'TRes> | |||

FuncRef1<'T0, 'T1, 'T2, 'T3, 'TRes> | |||

FuncRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'TRes> | |||

FuncRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'TRes> | |||

FuncRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TRes> | |||

FuncRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncRef1<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

FuncRef2<'T0, 'T1, 'TRes> | |||

FuncRef2<'T0, 'T1, 'T2, 'TRes> | |||

FuncRef2<'T0, 'T1, 'T2, 'T3, 'TRes> | |||

FuncRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'TRes> | |||

FuncRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'TRes> | |||

FuncRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TRes> | |||

FuncRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncRef2<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

FuncRef3<'T0, 'T1, 'T2, 'TRes> | |||

FuncRef3<'T0, 'T1, 'T2, 'T3, 'TRes> | |||

FuncRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'TRes> | |||

FuncRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'TRes> | |||

FuncRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TRes> | |||

FuncRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncRef3<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

FuncRef4<'T0, 'T1, 'T2, 'T3, 'TRes> | |||

FuncRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'TRes> | |||

FuncRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'TRes> | |||

FuncRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TRes> | |||

FuncRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncRef4<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

FuncRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'TRes> | |||

FuncRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'TRes> | |||

FuncRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TRes> | |||

FuncRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncRef5<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

FuncRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'TRes> | |||

FuncRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TRes> | |||

FuncRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncRef6<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

FuncRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TRes> | |||

FuncRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncRef7<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

FuncRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

FuncRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

FuncRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

FuncRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

FuncRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

FuncRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

FuncRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

FuncRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

FuncRef8<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

Geo | |||

GeoConstant | Static class. Provides constants for Geodesic Conversions. |
||

GeoDatum | Holds data for a geodesic transform from one datum to another. |
||

GeoEllipsoid | This struct provides properties for a particular World-Ellipsoid. It is defined by ist two radii: "a" and "b". |
||

GeometricProperties | |||

GeometryFun | Provides various methods for middle point computations. |
||

HSLf | Hue Saturation Value colors. All three components are defined in the range [0.0, 1.0]. |
||

HSVf | Hue Saturation Lightness colors. All three components are defined in the range [0.0, 1.0]. |
||

HaltonRandomSeries | A halton series generator, that uses a normal random generator for higher order series, in order to avoid the slow coverage of higher order halton series. |
||

HardwareThread | |||

HashCode | |||

HighFun | |||

Histogram | A data structure that maintains a histogram with a selectable number of slots. |
||

HistogramAndStats<'T> | |||

HistogramClass | |||

Hull | |||

Hull2d | A hull is an alternative representation of a convex polygon. |
||

Hull2dExtensions | |||

Hull3d | A hull is a set of planes that bounds a convex polyhedron. Normals are expected to point outside. |
||

Hull3dExtensions | |||

IArrayMatrix | |||

IArrayTensor | All tensors built on top of arrays implement this interface. |
||

IArrayTensor4 | |||

IArrayTensorN | |||

IArrayVector | |||

IArrayVolume | |||

IBoundingBox2d | Return an axis aligned two-dimensional box that contains the complete geometry. |
||

IBoundingBox3d | Return an axis aligned three-dimensional box that contains the complete geometry. |
||

IBoundingCircle2d | |||

IBoundingRange1d | |||

IBoundingSphere3d | |||

ICollectionExtensions | |||

ICountable | |||

ICountableDict | |||

ICountableDictSet | |||

IDict | |||

IDict<'TKey, 'TValue> | |||

IDictDepth | |||

IDictExtensions | |||

IDictSet | |||

IDictSet<'TKey> | |||

IDictionaryExtensions | |||

IEnumerableFun | |||

IGenerational | Associates a generation number with an object, which should change every time the object's observable state changes. Observers SHOULD NOT test for changes using 'greater than', but SHOULD compare the current generation with a previously observed generation using 'not equal'. Although most of the time a new generation number will be created by simply incrementing the current generation number, such a behaviour is not guaranteed. E.g. at the very least such an assumption will be violated when a generation number wraps around from int.MaxValue to int.MinValue. So always compare using 'not equal'. |
||

IIntCountable | |||

IJobReporter | |||

IListExtensions | |||

ILogTarget | |||

IMatrix | Non-generic Interface for Dim.X x Dim.Y - dimensional matrices. |
||

IMatrix<'T> | Generic Interface for NxM-dimensional matrix of Type T. The indexer of this interface has arguments of type long. |
||

IMatrix<'TMatrix, 'TVec, 'TVecSub1, 'TScalar> | A matrix is a transform and elements can be accessed by [row, column]. |
||

IMutablePolygon<'T> | |||

IOpacity | |||

IPix | |||

IPixCube | |||

IPixExtensions | |||

IPixImage | |||

IPixImage2d | |||

IPixImage3d | |||

IPixImageVisitor<'T> | |||

IPixMipMap2d | |||

IPixOp<'Tr> | |||

IPixProductOp<'Tr> | |||

IPixVolumeVisitor<'T> | |||

IPolygon<'T> | |||

IPolygonExtensions | |||

IRGB | |||

IRandomDistribution | |||

IRandomEnumerableExtensions | |||

IRandomSeries | Maintain multiple independent series of random or quasi-random variables. For two-dimensional sampling the random variables of two series need to be combined (e.g. a random variable of series k and a random variable of series k+1). For quasi-random sampling, the lower series are assumed to achieve a faster coverage of the domain, and should therefore be used for the sampling dimensions with a larger influence on the result. |
||

IRandomUniform | This interface enforces a common API for random number generators. |
||

IRandomUniformExtensions | |||

IRange | IRange enforces a uniform design of all range types. This non-generic interface contains all the methods and properties that are independent of type. It serves as a base interface to the generic IRange interface. |
||

IRange<'TValue, 'TDiff, 'TRange> | IRange enforces a uniform design of all range types. |
||

IRange<'TValue, 'TRange> | IRange enforces a uniform design of all range types. |
||

IReportable | |||

IReporter | The IReporter interface can be implemented for objects to catch reports on a level, where some info is passed with typed parameters (e.g. timing seconds as doubles, values as objects). As soon as a reporter object is added, all Report calls from the same thread are also delivered to that reporter object. Reporting on other threads, where the reporter object was not added, does not appear. If the same reporter object is added multiple times from different threads, all these methods need to do their own locking. If only one reporter object is added from one thread, no locking is necessary. The supplied threadIndex, is a running number for each thread assigned based on their first sending of a Report message. It can be directly used as a key in e.g. an IntDict. |
||

IShortestPath<'T> | |||

ISimpleRange<'TValue, 'TRange> | ISimpleRange enforces a uniform interface of range operations that ony require comparison of boundaries. |
||

ISize2d | A Size2d reprents the size of an object in two dimensions. |
||

ISize3d | A Size3d reprents the size of an object in three dimensions. |
||

ISize4d | A Size4d reprents the size of an object in four dimensions. |
||

ISquareMatrix<'TMat, 'TVec, 'TVecSub1, 'TScalar> | A square matrix is a matrix is a transform. |
||

ITensor | Non-generic Interface for arbitrarily sized tensors. |
||

ITensor<'T> | Generic Interface for arbitrarily sized tensors of Type T. The indexer of this interface has arguments of type long. |
||

ITensor4 | Non-generic Interface for Dim.X x Dim.Y x Dim.Z, Dim.W - dimensional volumes. |
||

ITensor4<'T> | Generic Interface for NxMxLXK-dimensional volume of Type T. The indexer of this interface has arguments of type long. |
||

ITensorAccessors | |||

ITensorInfo | Dimension independent properties of tensor infos, and actions that can be performed on tensors infos regardless of their dimension. |
||

ITensorLong | This interface defines properties of Tensors and TensorInfos that are independent of their dimension (rank). |
||

ITransform<'TTrafo, 'TVec, 'TVecSub1> | A transform can be inverted, and it can be used to transform vectors. |
||

ITypedSymbol | |||

IValidity | |||

IVector | Non-generic Interface for Dim - dimensional vectors. |
||

IVector<'T> | Generic Interface for N-dimensional vector of Type T. The indexer of this interface has arguments of type long. |
||

IVolume | Non-generic Interface for Dim.X x Dim.Y x Dim.Z - dimensional volumes. |
||

IVolume<'T> | Generic Interface for NxMxL-dimensional volume of Type T. The indexer of this interface has arguments of type long. |
||

IXml | |||

IXmlDocProperty | |||

IXmlItemProperty | |||

IXmlText | |||

ImageBorderType | |||

ImageInterpolation | Interpolation scheme.
Values correspond to IPPI |
||

ImageLoadException | |||

ImageTensors | |||

ImageTrafo | |||

ImprovedNoise | |||

IndexPolygon2d | |||

IndexPolygon2dExtensions | |||

IndexPolygon3d | |||

IndexPolygon3dExtensions | |||

IndexedValue<'T> | |||

IntDict<'TValue> | A IntDict is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

IntSet | A IntSet is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

Introspection | |||

IntrospectionProperties | |||

Ipol | |||

Ipol<'T> | |||

JobReporter | |||

KahanSum | A simple quadruple precision sum (around 108 bit) based on Kahan's summation method. This is used in Stats, to maintain higher precision sums for statistical moment computation. |
||

KeyValuePairs | |||

LambdaApplicationExtensions | |||

Line1i | A structure that holds the indices of the endpoints of a line. |
||

Line1iPoint | Represents a value at an interpolated point between two indexed values of an indexable set of values. This is implemented as a class in order to avoid duplicating interpolated points in some algorithms. |
||

Line2d | A two dimensional line with specified start and end points. |
||

Line2dExtensions | |||

Line3d | A three-dimensional line with specified start and end points. |
||

Line3dExtensions | |||

LinearCombination | |||

ListFun | |||

Localization | |||

LogMsg | |||

LogOpt | |||

LogType | |||

LongDict<'TValue> | A LongDict is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

LongSet | A LongSet is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

LruCache<'TKey, 'TValue> | A least-recently-used cache, with specifyable capacity and per-item size-, read-, and delete function. The indexer is used to access items. Capacity can be changed on the fly. All operations are synchronized for use in multi-threaded applications. |
||

M22Extensions | |||

M22d | |||

M22dEqualityComparer | |||

M22f | |||

M22fEqualityComparer | |||

M22i | |||

M22iEqualityComparer | |||

M22l | |||

M22lEqualityComparer | |||

M23d | |||

M23dEqualityComparer | |||

M23f | |||

M23fEqualityComparer | |||

M23i | |||

M23iEqualityComparer | |||

M23l | |||

M23lEqualityComparer | |||

M33Extensions | |||

M33d | |||

M33dEqualityComparer | |||

M33f | |||

M33fEqualityComparer | |||

M33i | |||

M33iEqualityComparer | |||

M33l | |||

M33lEqualityComparer | |||

M34d | |||

M34dEqualityComparer | |||

M34f | |||

M34fEqualityComparer | |||

M34i | |||

M34iEqualityComparer | |||

M34l | |||

M34lEqualityComparer | |||

M44d | |||

M44dEqualityComparer | |||

M44f | |||

M44fEqualityComparer | |||

M44i | |||

M44iEqualityComparer | |||

M44l | |||

M44lEqualityComparer | |||

Mapping | |||

Matrix<'Td> | Generic matrix of elements with arbitrary stride. All sizes are given as 2-dimensional vectors, with the first parameter specifying the inner dimension. The matrix does not exclusively own its underlying data array, it can also serve as a window into other arrays and tensors. Operations on matrixs are supported by function arguments which can be easily exploited by using lambda functions. Note: stride is called Delta (or D) within this data structure, the 2 stride direction(s) are called DX, DY, aso. |
||

Matrix<'Td, 'Tv> | Generic matrix of elements with arbitrary stride. All sizes are given as 2-dimensional vectors, with the first parameter specifying the inner dimension. The matrix does not exclusively own its underlying data array, it can also serve as a window into other arrays and tensors. Operations on matrixs are supported by function arguments which can be easily exploited by using lambda functions. Note: stride is called Delta (or D) within this data structure, the 2 stride direction(s) are called DX, DY, aso. The matrix has different view and data element types, i.e. although all data is stored using the data element type, in its interfaces it acts as a matrix of view element types. |
||

MatrixArrayExtensions | |||

MatrixInfo | A matrix info contains the complete indexing information for a matrix, but no data array. |
||

Meta | |||

Metric | |||

MinimumSpanningTree | |||

MinimumSpanningTreeTest | |||

MultiLogTarget | |||

Norm | |||

NullReporter | |||

NumericExtensions | |||

Numerics | |||

ObliqueCone3d | |||

OctoBox2d | |||

OnAardvarkInitAttribute | |||

Optional<'T> | |||

OrientedBox2d | |||

OrientedBox3d | |||

Otrthogonalism | Provides various methods determining normalism |
||

Pair | This static class allows the creation of pairs without specifying the type in angle brackets. |
||

Pair<'T> | A pair is a structure containing two elements of the same type, that can be accessed at index 0 and index 1, or using the fields E0 and E1. |
||

Parallelism | Provides various methods determining parallelism |
||

ParseError | |||

ParsedValue<'T> | A parsed value contains the actual value, the number of characters that have been parsed in Length, and an error value of the parse operation. |
||

ParserCase<'TNode> | Case represents a state transition of a generic recursive descent parser. |
||

ParserCases<'TNode> | The Cases class makes it possible to build a single state transition table by combining already defined case arrays. This makes it possible to avoid re-specifying cases that appear in multiple states. |
||

ParserException<'TPar> | The generic recursive descent parser throws this type of exception. |
||

ParserException | |||

ParserState<'TNode> | State of a generic recursive descent parser. |
||

PerThreadJobReporter | |||

PerThreadLogTarget | |||

PerlinNoise | Perlin noise generation class. Contains functions for 1D, 2D and 3D perlin noise generation. |
||

PhysicsConstant | |||

PixCopyOp | |||

PixCountPixImagesInMemory | |||

PixCreateMipMaps | |||

PixCube | |||

PixCubeMap | |||

PixEqualOp | |||

PixFileFormat | |||

PixFormat | The PixFormat encodes the channel type and the color format of an image. |
||

PixGetInfo | |||

PixGetPixImageArray | |||

PixImage | |||

PixImage<'T> | The generic PixImage stores an image with a specific channel type that is specified as type parameter. |
||

PixImageCube | |||

PixImageExtensions | |||

PixImageInfo | |||

PixImageMetaData | TODO: Design this |
||

PixImageMipMap | |||

PixImageMipMap<'T> | |||

PixInfoToZeroSize | |||

PixInnerProductOp<'Tr> | |||

PixIntSumProductOp | |||

PixLoadOp | |||

PixLoadOptions | |||

PixMipMap2d | |||

PixRemoveMipMaps | |||

PixSaveOp | |||

PixSaveOptions | |||

PixStack | |||

PixToPixImage<'T> | |||

PixVolume | |||

PixVolume<'T> | |||

PixVolumeInfo | |||

Plane2d | A line represented by a (possibly) normalized normal vector and the distance to the origin. Note that the plane does not enforce the normalized normal vector. Equation for points p on the plane: Normal dot p == Distance |
||

Plane3d | A plane represented by a (possibly) normalized normal vector and the distance to the origin. Note that the plane does not enforce the normalized normal vector. Equation for points p on the plane: Normal dot p == Distance |
||

Plane3dExtensions | |||

PlanePair3d | A plane pair defines a ray at their intersection. |
||

PlaneTriple3d | A plane triple defines a point at their intersection. |
||

PlaneWithPoint3d | A plane with a specific point that can be retrieved later. |
||

Polygon2d | A polygon internally represented by an array of points. Implemented as a structure, the validity of the polygon can be checked via its PointCount, which must be bigger than 0 for a polygon to hold any points, and bigger than 2 for a polygon to be geometrically valid. |
||

Polygon2dExtensions | |||

Polygon3d | A polygon internally represented by an array of points. Implemented as a structure, the validity of the polygon can be checked via its PointCount, which must be bigger than 0 for a polygon to hold any points, and bigger than 2 for a polygon to be geometrically valid. |
||

Polygon3dExtensions | |||

Polynomial | |||

Prime | |||

Quad | This static class allows the creation of quadruple without specifying the type in angle brackets. |
||

Quad<'T> | A quadruple is a structure containing three elements of the same type, that can be accessed at index 0, 1, 2, and 3, or using the fields E0, E1, E2, and E3. |
||

Quad1i | A structure that holds the indices of the vertices of a quad. |
||

Quad2d | A two-dimensional quadrangle specified by its four points. |
||

Quad2dExtensions | |||

Quad3d | A three-dimensional quadrangle specified by its four points. The points are not required to lie on the same plane. |
||

Quad3dExtensions | |||

Quadric | |||

Quasi | |||

RandomGaussian | |||

RandomIEnumerableExtensions | |||

RandomSample | |||

RandomSeriesExtensions | |||

RandomSystem | System Random Generator. |
||

Range1b | |||

Range1d | |||

Range1f | |||

Range1i | |||

Range1l | |||

Range1s | |||

Range1sb | |||

Range1ui | |||

Range1ul | |||

Range1us | |||

RangeExtensions | |||

Ray2d | A two-dimensional ray with an origin and a direction. |
||

Ray3d | A three-dimensional ray with an origin and a direction. |
||

RayHit3d | A ray hit represents the hit of a ray on a primitive object such as a triangle. It stores the ray parameter of the hit, the hit point, the hit point's coordinates, and a flag indicating if the backside of the primitive was hit. Optionally the part field can be used to store which part of a multi-part object was hit. If no multi-part objects are used, this field remains 0. |
||

Recursive<'T0, 'TRes> | |||

Recursive<'T0, 'T1, 'TRes> | |||

Recursive<'T0, 'T1, 'T2, 'TRes> | |||

Recursive<'T0, 'T1, 'T2, 'T3, 'TRes> | |||

RefAction<'T0> | |||

RefAction<'T0, 'T1> | |||

RefAction<'T0, 'T1, 'T2> | |||

RefAction<'T0, 'T1, 'T2, 'T3> | |||

RefAction<'T0, 'T1, 'T2, 'T3, 'T4> | |||

RefAction<'T0, 'T1, 'T2, 'T3, 'T4, 'T5> | |||

RefAction<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6> | |||

RefAction<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> | |||

RefAction<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8> | |||

RefAction<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9> | |||

RefAction<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10> | |||

RefAction<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11> | |||

RefAction<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12> | |||

RefAction<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13> | |||

RefAction<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14> | |||

RefAction<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15> | |||

RefFunc<'T0, 'TRes> | |||

RefFunc<'T0, 'T1, 'TRes> | |||

RefFunc<'T0, 'T1, 'T2, 'TRes> | |||

RefFunc<'T0, 'T1, 'T2, 'T3, 'TRes> | |||

RefFunc<'T0, 'T1, 'T2, 'T3, 'T4, 'TRes> | |||

RefFunc<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'TRes> | |||

RefFunc<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TRes> | |||

RefFunc<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TRes> | |||

RefFunc<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TRes> | |||

RefFunc<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'TRes> | |||

RefFunc<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'TRes> | |||

RefFunc<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'TRes> | |||

RefFunc<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'TRes> | |||

RefFunc<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'TRes> | |||

RefFunc<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'TRes> | |||

RefFunc<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9, 'T10, 'T11, 'T12, 'T13, 'T14, 'T15, 'TRes> | |||

Report | This class makes it possible to report messages with different verbosity levels to the console or a stream. In the simplest case, you can start by reporting single line messages with a level Report.Line. The level gives an indication of how important this message is: a value of 0 indicates that this is a message of utmost importance that cannot be suppressed. The higher the level, the lower the importance of the message. In the default case only messages of level 0, 1 and 2 are actually reported. The following use of levels is suggested:
The static Report class wraps all methods to a concrete reporter that performs the actual reporting. The default reporting setup consists of a console reporter at verbosity level 2, and a file reporter at reporting level 9 that writes it contents to the file "Aardvark.log". Each thread gets its own reporters, which report to the logs in a synchronized manner. In order to globally change the console report level, you can just conveniently use the static Verbosity property. |
||

ReportJob | |||

Requires | "Design by contract" helpers for pre-conditions. |
||

Rot2d | |||

Rot2f | |||

Rot3d | Represents an arbitrary rotation in three dimensions. Implemented as a normalized quaternion. |
||

Rot3f | Represents an arbitrary rotation in three dimensions. Implemented as a normalized quaternion. |
||

Rx | |||

SampleGrid2d | |||

Scale3d | A three dimensional scaling transform with different scaling values in each dimension. |
||

Scale3f | A three dimensional scaling transform with different scaling values in each dimension. |
||

SequenceExtensions | |||

Shift3d | |||

Shift3f | |||

ShortestPath<'T> | |||

Signs | This enum can be used to store an aggregate sign classification of multiple entities whose sign ccan be classified. |
||

Similarity3d | Represents a Similarity Transformation in 3D that is composed of a Uniform Scale and a subsequent Euclidean transformation (3D rotation Rot and a subsequent translation by a 3D vector Trans). This is an angle preserving Transformation. |
||

Similarity3f | Represents a Similarity Transformation in 3D that is composed of a Uniform Scale and a subsequent Euclidean transformation (3D rotation Rot and a subsequent translation by a 3D vector Trans). This is an angle preserving Transformation. |
||

SingleDeltaDict<'TKey, 'TValue> | A Dict that overrides a single value of a supplied base Dict. |
||

SingleDeltaSymbolDict<'TValue> | A SymbolDict that overrides a single value of a supplied base SymbolDict. |
||

SingleEntryDict<'TKey, 'TValue> | |||

SingleValueDict<'TKey, 'TValue> | An IDict where all contained keys return the same specified value. |
||

SingleValueSymbolDict<'TValue> | An IDict with Symbol keys where all contained keys return the same specified value. |
||

Skipper | This small struct helps to optimize the number of calls to Report.Progress. If you initialize it with a value of N, each Nth call of will return true. |
||

SortedSetExt<'T> | |||

SortingExtensions | |||

SpectralData | |||

Spectrum | |||

Sphere3d | A three dimensional sphere represented by center and radius. |
||

State<'TPar, 'TNode> | State of a generic recursive descent parser. |
||

Stats<'T> | A data structure for accumulating statistical moments. Currently only Count/Sum/Min/Max/Mean/Variance is implemented. Extend as necessary. |
||

StatsClass<'T> | |||

StatsOptions | |||

StreamCodeReader | |||

StreamCodeWriter | |||

StringFun | |||

StructsExtensions | |||

SubPrimitives | |||

SubRange<'T> | A SubRange is an IList that servers as a window into other ILists. |
||

SymMapBase | |||

SymMapBaseCollectionTraversal | |||

SymMapBaseTraversal | |||

SymMapBaseVisitor | |||

Symbol | |||

SymbolDict<'TValue> | A SymbolDict is an alternate implementation of a Dictionary that can optionally act as a stack for all items with the same key. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

SymbolExtensions | |||

SymbolSet | A SymbolSet is an alternate implementation of a HashSet. It is implemented as a hashtable with external linking, that uses primes as the table size in order to reduce the danger of funneling. |
||

SymmetricMatrix<'T> | |||

SystemDrawingExtensions | |||

Telemetry | |||

TelemetryExtensions | |||

Tensor | Symmetric operations with a scalar or non-tensor result. |
||

Tensor<'T> | Generic tensor of elements in r dimensons, each of arbitrary size
with arbitrary strides in each dimension. All sizes are given as
r-dimensional array of longs, with the dimensions ordered from
inner to outer dimension.
The tensor does not exclusively own its underlying data array, it
can also serve as a window into other arrays, matrices, volumes, and |
||

Tensor4<'Td> | Generic tensor4 of elements with arbitrary stride. All sizes are given as 4-dimensional vectors, with the first parameter specifying the inner dimension. The tensor4 does not exclusively own its underlying data array, it can also serve as a window into other arrays and tensors. Operations on tensor4s are supported by function arguments which can be easily exploited by using lambda functions. Note: stride is called Delta (or D) within this data structure, the 4 stride direction(s) are called DX, DY, aso. |
||

Tensor4<'Td, 'Tv> | Generic tensor4 of elements with arbitrary stride. All sizes are given as 4-dimensional vectors, with the first parameter specifying the inner dimension. The tensor4 does not exclusively own its underlying data array, it can also serve as a window into other arrays and tensors. Operations on tensor4s are supported by function arguments which can be easily exploited by using lambda functions. Note: stride is called Delta (or D) within this data structure, the 4 stride direction(s) are called DX, DY, aso. The tensor4 has different view and data element types, i.e. although all data is stored using the data element type, in its interfaces it acts as a tensor4 of view element types. |
||

Tensor4Info | A tensor4 info contains the complete indexing information for a tensor4, but no data array. |
||

TensorAccessors<'Td, 'Tv> | |||

TensorAccessors | |||

TensorArrayExtensions | |||

TensorExtensions | Wrappers for the best (fastest) available implementation of the respective tensor operation. |
||

TestInfo | A container for passed and failed counts. |
||

Text | A facade structure that represents a part of a string. This can be used to do string manipulations without copying too many strings. |
||

Text<'T> | |||

TextExtensions | |||

TextLogTarget | |||

TextParser<'TPar> | The recursive descent parser class contains parsing state and serves as a base class for specific parsers implementations. The specific derived parser class needs to be specified as type parameter. It should also contain the state transition table as static member variables. |
||

TextParser | |||

Torus3d | |||

Trafo2d | A trafo is a container for a forward and a backward matrix. |
||

Trafo3d | A trafo is a container for a forward and a backward matrix. |
||

Trafo3dExtensions | |||

Triangle1i | A structure that holds the indices of the vertices of a triangle. |
||

Triangle2d | A two-dimensional triangle represented by its three points. |
||

Triangle2dExtensions | |||

Triangle3d | A three-dimensional triangle represented by its three points. |
||

Triangle3dExtensions | |||

Triple | This static class allows the creation of triples without specifying the type in angle brackets. |
||

Triple<'T> | A triple is a structure containing three elements of the same type, that can be accessed at index 0, 1 and 2, or using the fields E0, E1, and E2. |
||

Tup<'T0, 'T1> | A tuple is a structure containing three elements of different types, that can be accessed using the fields E0, E1. |
||

Tup<'T0, 'T1, 'T2> | A tuple is a structure containing three elements of different types, that can be accessed using the fields E0, E1, E2. |
||

Tup<'T0, 'T1, 'T2, 'T3> | A tuple is a structure containing three elements of different types, that can be accessed using the fields E0, E1, E2, E3. |
||

Tup<'T0, 'T1, 'T2, 'T3, 'T4> | A tuple is a structure containing three elements of different types, that can be accessed using the fields E0, E1, E2, E3, E4. |
||

Tup<'T0, 'T1, 'T2, 'T3, 'T4, 'T5> | A tuple is a structure containing three elements of different types, that can be accessed using the fields E0, E1, E2, E3, E4, E5. |
||

Tup<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6> | A tuple is a structure containing three elements of different types, that can be accessed using the fields E0, E1, E2, E3, E4, E5, E6. |
||

Tup<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> | A tuple is a structure containing three elements of different types, that can be accessed using the fields E0, E1, E2, E3, E4, E5, E6, E7. |
||

Tup<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8> | A tuple is a structure containing three elements of different types, that can be accessed using the fields E0, E1, E2, E3, E4, E5, E6, E7, E8. |
||

Tup<'T0, 'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'T9> | A tuple is a structure containing three elements of different types, that can be accessed using the fields E0, E1, E2, E3, E4, E5, E6, E7, E8, E9. |
||

Tup | This static class allows the creation of tuples without specifying the types in angle brackets. |
||

Tup10<'T> | |||

Tup11<'T> | |||

Tup12<'T> | |||

Tup13<'T> | |||

Tup14<'T> | |||

Tup15<'T> | |||

Tup16<'T> | |||

Tup2<'T> | |||

Tup3<'T> | |||

Tup4<'T> | |||

Tup5<'T> | |||

Tup6<'T> | |||

Tup7<'T> | |||

Tup8<'T> | |||

Tup9<'T> | |||

TypedSymbol<'T> | A typed symbol is a symbol that is associated with a type at compile time. This can be used in Dicts to associate each key with a value type. |
||

UnionDict<'TKey, 'TValue> | A union of IDicts with left priority. |
||

UnionSymbolDict<'TValue> | A union of IDicts with Symbol keys with left priority. |
||

UniversalDict<'TKey, 'TValue> | An IDict where all possible keys return the same specified value. |
||

UniversalSymbolDict<'TValue> | An IDict with Symbol keys where all possible keys return the same specified value. |
||

V2d | |||

V2dArrayExtensions | |||

V2dConverter | |||

V2dEqualityComparer | |||

V2f | |||

V2fConverter | |||

V2fEqualityComparer | |||

V2i | |||

V2iConverter | |||

V2iEqualityComparer | |||

V2l | |||

V2lConverter | |||

V2lEqualityComparer | |||

V3d | |||

V3dConverter | |||

V3dEqualityComparer | |||

V3f | |||

V3fCoder | A V3fCoder can be used to encode direction vectors in unsigned integers. |
||

V3fConverter | |||

V3fEqualityComparer | |||

V3i | |||

V3iConverter | |||

V3iEqualityComparer | |||

V3l | |||

V3lConverter | |||

V3lEqualityComparer | |||

V4d | |||

V4dConverter | |||

V4dEqualityComparer | |||

V4f | |||

V4fConverter | |||

V4fEqualityComparer | |||

V4i | |||

V4iConverter | |||

V4iEqualityComparer | |||

V4l | |||

V4lConverter | |||

V4lEqualityComparer | |||

VariousExtensions | |||

Vec<'T> | An n-dimensional generic vector that can be used for numerical computations when used with a double type parameter. Note that the vector acts as a facade structure to an arbitrarily sized data array. This makes it possible to easily store multiple such vectors in the same data array. For this reason, modifying the vector will change the referenced data array. All operations that do that are prefixed with "Set...", including setting the individual data elements of the vector. |
||

Vec | |||

VecArray<'T> | A companion structure to the generic vector structure that holds arrays of generic vectors. Again this acts as a facade to an arbitrarily sized data array. |
||

VecBox<'T> | A companion bounding box data structure to the generic vector structure that holds a minimum and a maximum vector that is computed as the componentwise minimum/maximum of a sequence of vectors. This works on all vectors of comparable components. |
||

VecDouble | This static class contains a number of extension methods on the Vec with type parameter double. These methods allow standard numerical methods in arbitrary dimensions. Note that this class does not have the usual "Extensions" as parts of its name, so that the method name looks more natural when it is uses as a function parameter. |
||

VecExtensions | |||

VecFloat | This static class contains a number of extension methods on the Vec with type parameter float. These methods allow standard numerical methods in arbitrary dimensions. Note that this class does not have the usual "Extensions" as parts of its name, so that the method name looks more natural when it is uses as a function parameter. |
||

VecFun | This static class for extension functions for V2i has a non- standard name ending in "Fun" in order to shorten the function name when used as function parameters. |
||

Vector<'Td> | Generic vector of elements with arbitrary stride. All sizes are given as 1-dimensional vectors, with the first parameter specifying the inner dimension. The vector does not exclusively own its underlying data array, it can also serve as a window into other arrays and tensors. Operations on vectors are supported by function arguments which can be easily exploited by using lambda functions. Note: stride is called Delta (or D) within this data structure, the 1 stride direction(s) are called DX, DY, aso. |
||

Vector<'Td, 'Tv> | Generic vector of elements with arbitrary stride. All sizes are given as 1-dimensional vectors, with the first parameter specifying the inner dimension. The vector does not exclusively own its underlying data array, it can also serve as a window into other arrays and tensors. Operations on vectors are supported by function arguments which can be easily exploited by using lambda functions. Note: stride is called Delta (or D) within this data structure, the 1 stride direction(s) are called DX, DY, aso. The vector has different view and data element types, i.e. although all data is stored using the data element type, in its interfaces it acts as a vector of view element types. |
||

VectorExtensions | |||

VectorIEnumerableExtensions | |||

VectorInfo | A vector info contains the complete indexing information for a vector, but no data array. |
||

VerbatimStringTextParserExtension | |||

VolatileArray<'T> | A wrapper for a normal array for safe parallel (multi-threaded) writing. |
||

Volume<'Td> | Generic volume of elements with arbitrary stride. All sizes are given as 3-dimensional vectors, with the first parameter specifying the inner dimension. The volume does not exclusively own its underlying data array, it can also serve as a window into other arrays and tensors. Operations on volumes are supported by function arguments which can be easily exploited by using lambda functions. Note: stride is called Delta (or D) within this data structure, the 3 stride direction(s) are called DX, DY, aso. |
||

Volume<'Td, 'Tv> | Generic volume of elements with arbitrary stride. All sizes are given as 3-dimensional vectors, with the first parameter specifying the inner dimension. The volume does not exclusively own its underlying data array, it can also serve as a window into other arrays and tensors. Operations on volumes are supported by function arguments which can be easily exploited by using lambda functions. Note: stride is called Delta (or D) within this data structure, the 3 stride direction(s) are called DX, DY, aso. The volume has different view and data element types, i.e. although all data is stored using the data element type, in its interfaces it acts as a volume of view element types. |
||

VolumeInfo | A volume info contains the complete indexing information for a volume, but no data array. |
||

WeightedIndex | A structure holding a double weight and an index. |
||

Winding | |||

WorkDir | |||

XmlAtt | |||

XmlDirectText | |||

XmlDoc | |||

XmlItem | |||

XmlLazyText | |||

XmlParser | |||

Yuvf |

## Aardvark.Base.CSharp Namespace

Type | Description |

CSharpSequenceExtensions | The following extensions reside in the special namespace Aardvark.Base.CSharp as they mess with normal FSharp operation. |

## Aardvark.Base.Rendering Namespace

## System.Collections.Concurrent Namespace

Type | Description |

ConcurrentHashSet<'T> | Represents a thread-safe collection that can be accessed by multiple threads concurrently. |