Aardvark.Base

Fun

Static members

Static memberDescription
Abs(x)
Signature: x:sbyte -> sbyte

Returns the absolute value of the specified number.
Abs(x)
Signature: x:int16 -> int16

Returns the absolute value of the specified number.
Abs(x)
Signature: x:int -> int

Returns the absolute value of the specified number.
Abs(x)
Signature: x:int64 -> int64

Returns the absolute value of the specified number.
Abs(x)
Signature: x:float32 -> float32

Returns the absolute value of the specified number.
Abs(x)
Signature: x:float -> float

Returns the absolute value of the specified number.
Abs(x)
Signature: x:decimal -> decimal

Returns the absolute value of the specified number.
AbsSum(array)
Signature: array:IEnumerable<sbyte> -> int

Returns the sum of the absolute values of the given numbers.
AbsSum(array)
Signature: array:IEnumerable<int16> -> int64

Returns the sum of the absolute values of the given numbers.
AbsSum(array)
Signature: array:IEnumerable<int> -> int64

Returns the sum of the absolute values of the given numbers.
AbsSum(array)
Signature: array:IEnumerable<int64> -> int64

Returns the sum of the absolute values of the given numbers.
AbsSum(array)
Signature: array:IEnumerable<float32> -> float

Returns the sum of the absolute values of the given numbers.
AbsSum(array)
Signature: array:IEnumerable<float> -> float

Returns the sum of the absolute values of the given numbers.
AbsSum(array)
Signature: array:IEnumerable<decimal> -> decimal

Returns the sum of the absolute values of the given numbers.
Acos(x)
Signature: x:float32 -> float32

Returns the angle in radians whose cosine is the specified number.
Acos(x)
Signature: x:float -> float

Returns the angle in radians whose cosine is the specified number.
AcosC(x)
Signature: x:float32 -> float32

Returns the angle in radians whose cosine is the specified number while clamping the input to [-1, 1] in order to avoid numerical problems.
AcosC(x)
Signature: x:float -> float

Returns the angle in radians whose cosine is the specified number while clamping the input to [-1, 1] in order to avoid numerical problems.
Acosh(x)
Signature: x:float32 -> float32

Returns the inverse hyperbolic cosine of the specified number.
Acosh(x)
Signature: x:float -> float

Returns the inverse hyperbolic cosine of the specified number.
AggregateSigns(...)
Signature: (values:IEnumerable<float> * epsilon:float * negativeCount:byref<int> * zeroCount:byref<int> * positiveCount:byref<int>) -> unit
AggregateSigns(values, epsilon)
Signature: (values:IEnumerable<float> * epsilon:float) -> Signs
ApproximateEquals(x, y, epsilon)
Signature: (x:sbyte * y:sbyte * epsilon:sbyte) -> bool

Returns whether the distance between x and y is not more than epsilon.
ApproximateEquals(x, y, epsilon)
Signature: (x:int16 * y:int16 * epsilon:int16) -> bool

Returns whether the distance between x and y is not more than epsilon.
ApproximateEquals(x, y, epsilon)
Signature: (x:int * y:int * epsilon:int) -> bool

Returns whether the distance between x and y is not more than epsilon.
ApproximateEquals(x, y, epsilon)
Signature: (x:int64 * y:int64 * epsilon:int64) -> bool

Returns whether the distance between x and y is not more than epsilon.
ApproximateEquals(x, y, epsilon)
Signature: (x:float32 * y:float32 * epsilon:float32) -> bool

Returns whether the distance between x and y is not more than epsilon.
ApproximateEquals(x, y, epsilon)
Signature: (x:float * y:float * epsilon:float) -> bool

Returns whether the distance between x and y is not more than epsilon.
ApproximateEquals(x, y, epsilon)
Signature: (x:decimal * y:decimal * epsilon:decimal) -> bool

Returns whether the distance between x and y is not more than epsilon.
Asin(x)
Signature: x:float32 -> float32

Returns the angle in radians whose sine is the specified number.
Asin(x)
Signature: x:float -> float

Returns the angle in radians whose sine is the specified number.
AsinC(x)
Signature: x:float32 -> float32

Returns the angle in radians whose sine is the specified number while clamping the input to [-1, 1] in order to avoid numerical problems.
AsinC(x)
Signature: x:float -> float

Returns the angle in radians whose sine is the specified number while clamping the input to [-1, 1] in order to avoid numerical problems.
Asinh(x)
Signature: x:float32 -> float32

Returns the inverse hyperbolic sine of the specified number.
Asinh(x)
Signature: x:float -> float

Returns the inverse hyperbolic sine of the specified number.
Atan(x)
Signature: x:float32 -> float32

Returns the angle in radians whose tangent is the specified number.
Atan(x)
Signature: x:float -> float

Returns the angle in radians whose tangent is the specified number.
Atan2(y, x)
Signature: (y:float32 * x:float32) -> float32

Returns the angle in radians whose tangent is the quotient of the two specified number.
Atan2(y, x)
Signature: (y:float * x:float) -> float

Returns the angle in radians whose tangent is the quotient of the two specified number.
Atanh(x)
Signature: x:float32 -> float32

Returns the inverse hyperbolic tangent of the specified number. Note that the absolute value of the argument must be smaller than 1.
Atanh(x)
Signature: x:float -> float

Returns the inverse hyperbolic tangent of the specified number. Note that the absolute value of the argument must be smaller than 1.
BitwiseRotateLeft(value, numberOfBits)
Signature: (value:int * numberOfBits:int) -> int

Bitwise circular left shift.
BitwiseRotateLeft(value, numberOfBits)
Signature: (value:uint32 * numberOfBits:int) -> uint32

Bitwise circular left shift.
BitwiseRotateLeft(value, numberOfBits)
Signature: (value:int64 * numberOfBits:int) -> int64

Bitwise circular left shift.
BitwiseRotateLeft(value, numberOfBits)
Signature: (value:uint64 * numberOfBits:int) -> uint64

Bitwise circular left shift.
BSpline3d(t)
Signature: t:float -> Tup4<float>

Returns the weights of the cubic B-Spline function for four equally distant function points to approximate. The supplied parameter t in the range [0..1] traverses the approximation between the two center points.
BSpline3f(t)
Signature: t:float -> Tup4<float32>

Returns the weights of the cubic B-Spline function for four equally distant function points to approximate. The supplied parameter t in the range [0..1] traverses the approximation between the two center points.
BSpline5d(t)
Signature: t:float -> Tup6<float>

Returns the weights of the order 5 B-Spline function for six equally distant function points to approximate. The supplied parameter t in the range [0..1] traverses the approximation between the two center points.
BSpline5f(t)
Signature: t:float -> Tup6<float32>

Returns the weights of the order 5 B-Spline function for six equally distant function points to approximate. The supplied parameter t in the range [0..1] traverses the approximation between the two center points.
Cbrt(x)
Signature: x:float32 -> float
Cbrt(x)
Signature: x:float -> float
Ceiling(x)
Signature: x:float32 -> float32

Returns the smallest integer greater than or equal to the specified number.
Ceiling(x)
Signature: x:float -> float

Returns the smallest integer greater than or equal to the specified number.
Clamp(x, a, b)
Signature: (x:byte * a:byte * b:byte) -> byte

Clamps value to interval [a,b].
Clamp(x, a, b)
Signature: (x:sbyte * a:sbyte * b:sbyte) -> sbyte

Clamps value to interval [a,b].
Clamp(x, a, b)
Signature: (x:int16 * a:int16 * b:int16) -> int16

