Vector |
VectorMath provides common static functions concerning vectors.
Inheritance HierarchyNamespace: Altaxo.Calc.LinearAlgebra
Assembly: AltaxoCore (in AltaxoCore.dll) Version: 4.8.3179.0 (4.8.3179.0)
SyntaxC#
public static class VectorMath
The VectorMath type exposes the following members.
Methods| Name | Description | |
|---|---|---|
 | Add(Double, Double) | Adds all vector elements with a constant. |
| Add(Int32, Int32) | Adds all vector elements with a constant. |
| Add(IVectorDouble, Double) | Adds all vector elements with a constant. |
| Add(IVectorSingle, Single) | Adds all vector elements with a constant. |
| Add(Single, Single) | Adds all vector elements with a constant. |
  | Add(Double, Double, Double) | Adds (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length. |
| Add(Int32, Int32, Int32) | Adds (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length. |
| Add(IReadOnlyListDouble, IReadOnlyListDouble, IVectorDouble) | Adds (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length. |
| Add(IReadOnlyListSingle, IReadOnlyListSingle, IVectorSingle) | Adds (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length. |
| Add(Single, Single, Single) | Adds (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length. |
| AddScaled(Double, Double, Double, Double) | Adds (elementwise) two vectors a and (b scaled with scaleb) and stores the result in c, i.e. c = a + b * scaleb. All vectors must have the same length. The vectors a or b may be identical (the same instance) as c. |
| AddScaled(Int32, Int32, Int32, Int32) | Adds (elementwise) two vectors a and (b scaled with scaleb) and stores the result in c, i.e. c = a + b * scaleb. All vectors must have the same length. The vectors a or b may be identical (the same instance) as c. |
| AddScaled(IReadOnlyListDouble, IReadOnlyListDouble, Double, IVectorDouble) | Adds (elementwise) two vectors a and (b scaled with scaleb) and stores the result in c, i.e. c = a + b * scaleb. All vectors must have the same length. The vectors a or b may be identical (the same instance) as c. |
| AddScaled(IReadOnlyListSingle, IReadOnlyListSingle, Single, IVectorSingle) | Adds (elementwise) two vectors a and (b scaled with scaleb) and stores the result in c, i.e. c = a + b * scaleb. All vectors must have the same length. The vectors a or b may be identical (the same instance) as c. |
| AddScaled(Single, Single, Single, Single) | Adds (elementwise) two vectors a and (b scaled with scaleb) and stores the result in c, i.e. c = a + b * scaleb. All vectors must have the same length. The vectors a or b may be identical (the same instance) as c. |
| Any(Double) | Determines whether the given vector contains any elements. |
| Any(Int32) | Determines whether the given vector contains any elements. |
| Any(IReadOnlyListDouble) | Determines whether the given vector contains any elements. |
| Any(IReadOnlyListSingle) | Determines whether the given vector contains any elements. |
| Any(Single) | Determines whether the given vector contains any elements. |
| Any(Double, FuncDouble, Boolean) | Determines whether any element of the vector satisfies a condition. |
| Any(Int32, FuncInt32, Boolean) | Determines whether any element of the vector satisfies a condition. |
| Any(IReadOnlyListDouble, FuncDouble, Boolean) | Determines whether any element of the vector satisfies a condition. |
| Any(IReadOnlyListSingle, FuncSingle, Boolean) | Determines whether any element of the vector satisfies a condition. |
| Any(Single, FuncSingle, Boolean) | Determines whether any element of the vector satisfies a condition. |
| Any(Double, FuncDouble, Boolean, Int32) | Determines whether any element of the vector satisfies a condition. |
| Any(Int32, FuncInt32, Boolean, Int32) | Determines whether any element of the vector satisfies a condition. |
| Any(IReadOnlyListDouble, FuncDouble, Boolean, Int32) | Determines whether any element of the vector satisfies a condition. |
| Any(IReadOnlyListSingle, FuncSingle, Boolean, Int32) | Determines whether any element of the vector satisfies a condition. |
| Any(Single, FuncSingle, Boolean, Int32) | Determines whether any element of the vector satisfies a condition. |
| AreValuesEqual(Double, Double) | Returns true if and only if both vectors contain the same elements. Both vectors must have the same length. |
| AreValuesEqual(Int32, Int32) | Returns true if and only if both vectors contain the same elements. Both vectors must have the same length. |
| AreValuesEqual(IReadOnlyListDouble, IReadOnlyListDouble) | Returns true if and only if both vectors contain the same elements. Both vectors must have the same length. |
| AreValuesEqual(IReadOnlyListSingle, IReadOnlyListSingle) | Returns true if and only if both vectors contain the same elements. Both vectors must have the same length. |
| AreValuesEqual(Single, Single) | Returns true if and only if both vectors contain the same elements. Both vectors must have the same length. |
| Average(Double) | Returns the average (=sum/N) of the elements in vector. |
| Average(Int32) | Returns the average (=sum/N) of the elements in vector. |
| Average(IReadOnlyListDouble) | Returns the average (=sum/N) of the elements in vector. |
| Average(IReadOnlyListSingle) | Returns the average (=sum/N) of the elements in vector. |
| Average(Single) | Returns the average (=sum/N) of the elements in vector. |
| Clone(Double) | Returns a clone of the source vector. |
| Clone(Int16) | Returns a clone of the source vector. |
| Clone(Int32) | Returns a clone of the source vector. |
| Clone(SByte) | Returns a clone of the source vector. |
| Clone(Single) | Returns a clone of the source vector. |
| Copy(Boolean, IVectorBoolean) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(Boolean, Boolean) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(Double, IVectorDouble) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(Double, Double) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(Int32, IVectorDouble) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(Int32, IVectorInt32) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(Int32, IVectorSingle) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(Int32, Double) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(Int32, Int32) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(Int32, Single) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(IReadOnlyListBoolean, IVectorBoolean) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(IReadOnlyListBoolean, Boolean) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(IReadOnlyListDouble, IVectorDouble) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(IReadOnlyListDouble, Double) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(IReadOnlyListInt32, IVectorDouble) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(IReadOnlyListInt32, IVectorInt32) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(IReadOnlyListInt32, IVectorSingle) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(IReadOnlyListInt32, Double) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(IReadOnlyListInt32, Int32) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(IReadOnlyListInt32, Single) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(IReadOnlyListSingle, IVectorDouble) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(IReadOnlyListSingle, IVectorSingle) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(IReadOnlyListSingle, Double) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(IReadOnlyListSingle, Single) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(Single, IVectorDouble) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(Single, IVectorSingle) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(Single, Double) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(Single, Single) | Copies the source vector to the destination vector. Both vectors must have the same length. |
| Copy(Boolean, Int32, IVectorBoolean, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(Boolean, Int32, Boolean, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(Double, Int32, IVectorDouble, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(Double, Int32, Double, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(Int32, Int32, IVectorDouble, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(Int32, Int32, IVectorInt32, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(Int32, Int32, IVectorSingle, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(Int32, Int32, Double, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(Int32, Int32, Int32, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(Int32, Int32, Single, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(IReadOnlyListBoolean, Int32, IVectorBoolean, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(IReadOnlyListBoolean, Int32, Boolean, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(IReadOnlyListDouble, Int32, IVectorDouble, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(IReadOnlyListDouble, Int32, Double, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(IReadOnlyListInt32, Int32, IVectorDouble, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(IReadOnlyListInt32, Int32, IVectorInt32, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(IReadOnlyListInt32, Int32, IVectorSingle, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(IReadOnlyListInt32, Int32, Double, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(IReadOnlyListInt32, Int32, Int32, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(IReadOnlyListInt32, Int32, Single, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(IReadOnlyListSingle, Int32, IVectorDouble, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(IReadOnlyListSingle, Int32, IVectorSingle, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(IReadOnlyListSingle, Int32, Double, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(IReadOnlyListSingle, Int32, Single, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(Single, Int32, IVectorDouble, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(Single, Int32, IVectorSingle, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(Single, Int32, Double, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| Copy(Single, Int32, Single, Int32, Int32) | Copies elements of a source vector to a destination vector. |
| CopyT(IReadOnlyListT, Int32, T, Int32, Int32) | |
| CreateEquidistantSequenceByStartEndLength(Double, Double, Int32) | Creates a read-only vector with equidistant element values from start to end. The created vector consumes memory only for the three variables, independent of its length. |
| CreateEquidistantSequenceByStartEndLength(Int16, Int16, Int32) | Creates a read-only vector with equidistant element values from start to end. The created vector consumes memory only for the three variables, independent of its length. |
| CreateEquidistantSequenceByStartEndLength(Int32, Int32, Int32) | Creates a read-only vector with equidistant element values from start to end. The created vector consumes memory only for the three variables, independent of its length. |
| CreateEquidistantSequenceByStartEndLength(SByte, SByte, Int32) | Creates a read-only vector with equidistant element values from start to end. The created vector consumes memory only for the three variables, independent of its length. |
| CreateEquidistantSequenceByStartEndLength(Single, Single, Int32) | Creates a read-only vector with equidistant element values from start to end. The created vector consumes memory only for the three variables, independent of its length. |
| CreateEquidistantSequenceByStartStepLength(Double, Double, Int32) | Creates a read-only vector with equidistant elements with values from start to start+(length-1)*step. The created vector consumes memory only for the three variables, independent of its length. |
| CreateEquidistantSequenceByStartStepLength(Int16, Int16, Int32) | Creates a read-only vector with equidistant elements with values from start to start+(length-1)*step. The created vector consumes memory only for the three variables, independent of its length. |
| CreateEquidistantSequenceByStartStepLength(Int32, Int32, Int32) | Creates a read-only vector with equidistant elements with values from start to start+(length-1)*step. The created vector consumes memory only for the three variables, independent of its length. |
| CreateEquidistantSequenceByStartStepLength(SByte, SByte, Int32) | Creates a read-only vector with equidistant elements with values from start to start+(length-1)*step. The created vector consumes memory only for the three variables, independent of its length. |
| CreateEquidistantSequenceByStartStepLength(Single, Single, Int32) | Creates a read-only vector with equidistant elements with values from start to start+(length-1)*step. The created vector consumes memory only for the three variables, independent of its length. |
| CreateEquidistantSequencyByStartAtOffsetStepLength(Double, Int32, Double, Int32) | Creates a read-only vector with equidistant elements from start - startOffset*step to start + (length - 1 -startOffset)*step. The created vector consumes memory only for the three variables, independent of its length. |
| CreateEquidistantSequencyByStartAtOffsetStepLength(Int16, Int32, Int16, Int32) | Creates a read-only vector with equidistant elements from start - startOffset*step to start + (length - 1 -startOffset)*step. The created vector consumes memory only for the three variables, independent of its length. |
| CreateEquidistantSequencyByStartAtOffsetStepLength(Int32, Int32, Int32, Int32) | Creates a read-only vector with equidistant elements from start - startOffset*step to start + (length - 1 -startOffset)*step. The created vector consumes memory only for the three variables, independent of its length. |
| CreateEquidistantSequencyByStartAtOffsetStepLength(SByte, Int32, SByte, Int32) | Creates a read-only vector with equidistant elements from start - startOffset*step to start + (length - 1 -startOffset)*step. The created vector consumes memory only for the three variables, independent of its length. |
| CreateEquidistantSequencyByStartAtOffsetStepLength(Single, Int32, Single, Int32) | Creates a read-only vector with equidistant elements from start - startOffset*step to start + (length - 1 -startOffset)*step. The created vector consumes memory only for the three variables, independent of its length. |
| CreateExtensibleVectorT | Creates a new extensible vector of length length |
| Divide(Double, IVectorDouble) | Sets the element of the vector to the result of scalar x divided by each element y[i]. |
| Divide(Double, Double) | Sets the element of the vector to the result of scalar x divided by each element y[i]. |
| Divide(Int32, Int32) | Sets the element of the vector to the result of scalar x divided by each element y[i]. |
| Divide(Single, IVectorSingle) | Sets the element of the vector to the result of scalar x divided by each element y[i]. |
| Divide(Single, Single) | Sets the element of the vector to the result of scalar x divided by each element y[i]. |
| DotProduct(Double, Double) | Returns the dot product of vector1 and vector2. |
| DotProduct(Int32, Int32) | Returns the dot product of vector1 and vector2. |
| DotProduct(IReadOnlyListDouble, IReadOnlyListDouble) | Returns the dot product of vector1 and vector2. |
| DotProduct(IReadOnlyListSingle, IReadOnlyListSingle) | Returns the dot product of vector1 and vector2. |
| DotProduct(Single, Single) | Returns the dot product of vector1 and vector2. |
| ElementsAtT(T, Int32) | |
| ElementsAtT(IReadOnlyListT, Int32) | |
| ElementsWhereT(T, Boolean) | |
| ElementsWhereT(T, IEnumerableBoolean) | |
| ElementsWhereT(IReadOnlyListT, Boolean) | |
| ElementsWhereT(IReadOnlyListT, IEnumerableBoolean) | |
| EuclideanDistance(Double, Double) | Returns the Euclidean distance of two vectors, i.e. the L2-norm of the difference of the two vectors. |
| EuclideanDistance(Int32, Int32) | Returns the Euclidean distance of two vectors, i.e. the L2-norm of the difference of the two vectors. |
| EuclideanDistance(IReadOnlyListDouble, IReadOnlyListDouble) | Returns the Euclidean distance of two vectors, i.e. the L2-norm of the difference of the two vectors. |
| EuclideanDistance(IReadOnlyListSingle, IReadOnlyListSingle) | Returns the Euclidean distance of two vectors, i.e. the L2-norm of the difference of the two vectors. |
| EuclideanDistance(Single, Single) | Returns the Euclidean distance of two vectors, i.e. the L2-norm of the difference of the two vectors. |
| EuclideanNorm(Double) | Given an n-vector x, this function calculates the euclidean norm of x. |
| EuclideanNorm(Int32) | Given an n-vector x, this function calculates the euclidean norm of x. |
| EuclideanNorm(IReadOnlyListDouble) | Given an n-vector x, this function calculates the euclidean norm of x. |
| EuclideanNorm(IReadOnlyListSingle) | Given an n-vector x, this function calculates the euclidean norm of x. |
| EuclideanNorm(Single) | Given an n-vector x, this function calculates the euclidean norm of x. |
| ExcessKurtosisOfNormalized(Double) | Returns the excess kurtosis of the elements in vector. The excess kurtosis is defined as excesskurtosis(X) = E{X^4} - 3(E{X²})². |
| ExcessKurtosisOfNormalized(Int32) | Returns the excess kurtosis of the elements in vector. The excess kurtosis is defined as excesskurtosis(X) = E{X^4} - 3(E{X²})². |
| ExcessKurtosisOfNormalized(IReadOnlyListDouble) | Returns the excess kurtosis of the elements in vector. The excess kurtosis is defined as excesskurtosis(X) = E{X^4} - 3(E{X²})². |
| ExcessKurtosisOfNormalized(IReadOnlyListSingle) | Returns the excess kurtosis of the elements in vector. The excess kurtosis is defined as excesskurtosis(X) = E{X^4} - 3(E{X²})². |
| ExcessKurtosisOfNormalized(Single) | Returns the excess kurtosis of the elements in vector. The excess kurtosis is defined as excesskurtosis(X) = E{X^4} - 3(E{X²})². |
| FillWith(Double, Double) | Fills a vector with a certain value. so that all elements are equal. |
| FillWith(Int32, Int32) | Fills a vector with a certain value. so that all elements are equal. |
| FillWith(IVectorDouble, Double) | Fills a vector with a certain value. so that all elements are equal. |
| FillWith(IVectorSingle, Single) | Fills a vector with a certain value. so that all elements are equal. |
| FillWith(Single, Single) | Fills a vector with a certain value. so that all elements are equal. |
| FillWithT(VectorT, T) | |
| FillWithLinearSequenceGivenByStartAndEnd(Double, Double, Double) | Fills the vector v with a linear sequence beginning from start (first element) until end (last element). |
| FillWithLinearSequenceGivenByStartAndEnd(Int32, Int32, Int32) | Fills the vector v with a linear sequence beginning from start (first element) until end (last element). |
| FillWithLinearSequenceGivenByStartAndEnd(IVectorDouble, Double, Double) | Fills the vector v with a linear sequence beginning from start (first element) until end (last element). |
| FillWithLinearSequenceGivenByStartAndEnd(IVectorSingle, Single, Single) | Fills the vector v with a linear sequence beginning from start (first element) until end (last element). |
| FillWithLinearSequenceGivenByStartAndEnd(Single, Single, Single) | Fills the vector v with a linear sequence beginning from start (first element) until end (last element). |
| GetConstantVector(Double, Int32) | Gets a vector with all elements equal to a provided value. |
| GetConstantVector(Int16, Int32) | Gets a vector with all elements equal to a provided value. |
| GetConstantVector(Int32, Int32) | Gets a vector with all elements equal to a provided value. |
| GetConstantVector(SByte, Int32) | Gets a vector with all elements equal to a provided value. |
| GetConstantVector(Single, Int32) | Gets a vector with all elements equal to a provided value. |
| GetUsedLength(Double) | Returns the used length of the vector. This is one more than the highest index of the element that is different from NaN. |
| GetUsedLength(IReadOnlyListDouble) | Returns the used length of the vector. This is one more than the highest index of the element that is different from NaN. |
| GetUsedLength(IReadOnlyListSingle) | Returns the used length of the vector. This is one more than the highest index of the element that is different from NaN. |
| GetUsedLength(Single) | Returns the used length of the vector. This is one more than the highest index of the element that is different from NaN. |
| GetUsedLength(Double, Int32) | Returns the used length of the vector. This is one more than the highest index of the element that is different from Double.NaN. |
| GetUsedLength(IReadOnlyListDouble, Int32) | Returns the used length of the vector. This is one more than the highest index of the element that is different from Double.NaN. |
| GetUsedLength(IReadOnlyListSingle, Int32) | Returns the used length of the vector. This is one more than the highest index of the element that is different from Double.NaN. |
| GetUsedLength(Single, Int32) | Returns the used length of the vector. This is one more than the highest index of the element that is different from Double.NaN. |
| IndexOfMaxAbsoluteValue(Double) | Return the index of the first element with the maximum absolute value in a vector |
| IndexOfMaxAbsoluteValue(Int32) | Return the index of the first element with the maximum absolute value in a vector |
| IndexOfMaxAbsoluteValue(IReadOnlyListDouble) | Return the index of the first element with the maximum absolute value in a vector |
| IndexOfMaxAbsoluteValue(IReadOnlyListSingle) | Return the index of the first element with the maximum absolute value in a vector |
| IndexOfMaxAbsoluteValue(Single) | Return the index of the first element with the maximum absolute value in a vector |
| IndexOfMaxValue(Double) | Return the index of the first element with the maximum value in a vector |
| IndexOfMaxValue(Int32) | Return the index of the first element with the maximum value in a vector |
| IndexOfMaxValue(IReadOnlyListDouble) | Return the index of the first element with the maximum value in a vector |
| IndexOfMaxValue(IReadOnlyListSingle) | Return the index of the first element with the maximum value in a vector |
| IndexOfMaxValue(Single) | Return the index of the first element with the maximum value in a vector |
| IndexOfMinAbsoluteValue(Double) | Return the index of the first element with the minimum absolute value in a vector |
| IndexOfMinAbsoluteValue(Int32) | Return the index of the first element with the minimum absolute value in a vector |
| IndexOfMinAbsoluteValue(IReadOnlyListDouble) | Return the index of the first element with the minimum absolute value in a vector |
| IndexOfMinAbsoluteValue(IReadOnlyListSingle) | Return the index of the first element with the minimum absolute value in a vector |
| IndexOfMinAbsoluteValue(Single) | Return the index of the first element with the minimum absolute value in a vector |
| IndexOfMinValue(Double) | Return the index of the first element with the minimum value in a vector |
| IndexOfMinValue(Int32) | Return the index of the first element with the minimum value in a vector |
| IndexOfMinValue(IReadOnlyListDouble) | Return the index of the first element with the minimum value in a vector |
| IndexOfMinValue(IReadOnlyListSingle) | Return the index of the first element with the minimum value in a vector |
| IndexOfMinValue(Single) | Return the index of the first element with the minimum value in a vector |
| IsStrictlyDecreasing(Double) | Returns true if the sequence given by the vector argument is strictly decreasing. |
| IsStrictlyDecreasing(Int32) | Returns true if the sequence given by the vector argument is strictly decreasing. |
| IsStrictlyDecreasing(IReadOnlyListDouble) | Returns true if the sequence given by the vector argument is strictly decreasing. |
| IsStrictlyDecreasing(IReadOnlyListSingle) | Returns true if the sequence given by the vector argument is strictly decreasing. |
| IsStrictlyDecreasing(Single) | Returns true if the sequence given by the vector argument is strictly decreasing. |
| IsStrictlyIncreasing(Double) | Returns true if the sequence given by the vector argument is strictly increasing. |
| IsStrictlyIncreasing(Int32) | Returns true if the sequence given by the vector argument is strictly increasing. |
| IsStrictlyIncreasing(IReadOnlyListDouble) | Returns true if the sequence given by the vector argument is strictly increasing. |
| IsStrictlyIncreasing(IReadOnlyListSingle) | Returns true if the sequence given by the vector argument is strictly increasing. |
| IsStrictlyIncreasing(Single) | Returns true if the sequence given by the vector argument is strictly increasing. |
| IsStrictlyIncreasingOrDecreasing(Double) | Returns true if the sequence given by the vector argument is strictly increasing or decreasing. |
| IsStrictlyIncreasingOrDecreasing(Int32) | Returns true if the sequence given by the vector argument is strictly increasing or decreasing. |
| IsStrictlyIncreasingOrDecreasing(IReadOnlyListDouble) | Returns true if the sequence given by the vector argument is strictly increasing or decreasing. |
| IsStrictlyIncreasingOrDecreasing(IReadOnlyListSingle) | Returns true if the sequence given by the vector argument is strictly increasing or decreasing. |
| IsStrictlyIncreasingOrDecreasing(Single) | Returns true if the sequence given by the vector argument is strictly increasing or decreasing. |
| IsStrictlyIncreasingOrDecreasing(Double, Boolean) | Returns true if the sequence given by the vector argument is strictly increasing or decreasing. |
| IsStrictlyIncreasingOrDecreasing(Int32, Boolean) | Returns true if the sequence given by the vector argument is strictly increasing or decreasing. |
| IsStrictlyIncreasingOrDecreasing(IReadOnlyListDouble, Boolean) | Returns true if the sequence given by the vector argument is strictly increasing or decreasing. |
| IsStrictlyIncreasingOrDecreasing(IReadOnlyListSingle, Boolean) | Returns true if the sequence given by the vector argument is strictly increasing or decreasing. |
| IsStrictlyIncreasingOrDecreasing(Single, Boolean) | Returns true if the sequence given by the vector argument is strictly increasing or decreasing. |
| Kurtosis(Double) | Returns the kurtosis of the elements in vector. The kurtosis is defined as kurtosis(X) = E{(X-µ)^4}/((E{(X-µ)²})². |
| Kurtosis(Int32) | Returns the kurtosis of the elements in vector. The kurtosis is defined as kurtosis(X) = E{(X-µ)^4}/((E{(X-µ)²})². |
| Kurtosis(IReadOnlyListDouble) | Returns the kurtosis of the elements in vector. The kurtosis is defined as kurtosis(X) = E{(X-µ)^4}/((E{(X-µ)²})². |
| Kurtosis(IReadOnlyListSingle) | Returns the kurtosis of the elements in vector. The kurtosis is defined as kurtosis(X) = E{(X-µ)^4}/((E{(X-µ)²})². |
| Kurtosis(Single) | Returns the kurtosis of the elements in vector. The kurtosis is defined as kurtosis(X) = E{(X-µ)^4}/((E{(X-µ)²})². |
| L1Norm(Double) | Calculates the L1 norm of the vector (as the sum of the absolute values of the elements). |
| L1Norm(Int32) | Calculates the L1 norm of the vector (as the sum of the absolute values of the elements). |
| L1Norm(IReadOnlyListDouble) | Calculates the L1 norm of the vector (as the sum of the absolute values of the elements). |
| L1Norm(IReadOnlyListSingle) | Calculates the L1 norm of the vector (as the sum of the absolute values of the elements). |
| L1Norm(Single) | Calculates the L1 norm of the vector (as the sum of the absolute values of the elements). |
| L2Norm(Double) | Given an n-vector x, this function calculates the euclidean norm of x. |
| L2Norm(Int32) | Given an n-vector x, this function calculates the euclidean norm of x. |
| L2Norm(IReadOnlyListDouble) | Given an n-vector x, this function calculates the euclidean norm of x. |
| L2Norm(IReadOnlyListSingle) | Given an n-vector x, this function calculates the euclidean norm of x. |
| L2Norm(Single) | Given an n-vector x, this function calculates the euclidean norm of x. |
| L2Norm(Double, Int32, Int32) | Given an n-vector x, this function calculates the euclidean norm of x. |
| L2Norm(Int32, Int32, Int32) | Given an n-vector x, this function calculates the euclidean norm of x. |
| L2Norm(IReadOnlyListDouble, Int32, Int32) | Given an n-vector x, this function calculates the euclidean norm of x. |
| L2Norm(IReadOnlyListSingle, Int32, Int32) | Given an n-vector x, this function calculates the euclidean norm of x. |
| L2Norm(Single, Int32, Int32) | Given an n-vector x, this function calculates the euclidean norm of x. |
| Lerp(Double, Double, IReadOnlyListDouble, Double, IReadOnlyListDouble, IVectorDouble) | Performs linear interpolation between two vectors at specified points. |
| Lerp(Double, Double, IReadOnlyListSingle, Double, IReadOnlyListSingle, IVectorSingle) | Performs linear interpolation between two vectors at specified points. |
| Lerp(Double, Double, Double, Double, Double, Double) | Performs linear interpolation between two vectors at specified points. |
| Lerp(Double, Double, Int32, Double, Int32, Int32) | Performs linear interpolation between two vectors at specified points. |
| Lerp(Double, Double, Single, Double, Single, Single) | Performs linear interpolation between two vectors at specified points. |
| LInfinityNorm(Double) | Returns the L-infinity norm of the provided vector (as is the maximum of the absolute value of the elements). If one of the elements of the vector is invalid, the return value is also invalid (for the floating point types). |
| LInfinityNorm(Int32) | Returns the L-infinity norm of the provided vector (as is the maximum of the absolute value of the elements). If one of the elements of the vector is invalid, the return value is also invalid (for the floating point types). |
| LInfinityNorm(IReadOnlyListDouble) | Returns the L-infinity norm of the provided vector (as is the maximum of the absolute value of the elements). If one of the elements of the vector is invalid, the return value is also invalid (for the floating point types). |
| LInfinityNorm(IReadOnlyListSingle) | Returns the L-infinity norm of the provided vector (as is the maximum of the absolute value of the elements). If one of the elements of the vector is invalid, the return value is also invalid (for the floating point types). |
| LInfinityNorm(Single) | Returns the L-infinity norm of the provided vector (as is the maximum of the absolute value of the elements). If one of the elements of the vector is invalid, the return value is also invalid (for the floating point types). |
| LInfinityNorm(Double, Double) | Returns the L-infinity norm of the difference of vector1 and vector2 (as is the maximum of the absolute value of the differences of the elements). If one of the elements of the vector is invalid, the return value is also invalid (for the floating point types). |
| LInfinityNorm(Int32, Int32) | Returns the L-infinity norm of the difference of vector1 and vector2 (as is the maximum of the absolute value of the differences of the elements). If one of the elements of the vector is invalid, the return value is also invalid (for the floating point types). |
| LInfinityNorm(IReadOnlyListDouble, IReadOnlyListDouble) | Returns the L-infinity norm of the difference of vector1 and vector2 (as is the maximum of the absolute value of the differences of the elements). If one of the elements of the vector is invalid, the return value is also invalid (for the floating point types). |
| LInfinityNorm(IReadOnlyListSingle, IReadOnlyListSingle) | Returns the L-infinity norm of the difference of vector1 and vector2 (as is the maximum of the absolute value of the differences of the elements). If one of the elements of the vector is invalid, the return value is also invalid (for the floating point types). |
| LInfinityNorm(Single, Single) | Returns the L-infinity norm of the difference of vector1 and vector2 (as is the maximum of the absolute value of the differences of the elements). If one of the elements of the vector is invalid, the return value is also invalid (for the floating point types). |
| LpNorm(Double, Double) | Compute the p Norm of this vector. |
| LpNorm(Int32, Double) | Compute the p Norm of this vector. |
| LpNorm(IReadOnlyListDouble, Double) | Compute the p Norm of this vector. |
| LpNorm(IReadOnlyListSingle, Double) | Compute the p Norm of this vector. |
| LpNorm(Single, Double) | Compute the p Norm of this vector. |
| Map(Double, FuncDouble, Double) | Elementwise application of a function to each element of a vector. |
| Map(Int32, FuncInt32, Int32) | Elementwise application of a function to each element of a vector. |
| Map(IVectorDouble, FuncDouble, Double) | Elementwise application of a function to each element of a vector. |
| Map(IVectorSingle, FuncSingle, Single) | Elementwise application of a function to each element of a vector. |
| Map(Single, FuncSingle, Single) | Elementwise application of a function to each element of a vector. |
| Map(Double, FuncDouble, Double, Double) | Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector. |
| Map(Int32, FuncInt32, Int32, Int32) | Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector. |
| Map(IReadOnlyListDouble, FuncDouble, Double, IVectorDouble) | Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector. |
| Map(IReadOnlyListSingle, FuncSingle, Single, IVectorSingle) | Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector. |
| Map(Single, FuncSingle, Single, Single) | Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector. |
| Map(Double, Double, FuncDouble, Double, Double, Double) | Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector. |
| Map(Int32, Int32, FuncInt32, Int32, Int32, Int32) | Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector. |
| Map(IReadOnlyListDouble, IReadOnlyListDouble, FuncDouble, Double, Double, IVectorDouble) | Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector. |
| Map(IReadOnlyListSingle, IReadOnlyListSingle, FuncSingle, Single, Single, IVectorSingle) | Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector. |
| Map(Single, Single, FuncSingle, Single, Single, Single) | Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector. |
| Map(Double, Double, Double, FuncDouble, Double, Double, Double, Double) | Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector. |
| Map(Int32, Int32, Int32, FuncInt32, Int32, Int32, Int32, Int32) | Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector. |
| Map(IReadOnlyListDouble, IReadOnlyListDouble, IReadOnlyListDouble, FuncDouble, Double, Double, Double, IVectorDouble) | Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector. |
| Map(IReadOnlyListSingle, IReadOnlyListSingle, IReadOnlyListSingle, FuncSingle, Single, Single, Single, IVectorSingle) | Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector. |
| Map(Single, Single, Single, FuncSingle, Single, Single, Single, Single) | Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector. |
| MapT1(Double, T1, FuncDouble, T1, Double, Double) | Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector. |
| MapT1(Int32, T1, FuncInt32, T1, Int32, Int32) | Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector. |
| MapT1(IReadOnlyListDouble, T1, FuncDouble, T1, Double, IVectorDouble) | Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector. |
| MapT1(IReadOnlyListSingle, T1, FuncSingle, T1, Single, IVectorSingle) | Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector. |
| MapT1(Single, T1, FuncSingle, T1, Single, Single) | Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector. |
| MapT1(Double, Double, T1, FuncDouble, Double, T1, Double, Double) | Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector. |
| MapT1(Int32, Int32, T1, FuncInt32, Int32, T1, Int32, Int32) | Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector. |
| MapT1(IReadOnlyListDouble, IReadOnlyListDouble, T1, FuncDouble, Double, T1, Double, IVectorDouble) | Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector. |
| MapT1(IReadOnlyListSingle, IReadOnlyListSingle, T1, FuncSingle, Single, T1, Single, IVectorSingle) | Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector. |
| MapT1(Single, Single, T1, FuncSingle, Single, T1, Single, Single) | Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector. |
| MapT1(Double, Double, Double, T1, FuncDouble, Double, Double, T1, Double, Double) | Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector. |
| MapT1(Int32, Int32, Int32, T1, FuncInt32, Int32, Int32, T1, Int32, Int32) | Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector. |
| MapT1(IReadOnlyListDouble, IReadOnlyListDouble, IReadOnlyListDouble, T1, FuncDouble, Double, Double, T1, Double, IVectorDouble) | Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector. |
| MapT1(IReadOnlyListSingle, IReadOnlyListSingle, IReadOnlyListSingle, T1, FuncSingle, Single, Single, T1, Single, IVectorSingle) | Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector. |
| MapT1(Single, Single, Single, T1, FuncSingle, Single, Single, T1, Single, Single) | Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector. |
| MapIndexed(Double, FuncInt32, Double, Double, Double) | Elementwise application of a function to each element of a vector. |
| MapIndexed(Int32, FuncInt32, Int32, Int32, Int32) | Elementwise application of a function to each element of a vector. |
| MapIndexed(IReadOnlyListDouble, FuncInt32, Double, Double, IVectorDouble) | Elementwise application of a function to each element of a vector. |
| MapIndexed(IReadOnlyListSingle, FuncInt32, Single, Single, IVectorSingle) | Elementwise application of a function to each element of a vector. |
| MapIndexed(Single, FuncInt32, Single, Single, Single) | Elementwise application of a function to each element of a vector. |
| MapIndexed(Double, Double, FuncInt32, Double, Double, Double, Double) | Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector. |
| MapIndexed(Int32, Int32, FuncInt32, Int32, Int32, Int32, Int32) | Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector. |
| MapIndexed(IReadOnlyListDouble, IReadOnlyListDouble, FuncInt32, Double, Double, Double, IVectorDouble) | Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector. |
| MapIndexed(IReadOnlyListSingle, IReadOnlyListSingle, FuncInt32, Single, Single, Single, IVectorSingle) | Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector. |
| MapIndexed(Single, Single, FuncInt32, Single, Single, Single, Single) | Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector. |
| MapIndexed(Double, Double, Double, FuncInt32, Double, Double, Double, Double, Double) | Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector. |
| MapIndexed(Int32, Int32, Int32, FuncInt32, Int32, Int32, Int32, Int32, Int32) | Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector. |
| MapIndexed(IReadOnlyListDouble, IReadOnlyListDouble, IReadOnlyListDouble, FuncInt32, Double, Double, Double, Double, IVectorDouble) | Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector. |
| MapIndexed(IReadOnlyListSingle, IReadOnlyListSingle, IReadOnlyListSingle, FuncInt32, Single, Single, Single, Single, IVectorSingle) | Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector. |
| MapIndexed(Single, Single, Single, FuncInt32, Single, Single, Single, Single, Single) | Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector. |
| Max(Double) | Returns the maximum of the elements in vector. |
| Max(Int32) | Returns the maximum of the elements in vector. |
| Max(IReadOnlyListDouble) | Returns the maximum of the elements in vector. |
| Max(IReadOnlyListSingle) | Returns the maximum of the elements in vector. |
| Max(Single) | Returns the maximum of the elements in vector. |
| Max(Double, Int32, Int32) | Returns the maximum of the elements in vector. |
| Max(Int32, Int32, Int32) | Returns the maximum of the elements in vector. |
| Max(IReadOnlyListDouble, Int32, Int32) | Returns the maximum of the elements in vector. |
| Max(IReadOnlyListSingle, Int32, Int32) | Returns the maximum of the elements in vector. |
| Max(Single, Int32, Int32) | Returns the maximum of the elements in vector. |
| MaxOf(Double, Double, Double) | Creates a new vector, whose elements are the maximum of the elements of a given input vector and a given number. |
| MaxOf(Double, Double, Double) | Gives the parallel maximum of vector a and b. The first element of the resulting vector is the maximum of the first element of a and the first element of b. The second element of the resulting vector is the maximum of the second element of a and the second element of b, and so on. |
| MaxOf(Int32, Int32, Int32) | Creates a new vector, whose elements are the maximum of the elements of a given input vector and a given number. |
| MaxOf(Int32, Int32, Int32) | Gives the parallel maximum of vector a and b. The first element of the resulting vector is the maximum of the first element of a and the first element of b. The second element of the resulting vector is the maximum of the second element of a and the second element of b, and so on. |
| MaxOf(IReadOnlyListDouble, IReadOnlyListDouble, IVectorDouble) | Gives the parallel maximum of vector a and b. The first element of the resulting vector is the maximum of the first element of a and the first element of b. The second element of the resulting vector is the maximum of the second element of a and the second element of b, and so on. |
| MaxOf(IReadOnlyListDouble, Double, IVectorDouble) | Creates a new vector, whose elements are the maximum of the elements of a given input vector and a given number. |
| MaxOf(IReadOnlyListSingle, IReadOnlyListSingle, IVectorSingle) | Gives the parallel maximum of vector a and b. The first element of the resulting vector is the maximum of the first element of a and the first element of b. The second element of the resulting vector is the maximum of the second element of a and the second element of b, and so on. |
| MaxOf(IReadOnlyListSingle, Single, IVectorSingle) | Creates a new vector, whose elements are the maximum of the elements of a given input vector and a given number. |
| MaxOf(Single, Single, Single) | Creates a new vector, whose elements are the maximum of the elements of a given input vector and a given number. |
| MaxOf(Single, Single, Single) | Gives the parallel maximum of vector a and b. The first element of the resulting vector is the maximum of the first element of a and the first element of b. The second element of the resulting vector is the maximum of the second element of a and the second element of b, and so on. |
| MaxOfValidElements(Double) | Returns the maximum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered). |
| MaxOfValidElements(IReadOnlyListDouble) | Returns the maximum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered). |
| MaxOfValidElements(IReadOnlyListSingle) | Returns the maximum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered). |
| MaxOfValidElements(Single) | Returns the maximum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered). |
| Mean(Double) | Returns the average (=sum/N) of the elements in vector. |
| Mean(Int32) | Returns the average (=sum/N) of the elements in vector. |
| Mean(IReadOnlyListDouble) | Returns the average (=sum/N) of the elements in vector. |
| Mean(IReadOnlyListSingle) | Returns the average (=sum/N) of the elements in vector. |
| Mean(Single) | Returns the average (=sum/N) of the elements in vector. |
| MeanAndVariance(Double) | Returns the average (=sum/N) of the elements in vector, as well as the variance (sum of squares of the mean centered values divided by length of the vector). |
| MeanAndVariance(Int32) | Returns the average (=sum/N) of the elements in vector, as well as the variance (sum of squares of the mean centered values divided by length of the vector). |
| MeanAndVariance(IReadOnlyListDouble) | Returns the average (=sum/N) of the elements in vector, as well as the variance (sum of squares of the mean centered values divided by length of the vector). |
| MeanAndVariance(IReadOnlyListSingle) | Returns the average (=sum/N) of the elements in vector, as well as the variance (sum of squares of the mean centered values divided by length of the vector). |
| MeanAndVariance(Single) | Returns the average (=sum/N) of the elements in vector, as well as the variance (sum of squares of the mean centered values divided by length of the vector). |
| Min(Double) | Returns the minimum of the elements in vector. |
| Min(Int32) | Returns the minimum of the elements in vector. |
| Min(IReadOnlyListDouble) | Returns the minimum of the elements in vector. |
| Min(IReadOnlyListSingle) | Returns the minimum of the elements in vector. |
| Min(Single) | Returns the minimum of the elements in vector. |
| Min(Double, Int32, Int32) | Returns the minimum of the elements in vector. |
| Min(Int32, Int32, Int32) | Returns the minimum of the elements in vector. |
| Min(IReadOnlyListDouble, Int32, Int32) | Returns the minimum of the elements in vector. |
| Min(IReadOnlyListSingle, Int32, Int32) | Returns the minimum of the elements in vector. |
| Min(Single, Int32, Int32) | Returns the minimum of the elements in vector. |
| MinOfValidElements(Double) | Returns the minimum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered). |
| MinOfValidElements(IReadOnlyListDouble) | Returns the minimum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered). |
| MinOfValidElements(IReadOnlyListSingle) | Returns the minimum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered). |
| MinOfValidElements(Single) | Returns the minimum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered). |
| Multiply(Double, Double) | Multiplies all vector elements with a constant. |
| Multiply(Int32, Int32) | Multiplies all vector elements with a constant. |
| Multiply(IVectorDouble, Double) | Multiplies all vector elements with a constant. |
| Multiply(IVectorSingle, Single) | Multiplies all vector elements with a constant. |
| Multiply(Single, Single) | Multiplies all vector elements with a constant. |
| Multiply(Double, Double, Double) | Multiplies (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length. |
| Multiply(Int32, Int32, Int32) | Multiplies (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length. |
| Multiply(IReadOnlyListDouble, IReadOnlyListDouble, IVectorDouble) | Multiplies (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length. |
| Multiply(IReadOnlyListSingle, IReadOnlyListSingle, IVectorSingle) | Multiplies (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length. |
| Multiply(Single, Single, Single) | Multiplies (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length. |
| Rotate(Double, Int32) | Shifts the element of this vector by moving them from index i to index i+increment. The elements at the end of the vector are wrapped back to the start of the vector. Thus, effectively, the elements of the vector are rotated. |
| Rotate(Int32, Int32) | Shifts the element of this vector by moving them from index i to index i+increment. The elements at the end of the vector are wrapped back to the start of the vector. Thus, effectively, the elements of the vector are rotated. |
| Rotate(IVectorDouble, Int32) | Shifts the element of this vector by moving them from index i to index i+increment. The elements at the end of the vector are wrapped back to the start of the vector. Thus, effectively, the elements of the vector are rotated. |
| Rotate(IVectorSingle, Int32) | Shifts the element of this vector by moving them from index i to index i+increment. The elements at the end of the vector are wrapped back to the start of the vector. Thus, effectively, the elements of the vector are rotated. |
| Rotate(Single, Int32) | Shifts the element of this vector by moving them from index i to index i+increment. The elements at the end of the vector are wrapped back to the start of the vector. Thus, effectively, the elements of the vector are rotated. |
| SetValuesT | |
| SumOfSquaredDifferences(Double, Double) | Returns the sum of squared differences of the elements of xarray and yarray. |
| SumOfSquaredDifferences(Int32, Int32) | Returns the sum of squared differences of the elements of xarray and yarray. |
| SumOfSquaredDifferences(IReadOnlyListDouble, IReadOnlyListDouble) | Returns the sum of squared differences of the elements of xarray and yarray. |
| SumOfSquaredDifferences(IReadOnlyListSingle, IReadOnlyListSingle) | Returns the sum of squared differences of the elements of xarray and yarray. |
| SumOfSquaredDifferences(Single, Single) | Returns the sum of squared differences of the elements of xarray and yarray. |
| ToInverseROVector(IReadOnlyListDouble) | Wraps a double[] array to get an [!:IReadOnlyList<double>] with elements = 1 / elements of the original vector. |
| ToInverseROVector(IReadOnlyListInt16) | Wraps a Int16[] array to get an IReadOnlyListT with elements = 1 / elements of the original vector. |
| ToInverseROVector(IReadOnlyListInt32) | Wraps a Int32[] array to get an IReadOnlyListT with elements = 1 / elements of the original vector. |
| ToInverseROVector(IReadOnlyListSByte) | Wraps a SByte[] array to get an IReadOnlyListT with elements = 1 / elements of the original vector. |
| ToInverseROVector(IReadOnlyListSingle) | Wraps a float[] array to get an [!:IReadOnlyList<float>] with elements = 1 / elements of the original vector. |
| ToInverseROVector(IReadOnlyListDouble, Int32) | Wraps a double[] array till a given length to get an [!:IReadOnlyList<double>] with elements = 1 / elements of the original vector. |
| ToInverseROVector(IReadOnlyListInt16, Int32) | Wraps a Int16[] array till a given length to get an IReadOnlyListT with elements = 1 / elements of the original vector. |
| ToInverseROVector(IReadOnlyListInt32, Int32) | Wraps a Int32[] array till a given length to get an IReadOnlyListT with elements = 1 / elements of the original vector. |
| ToInverseROVector(IReadOnlyListSByte, Int32) | Wraps a SByte[] array till a given length to get an IReadOnlyListT with elements = 1 / elements of the original vector. |
| ToInverseROVector(IReadOnlyListSingle, Int32) | Wraps a float[] array till a given length to get an [!:IReadOnlyList<float>] with elements = 1 / elements of the original vector. |
| ToRODoubleVector(Double) | Wraps a double[] array to get an IReadOnlyListT. |
| ToRODoubleVector(Int16) | Wraps a Int16[] array to get an IReadOnlyListT. |
| ToRODoubleVector(Int32) | Wraps a Int32[] array to get an IReadOnlyListT. |
| ToRODoubleVector(SByte) | Wraps a SByte[] array to get an IReadOnlyListT. |
| ToRODoubleVector(Single) | Wraps a float[] array to get an IReadOnlyListT. |
| ToRODoubleVector(Double, Int32) | Wraps a double[] array till a given length to get an IReadOnlyListT. |
| ToRODoubleVector(Int16, Int32) | Wraps a Int16[] array till a given length to get an IReadOnlyListT. |
| ToRODoubleVector(Int32, Int32) | Wraps a Int32[] array till a given length to get an IReadOnlyListT. |
| ToRODoubleVector(SByte, Int32) | Wraps a SByte[] array till a given length to get an IReadOnlyListT. |
| ToRODoubleVector(Single, Int32) | Wraps a float[] array till a given length to get an IReadOnlyListT. |
| ToROVector(Double) | Wraps a double[] array to get an [!:IReadOnlyList<double>]. |
| ToROVector(Int16) | Wraps a Int16[] array to get an IReadOnlyListT. |
| ToROVector(Int32) | Wraps a Int32[] array to get an IReadOnlyListT. |
| ToROVector(SByte) | Wraps a SByte[] array to get an IReadOnlyListT. |
| ToROVector(Single) | Wraps a float[] array to get an [!:IReadOnlyList<float>]. |
| ToROVector(Double, Int32) | Wraps a double[] array till a given length to get an [!:IReadOnlyList<double>]. |
| ToROVector(Int16, Int32) | Wraps a Int16[] array till a given length to get an IReadOnlyListT. |
| ToROVector(Int32, Int32) | Wraps a Int32[] array till a given length to get an IReadOnlyListT. |
| ToROVector(SByte, Int32) | Wraps a SByte[] array till a given length to get an IReadOnlyListT. |
| ToROVector(Single, Int32) | Wraps a float[] array till a given length to get an [!:IReadOnlyList<float>]. |
| ToROVector(Double, Int32, Int32) | Wraps an array to an [!:IReadOnlyList<double>]. Start and length of the used section of the array are specified in the parameters. |
| ToROVector(Int16, Int32, Int32) | Wraps an array to an IReadOnlyListT. Start and length of the used section of the array are specified in the parameters. |
| ToROVector(Int32, Int32, Int32) | Wraps an array to an IReadOnlyListT. Start and length of the used section of the array are specified in the parameters. |
| ToROVector(IReadOnlyListDouble, Int32, Int32) | Wraps a section of an original vector into a new vector. |
| ToROVector(IReadOnlyListInt16, Int32, Int32) | Wraps a section of an original vector into a new vector. |
| ToROVector(IReadOnlyListInt32, Int32, Int32) | Wraps a section of an original vector into a new vector. |
| ToROVector(IReadOnlyListSByte, Int32, Int32) | Wraps a section of an original vector into a new vector. |
| ToROVector(IReadOnlyListSingle, Int32, Int32) | Wraps a section of an original vector into a new vector. |
| ToROVector(SByte, Int32, Int32) | Wraps an array to an IReadOnlyListT. Start and length of the used section of the array are specified in the parameters. |
| ToROVector(Single, Int32, Int32) | Wraps an array to an [!:IReadOnlyList<float>]. Start and length of the used section of the array are specified in the parameters. |
| ToROVectorAmendedShifted(Double, Double, Int32, Double, Int32) | Wraps a double[] array to get an [!:IReadOnlyList<double>]. |
| ToROVectorAmendedShifted(Int16, Int16, Int32, Int16, Int32) | Wraps a Int16[] array to get an IReadOnlyListT. |
| ToROVectorAmendedShifted(Int32, Int32, Int32, Int32, Int32) | Wraps a Int32[] array to get an IReadOnlyListT. |
| ToROVectorAmendedShifted(SByte, SByte, Int32, SByte, Int32) | Wraps a SByte[] array to get an IReadOnlyListT. |
| ToROVectorAmendedShifted(Single, Single, Int32, Single, Int32) | Wraps a float[] array to get an [!:IReadOnlyList<float>]. |
| ToROVectorAmendedShifted(Double, Int32, Double, Int32, Double, Int32) | Wraps a double[] array till a given length to get an [!:IReadOnlyList<double>]. |
| ToROVectorAmendedShifted(Int16, Int32, Int16, Int32, Int16, Int32) | Wraps a Int16[] array till a given length to get an IReadOnlyListT. |
| ToROVectorAmendedShifted(Int32, Int32, Int32, Int32, Int32, Int32) | Wraps a Int32[] array till a given length to get an IReadOnlyListT. |
| ToROVectorAmendedShifted(SByte, Int32, SByte, Int32, SByte, Int32) | Wraps a SByte[] array till a given length to get an IReadOnlyListT. |
| ToROVectorAmendedShifted(Single, Int32, Single, Int32, Single, Int32) | Wraps a float[] array till a given length to get an [!:IReadOnlyList<float>]. |
| ToROVectorStructAmendedUnshifted(Double, Double, Double) | Wraps a double[] array to get a struct with an [!:IReadOnlyList<double>] implementation. The wrapping is done lazily, i.e. you can access elements with indices below zero and above Length, which is normally forbidden. The values for that are given as parameters. |
| ToROVectorStructAmendedUnshifted(Int16, Int16, Int16) | Wraps a Int16[] array to get a struct with an IReadOnlyListT implementation. The wrapping is done lazily, i.e. you can access elements with indices below zero and above Length, which is normally forbidden. The values for that are given as parameters. |
| ToROVectorStructAmendedUnshifted(Int32, Int32, Int32) | Wraps a Int32[] array to get a struct with an IReadOnlyListT implementation. The wrapping is done lazily, i.e. you can access elements with indices below zero and above Length, which is normally forbidden. The values for that are given as parameters. |
| ToROVectorStructAmendedUnshifted(SByte, SByte, SByte) | Wraps a SByte[] array to get a struct with an IReadOnlyListT implementation. The wrapping is done lazily, i.e. you can access elements with indices below zero and above Length, which is normally forbidden. The values for that are given as parameters. |
| ToROVectorStructAmendedUnshifted(Single, Single, Single) | Wraps a float[] array to get a struct with an [!:IReadOnlyList<float>] implementation. The wrapping is done lazily, i.e. you can access elements with indices below zero and above Length, which is normally forbidden. The values for that are given as parameters. |
| ToROVectorStructAmendedUnshifted(Double, Int32, Double, Double) | Wraps a double[] array till a given length to get a struct with an [!:IReadOnlyList<double>] implementation. The wrapping is done lazily, i.e. you can access elements with indices below zero and above usedlength, which is normally forbidden. The values for that are given as parameters. |
| ToROVectorStructAmendedUnshifted(Int16, Int32, Int16, Int16) | Wraps a Int16[] array till a given length to get a struct with an IReadOnlyListT implementation. The wrapping is done lazily, i.e. you can access elements with indices below zero and above usedlength, which is normally forbidden. The values for that are given as parameters. |
| ToROVectorStructAmendedUnshifted(Int32, Int32, Int32, Int32) | Wraps a Int32[] array till a given length to get a struct with an IReadOnlyListT implementation. The wrapping is done lazily, i.e. you can access elements with indices below zero and above usedlength, which is normally forbidden. The values for that are given as parameters. |
| ToROVectorStructAmendedUnshifted(SByte, Int32, SByte, SByte) | Wraps a SByte[] array till a given length to get a struct with an IReadOnlyListT implementation. The wrapping is done lazily, i.e. you can access elements with indices below zero and above usedlength, which is normally forbidden. The values for that are given as parameters. |
| ToROVectorStructAmendedUnshifted(Single, Int32, Single, Single) | Wraps a float[] array till a given length to get a struct with an [!:IReadOnlyList<float>] implementation. The wrapping is done lazily, i.e. you can access elements with indices below zero and above usedlength, which is normally forbidden. The values for that are given as parameters. |
| ToVector(Double) | Wraps an array to get an [!:IVector<double>] |
| ToVector(Int16) | Wraps an array to get an IVectorT |
| ToVector(Int32) | Wraps an array to get an IVectorT |
| ToVector(SByte) | Wraps an array to get an IVectorT |
| ToVector(Single) | Wraps an array to get an [!:IVector<float>] |
| ToVector(Double, Int32) | Wraps an array to get an [!:IVector<double>]. |
| ToVector(Int16, Int32) | Wraps an array to get an IVectorT. |
| ToVector(Int32, Int32) | Wraps an array to get an IVectorT. |
| ToVector(SByte, Int32) | Wraps an array to get an IVectorT. |
| ToVector(Single, Int32) | Wraps an array to get an [!:IVector<float>]. |
| ToVector(Double, Int32, Int32) | Wraps a section of an array to get a [!:IVector<double>]. |
| ToVector(Int16, Int32, Int32) | Wraps a section of an array to get a IVectorT. |
| ToVector(Int32, Int32, Int32) | Wraps a section of an array to get a IVectorT. |
| ToVector(IVectorDouble, Int32, Int32) | Wraps a section of an original vector into a new vector. |
| ToVector(IVectorInt16, Int32, Int32) | Wraps a section of an original vector into a new vector. |
| ToVector(IVectorInt32, Int32, Int32) | Wraps a section of an original vector into a new vector. |
| ToVector(IVectorSByte, Int32, Int32) | Wraps a section of an original vector into a new vector. |
| ToVector(IVectorSingle, Int32, Int32) | Wraps a section of an original vector into a new vector. |
| ToVector(SByte, Int32, Int32) | Wraps a section of an array to get a IVectorT. |
| ToVector(Single, Int32, Int32) | Wraps a section of an array to get a [!:IVector<float>]. |
| ToZeroMean(Double) | Normalizes the vector elements so that the mean of the elements is zero. |
| ToZeroMean(Int32) | Normalizes the vector elements so that the mean of the elements is zero. |
| ToZeroMean(IVectorDouble) | Normalizes the vector elements so that the mean of the elements is zero. |
| ToZeroMean(IVectorSingle) | Normalizes the vector elements so that the mean of the elements is zero. |
| ToZeroMean(Single) | Normalizes the vector elements so that the mean of the elements is zero. |
| ToZeroMeanAndUnitVariance(Double) | Normalizes the vector elements so that the mean of the elements is zero. |
| ToZeroMeanAndUnitVariance(Int32) | Normalizes the vector elements so that the mean of the elements is zero. |
| ToZeroMeanAndUnitVariance(IVectorDouble) | Normalizes the vector elements so that the mean of the elements is zero. |
| ToZeroMeanAndUnitVariance(IVectorSingle) | Normalizes the vector elements so that the mean of the elements is zero. |
| ToZeroMeanAndUnitVariance(Single) | Normalizes the vector elements so that the mean of the elements is zero. |
See Also