Clamps value to interval [a,b].
Clamp(x, a, b)
Signature: (x:uint16 * a:uint16 * b:uint16) -> uint16

Clamps value to interval [a,b].
Clamp(x, a, b)
Signature: (x:int * a:int * b:int) -> int

Clamps value to interval [a,b].
Clamp(x, a, b)
Signature: (x:uint32 * a:uint32 * b:uint32) -> uint32

Clamps value to interval [a,b].
Clamp(x, a, b)
Signature: (x:int64 * a:int64 * b:int64) -> int64

Clamps value to interval [a,b].
Clamp(x, a, b)
Signature: (x:uint64 * a:uint64 * b:uint64) -> uint64

Clamps value to interval [a,b].
Clamp(x, a, b)
Signature: (x:float32 * a:float32 * b:float32) -> float32

Clamps value to interval [a,b].
Clamp(x, a, b)
Signature: (x:float * a:float * b:float) -> float

Clamps value to interval [a,b].
Clamp(x, a, b)
Signature: (x:decimal * a:decimal * b:decimal) -> decimal

Clamps value to interval [a,b].
Clamp(x, range)
Signature: (x:int * range:Range1i) -> int

Clamps value to interval [a,b].
Clamp(x, range)
Signature: (x:int64 * range:Range1l) -> int64

Clamps value to interval [a,b].
Clamp(x, range)
Signature: (x:float32 * range:Range1f) -> float32

Clamps value to interval [a,b].
Clamp(x, range)
Signature: (x:float * range:Range1d) -> float

Clamps value to interval [a,b].
ClampExcl(x, a, b)
Signature: (x:byte * a:byte * b:byte) -> byte

Clamps value to interval [a,b[.
ClampExcl(x, a, b)
Signature: (x:sbyte * a:sbyte * b:sbyte) -> sbyte

Clamps value to interval [a,b[.
ClampExcl(x, a, b)
Signature: (x:int16 * a:int16 * b:int16) -> int16

Clamps value to interval [a,b[.
ClampExcl(x, a, b)
Signature: (x:uint16 * a:uint16 * b:uint16) -> uint16

Clamps value to interval [a,b[.
ClampExcl(x, a, b)
Signature: (x:int * a:int * b:int) -> int

Clamps value to interval [a,b[.
ClampExcl(x, a, b)
Signature: (x:uint32 * a:uint32 * b:uint32) -> uint32

Clamps value to interval [a,b[.
ClampExcl(x, a, b)
Signature: (x:int64 * a:int64 * b:int64) -> int64

Clamps value to interval [a,b[.
ClampExcl(x, a, b)
Signature: (x:uint64 * a:uint64 * b:uint64) -> uint64

Clamps value to interval [a,b[.
ClampExcl(x, a, b)
Signature: (x:decimal * a:decimal * b:decimal) -> decimal

Clamps value to interval [a,b[.
ClampExcl(x, range)
Signature: (x:int * range:Range1i) -> int

Clamps value to interval [a,b[.
ClampExcl(x, range)
Signature: (x:int64 * range:Range1l) -> int64

Clamps value to interval [a,b[.
ClampWrap(x, a, b)
Signature: (x:byte * a:byte * b:byte) -> byte

Clamps value to interval [a,b[ and cyclically wraps around values outside this interval.
ClampWrap(x, a, b)
Signature: (x:sbyte * a:sbyte * b:sbyte) -> sbyte

Clamps value to interval [a,b[ and cyclically wraps around values outside this interval.
ClampWrap(x, a, b)
Signature: (x:int16 * a:int16 * b:int16) -> int16

Clamps value to interval [a,b[ and cyclically wraps around values outside this interval.
ClampWrap(x, a, b)
Signature: (x:uint16 * a:uint16 * b:uint16) -> uint16

Clamps value to interval [a,b[ and cyclically wraps around values outside this interval.
ClampWrap(x, a, b)
Signature: (x:int * a:int * b:int) -> int

Clamps value to interval [a,b[ and cyclically wraps around values outside this interval.
ClampWrap(x, a, b)
Signature: (x:uint32 * a:uint32 * b:uint32) -> uint32

Clamps value to interval [a,b[ and cyclically wraps around values outside this interval.
ClampWrap(x, a, b)
Signature: (x:int64 * a:int64 * b:int64) -> int64

Clamps value to interval [a,b[ and cyclically wraps around values outside this interval.
ClampWrap(x, a, b)
Signature: (x:float32 * a:float32 * b:float32) -> float32

Clamps value to interval [a,b[ and cyclically wraps around values outside this interval.
ClampWrap(x, a, b)
Signature: (x:float * a:float * b:float) -> float

Clamps value to interval [a,b[ and cyclically wraps around values outside this interval.
ClampWrap(x, a, b)
Signature: (x:decimal * a:decimal * b:decimal) -> decimal

Clamps value to interval [a,b[ and cyclically wraps around values outside this interval.
ClampWrap(x, range)
Signature: (x:int * range:Range1i) -> int

Clamps value to interval [a,b[ and cyclically wraps around values outside this interval.
ClampWrap(x, range)
Signature: (x:int64 * range:Range1l) -> int64

Clamps value to interval [a,b[ and cyclically wraps around values outside this interval.
ClampWrap(x, range)
Signature: (x:float32 * range:Range1f) -> float32

Clamps value to interval [a,b[ and cyclically wraps around values outside this interval.
ClampWrap(x, range)
Signature: (x:float * range:Range1d) -> float

Clamps value to interval [a,b[ and cyclically wraps around values outside this interval.
Cos(x)
Signature: x:float32 -> float32

Returns the cosine of the specified angle in radians.
Cos(x)
Signature: x:float -> float

Returns the cosine of the specified angle in radians.
Cosh(x)
Signature: x:float32 -> float32

Returns the hyperbolic cosine of the specified number.
Cosh(x)
Signature: x:float -> float

Returns the hyperbolic cosine of the specified number.
CountNegatives(array)
Signature: array:IEnumerable<sbyte> -> int

Return the number of values less than 0.
CountNegatives(array)
Signature: array:IEnumerable<int16> -> int

Return the number of values less than 0.
CountNegatives(array)
Signature: array:IEnumerable<int> -> int

Return the number of values less than 0.
CountNegatives(array)
Signature: array:IEnumerable<int64> -> int

Return the number of values less than 0.
CountNegatives(array)
Signature: array:IEnumerable<float32> -> int

Return the number of values less than 0.
CountNegatives(array)
Signature: array:IEnumerable<float> -> int

Return the number of values less than 0.
CountNegatives(array)
Signature: array:IEnumerable<decimal> -> int

Return the number of values less than 0.
CountPositives(array)
Signature: array:IEnumerable<sbyte> -> int

Return the number of values greater than 0.
CountPositives(array)
Signature: array:IEnumerable<int16> -> int

Return the number of values greater than 0.
CountPositives(array)
Signature: array:IEnumerable<int> -> int

Return the number of values greater than 0.
CountPositives(array)
Signature: array:IEnumerable<int64> -> int

Return the number of values greater than 0.
CountPositives(array)
Signature: array:IEnumerable<float32> -> int

Return the number of values greater than 0.
CountPositives(array)
Signature: array:IEnumerable<float> -> int

Return the number of values greater than 0.
CountPositives(array)
Signature: array:IEnumerable<decimal> -> int

Return the number of values greater than 0.
CreateCubicTup4d(a)
Signature: a:float -> Func<float,Tup4<float>>

Creates weight function for cubic interpolation according to "Comparison of Interpolating for Image Resampling" by J.A.Parker, R.V.Kenyon & D.E.Troxel, IEEE Transactions on Medical Imaging Vol. 2, 1983. Recommended values for a: -0.5 for medical/astronomical images, -1.0 for other photos. a = -0.5 exactly reconstructs second degree polynomials, a = -0.75 results in a continuous second derivative of the two polynomials used a = -1.0 matches the slope of the sinc function at 1 (amplifying frequencies just below the cutoff frequency)
CreateCubicTup4f(a)
Signature: a:float -> Func<float,Tup4<float32>>

Creates weight function for cubic interpolation according to "Comparison of Interpolating for Image Resampling" by J.A.Parker, R.V.Kenyon & D.E.Troxel, IEEE Transactions on Medical Imaging Vol. 2, 1983. Recommended values for a: -0.5 for medical/astronomical images, -1.0 for other photos. a = -0.5 exactly reconstructs second degree polynomials, a = -0.75 results in a continuous second derivative of the two polynomials used a = -1.0 matches the slope of the sinc function at 1 (amplifying frequencies just below the cutoff frequency)
DigitCountOfFractionalPart(value)
Signature: value:float -> int
DigitCountOfFractionalPart(value)
Signature: value:float32 -> int
DigitCountOfIntegerPart(value)
Signature: value:float -> int
DigitCountOfIntegerPart(value)
Signature: value:float32 -> int
Entropy(xs)
Signature: xs:IEnumerable<'T> -> float
Type parameters: 'T

Shannon entropy of values.
Entropy(xs)
Signature: (xs:bool []) -> float
Type parameters: 'T

Shannon entropy of bipartite set.
Entropy(xs, weights)
Signature: (xs:bool [] * weights:float []) -> float

Shannon entropy of weighted bipartite set.
Exp(x)
Signature: x:float32 -> float32

Returns e raised to the specified number.
Exp(x)
Signature: x:float -> float

Returns e raised to the specified number.
FastAtan2(y, x)
Signature: (y:float32 * x:float32) -> float32

Returns the angle in radians whose tangent is the quotient of the two specified number using a faster algorithm than Math.Atan2. NOTE: Accuracy untested
FastAtan2(y, x)
Signature: (y:float * x:float) -> float

Returns the angle in radians whose tangent is the quotient of the two specified number using a faster algorithm than Math.Atan2. NOTE: Accuracy untested
Floor(x)
Signature: x:float32 -> float32

Returns the largest integer less than or equal to the specified number.
Floor(x)
Signature: x:float -> float

Returns the largest integer less than or equal to the specified number.
Frac(t)
Signature: t:float -> float

Returns fractional part of t. Calculated as t - floor(t).
Frac(t)
Signature: t:float32 -> float32

Returns fractional part of t. Calculated as t - floor(t).
Frac(t)
Signature: t:decimal -> decimal

Returns fractional part of t. Calculated as t - floor(t).
GetSigns(value, epsilon)
Signature: (value:float * epsilon:float) -> Signs
GreatestCommonDivisor(a, b)
Signature: (a:int64 * b:int64) -> int64
HighestBit(i)
Signature: i:int -> int
Identity(value)
Signature: value:'T -> 'T
Type parameters: 'T
IndexOfLargestLessOrEqual(a, x)
Signature: (a:'T [] * x:'T) -> int
Type parameters: 'T

For an array of monotonically increasing values, returns the index i of the largest value such that array[i] <= x. If x is smaller than the first value, then -1 is returned. If x is greater than the last value, then a.Length is returned.
IndexOfLargestLessOrEqual(a, x)
Signature: (a:List<'T> * x:'T) -> int
Type parameters: 'T

For a list of monotonically increasing values, returns the index i of the largest value such that list[i] <= x. If x is smaller than the first value, then -1 is returned. If x is greater than the last value, then a.Count is returned.
InvLerp(y, a, b)
Signature: (y:float32 * a:float32 * b:float32) -> float32

The inverse of Lerp.
InvLerp(y, a, b)
Signature: (y:float32 * a:float * b:float) -> float

The inverse of Lerp.
InvLerp(y, a, b)
Signature: (y:float * a:float32 * b:float32) -> float32

The inverse of Lerp.
InvLerp(y, a, b)
Signature: (y:float * a:float * b:float) -> float

The inverse of Lerp.
IsInfinity(v)
Signature: v:float -> bool
IsInfinity(v)
Signature: v:float32 -> bool
IsMonotonicallyDecreasing(self)
Signature: self:IEnumerable<'T> -> bool
Type parameters: 'T
IsMonotonicallyIncreasing(self)
Signature: self:IEnumerable<'T> -> bool
Type parameters: 'T
IsNaN(v)
Signature: v:float -> bool
IsNaN(v)
Signature: v:float32 -> bool
IsNegativeInfinity(v)
Signature: v:float -> bool
IsNegativeInfinity(v)
Signature: v:float32 -> bool
IsPositiveInfinity(v)
Signature: v:float -> bool
IsPositiveInfinity(v)
Signature: v:float32 -> bool
IsPowerOfTwo(x)
Signature: x:int -> bool

Returns true if the supplied number is 0 or a power of two.
IsPowerOfTwo(x)
Signature: x:int64 -> bool

Returns true if the supplied number is 0 or a power of two.
IsPrime(value)
Signature: value:int -> bool

Checks if the given value is a prime number.
IsPrime(value)
Signature: value:int64 -> bool

Checks if the given value is a prime number.
IsStrictlyDecreasing(self)
Signature: self:IEnumerable<'T> -> bool
Type parameters: 'T
IsStrictlyIncreasing(self)
Signature: self:IEnumerable<'T> -> bool
Type parameters: 'T
IsTiny(x)
Signature: x:float32 -> bool

Returns true if the absolulte value of the supplied float is smaller than 4 times the machine epsilon.
IsTiny(x, epsilon)
Signature: (x:float32 * epsilon:float32) -> bool

Returns true if the absolulte value of the supplied float is smaller than the supplied .
IsTiny(x)
Signature: x:float -> bool

Returns true if the absolulte value of the supplied float is smaller than 4 times the machine epsilon.
IsTiny(x, epsilon)
Signature: (x:float * epsilon:float) -> bool

Returns true if the absolulte value of the supplied float is smaller than the supplied .
Lanczos3d(x)
Signature: x:float -> Tup6<float>
Lanczos3f(x)
Signature: x:float -> Tup6<float32>
LeastCommonMultiple(a, b)
Signature: (a:int64 * b:int64) -> int64
Lerp(x, a, b)
Signature: (x:float32 * a:byte * b:byte) -> byte
Lerp(x, a, b)
Signature: (x:float32 * a:uint16 * b:uint16) -> uint16
Lerp(x, a, b)
Signature: (x:float32 * a:int16 * b:int16) -> int16
Lerp(x, a, b)
Signature: (x:float32 * a:uint32 * b:uint32) -> uint32
Lerp(x, a, b)
Signature: (x:float32 * a:int * b:int) -> int
Lerp(x, a, b)
Signature: (x:float32 * a:float32 * b:float32) -> float32
Lerp(x, a, b)
Signature: (x:float32 * a:float * b:float) -> float
Lerp(x, a, b)
Signature: (x:float * a:byte * b:byte) -> byte
Lerp(x, a, b)
Signature: (x:float * a:uint16 * b:uint16) -> uint16
Lerp(x, a, b)
Signature: (x:float * a:int16 * b:int16) -> int16
Lerp(x, a, b)
Signature: (x:float * a:uint32 * b:uint32) -> uint32
Lerp(x, a, b)
Signature: (x:float * a:int * b:int) -> int
Lerp(x, a, b)
Signature: (x:float * a:float32 * b:float32) -> float32
Lerp(x, a, b)
Signature: (x:float * a:float * b:float) -> float
LinCom(p0, p1, p2, p3, w)
Signature: (p0:byte * p1:byte * p2:byte * p3:byte * w:byref<Tup4<float32>>) -> byte
LinCom(p0, p1, p2, p3, w)
Signature: (p0:byte * p1:byte * p2:byte * p3:byte * w:byref<Tup4<float>>) -> byte
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:byte * p1:byte * p2:byte * p3:byte * p4:byte * p5:byte * w:byref<Tup6<float32>>) -> byte
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:byte * p1:byte * p2:byte * p3:byte * p4:byte * p5:byte * w:byref<Tup6<float>>) -> byte
LinCom(p0, p1, p2, p3, w)
Signature: (p0:sbyte * p1:sbyte * p2:sbyte * p3:sbyte * w:byref<Tup4<float32>>) -> sbyte
LinCom(p0, p1, p2, p3, w)
Signature: (p0:sbyte * p1:sbyte * p2:sbyte * p3:sbyte * w:byref<Tup4<float>>) -> sbyte
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:sbyte * p1:sbyte * p2:sbyte * p3:sbyte * p4:sbyte * p5:sbyte * w:byref<Tup6<float32>>) -> sbyte
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:sbyte * p1:sbyte * p2:sbyte * p3:sbyte * p4:sbyte * p5:sbyte * w:byref<Tup6<float>>) -> sbyte
LinCom(p0, p1, p2, p3, w)
Signature: (p0:int16 * p1:int16 * p2:int16 * p3:int16 * w:byref<Tup4<float32>>) -> int16
LinCom(p0, p1, p2, p3, w)
Signature: (p0:int16 * p1:int16 * p2:int16 * p3:int16 * w:byref<Tup4<float>>) -> int16
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:int16 * p1:int16 * p2:int16 * p3:int16 * p4:int16 * p5:int16 * w:byref<Tup6<float32>>) -> int16
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:int16 * p1:int16 * p2:int16 * p3:int16 * p4:int16 * p5:int16 * w:byref<Tup6<float>>) -> int16
LinCom(p0, p1, p2, p3, w)
Signature: (p0:uint16 * p1:uint16 * p2:uint16 * p3:uint16 * w:byref<Tup4<float32>>) -> uint16
LinCom(p0, p1, p2, p3, w)
Signature: (p0:uint16 * p1:uint16 * p2:uint16 * p3:uint16 * w:byref<Tup4<float>>) -> uint16
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:uint16 * p1:uint16 * p2:uint16 * p3:uint16 * p4:uint16 * p5:uint16 * w:byref<Tup6<float32>>) -> uint16
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:uint16 * p1:uint16 * p2:uint16 * p3:uint16 * p4:uint16 * p5:uint16 * w:byref<Tup6<float>>) -> uint16
LinCom(p0, p1, p2, p3, w)
Signature: (p0:int * p1:int * p2:int * p3:int * w:byref<Tup4<float32>>) -> int
LinCom(p0, p1, p2, p3, w)
Signature: (p0:int * p1:int * p2:int * p3:int * w:byref<Tup4<float>>) -> int
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:int * p1:int * p2:int * p3:int * p4:int * p5:int * w:byref<Tup6<float32>>) -> int
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:int * p1:int * p2:int * p3:int * p4:int * p5:int * w:byref<Tup6<float>>) -> int
LinCom(p0, p1, p2, p3, w)
Signature: (p0:uint32 * p1:uint32 * p2:uint32 * p3:uint32 * w:byref<Tup4<float32>>) -> uint32
LinCom(p0, p1, p2, p3, w)
Signature: (p0:uint32 * p1:uint32 * p2:uint32 * p3:uint32 * w:byref<Tup4<float>>) -> uint32
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:uint32 * p1:uint32 * p2:uint32 * p3:uint32 * p4:uint32 * p5:uint32 * w:byref<Tup6<float32>>) -> uint32
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:uint32 * p1:uint32 * p2:uint32 * p3:uint32 * p4:uint32 * p5:uint32 * w:byref<Tup6<float>>) -> uint32
LinCom(p0, p1, p2, p3, w)
Signature: (p0:int64 * p1:int64 * p2:int64 * p3:int64 * w:byref<Tup4<float32>>) -> int64
LinCom(p0, p1, p2, p3, w)
Signature: (p0:int64 * p1:int64 * p2:int64 * p3:int64 * w:byref<Tup4<float>>) -> int64
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:int64 * p1:int64 * p2:int64 * p3:int64 * p4:int64 * p5:int64 * w:byref<Tup6<float32>>) -> int64
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:int64 * p1:int64 * p2:int64 * p3:int64 * p4:int64 * p5:int64 * w:byref<Tup6<float>>) -> int64
LinCom(p0, p1, p2, p3, w)
Signature: (p0:uint64 * p1:uint64 * p2:uint64 * p3:uint64 * w:byref<Tup4<float32>>) -> uint64
LinCom(p0, p1, p2, p3, w)
Signature: (p0:uint64 * p1:uint64 * p2:uint64 * p3:uint64 * w:byref<Tup4<float>>) -> uint64
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:uint64 * p1:uint64 * p2:uint64 * p3:uint64 * p4:uint64 * p5:uint64 * w:byref<Tup6<float32>>) -> uint64
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:uint64 * p1:uint64 * p2:uint64 * p3:uint64 * p4:uint64 * p5:uint64 * w:byref<Tup6<float>>) -> uint64
LinCom(p0, p1, w)
Signature: (p0:float32 * p1:float32 * w:byref<Tup2<float32>>) -> float32
LinCom(p0, p1, w)
Signature: (p0:float * p1:float * w:byref<Tup2<float>>) -> float
LinCom(p0, p1, p2, w)
Signature: (p0:float32 * p1:float32 * p2:float32 * w:byref<Tup3<float32>>) -> float32
LinCom(p0, p1, p2, w)
Signature: (p0:float * p1:float * p2:float * w:byref<Tup3<float>>) -> float
LinCom(p0, p1, p2, p3, w)
Signature: (p0:float32 * p1:float32 * p2:float32 * p3:float32 * w:byref<Tup4<float32>>) -> float32
LinCom(p0, p1, p2, p3, w)
Signature: (p0:float * p1:float * p2:float * p3:float * w:byref<Tup4<float>>) -> float
LinCom(p0, p1, p2, p3, p4, w)
Signature: (p0:float32 * p1:float32 * p2:float32 * p3:float32 * p4:float32 * w:byref<Tup5<float32>>) -> float32
LinCom(p0, p1, p2, p3, p4, w)
Signature: (p0:float * p1:float * p2:float * p3:float * p4:float * w:byref<Tup5<float>>) -> float
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:float32 * p1:float32 * p2:float32 * p3:float32 * p4:float32 * p5:float32 * w:byref<Tup6<float32>>) -> float32
LinCom(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:float * p1:float * p2:float * p3:float * p4:float * p5:float * w:byref<Tup6<float>>) -> float
LinCom(p0, p1, p2, p3, p4, p5, p6, w)
Signature: (p0:float32 * p1:float32 * p2:float32 * p3:float32 * p4:float32 * p5:float32 * p6:float32 * w:byref<Tup7<float32>>) -> float32
LinCom(p0, p1, p2, p3, p4, p5, p6, w)
Signature: (p0:float * p1:float * p2:float * p3:float * p4:float * p5:float * p6:float * w:byref<Tup7<float>>) -> float
LinComRawD(p0, p1, p2, p3, w)
Signature: (p0:byte * p1:byte * p2:byte * p3:byte * w:byref<Tup4<float>>) -> float
LinComRawD(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:byte * p1:byte * p2:byte * p3:byte * p4:byte * p5:byte * w:byref<Tup6<float>>) -> float
LinComRawD(p0, p1, p2, p3, w)
Signature: (p0:sbyte * p1:sbyte * p2:sbyte * p3:sbyte * w:byref<Tup4<float>>) -> float
LinComRawD(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:sbyte * p1:sbyte * p2:sbyte * p3:sbyte * p4:sbyte * p5:sbyte * w:byref<Tup6<float>>) -> float
LinComRawD(p0, p1, p2, p3, w)
Signature: (p0:int16 * p1:int16 * p2:int16 * p3:int16 * w:byref<Tup4<float>>) -> float
LinComRawD(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:int16 * p1:int16 * p2:int16 * p3:int16 * p4:int16 * p5:int16 * w:byref<Tup6<float>>) -> float
LinComRawD(p0, p1, p2, p3, w)
Signature: (p0:uint16 * p1:uint16 * p2:uint16 * p3:uint16 * w:byref<Tup4<float>>) -> float
LinComRawD(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:uint16 * p1:uint16 * p2:uint16 * p3:uint16 * p4:uint16 * p5:uint16 * w:byref<Tup6<float>>) -> float
LinComRawD(p0, p1, p2, p3, w)
Signature: (p0:int * p1:int * p2:int * p3:int * w:byref<Tup4<float>>) -> float
LinComRawD(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:int * p1:int * p2:int * p3:int * p4:int * p5:int * w:byref<Tup6<float>>) -> float
LinComRawD(p0, p1, p2, p3, w)
Signature: (p0:uint32 * p1:uint32 * p2:uint32 * p3:uint32 * w:byref<Tup4<float>>) -> float
LinComRawD(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:uint32 * p1:uint32 * p2:uint32 * p3:uint32 * p4:uint32 * p5:uint32 * w:byref<Tup6<float>>) -> float
LinComRawD(p0, p1, p2, p3, w)
Signature: (p0:int64 * p1:int64 * p2:int64 * p3:int64 * w:byref<Tup4<float>>) -> float
LinComRawD(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:int64 * p1:int64 * p2:int64 * p3:int64 * p4:int64 * p5:int64 * w:byref<Tup6<float>>) -> float
LinComRawD(p0, p1, p2, p3, w)
Signature: (p0:uint64 * p1:uint64 * p2:uint64 * p3:uint64 * w:byref<Tup4<float>>) -> float
LinComRawD(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:uint64 * p1:uint64 * p2:uint64 * p3:uint64 * p4:uint64 * p5:uint64 * w:byref<Tup6<float>>) -> float
LinComRawF(p0, p1, p2, p3, w)
Signature: (p0:byte * p1:byte * p2:byte * p3:byte * w:byref<Tup4<float32>>) -> float32
LinComRawF(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:byte * p1:byte * p2:byte * p3:byte * p4:byte * p5:byte * w:byref<Tup6<float32>>) -> float32
LinComRawF(p0, p1, p2, p3, w)
Signature: (p0:sbyte * p1:sbyte * p2:sbyte * p3:sbyte * w:byref<Tup4<float32>>) -> float32
LinComRawF(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:sbyte * p1:sbyte * p2:sbyte * p3:sbyte * p4:sbyte * p5:sbyte * w:byref<Tup6<float32>>) -> float32
LinComRawF(p0, p1, p2, p3, w)
Signature: (p0:int16 * p1:int16 * p2:int16 * p3:int16 * w:byref<Tup4<float32>>) -> float32
LinComRawF(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:int16 * p1:int16 * p2:int16 * p3:int16 * p4:int16 * p5:int16 * w:byref<Tup6<float32>>) -> float32
LinComRawF(p0, p1, p2, p3, w)
Signature: (p0:uint16 * p1:uint16 * p2:uint16 * p3:uint16 * w:byref<Tup4<float32>>) -> float32
LinComRawF(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:uint16 * p1:uint16 * p2:uint16 * p3:uint16 * p4:uint16 * p5:uint16 * w:byref<Tup6<float32>>) -> float32
LinComRawF(p0, p1, p2, p3, w)
Signature: (p0:int * p1:int * p2:int * p3:int * w:byref<Tup4<float32>>) -> float32
LinComRawF(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:int * p1:int * p2:int * p3:int * p4:int * p5:int * w:byref<Tup6<float32>>) -> float32
LinComRawF(p0, p1, p2, p3, w)
Signature: (p0:uint32 * p1:uint32 * p2:uint32 * p3:uint32 * w:byref<Tup4<float32>>) -> float32
LinComRawF(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:uint32 * p1:uint32 * p2:uint32 * p3:uint32 * p4:uint32 * p5:uint32 * w:byref<Tup6<float32>>) -> float32
LinComRawF(p0, p1, p2, p3, w)
Signature: (p0:int64 * p1:int64 * p2:int64 * p3:int64 * w:byref<Tup4<float32>>) -> float32
LinComRawF(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:int64 * p1:int64 * p2:int64 * p3:int64 * p4:int64 * p5:int64 * w:byref<Tup6<float32>>) -> float32
LinComRawF(p0, p1, p2, p3, w)
Signature: (p0:uint64 * p1:uint64 * p2:uint64 * p3:uint64 * w:byref<Tup4<float32>>) -> float32
LinComRawF(p0, p1, p2, p3, p4, p5, w)
Signature: (p0:uint64 * p1:uint64 * p2:uint64 * p3:uint64 * p4:uint64 * p5:uint64 * w:byref<Tup6<float32>>) -> float32
Log(x)
Signature: x:byte -> float

Returns the natural (base e) logarithm of the specified number.
Log(x, basis)
Signature: (x:byte * basis:float) -> float

Returns the values logarithm of the specified basis.
Log(x)
Signature: x:sbyte -> float

Returns the natural (base e) logarithm of the specified number.
Log(x, basis)
Signature: (x:sbyte * basis:float) -> float

Returns the values logarithm of the specified basis.
Log(x)
Signature: x:int16 -> float

Returns the natural (base e) logarithm of the specified number.
Log(x, basis)
Signature: (x:int16 * basis:float) -> float

Returns the values logarithm of the specified basis.
Log(x)
Signature: x:uint16 -> float

Returns the natural (base e) logarithm of the specified number.
Log(x, basis)
Signature: (x:uint16 * basis:float) -> float

Returns the values logarithm of the specified basis.
Log(x)
Signature: x:int -> float

Returns the natural (base e) logarithm of the specified number.
Log(x, basis)
Signature: (x:int * basis:float) -> float

Returns the values logarithm of the specified basis.
Log(x)
Signature: x:uint32 -> float

Returns the natural (base e) logarithm of the specified number.
Log(x, basis)
Signature: (x:uint32 * basis:float) -> float

Returns the values logarithm of the specified basis.
Log(x)
Signature: x:int64 -> float

Returns the natural (base e) logarithm of the specified number.
Log(x, basis)
Signature: (x:int64 * basis:float) -> float

Returns the values logarithm of the specified basis.
Log(x)
Signature: x:uint64 -> float

Returns the natural (base e) logarithm of the specified number.
Log(x, basis)
Signature: (x:uint64 * basis:float) -> float

Returns the values logarithm of the specified basis.
Log(x)
Signature: x:float32 -> float

Returns the natural (base e) logarithm of the specified number.
Log(x, basis)
Signature: (x:float32 * basis:float) -> float

Returns the values logarithm of the specified basis.
Log(x)
Signature: x:float -> float

Returns the natural (base e) logarithm of the specified number.
Log(x, basis)
Signature: (x:float * basis:float) -> float

Returns the values logarithm of the specified basis.
Log10(x)
Signature: x:byte -> float

Returns the base 10 logarithm of the specified number.
Log10(x)
Signature: x:sbyte -> float

Returns the base 10 logarithm of the specified number.
Log10(x)
Signature: x:int16 -> float

Returns the base 10 logarithm of the specified number.
Log10(x)
Signature: x:uint16 -> float

Returns the base 10 logarithm of the specified number.
Log10(x)
Signature: x:int -> float

Returns the base 10 logarithm of the specified number.
Log10(x)
Signature: x:uint32 -> float

Returns the base 10 logarithm of the specified number.
Log10(x)
Signature: x:int64 -> float

Returns the base 10 logarithm of the specified number.
Log10(x)
Signature: x:uint64 -> float

Returns the base 10 logarithm of the specified number.
Log10(x)
Signature: x:float32 -> float

Returns the base 10 logarithm of the specified number.
Log10(x)
Signature: x:float -> float

Returns the base 10 logarithm of the specified number.
Log2(x)
Signature: x:byte -> float

Returns the base 2 logarithm of the specified number.
Log2(x)
Signature: x:sbyte -> float

Returns the base 2 logarithm of the specified number.
Log2(x)
Signature: x:int16 -> float

Returns the base 2 logarithm of the specified number.
Log2(x)
Signature: x:uint16 -> float

Returns the base 2 logarithm of the specified number.
Log2(x)
Signature: x:int -> float

Returns the base 2 logarithm of the specified number.
Log2(x)
Signature: x:uint32 -> float

Returns the base 2 logarithm of the specified number.
Log2(x)
Signature: x:int64 -> float

Returns the base 2 logarithm of the specified number.
Log2(x)
Signature: x:uint64 -> float

Returns the base 2 logarithm of the specified number.
Log2(x)
Signature: x:float32 -> float

Returns the base 2 logarithm of the specified number.
Log2(x)
Signature: x:float -> float

Returns the base 2 logarithm of the specified number.
Log2Int(v)
Signature: v:float -> int

efficiently computes the Log2 for the given value rounded to the next integer towards -inf
LongIndexOfLargestLessOrEqual(a, x)
Signature: (a:'T [] * x:'T) -> int64
Type parameters: 'T

For an array of monotonically increasing values, returns the index i of the largest value such that array[i] <= x. If x is smaller than the first value, then -1 is returned. If x is greater than the last value, then a.Length is returned.
MapToUnitInterval(...)
Signature: (t:float * tMax:float * repeat:bool * mirror:bool) -> float

Maps value from interval [0, tMax] to interval [0, 1]. Values outside [0, tMax] are clamped - if t is greater than tMax then 1 is returned, if t is less than 0 then 0 is returned. If 'repeat' is true, then every interval [i tMax, (i+1) tMax] (for i from integers) is mapped to [0, 1]. If 'mirror' is true, then every second interval is flipped, such that [0, tMax) [tMax, 2tMax) [2tMax, 3*tMax] ... is mapped to [0,1)[1,0)[0,1)...
MapToUnitInterval(t, tMax, repeat)
Signature: (t:float * tMax:float * repeat:bool) -> float

Maps value from interval [0, tMax] to interval [0, 1]. If 'repeat' is true, then every interval [i tMax, (i+1) tMax] (for i from integers) is mapped to [0, 1].
MapToUnitInterval(t, tMax)
Signature: (t:float * tMax:float) -> float

Maps value from interval [0, tMax] to interval [0, 1].
MapToUnitInterval(t, tMin, tMax)
Signature: (t:float * tMin:float * tMax:float) -> float

Maps value from interval [tMin, tMax] to interval [0, 1].
Max(a, b)
Signature: (a:byte * b:byte) -> byte
Max(a, b, c)
Signature: (a:byte * b:byte * c:byte) -> byte
Max(a, b, c, d)
Signature: (a:byte * b:byte * c:byte * d:byte) -> byte
Max(a, b)
Signature: (a:sbyte * b:sbyte) -> sbyte
Max(a, b, c)
Signature: (a:sbyte * b:sbyte * c:sbyte) -> sbyte
Max(a, b, c, d)
Signature: (a:sbyte * b:sbyte * c:sbyte * d:sbyte) -> sbyte
Max(a, b)
Signature: (a:int16 * b:int16) -> int16
Max(a, b, c)
Signature: (a:int16 * b:int16 * c:int16) -> int16
Max(a, b, c, d)
Signature: (a:int16 * b:int16 * c:int16 * d:int16) -> int16
Max(a, b)
Signature: (a:uint16 * b:uint16) -> uint16
Max(a, b, c)
Signature: (a:uint16 * b:uint16 * c:uint16) -> uint16
Max(a, b, c, d)
Signature: (a:uint16 * b:uint16 * c:uint16 * d:uint16) -> uint16
Max(a, b)
Signature: (a:int * b:int) -> int
Max(a, b, c)
Signature: (a:int * b:int * c:int) -> int
Max(a, b, c, d)
Signature: (a:int * b:int * c:int * d:int) -> int
Max(a, b)
Signature: (a:uint32 * b:uint32) -> uint32
Max(a, b, c)
Signature: (a:uint32 * b:uint32 * c:uint32) -> uint32
Max(a, b, c, d)
Signature: (a:uint32 * b:uint32 * c:uint32 * d:uint32) -> uint32
Max(a, b)
Signature: (a:int64 * b:int64) -> int64
Max(a, b, c)
Signature: (a:int64 * b:int64 * c:int64) -> int64
Max(a, b, c, d)
Signature: (a:int64 * b:int64 * c:int64 * d:int64) -> int64
Max(a, b)
Signature: (a:uint64 * b:uint64) -> uint64
Max(a, b, c)
Signature: (a:uint64 * b:uint64 * c:uint64) -> uint64
Max(a, b, c, d)
Signature: (a:uint64 * b:uint64 * c:uint64 * d:uint64) -> uint64
Max(a, b)
Signature: (a:float32 * b:float32) -> float32
Max(a, b, c)
Signature: (a:float32 * b:float32 * c:float32) -> float32
Max(a, b, c, d)
Signature: (a:float32 * b:float32 * c:float32 * d:float32) -> float32
Max(a, b)
Signature: (a:float * b:float) -> float
Max(a, b, c)
Signature: (a:float * b:float * c:float) -> float
Max(a, b, c, d)
Signature: (a:float * b:float * c:float * d:float) -> float
Max(a, b)
Signature: (a:Fraction * b:Fraction) -> Fraction
Max(a, b, c)
Signature: (a:Fraction * b:Fraction * c:Fraction) -> Fraction
Max(a, b, c, d)
Signature: (a:Fraction * b:Fraction * c:Fraction * d:Fraction) -> Fraction
Max(a, b)
Signature: (a:DateTime * b:DateTime) -> DateTime
Max(a, b, c)
Signature: (a:DateTime * b:DateTime * c:DateTime) -> DateTime
Max(a, b, c, d)
Signature: (a:DateTime * b:DateTime * c:DateTime * d:DateTime) -> DateTime
Max(a, b)
Signature: (a:TimeSpan * b:TimeSpan) -> TimeSpan
Max(a, b, c)
Signature: (a:TimeSpan * b:TimeSpan * c:TimeSpan) -> TimeSpan
Max(a, b, c, d)
Signature: (a:TimeSpan * b:TimeSpan * c:TimeSpan * d:TimeSpan) -> TimeSpan
Mean(array)
Signature: array:IEnumerable<byte> -> float

Returns the mean of the given values.
Mean(array)
Signature: array:IEnumerable<sbyte> -> float

Returns the mean of the given values.
Mean(array)
Signature: array:IEnumerable<int16> -> float

Returns the mean of the given values.
Mean(array)
Signature: array:IEnumerable<uint16> -> float

Returns the mean of the given values.
Mean(array)
Signature: array:IEnumerable<int> -> float

Returns the mean of the given values.
Mean(array)
Signature: array:IEnumerable<uint32> -> float

Returns the mean of the given values.
Mean(array)
Signature: array:IEnumerable<int64> -> float

Returns the mean of the given values.
Mean(array)
Signature: array:IEnumerable<uint64> -> float

Returns the mean of the given values.
Mean(array)
Signature: array:IEnumerable<float32> -> float

Returns the mean of the given values.
Mean(array)
Signature: array:IEnumerable<float> -> float

Returns the mean of the given values.
Mean(array)
Signature: array:IEnumerable<decimal> -> decimal
Mean(array, selector)
Signature: (array:IEnumerable<'T> * selector:Func<'T,float>) -> float
Type parameters: 'T

Returns the mean of the given values.
Min(a, b)
Signature: (a:byte * b:byte) -> byte
Min(a, b, c)
Signature: (a:byte * b:byte * c:byte) -> byte
Min(a, b, c, d)
Signature: (a:byte * b:byte * c:byte * d:byte) -> byte
Min(a, b)
Signature: (a:sbyte * b:sbyte) -> sbyte
Min(a, b, c)
Signature: (a:sbyte * b:sbyte * c:sbyte) -> sbyte
Min(a, b, c, d)
Signature: (a:sbyte * b:sbyte * c:sbyte * d:sbyte) -> sbyte
Min(a, b)
Signature: (a:int16 * b:int16) -> int16
Min(a, b, c)
Signature: (a:int16 * b:int16 * c:int16) -> int16
Min(a, b, c, d)
Signature: (a:int16 * b:int16 * c:int16 * d:int16) -> int16
Min(a, b)
Signature: (a:uint16 * b:uint16) -> uint16
Min(a, b, c)
Signature: (a:uint16 * b:uint16 * c:uint16) -> uint16
Min(a, b, c, d)
Signature: (a:uint16 * b:uint16 * c:uint16 * d:uint16) -> uint16
Min(a, b)
Signature: (a:int * b:int) -> int
Min(a, b, c)
Signature: (a:int * b:int * c:int) -> int
Min(a, b, c, d)
Signature: (a:int * b:int * c:int * d:int) -> int
Min(a, b)
Signature: (a:uint32 * b:uint32) -> uint32
Min(a, b, c)
Signature: (a:uint32 * b:uint32 * c:uint32) -> uint32
Min(a, b, c, d)
Signature: (a:uint32 * b:uint32 * c:uint32 * d:uint32) -> uint32
Min(a, b)
Signature: (a:int64 * b:int64) -> int64
Min(a, b, c)
Signature: (a:int64 * b:int64 * c:int64) -> int64
Min(a, b, c, d)
Signature: (a:int64 * b:int64 * c:int64 * d:int64) -> int64
Min(a, b)
Signature: (a:uint64 * b:uint64) -> uint64
Min(a, b, c)
Signature: (a:uint64 * b:uint64 * c:uint64) -> uint64
Min(a, b, c, d)
Signature: (a:uint64 * b:uint64 * c:uint64 * d:uint64) -> uint64
Min(a, b)
Signature: (a:float32 * b:float32) -> float32
Min(a, b, c)
Signature: (a:float32 * b:float32 * c:float32) -> float32
Min(a, b, c, d)
Signature: (a:float32 * b:float32 * c:float32 * d:float32) -> float32
Min(a, b)
Signature: (a:float * b:float) -> float
Min(a, b, c)
Signature: (a:float * b:float * c:float) -> float
Min(a, b, c, d)
Signature: (a:float * b:float * c:float * d:float) -> float
Min(a, b)
Signature: (a:Fraction * b:Fraction) -> Fraction
Min(a, b, c)
Signature: (a:Fraction * b:Fraction * c:Fraction) -> Fraction
Min(a, b, c, d)
Signature: (a:Fraction * b:Fraction * c:Fraction * d:Fraction) -> Fraction
Min(a, b)
Signature: (a:DateTime * b:DateTime) -> DateTime
Min(a, b, c)
Signature: (a:DateTime * b:DateTime * c:DateTime) -> DateTime
Min(a, b, c, d)
Signature: (a:DateTime * b:DateTime * c:DateTime * d:DateTime) -> DateTime
Min(a, b)
Signature: (a:TimeSpan * b:TimeSpan) -> TimeSpan
Min(a, b, c)
Signature: (a:TimeSpan * b:TimeSpan * c:TimeSpan) -> TimeSpan
Min(a, b, c, d)
Signature: (a:TimeSpan * b:TimeSpan * c:TimeSpan * d:TimeSpan) -> TimeSpan
MinusRelativeEps(value, eps)
Signature: (value:float32 * eps:float32) -> float32
MinusRelativeEps(value, eps)
Signature: (value:float * eps:float32) -> float
ModP(a, b)
Signature: (a:sbyte * b:sbyte) -> sbyte

Returns the positive modulo operation a mod b giving values between [0,b[ instead of a % b giving values between ]-b,b[.
ModP(a, b)
Signature: (a:int16 * b:int16) -> int16

Returns the positive modulo operation a mod b giving values between [0,b[ instead of a % b giving values between ]-b,b[.
ModP(a, b)
Signature: (a:int * b:int) -> int

Returns the positive modulo operation a mod b giving values between [0,b[ instead of a % b giving values between ]-b,b[.
ModP(a, b)
Signature: (a:int64 * b:int64) -> int64

Returns the positive modulo operation a mod b giving values between [0,b[ instead of a % b giving values between ]-b,b[.
ModP(a, b)
Signature: (a:float32 * b:float32) -> float32

Returns the positive modulo operation a mod b giving values between [0,b[ instead of a % b giving values between ]-b,b[.
ModP(a, b)
Signature: (a:float * b:float) -> float

Returns the positive modulo operation a mod b giving values between [0,b[ instead of a % b giving values between ]-b,b[.
ModP(a, b)
Signature: (a:decimal * b:decimal) -> decimal

Returns the positive modulo operation a mod b giving values between [0,b[ instead of a % b giving values between ]-b,b[.
NextPowerOfTwo(x)
Signature: x:int -> int

Returns the nearest superior power of two of the value. E.g. x = 401 -> 512. E.g. x = 256 -> 256.
NextPowerOfTwo(x)
Signature: x:int64 -> int64

Returns the nearest superior power of two of the value. E.g. x = 401 -> 512. E.g. x = 256 -> 256.
OuterSum(x, y)
Signature: (x:Tup2<int64> * y:Tup2<int64>) -> Tup4<int64>
OuterSum(x, y, z)
Signature: (x:Tup2<int64> * y:Tup2<int64> * z:Tup2<int64>) -> Tup8<int64>
OuterSum(x, y)
Signature: (x:Tup4<int64> * y:Tup4<int64>) -> Tup16<int64>
PlusRelativeEps(value, eps)
Signature: (value:float32 * eps:float32) -> float32
PlusRelativeEps(value, eps)
Signature: (value:float * eps:float32) -> float
Pow(x, y)
Signature: (x:int * y:float) -> float

Returns the number raised to the specified power.
Pow(x, y)
Signature: (x:int64 * y:float) -> float

Returns the number raised to the specified power.
Pow(x, y)
Signature: (x:float32 * y:float32) -> float32

Returns the number raised to the specified power.
Pow(x, y)
Signature: (x:float * y:float) -> float

Returns the number raised to the specified power.
PowerOfTwo(x)
Signature: x:int64 -> int64

Returns 2 raised to the power of the value.
PowerOfTwo(x)
Signature: x:float32 -> float32

Returns 2 raised to the power of the value.
PowerOfTwo(x)
Signature: x:float -> float

Returns 2 raised to the power of the value.
PrevPowerOfTwo(x)
Signature: x:int -> int

Returns the nearest inferior power of two of the value. E.g. x = 401 -> 256. E.g. x = 512 -> 512.
PrevPowerOfTwo(x)
Signature: x:int64 -> int64

Returns the nearest inferior power of two of the value. E.g. x = 401 -> 256. E.g. x = 512 -> 512.
Pythag(a, b)
Signature: (a:float * b:float) -> float

Computes sqrt(a²+b²) without destructive underflow or overflow.
Rotate(a, b, c)
Signature: (a:byref<'T> * b:byref<'T> * c:byref<'T>) -> unit
Type parameters: 'T

Rotates left , , and , so that afterwards a=b, b=c and c=a.
Rotate(a, b, c, d)
Signature: (a:byref<'T> * b:byref<'T> * c:byref<'T> * d:byref<'T>) -> unit
Type parameters: 'T

Rotates left , , , and , so that afterwards a=b, b=c, c=b and d=a.
Rotate(a, b, c, d, e)
Signature: (a:byref<'T> * b:byref<'T> * c:byref<'T> * d:byref<'T> * e:byref<'T>) -> unit
Type parameters: 'T

Rotates left , , , , and , so that afterwards a=b, b=c, c=b and d=c and e=a.
Round(x)
Signature: x:float32 -> float32

Rounds a float-point value to the nearest integral value.
Round(x)
Signature: x:float -> float

Rounds a float-point value to the nearest integral value.
Sign(x)
Signature: x:sbyte -> int

Returns either -1, 0, or +1, indicating the sign of the specified value .
Sign(x)
Signature: x:int16 -> int

Returns either -1, 0, or +1, indicating the sign of the specified value .
Sign(x)
Signature: x:int -> int

Returns either -1, 0, or +1, indicating the sign of the specified value .
Sign(x)
Signature: x:int64 -> int

Returns either -1, 0, or +1, indicating the sign of the specified value .
Sign(x)
Signature: x:float32 -> int

Returns either -1, 0, or +1, indicating the sign of the specified value .
Sign(x)
Signature: x:float -> int

Returns either -1, 0, or +1, indicating the sign of the specified value .
Sign(x)
Signature: x:decimal -> int

Returns either -1, 0, or +1, indicating the sign of the specified value .
Sin(x)
Signature: x:float32 -> float32

Returns the cosine of the specified angle in radians.
Sin(x)
Signature: x:float -> float

Returns the cosine of the specified angle in radians.
Sinh(x)
Signature: x:float32 -> float32

Returns the hyperbolic sine of the specified number.
Sinh(x)
Signature: x:float -> float

Returns the hyperbolic sine of the specified number.
Sqrt(x)
Signature: x:byte -> float

Returns the square root of the specified number.
Sqrt(x)
Signature: x:sbyte -> float

Returns the square root of the specified number.
Sqrt(x)
Signature: x:int16 -> float

Returns the square root of the specified number.
Sqrt(x)
Signature: x:uint16 -> float

Returns the square root of the specified number.
Sqrt(x)
Signature: x:int -> float

Returns the square root of the specified number.
Sqrt(x)
Signature: x:uint32 -> float

Returns the square root of the specified number.
Sqrt(x)
Signature: x:int64 -> float

Returns the square root of the specified number.
Sqrt(x)
Signature: x:uint64 -> float

Returns the square root of the specified number.
Sqrt(x)
Signature: x:float -> float

Returns the square root of the specified number.
Sqrt(x)
Signature: x:float32 -> float32

Returns the square root of the specified number.
Square(x)
Signature: x:byte -> int

Returns the square of the specified number.
Square(x)
Signature: x:sbyte -> int

Returns the square of the specified number.
Square(x)
Signature: x:int16 -> int64

Returns the square of the specified number.
Square(x)
Signature: x:uint16 -> int64

Returns the square of the specified number.
Square(x)
Signature: x:int -> int64

Returns the square of the specified number.
Square(x)
Signature: x:uint32 -> int64

Returns the square of the specified number.
Square(x)
Signature: x:int64 -> int64

Returns the square of the specified number.
Square(x)
Signature: x:uint64 -> uint64

Returns the square of the specified number.
Square(x)
Signature: x:float32 -> float

Returns the square of the specified number.
Square(x)
Signature: x:float -> float

Returns the square of the specified number.
Square(x)
Signature: x:decimal -> decimal

Returns the square of the specified number.
StandardDeviation(data)
Signature: data:IEnumerable<int> -> float

Calculates the standard deviation of given elements.
StandardDeviation(data)
Signature: data:IEnumerable<int64> -> float

Calculates the standard deviation of given elements.
StandardDeviation(data)
Signature: data:IEnumerable<float32> -> float

Calculates the standard deviation of given elements.
StandardDeviation(data)
Signature: data:IEnumerable<float> -> float

Calculates the standard deviation of given elements.
StandardDeviation(data, selector)
Signature: (data:IEnumerable<'T> * selector:Func<'T,float>) -> float
Type parameters: 'T

Calculates the standard deviation of given elements.
Step(x, a, b)
Signature: (x:float32 * a:'T * b:'T) -> 'T
Type parameters: 'T
Step(x, a, b)
Signature: (x:float * a:'T * b:'T) -> 'T
Type parameters: 'T
Swap(a, b)
Signature: (a:byref<'T> * b:byref<'T>) -> unit
Type parameters: 'T

Swaps and , so that afterwards a=b and b=a.
Tan(x)
Signature: x:float32 -> float32

Returns the tangent of the specified angle in radians.
Tan(x)
Signature: x:float -> float

Returns the tangent of the specified angle in radians.
Tanh(x)
Signature: x:float32 -> float32

Returns the hyperbolic tangent of the specified number.
Tanh(x)
Signature: x:float -> float

Returns the hyperbolic tangent of the specified number.
ToInt(x)
Signature: x:float32 -> int
ToInt(x)
Signature: x:float -> int
ToLong(x)
Signature: x:float32 -> int64
ToLong(x)
Signature: x:float -> int64
TrailingZeroBitCount(x)
Signature: x:int64 -> int
TrailingZeroBitCount(x)
Signature: x:int -> int
Variance(data)
Signature: data:IEnumerable<int> -> float

Calculates the variance of given elements.
Variance(data)
Signature: data:IEnumerable<int64> -> float

Calculates the variance of given elements.
Variance(data)
Signature: data:IEnumerable<float32> -> float

Calculates the variance of given elements.
Variance(data)
Signature: data:IEnumerable<float> -> float

Calculates the variance of given elements.
Variance(data, selector)
Signature: (data:IEnumerable<'T> * selector:Func<'T,float>) -> float
Type parameters: 'T

Calculates the variance of given elements.
WeightedSum(items, weights)
Signature: (items:float [] * weights:float []) -> float
Fork me on GitHub