VectorMath Type

Namespace: Altaxo.Calc.LinearAlgebra
Assembly: AltaxoCore.Redist.dll
Base Type: obj

VectorMath provides common static functions concerning vectors.

Static members

Static member Description

VectorMath.Add(a, b, c)

Full Usage: VectorMath.Add(a, b, c)

Parameters:
    a : float[] - First summand.
    b : float[] - Second summand.
    c : float[] - The resulting vector.

Adds (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length.

a : float[]

First summand.

b : float[]

Second summand.

c : float[]

The resulting vector.

VectorMath.Add(a, b, c)

Full Usage: VectorMath.Add(a, b, c)

Parameters:
    a : float32[] - First summand.
    b : float32[] - Second summand.
    c : float32[] - The resulting vector.

Adds (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length.

a : float32[]

First summand.

b : float32[]

Second summand.

c : float32[]

The resulting vector.

VectorMath.Add(a, b, c)

Full Usage: VectorMath.Add(a, b, c)

Parameters:
    a : int[] - First summand.
    b : int[] - Second summand.
    c : int[] - The resulting vector.

Adds (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length.

a : int[]

First summand.

b : int[]

Second summand.

c : int[]

The resulting vector.

VectorMath.Add(a, b, c)

Full Usage: VectorMath.Add(a, b, c)

Parameters:

Adds (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length.

a : IReadOnlyList<float>

First summand.

b : IReadOnlyList<float>

Second summand.

c : IVector<float>

The resulting vector.

VectorMath.Add(a, b, c)

Full Usage: VectorMath.Add(a, b, c)

Parameters:

Adds (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length.

a : IReadOnlyList<float32>

First summand.

b : IReadOnlyList<float32>

Second summand.

c : IVector<float32>

The resulting vector.

VectorMath.AddScaled(a, b, scaleb, c)

Full Usage: VectorMath.AddScaled(a, b, scaleb, c)

Parameters:
    a : float[] - First summand.
    b : float[] - Second summand.
    scaleb : float - Scale factor for vector b.
    c : float[] - The resulting vector calculated as a + b * scaleb.

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.

a : float[]

First summand.

b : float[]

Second summand.

scaleb : float

Scale factor for vector b.

c : float[]

The resulting vector calculated as a + b * scaleb.

VectorMath.AddScaled(a, b, scaleb, c)

Full Usage: VectorMath.AddScaled(a, b, scaleb, c)

Parameters:
    a : float32[] - First summand.
    b : float32[] - Second summand.
    scaleb : float32 - Scale factor for vector b.
    c : float32[] - The resulting vector calculated as a + b * scaleb.

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.

a : float32[]

First summand.

b : float32[]

Second summand.

scaleb : float32

Scale factor for vector b.

c : float32[]

The resulting vector calculated as a + b * scaleb.

VectorMath.AddScaled(a, b, scaleb, c)

Full Usage: VectorMath.AddScaled(a, b, scaleb, c)

Parameters:
    a : int[] - First summand.
    b : int[] - Second summand.
    scaleb : int - Scale factor for vector b.
    c : int[] - The resulting vector calculated as a + b * scaleb.

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.

a : int[]

First summand.

b : int[]

Second summand.

scaleb : int

Scale factor for vector b.

c : int[]

The resulting vector calculated as a + b * scaleb.

VectorMath.AddScaled(a, b, scaleb, c)

Full Usage: VectorMath.AddScaled(a, b, scaleb, c)

Parameters:
    a : IReadOnlyList<float> - First summand.
    b : IReadOnlyList<float> - Second summand.
    scaleb : float - Scale factor for vector b.
    c : IVector<float> - The resulting vector calculated as a + b * scaleb.

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.

a : IReadOnlyList<float>

First summand.

b : IReadOnlyList<float>

Second summand.

scaleb : float

Scale factor for vector b.

c : IVector<float>

The resulting vector calculated as a + b * scaleb.

VectorMath.AddScaled(a, b, scaleb, c)

Full Usage: VectorMath.AddScaled(a, b, scaleb, c)

Parameters:
    a : IReadOnlyList<float32> - First summand.
    b : IReadOnlyList<float32> - Second summand.
    scaleb : float32 - Scale factor for vector b.
    c : IVector<float32> - The resulting vector calculated as a + b * scaleb.

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.

a : IReadOnlyList<float32>

First summand.

b : IReadOnlyList<float32>

Second summand.

scaleb : float32

Scale factor for vector b.

c : IVector<float32>

The resulting vector calculated as a + b * scaleb.

VectorMath.Any(vector)

Full Usage: VectorMath.Any(vector)

Parameters:
    vector : float[] - The vector.

Returns: bool True if the vector contains any element; false otherwise, or if the vector is null.

Determines whether the given vector contains any elements.

vector : float[]

The vector.

Returns: bool

True if the vector contains any element; false otherwise, or if the vector is null.

VectorMath.Any(vector, predicate)

Full Usage: VectorMath.Any(vector, predicate)

Parameters:
    vector : float[] - The vector.
    predicate : Func<float, bool> - The condition to satisfy.

Returns: bool True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

Determines whether any element of the vector satisfies a condition.

vector : float[]

The vector.

predicate : Func<float, bool>

The condition to satisfy.

Returns: bool

True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

VectorMath.Any(vector, predicate, atIndex)

Full Usage: VectorMath.Any(vector, predicate, atIndex)

Parameters:
    vector : float[] - The vector.
    predicate : Func<float, bool> - The condition to satisfy.
    atIndex : byref<int> - The index of the first element that satisfied the condition; or -1 if no element satisfied the condition.

Returns: bool True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

Determines whether any element of the vector satisfies a condition.

vector : float[]

The vector.

predicate : Func<float, bool>

The condition to satisfy.

atIndex : byref<int>

The index of the first element that satisfied the condition; or -1 if no element satisfied the condition.

Returns: bool

True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

VectorMath.Any(vector)

Full Usage: VectorMath.Any(vector)

Parameters:
    vector : float32[] - The vector.

Returns: bool True if the vector contains any element; false otherwise, or if the vector is null.

Determines whether the given vector contains any elements.

vector : float32[]

The vector.

Returns: bool

True if the vector contains any element; false otherwise, or if the vector is null.

VectorMath.Any(vector, predicate)

Full Usage: VectorMath.Any(vector, predicate)

Parameters:
    vector : float32[] - The vector.
    predicate : Func<float32, bool> - The condition to satisfy.

Returns: bool True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

Determines whether any element of the vector satisfies a condition.

vector : float32[]

The vector.

predicate : Func<float32, bool>

The condition to satisfy.

Returns: bool

True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

VectorMath.Any(vector, predicate, atIndex)

Full Usage: VectorMath.Any(vector, predicate, atIndex)

Parameters:
    vector : float32[] - The vector.
    predicate : Func<float32, bool> - The condition to satisfy.
    atIndex : byref<int> - The index of the first element that satisfied the condition; or -1 if no element satisfied the condition.

Returns: bool True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

Determines whether any element of the vector satisfies a condition.

vector : float32[]

The vector.

predicate : Func<float32, bool>

The condition to satisfy.

atIndex : byref<int>

The index of the first element that satisfied the condition; or -1 if no element satisfied the condition.

Returns: bool

True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

VectorMath.Any(vector)

Full Usage: VectorMath.Any(vector)

Parameters:
    vector : int[] - The vector.

Returns: bool True if the vector contains any element; false otherwise, or if the vector is null.

Determines whether the given vector contains any elements.

vector : int[]

The vector.

Returns: bool

True if the vector contains any element; false otherwise, or if the vector is null.

VectorMath.Any(vector, predicate)

Full Usage: VectorMath.Any(vector, predicate)

Parameters:
    vector : int[] - The vector.
    predicate : Func<int, bool> - The condition to satisfy.

Returns: bool True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

Determines whether any element of the vector satisfies a condition.

vector : int[]

The vector.

predicate : Func<int, bool>

The condition to satisfy.

Returns: bool

True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

VectorMath.Any(vector, predicate, atIndex)

Full Usage: VectorMath.Any(vector, predicate, atIndex)

Parameters:
    vector : int[] - The vector.
    predicate : Func<int, bool> - The condition to satisfy.
    atIndex : byref<int> - The index of the first element that satisfied the condition; or -1 if no element satisfied the condition.

Returns: bool True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

Determines whether any element of the vector satisfies a condition.

vector : int[]

The vector.

predicate : Func<int, bool>

The condition to satisfy.

atIndex : byref<int>

The index of the first element that satisfied the condition; or -1 if no element satisfied the condition.

Returns: bool

True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

VectorMath.Any(vector)

Full Usage: VectorMath.Any(vector)

Parameters:
Returns: bool True if the vector contains any element; false otherwise, or if the vector is null.

Determines whether the given vector contains any elements.

vector : IReadOnlyList<float>

The vector.

Returns: bool

True if the vector contains any element; false otherwise, or if the vector is null.

VectorMath.Any(vector, predicate)

Full Usage: VectorMath.Any(vector, predicate)

Parameters:
    vector : IReadOnlyList<float> - The vector.
    predicate : Func<float, bool> - The condition to satisfy.

Returns: bool True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

Determines whether any element of the vector satisfies a condition.

vector : IReadOnlyList<float>

The vector.

predicate : Func<float, bool>

The condition to satisfy.

Returns: bool

True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

VectorMath.Any(vector, predicate, atIndex)

Full Usage: VectorMath.Any(vector, predicate, atIndex)

Parameters:
    vector : IReadOnlyList<float> - The vector.
    predicate : Func<float, bool> - The condition to satisfy.
    atIndex : byref<int> - The index of the first element that satisfied the condition; or -1 if no element satisfied the condition.

Returns: bool True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

Determines whether any element of the vector satisfies a condition.

vector : IReadOnlyList<float>

The vector.

predicate : Func<float, bool>

The condition to satisfy.

atIndex : byref<int>

The index of the first element that satisfied the condition; or -1 if no element satisfied the condition.

Returns: bool

True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

VectorMath.Any(vector)

Full Usage: VectorMath.Any(vector)

Parameters:
Returns: bool True if the vector contains any element; false otherwise, or if the vector is null.

Determines whether the given vector contains any elements.

vector : IReadOnlyList<float32>

The vector.

Returns: bool

True if the vector contains any element; false otherwise, or if the vector is null.

VectorMath.Any(vector, predicate)

Full Usage: VectorMath.Any(vector, predicate)

Parameters:
    vector : IReadOnlyList<float32> - The vector.
    predicate : Func<float32, bool> - The condition to satisfy.

Returns: bool True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

Determines whether any element of the vector satisfies a condition.

vector : IReadOnlyList<float32>

The vector.

predicate : Func<float32, bool>

The condition to satisfy.

Returns: bool

True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

VectorMath.Any(vector, predicate, atIndex)

Full Usage: VectorMath.Any(vector, predicate, atIndex)

Parameters:
    vector : IReadOnlyList<float32> - The vector.
    predicate : Func<float32, bool> - The condition to satisfy.
    atIndex : byref<int> - The index of the first element that satisfied the condition; or -1 if no element satisfied the condition.

Returns: bool True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

Determines whether any element of the vector satisfies a condition.

vector : IReadOnlyList<float32>

The vector.

predicate : Func<float32, bool>

The condition to satisfy.

atIndex : byref<int>

The index of the first element that satisfied the condition; or -1 if no element satisfied the condition.

Returns: bool

True if any element of the vector satisfies the condition; false otherwise, or if the vector is null.

VectorMath.AreValuesEqual(vector1, vector2)

Full Usage: VectorMath.AreValuesEqual(vector1, vector2)

Parameters:
    vector1 : float[] - First vector.
    vector2 : float[] - Second vector.

Returns: bool True if both vectors contain the same elements.

Returns true if and only if both vectors contain the same elements. Both vectors must have the same length.

vector1 : float[]

First vector.

vector2 : float[]

Second vector.

Returns: bool

True if both vectors contain the same elements.

VectorMath.AreValuesEqual(vector1, vector2)

Full Usage: VectorMath.AreValuesEqual(vector1, vector2)

Parameters:
    vector1 : float32[] - First vector.
    vector2 : float32[] - Second vector.

Returns: bool True if both vectors contain the same elements.

Returns true if and only if both vectors contain the same elements. Both vectors must have the same length.

vector1 : float32[]

First vector.

vector2 : float32[]

Second vector.

Returns: bool

True if both vectors contain the same elements.

VectorMath.AreValuesEqual(vector1, vector2)

Full Usage: VectorMath.AreValuesEqual(vector1, vector2)

Parameters:
    vector1 : int[] - First vector.
    vector2 : int[] - Second vector.

Returns: bool True if both vectors contain the same elements.

Returns true if and only if both vectors contain the same elements. Both vectors must have the same length.

vector1 : int[]

First vector.

vector2 : int[]

Second vector.

Returns: bool

True if both vectors contain the same elements.

VectorMath.AreValuesEqual(vector1, vector2)

Full Usage: VectorMath.AreValuesEqual(vector1, vector2)

Parameters:
Returns: bool True if both vectors contain the same elements.

Returns true if and only if both vectors contain the same elements. Both vectors must have the same length.

vector1 : IReadOnlyList<float>

First vector.

vector2 : IReadOnlyList<float>

Second vector.

Returns: bool

True if both vectors contain the same elements.

VectorMath.AreValuesEqual(vector1, vector2)

Full Usage: VectorMath.AreValuesEqual(vector1, vector2)

Parameters:
Returns: bool True if both vectors contain the same elements.

Returns true if and only if both vectors contain the same elements. Both vectors must have the same length.

vector1 : IReadOnlyList<float32>

First vector.

vector2 : IReadOnlyList<float32>

Second vector.

Returns: bool

True if both vectors contain the same elements.

VectorMath.Average(vector)

Full Usage: VectorMath.Average(vector)

Parameters:
    vector : float[] - The vector.

Returns: float The average of all elements in vector.

Returns the average (=sum/N) of the elements in vector.

vector : float[]

The vector.

Returns: float

The average of all elements in vector.

VectorMath.Average(vector)

Full Usage: VectorMath.Average(vector)

Parameters:
    vector : float32[] - The vector.

Returns: float The average of all elements in vector.

Returns the average (=sum/N) of the elements in vector.

vector : float32[]

The vector.

Returns: float

The average of all elements in vector.

VectorMath.Average(vector)

Full Usage: VectorMath.Average(vector)

Parameters:
    vector : int[] - The vector.

Returns: float The average of all elements in vector.

Returns the average (=sum/N) of the elements in vector.

vector : int[]

The vector.

Returns: float

The average of all elements in vector.

VectorMath.Average(vector)

Full Usage: VectorMath.Average(vector)

Parameters:
Returns: float The average of all elements in vector.

Returns the average (=sum/N) of the elements in vector.

vector : IReadOnlyList<float>

The vector.

Returns: float

The average of all elements in vector.

VectorMath.Average(vector)

Full Usage: VectorMath.Average(vector)

Parameters:
Returns: float The average of all elements in vector.

Returns the average (=sum/N) of the elements in vector.

vector : IReadOnlyList<float32>

The vector.

Returns: float

The average of all elements in vector.

VectorMath.Clone(sourceVector)

Full Usage: VectorMath.Clone(sourceVector)

Parameters:
    sourceVector : float[] - The source vector.

Returns: float[] A freshly allocated clone of the sourceVector, with the same element values as the source vector.

Returns a clone of the source vector.

sourceVector : float[]

The source vector.

Returns: float[]

A freshly allocated clone of the sourceVector, with the same element values as the source vector.

VectorMath.Clone(sourceVector)

Full Usage: VectorMath.Clone(sourceVector)

Parameters:
    sourceVector : float32[] - The source vector.

Returns: float32[] A freshly allocated clone of the sourceVector, with the same element values as the source vector.

Returns a clone of the source vector.

sourceVector : float32[]

The source vector.

Returns: float32[]

A freshly allocated clone of the sourceVector, with the same element values as the source vector.

VectorMath.Clone(sourceVector)

Full Usage: VectorMath.Clone(sourceVector)

Parameters:
    sourceVector : int[] - The source vector.

Returns: int[] A freshly allocated clone of the sourceVector, with the same element values as the source vector.

Returns a clone of the source vector.

sourceVector : int[]

The source vector.

Returns: int[]

A freshly allocated clone of the sourceVector, with the same element values as the source vector.

VectorMath.Clone(sourceVector)

Full Usage: VectorMath.Clone(sourceVector)

Parameters:
    sourceVector : int16[] - The source vector.

Returns: int16[] A freshly allocated clone of the sourceVector, with the same element values as the source vector.

Returns a clone of the source vector.

sourceVector : int16[]

The source vector.

Returns: int16[]

A freshly allocated clone of the sourceVector, with the same element values as the source vector.

VectorMath.Clone(sourceVector)

Full Usage: VectorMath.Clone(sourceVector)

Parameters:
    sourceVector : sbyte[] - The source vector.

Returns: sbyte[] A freshly allocated clone of the sourceVector, with the same element values as the source vector.

Returns a clone of the source vector.

sourceVector : sbyte[]

The source vector.

Returns: sbyte[]

A freshly allocated clone of the sourceVector, with the same element values as the source vector.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : float[] - The source vector.
    destinationVector : float[] - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : float[]

The source vector.

destinationVector : float[]

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : float[] - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : float[] - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : float[]

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : float[]

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : IReadOnlyList<float> - The source vector.
    destinationVector : float[] - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : IReadOnlyList<float>

The source vector.

destinationVector : float[]

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : IReadOnlyList<float> - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : float[] - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : IReadOnlyList<float>

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : float[]

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : float[] - The source vector.
    destinationVector : IVector<float> - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : float[]

The source vector.

destinationVector : IVector<float>

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : float[] - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : IVector<float> - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : float[]

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : IVector<float>

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : IReadOnlyList<float> - The source vector.
    destinationVector : IVector<float> - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : IReadOnlyList<float>

The source vector.

destinationVector : IVector<float>

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : IReadOnlyList<float> - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : IVector<float> - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : IReadOnlyList<float>

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : IVector<float>

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : float32[] - The source vector.
    destinationVector : float[] - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : float32[]

The source vector.

destinationVector : float[]

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : float32[] - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : float[] - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : float32[]

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : float[]

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : IReadOnlyList<float32> - The source vector.
    destinationVector : float[] - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : IReadOnlyList<float32>

The source vector.

destinationVector : float[]

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : IReadOnlyList<float32> - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : float[] - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : IReadOnlyList<float32>

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : float[]

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : float32[] - The source vector.
    destinationVector : IVector<float> - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : float32[]

The source vector.

destinationVector : IVector<float>

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : float32[] - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : IVector<float> - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : float32[]

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : IVector<float>

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : IReadOnlyList<float32> - The source vector.
    destinationVector : IVector<float> - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : IReadOnlyList<float32>

The source vector.

destinationVector : IVector<float>

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : IReadOnlyList<float32> - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : IVector<float> - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : IReadOnlyList<float32>

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : IVector<float>

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : float32[] - The source vector.
    destinationVector : float32[] - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : float32[]

The source vector.

destinationVector : float32[]

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : float32[] - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : float32[] - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : float32[]

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : float32[]

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : IReadOnlyList<float32> - The source vector.
    destinationVector : float32[] - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : IReadOnlyList<float32>

The source vector.

destinationVector : float32[]

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : IReadOnlyList<float32> - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : float32[] - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : IReadOnlyList<float32>

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : float32[]

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : float32[] - The source vector.
    destinationVector : IVector<float32> - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : float32[]

The source vector.

destinationVector : IVector<float32>

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : float32[] - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : IVector<float32> - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : float32[]

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : IVector<float32>

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : IReadOnlyList<float32> - The source vector.
    destinationVector : IVector<float32> - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : IReadOnlyList<float32>

The source vector.

destinationVector : IVector<float32>

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : IReadOnlyList<float32> - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : IVector<float32> - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : IReadOnlyList<float32>

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : IVector<float32>

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : int[] - The source vector.
    destinationVector : float[] - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : int[]

The source vector.

destinationVector : float[]

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : int[] - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : float[] - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : int[]

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : float[]

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : IReadOnlyList<int> - The source vector.
    destinationVector : float[] - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : IReadOnlyList<int>

The source vector.

destinationVector : float[]

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : IReadOnlyList<int> - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : float[] - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : IReadOnlyList<int>

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : float[]

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : int[] - The source vector.
    destinationVector : IVector<float> - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : int[]

The source vector.

destinationVector : IVector<float>

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : int[] - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : IVector<float> - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : int[]

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : IVector<float>

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : IReadOnlyList<int> - The source vector.
    destinationVector : IVector<float> - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : IReadOnlyList<int>

The source vector.

destinationVector : IVector<float>

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : IReadOnlyList<int> - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : IVector<float> - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : IReadOnlyList<int>

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : IVector<float>

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : int[] - The source vector.
    destinationVector : float32[] - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : int[]

The source vector.

destinationVector : float32[]

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : int[] - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : float32[] - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : int[]

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : float32[]

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : IReadOnlyList<int> - The source vector.
    destinationVector : float32[] - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : IReadOnlyList<int>

The source vector.

destinationVector : float32[]

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : IReadOnlyList<int> - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : float32[] - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : IReadOnlyList<int>

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : float32[]

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : int[] - The source vector.
    destinationVector : IVector<float32> - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : int[]

The source vector.

destinationVector : IVector<float32>

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : int[] - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : IVector<float32> - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : int[]

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : IVector<float32>

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : IReadOnlyList<int> - The source vector.
    destinationVector : IVector<float32> - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : IReadOnlyList<int>

The source vector.

destinationVector : IVector<float32>

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : IReadOnlyList<int> - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : IVector<float32> - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : IReadOnlyList<int>

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : IVector<float32>

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : int[] - The source vector.
    destinationVector : int[] - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : int[]

The source vector.

destinationVector : int[]

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : int[] - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : int[] - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : int[]

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : int[]

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : IReadOnlyList<int> - The source vector.
    destinationVector : int[] - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : IReadOnlyList<int>

The source vector.

destinationVector : int[]

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : IReadOnlyList<int> - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : int[] - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : IReadOnlyList<int>

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : int[]

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : int[] - The source vector.
    destinationVector : IVector<int> - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : int[]

The source vector.

destinationVector : IVector<int>

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : int[] - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : IVector<int> - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : int[]

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : IVector<int>

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.Copy(sourceVector, destinationVector)

Full Usage: VectorMath.Copy(sourceVector, destinationVector)

Parameters:
    sourceVector : IReadOnlyList<int> - The source vector.
    destinationVector : IVector<int> - The destination vector.

Copies the source vector to the destination vector. Both vectors must have the same length.

sourceVector : IReadOnlyList<int>

The source vector.

destinationVector : IVector<int>

The destination vector.

VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Full Usage: VectorMath.Copy(sourceVector, sourceStartIndex, destinationVector, destinationStartIndex, count)

Parameters:
    sourceVector : IReadOnlyList<int> - The source vector.
    sourceStartIndex : int - First element of the source vector to copy.
    destinationVector : IVector<int> - The destination vector.
    destinationStartIndex : int - First element of the destination vector to copy to.
    count : int - Number of elements to copy.

Copies elements of a source vector to a destination vector.

sourceVector : IReadOnlyList<int>

The source vector.

sourceStartIndex : int

First element of the source vector to copy.

destinationVector : IVector<int>

The destination vector.

destinationStartIndex : int

First element of the destination vector to copy to.

count : int

Number of elements to copy.

VectorMath.CreateEquidistantSequenceByStartEndLength(start, end, length)

Full Usage: VectorMath.CreateEquidistantSequenceByStartEndLength(start, end, length)

Parameters:
    start : float - First element of the vector.
    end : float - Last element of the vector.
    length : int - Length of the vector.

Returns: IROVector<float> Read-only vector with equidistant element values from start to end.

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.

start : float

First element of the vector.

end : float

Last element of the vector.

length : int

Length of the vector.

Returns: IROVector<float>

Read-only vector with equidistant element values from start to end.

VectorMath.CreateEquidistantSequenceByStartEndLength(start, end, length)

Full Usage: VectorMath.CreateEquidistantSequenceByStartEndLength(start, end, length)

Parameters:
    start : float32 - First element of the vector.
    end : float32 - Last element of the vector.
    length : int - Length of the vector.

Returns: IROVector<float32> Read-only vector with equidistant element values from start to end.

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.

start : float32

First element of the vector.

end : float32

Last element of the vector.

length : int

Length of the vector.

Returns: IROVector<float32>

Read-only vector with equidistant element values from start to end.

VectorMath.CreateEquidistantSequenceByStartEndLength(start, end, length)

Full Usage: VectorMath.CreateEquidistantSequenceByStartEndLength(start, end, length)

Parameters:
    start : int - First element of the vector.
    end : int - Last element of the vector.
    length : int - Length of the vector.

Returns: IROVector<int> Read-only vector with equidistant element values from start to end.

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.

start : int

First element of the vector.

end : int

Last element of the vector.

length : int

Length of the vector.

Returns: IROVector<int>

Read-only vector with equidistant element values from start to end.

VectorMath.CreateEquidistantSequenceByStartEndLength(start, end, length)

Full Usage: VectorMath.CreateEquidistantSequenceByStartEndLength(start, end, length)

Parameters:
    start : int16 - First element of the vector.
    end : int16 - Last element of the vector.
    length : int - Length of the vector.

Returns: IROVector<int16> Read-only vector with equidistant element values from start to end.

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.

start : int16

First element of the vector.

end : int16

Last element of the vector.

length : int

Length of the vector.

Returns: IROVector<int16>

Read-only vector with equidistant element values from start to end.

VectorMath.CreateEquidistantSequenceByStartEndLength(start, end, length)

Full Usage: VectorMath.CreateEquidistantSequenceByStartEndLength(start, end, length)

Parameters:
    start : sbyte - First element of the vector.
    end : sbyte - Last element of the vector.
    length : int - Length of the vector.

Returns: IROVector<sbyte> Read-only vector with equidistant element values from start to end.

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.

start : sbyte

First element of the vector.

end : sbyte

Last element of the vector.

length : int

Length of the vector.

Returns: IROVector<sbyte>

Read-only vector with equidistant element values from start to end.

VectorMath.CreateEquidistantSequenceByStartStepLength(start, step, length)

Full Usage: VectorMath.CreateEquidistantSequenceByStartStepLength(start, step, length)

Parameters:
    start : float - First element of the vector.
    step : float - Difference between two successive elements.
    length : int - Length of the vector.

Returns: IROVector<float> Read-only vector with equidistant elements with values from start to start+(length-1)*step.

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.

start : float

First element of the vector.

step : float

Difference between two successive elements.

length : int

Length of the vector.

Returns: IROVector<float>

Read-only vector with equidistant elements with values from start to start+(length-1)*step.

VectorMath.CreateEquidistantSequenceByStartStepLength(start, step, length)

Full Usage: VectorMath.CreateEquidistantSequenceByStartStepLength(start, step, length)

Parameters:
    start : float32 - First element of the vector.
    step : float32 - Difference between two successive elements.
    length : int - Length of the vector.

Returns: IROVector<float32> Read-only vector with equidistant elements with values from start to start+(length-1)*step.

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.

start : float32

First element of the vector.

step : float32

Difference between two successive elements.

length : int

Length of the vector.

Returns: IROVector<float32>

Read-only vector with equidistant elements with values from start to start+(length-1)*step.

VectorMath.CreateEquidistantSequenceByStartStepLength(start, step, length)

Full Usage: VectorMath.CreateEquidistantSequenceByStartStepLength(start, step, length)

Parameters:
    start : int - First element of the vector.
    step : int - Difference between two successive elements.
    length : int - Length of the vector.

Returns: IROVector<int> Read-only vector with equidistant elements with values from start to start+(length-1)*step.

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.

start : int

First element of the vector.

step : int

Difference between two successive elements.

length : int

Length of the vector.

Returns: IROVector<int>

Read-only vector with equidistant elements with values from start to start+(length-1)*step.

VectorMath.CreateEquidistantSequenceByStartStepLength(start, step, length)

Full Usage: VectorMath.CreateEquidistantSequenceByStartStepLength(start, step, length)

Parameters:
    start : int16 - First element of the vector.
    step : int16 - Difference between two successive elements.
    length : int - Length of the vector.

Returns: IROVector<int16> Read-only vector with equidistant elements with values from start to start+(length-1)*step.

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.

start : int16

First element of the vector.

step : int16

Difference between two successive elements.

length : int

Length of the vector.

Returns: IROVector<int16>

Read-only vector with equidistant elements with values from start to start+(length-1)*step.

VectorMath.CreateEquidistantSequenceByStartStepLength(start, step, length)

Full Usage: VectorMath.CreateEquidistantSequenceByStartStepLength(start, step, length)

Parameters:
    start : sbyte - First element of the vector.
    step : sbyte - Difference between two successive elements.
    length : int - Length of the vector.

Returns: IROVector<sbyte> Read-only vector with equidistant elements with values from start to start+(length-1)*step.

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.

start : sbyte

First element of the vector.

step : sbyte

Difference between two successive elements.

length : int

Length of the vector.

Returns: IROVector<sbyte>

Read-only vector with equidistant elements with values from start to start+(length-1)*step.

VectorMath.CreateEquidistantSequencyByStartAtOffsetStepLength(start, startOffset, step, length)

Full Usage: VectorMath.CreateEquidistantSequencyByStartAtOffsetStepLength(start, startOffset, step, length)

Parameters:
    start : float - Value of the element of the vector at index startOffset).
    startOffset : int - Index of the element of the vector which gets the value of start.
    step : float - Difference between two successive elements.
    length : int - Length of the vector.

Returns: IROVector<float> Read-only vector with equidistant elements from start - startOffset*step to start + (length - 1 -startOffset)*step.

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.

start : float

Value of the element of the vector at index startOffset).

startOffset : int

Index of the element of the vector which gets the value of start.

step : float

Difference between two successive elements.

length : int

Length of the vector.

Returns: IROVector<float>

Read-only vector with equidistant elements from start - startOffset*step to start + (length - 1 -startOffset)*step.

VectorMath.CreateEquidistantSequencyByStartAtOffsetStepLength(start, startOffset, step, length)

Full Usage: VectorMath.CreateEquidistantSequencyByStartAtOffsetStepLength(start, startOffset, step, length)

Parameters:
    start : float32 - Value of the element of the vector at index startOffset).
    startOffset : int - Index of the element of the vector which gets the value of start.
    step : float32 - Difference between two successive elements.
    length : int - Length of the vector.

Returns: IROVector<float32> Read-only vector with equidistant elements from start - startOffset*step to start + (length - 1 -startOffset)*step.

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.

start : float32

Value of the element of the vector at index startOffset).

startOffset : int

Index of the element of the vector which gets the value of start.

step : float32

Difference between two successive elements.

length : int

Length of the vector.

Returns: IROVector<float32>

Read-only vector with equidistant elements from start - startOffset*step to start + (length - 1 -startOffset)*step.

VectorMath.CreateEquidistantSequencyByStartAtOffsetStepLength(start, startOffset, step, length)

Full Usage: VectorMath.CreateEquidistantSequencyByStartAtOffsetStepLength(start, startOffset, step, length)

Parameters:
    start : int - Value of the element of the vector at index startOffset).
    startOffset : int - Index of the element of the vector which gets the value of start.
    step : int - Difference between two successive elements.
    length : int - Length of the vector.

Returns: IROVector<int> Read-only vector with equidistant elements from start - startOffset*step to start + (length - 1 -startOffset)*step.

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.

start : int

Value of the element of the vector at index startOffset).

startOffset : int

Index of the element of the vector which gets the value of start.

step : int

Difference between two successive elements.

length : int

Length of the vector.

Returns: IROVector<int>

Read-only vector with equidistant elements from start - startOffset*step to start + (length - 1 -startOffset)*step.

VectorMath.CreateEquidistantSequencyByStartAtOffsetStepLength(start, startOffset, step, length)

Full Usage: VectorMath.CreateEquidistantSequencyByStartAtOffsetStepLength(start, startOffset, step, length)

Parameters:
    start : int16 - Value of the element of the vector at index startOffset).
    startOffset : int - Index of the element of the vector which gets the value of start.
    step : int16 - Difference between two successive elements.
    length : int - Length of the vector.

Returns: IROVector<int16> Read-only vector with equidistant elements from start - startOffset*step to start + (length - 1 -startOffset)*step.

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.

start : int16

Value of the element of the vector at index startOffset).

startOffset : int

Index of the element of the vector which gets the value of start.

step : int16

Difference between two successive elements.

length : int

Length of the vector.

Returns: IROVector<int16>

Read-only vector with equidistant elements from start - startOffset*step to start + (length - 1 -startOffset)*step.

VectorMath.CreateEquidistantSequencyByStartAtOffsetStepLength(start, startOffset, step, length)

Full Usage: VectorMath.CreateEquidistantSequencyByStartAtOffsetStepLength(start, startOffset, step, length)

Parameters:
    start : sbyte - Value of the element of the vector at index startOffset).
    startOffset : int - Index of the element of the vector which gets the value of start.
    step : sbyte - Difference between two successive elements.
    length : int - Length of the vector.

Returns: IROVector<sbyte> Read-only vector with equidistant elements from start - startOffset*step to start + (length - 1 -startOffset)*step.

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.

start : sbyte

Value of the element of the vector at index startOffset).

startOffset : int

Index of the element of the vector which gets the value of start.

step : sbyte

Difference between two successive elements.

length : int

Length of the vector.

Returns: IROVector<sbyte>

Read-only vector with equidistant elements from start - startOffset*step to start + (length - 1 -startOffset)*step.

VectorMath.CreateExtensibleVector(length)

Full Usage: VectorMath.CreateExtensibleVector(length)

Parameters:
    length : int - The inital length of the vector.

Returns: IExtensibleVector<'T> An instance of a extensible vector.

Creates a new extensible vector of length length

length : int

The inital length of the vector.

Returns: IExtensibleVector<'T>

An instance of a extensible vector.

VectorMath.Divide(x, y)

Full Usage: VectorMath.Divide(x, y)

Parameters:
    x : float - A scalar value
    y : float[] - A vector.

Sets the element of the vector to the result of scalar x divided by each element y[i].

x : float

A scalar value

y : float[]

A vector.

VectorMath.Divide(x, y)

Full Usage: VectorMath.Divide(x, y)

Parameters:
    x : float32 - A scalar value
    y : float32[] - A vector.

Sets the element of the vector to the result of scalar x divided by each element y[i].

x : float32

A scalar value

y : float32[]

A vector.

VectorMath.Divide(x, y)

Full Usage: VectorMath.Divide(x, y)

Parameters:
    x : int - A scalar value
    y : int[] - A vector.

Sets the element of the vector to the result of scalar x divided by each element y[i].

x : int

A scalar value

y : int[]

A vector.

VectorMath.Divide(x, y)

Full Usage: VectorMath.Divide(x, y)

Parameters:
    x : float - A scalar value
    y : IVector<float> - A vector.

Sets the element of the vector to the result of scalar x divided by each element y[i].

x : float

A scalar value

y : IVector<float>

A vector.

VectorMath.Divide(x, y)

Full Usage: VectorMath.Divide(x, y)

Parameters:
    x : float32 - A scalar value
    y : IVector<float32> - A vector.

Sets the element of the vector to the result of scalar x divided by each element y[i].

x : float32

A scalar value

y : IVector<float32>

A vector.

VectorMath.DotProduct(vector1, vector2)

Full Usage: VectorMath.DotProduct(vector1, vector2)

Parameters:
    vector1 : float[] - The first array.
    vector2 : float[] - The other array.

Returns: float The dot product (sum of vector1[i]*vector2[i].

Returns the dot product of vector1 and vector2.

vector1 : float[]

The first array.

vector2 : float[]

The other array.

Returns: float

The dot product (sum of vector1[i]*vector2[i].

VectorMath.DotProduct(vector1, vector2)

Full Usage: VectorMath.DotProduct(vector1, vector2)

Parameters:
    vector1 : float32[] - The first array.
    vector2 : float32[] - The other array.

Returns: float The dot product (sum of vector1[i]*vector2[i].

Returns the dot product of vector1 and vector2.

vector1 : float32[]

The first array.

vector2 : float32[]

The other array.

Returns: float

The dot product (sum of vector1[i]*vector2[i].

VectorMath.DotProduct(vector1, vector2)

Full Usage: VectorMath.DotProduct(vector1, vector2)

Parameters:
    vector1 : int[] - The first array.
    vector2 : int[] - The other array.

Returns: float The dot product (sum of vector1[i]*vector2[i].

Returns the dot product of vector1 and vector2.

vector1 : int[]

The first array.

vector2 : int[]

The other array.

Returns: float

The dot product (sum of vector1[i]*vector2[i].

VectorMath.DotProduct(vector1, vector2)

Full Usage: VectorMath.DotProduct(vector1, vector2)

Parameters:
Returns: float The dot product (sum of vector1[i]*vector2[i].

Returns the dot product of vector1 and vector2.

vector1 : IReadOnlyList<float>

The first array.

vector2 : IReadOnlyList<float>

The other array.

Returns: float

The dot product (sum of vector1[i]*vector2[i].

VectorMath.DotProduct(vector1, vector2)

Full Usage: VectorMath.DotProduct(vector1, vector2)

Parameters:
Returns: float The dot product (sum of vector1[i]*vector2[i].

Returns the dot product of vector1 and vector2.

vector1 : IReadOnlyList<float32>

The first array.

vector2 : IReadOnlyList<float32>

The other array.

Returns: float

The dot product (sum of vector1[i]*vector2[i].

VectorMath.ElementsAt(array, indices)

Full Usage: VectorMath.ElementsAt(array, indices)

Parameters:
    array : 'T[]
    indices : int[]

Returns: 'T[]

array : 'T[]
indices : int[]
Returns: 'T[]

VectorMath.ElementsAt(array, indices)

Full Usage: VectorMath.ElementsAt(array, indices)

Parameters:
Returns: IReadOnlyList<'T>

array : IReadOnlyList<'T>
indices : int[]
Returns: IReadOnlyList<'T>

VectorMath.ElementsWhere(array, condition)

Full Usage: VectorMath.ElementsWhere(array, condition)

Parameters:
    array : 'T[]
    condition : bool[]

Returns: 'T[]

array : 'T[]
condition : bool[]
Returns: 'T[]

VectorMath.ElementsWhere(array, condition)

Full Usage: VectorMath.ElementsWhere(array, condition)

Parameters:
Returns: IReadOnlyList<'T>

array : IReadOnlyList<'T>
condition : bool[]
Returns: IReadOnlyList<'T>

VectorMath.ElementsWhere(array, condition)

Full Usage: VectorMath.ElementsWhere(array, condition)

Parameters:
Returns: 'T[]

array : 'T[]
condition : IEnumerable<bool>
Returns: 'T[]

VectorMath.ElementsWhere(array, condition)

Full Usage: VectorMath.ElementsWhere(array, condition)

Parameters:
Returns: IReadOnlyList<'T>

array : IReadOnlyList<'T>
condition : IEnumerable<bool>
Returns: IReadOnlyList<'T>

VectorMath.EuclideanDistance(vector1, vector2)

Full Usage: VectorMath.EuclideanDistance(vector1, vector2)

Parameters:
    vector1 : float[] - The first vector.
    vector2 : float[] - The other vector.

Returns: float The Euclidean distance of vector1 and vector2.

Returns the Euclidean distance of two vectors, i.e. the L2-norm of the difference of the two vectors.

vector1 : float[]

The first vector.

vector2 : float[]

The other vector.

Returns: float

The Euclidean distance of vector1 and vector2.

VectorMath.EuclideanDistance(vector1, vector2)

Full Usage: VectorMath.EuclideanDistance(vector1, vector2)

Parameters:
    vector1 : float32[] - The first vector.
    vector2 : float32[] - The other vector.

Returns: float The Euclidean distance of vector1 and vector2.

Returns the Euclidean distance of two vectors, i.e. the L2-norm of the difference of the two vectors.

vector1 : float32[]

The first vector.

vector2 : float32[]

The other vector.

Returns: float

The Euclidean distance of vector1 and vector2.

VectorMath.EuclideanDistance(vector1, vector2)

Full Usage: VectorMath.EuclideanDistance(vector1, vector2)

Parameters:
    vector1 : int[] - The first vector.
    vector2 : int[] - The other vector.

Returns: float The Euclidean distance of vector1 and vector2.

Returns the Euclidean distance of two vectors, i.e. the L2-norm of the difference of the two vectors.

vector1 : int[]

The first vector.

vector2 : int[]

The other vector.

Returns: float

The Euclidean distance of vector1 and vector2.

VectorMath.EuclideanDistance(vector1, vector2)

Full Usage: VectorMath.EuclideanDistance(vector1, vector2)

Parameters:
Returns: float The Euclidean distance of vector1 and vector2.

Returns the Euclidean distance of two vectors, i.e. the L2-norm of the difference of the two vectors.

vector1 : IReadOnlyList<float>

The first vector.

vector2 : IReadOnlyList<float>

The other vector.

Returns: float

The Euclidean distance of vector1 and vector2.

VectorMath.EuclideanDistance(vector1, vector2)

Full Usage: VectorMath.EuclideanDistance(vector1, vector2)

Parameters:
Returns: float The Euclidean distance of vector1 and vector2.

Returns the Euclidean distance of two vectors, i.e. the L2-norm of the difference of the two vectors.

vector1 : IReadOnlyList<float32>

The first vector.

vector2 : IReadOnlyList<float32>

The other vector.

Returns: float

The Euclidean distance of vector1 and vector2.

VectorMath.EuclideanNorm(vector)

Full Usage: VectorMath.EuclideanNorm(vector)

Parameters:
    vector : float[] - An input array of length n.

Returns: float The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

Given an n-vector x, this function calculates the euclidean norm of x.

the euclidean norm is computed by accumulating the sum of squares in three different sums. the sums of squares for the small and large components are scaled so that no overflows occur. non-destructive underflows are permitted. underflows and overflows do not occur in the computation of the unscaled sum of squares for the intermediate components. the definitions of small, intermediate and large components depend on two constants, rdwarf and rgiant. the main restrictions on these constants are that rdwarf**2 not underflow and rgiant**2 not overflow. the constants given here are suitable for every known computer.

burton s. garbow, kenneth e. hillstrom, jorge j. more

vector : float[]

An input array of length n.

Returns: float

The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

VectorMath.EuclideanNorm(vector)

Full Usage: VectorMath.EuclideanNorm(vector)

Parameters:
    vector : float32[] - An input array of length n.

Returns: float The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

Given an n-vector x, this function calculates the euclidean norm of x.

the euclidean norm is computed by accumulating the sum of squares in three different sums. the sums of squares for the small and large components are scaled so that no overflows occur. non-destructive underflows are permitted. underflows and overflows do not occur in the computation of the unscaled sum of squares for the intermediate components. the definitions of small, intermediate and large components depend on two constants, rdwarf and rgiant. the main restrictions on these constants are that rdwarf**2 not underflow and rgiant**2 not overflow. the constants given here are suitable for every known computer.

burton s. garbow, kenneth e. hillstrom, jorge j. more

vector : float32[]

An input array of length n.

Returns: float

The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

VectorMath.EuclideanNorm(vector)

Full Usage: VectorMath.EuclideanNorm(vector)

Parameters:
    vector : int[] - An input array of length n.

Returns: float The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

Given an n-vector x, this function calculates the euclidean norm of x.

the euclidean norm is computed by accumulating the sum of squares in three different sums. the sums of squares for the small and large components are scaled so that no overflows occur. non-destructive underflows are permitted. underflows and overflows do not occur in the computation of the unscaled sum of squares for the intermediate components. the definitions of small, intermediate and large components depend on two constants, rdwarf and rgiant. the main restrictions on these constants are that rdwarf**2 not underflow and rgiant**2 not overflow. the constants given here are suitable for every known computer.

burton s. garbow, kenneth e. hillstrom, jorge j. more

vector : int[]

An input array of length n.

Returns: float

The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

VectorMath.EuclideanNorm(vector)

Full Usage: VectorMath.EuclideanNorm(vector)

Parameters:
Returns: float The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

Given an n-vector x, this function calculates the euclidean norm of x.

the euclidean norm is computed by accumulating the sum of squares in three different sums. the sums of squares for the small and large components are scaled so that no overflows occur. non-destructive underflows are permitted. underflows and overflows do not occur in the computation of the unscaled sum of squares for the intermediate components. the definitions of small, intermediate and large components depend on two constants, rdwarf and rgiant. the main restrictions on these constants are that rdwarf**2 not underflow and rgiant**2 not overflow. the constants given here are suitable for every known computer.

burton s. garbow, kenneth e. hillstrom, jorge j. more

vector : IReadOnlyList<float>

An input array of length n.

Returns: float

The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

VectorMath.EuclideanNorm(vector)

Full Usage: VectorMath.EuclideanNorm(vector)

Parameters:
Returns: float The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

Given an n-vector x, this function calculates the euclidean norm of x.

the euclidean norm is computed by accumulating the sum of squares in three different sums. the sums of squares for the small and large components are scaled so that no overflows occur. non-destructive underflows are permitted. underflows and overflows do not occur in the computation of the unscaled sum of squares for the intermediate components. the definitions of small, intermediate and large components depend on two constants, rdwarf and rgiant. the main restrictions on these constants are that rdwarf**2 not underflow and rgiant**2 not overflow. the constants given here are suitable for every known computer.

burton s. garbow, kenneth e. hillstrom, jorge j. more

vector : IReadOnlyList<float32>

An input array of length n.

Returns: float

The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

VectorMath.ExcessKurtosisOfNormalized(vector)

Full Usage: VectorMath.ExcessKurtosisOfNormalized(vector)

Parameters:
    vector : float[] - The vector.

Returns: float The excess kurtosis of the elements in vector.

Returns the excess kurtosis of the elements in vector. The excess kurtosis is defined as excesskurtosis(X) = E{X^4} - 3(E{X²})².

vector : float[]

The vector.

Returns: float

The excess kurtosis of the elements in vector.

VectorMath.ExcessKurtosisOfNormalized(vector)

Full Usage: VectorMath.ExcessKurtosisOfNormalized(vector)

Parameters:
    vector : float32[] - The vector.

Returns: float The excess kurtosis of the elements in vector.

Returns the excess kurtosis of the elements in vector. The excess kurtosis is defined as excesskurtosis(X) = E{X^4} - 3(E{X²})².

vector : float32[]

The vector.

Returns: float

The excess kurtosis of the elements in vector.

VectorMath.ExcessKurtosisOfNormalized(vector)

Full Usage: VectorMath.ExcessKurtosisOfNormalized(vector)

Parameters:
    vector : int[] - The vector.

Returns: float The excess kurtosis of the elements in vector.

Returns the excess kurtosis of the elements in vector. The excess kurtosis is defined as excesskurtosis(X) = E{X^4} - 3(E{X²})².

vector : int[]

The vector.

Returns: float

The excess kurtosis of the elements in vector.

VectorMath.ExcessKurtosisOfNormalized(vector)

Full Usage: VectorMath.ExcessKurtosisOfNormalized(vector)

Parameters:
Returns: float The excess kurtosis of the elements in vector.

Returns the excess kurtosis of the elements in vector. The excess kurtosis is defined as excesskurtosis(X) = E{X^4} - 3(E{X²})².

vector : IReadOnlyList<float>

The vector.

Returns: float

The excess kurtosis of the elements in vector.

VectorMath.ExcessKurtosisOfNormalized(vector)

Full Usage: VectorMath.ExcessKurtosisOfNormalized(vector)

Parameters:
Returns: float The excess kurtosis of the elements in vector.

Returns the excess kurtosis of the elements in vector. The excess kurtosis is defined as excesskurtosis(X) = E{X^4} - 3(E{X²})².

vector : IReadOnlyList<float32>

The vector.

Returns: float

The excess kurtosis of the elements in vector.

VectorMath.FillWith(vector, val)

Full Usage: VectorMath.FillWith(vector, val)

Parameters:
    vector : float[] - The vector to fill.
    val : float - The value each element is set to.

Fills a vector with a certain value. so that all elements are equal.

vector : float[]

The vector to fill.

val : float

The value each element is set to.

VectorMath.FillWith(vector, val)

Full Usage: VectorMath.FillWith(vector, val)

Parameters:
    vector : float32[] - The vector to fill.
    val : float32 - The value each element is set to.

Fills a vector with a certain value. so that all elements are equal.

vector : float32[]

The vector to fill.

val : float32

The value each element is set to.

VectorMath.FillWith(vector, val)

Full Usage: VectorMath.FillWith(vector, val)

Parameters:
    vector : int[] - The vector to fill.
    val : int - The value each element is set to.

Fills a vector with a certain value. so that all elements are equal.

vector : int[]

The vector to fill.

val : int

The value each element is set to.

VectorMath.FillWith(vector, val)

Full Usage: VectorMath.FillWith(vector, val)

Parameters:
    vector : IVector<float> - The vector to fill.
    val : float - The value each element is set to.

Fills a vector with a certain value. so that all elements are equal.

vector : IVector<float>

The vector to fill.

val : float

The value each element is set to.

VectorMath.FillWith(vector, val)

Full Usage: VectorMath.FillWith(vector, val)

Parameters:
    vector : IVector<float32> - The vector to fill.
    val : float32 - The value each element is set to.

Fills a vector with a certain value. so that all elements are equal.

vector : IVector<float32>

The vector to fill.

val : float32

The value each element is set to.

VectorMath.FillWithLinearSequenceGivenByStartAndEnd(vector, startValue, endValue)

Full Usage: VectorMath.FillWithLinearSequenceGivenByStartAndEnd(vector, startValue, endValue)

Parameters:
    vector : float[] - The vector to be filled.
    startValue : float - First value of the vector (value at index 0).
    endValue : float - Last value of the vector (value at index Length-1).

Fills the vector v with a linear sequence beginning from start (first element) until end (last element).

vector : float[]

The vector to be filled.

startValue : float

First value of the vector (value at index 0).

endValue : float

Last value of the vector (value at index Length-1).

VectorMath.FillWithLinearSequenceGivenByStartAndEnd(vector, startValue, endValue)

Full Usage: VectorMath.FillWithLinearSequenceGivenByStartAndEnd(vector, startValue, endValue)

Parameters:
    vector : float32[] - The vector to be filled.
    startValue : float32 - First value of the vector (value at index 0).
    endValue : float32 - Last value of the vector (value at index Length-1).

Fills the vector v with a linear sequence beginning from start (first element) until end (last element).

vector : float32[]

The vector to be filled.

startValue : float32

First value of the vector (value at index 0).

endValue : float32

Last value of the vector (value at index Length-1).

VectorMath.FillWithLinearSequenceGivenByStartAndEnd(vector, startValue, endValue)

Full Usage: VectorMath.FillWithLinearSequenceGivenByStartAndEnd(vector, startValue, endValue)

Parameters:
    vector : int[] - The vector to be filled.
    startValue : int - First value of the vector (value at index 0).
    endValue : int - Last value of the vector (value at index Length-1).

Fills the vector v with a linear sequence beginning from start (first element) until end (last element).

vector : int[]

The vector to be filled.

startValue : int

First value of the vector (value at index 0).

endValue : int

Last value of the vector (value at index Length-1).

VectorMath.FillWithLinearSequenceGivenByStartAndEnd(vector, startValue, endValue)

Full Usage: VectorMath.FillWithLinearSequenceGivenByStartAndEnd(vector, startValue, endValue)

Parameters:
    vector : IVector<float> - The vector to be filled.
    startValue : float - First value of the vector (value at index 0).
    endValue : float - Last value of the vector (value at index Length-1).

Fills the vector v with a linear sequence beginning from start (first element) until end (last element).

vector : IVector<float>

The vector to be filled.

startValue : float

First value of the vector (value at index 0).

endValue : float

Last value of the vector (value at index Length-1).

VectorMath.FillWithLinearSequenceGivenByStartAndEnd(vector, startValue, endValue)

Full Usage: VectorMath.FillWithLinearSequenceGivenByStartAndEnd(vector, startValue, endValue)

Parameters:
    vector : IVector<float32> - The vector to be filled.
    startValue : float32 - First value of the vector (value at index 0).
    endValue : float32 - Last value of the vector (value at index Length-1).

Fills the vector v with a linear sequence beginning from start (first element) until end (last element).

vector : IVector<float32>

The vector to be filled.

startValue : float32

First value of the vector (value at index 0).

endValue : float32

Last value of the vector (value at index Length-1).

VectorMath.GetConstantVector(value, length)

Full Usage: VectorMath.GetConstantVector(value, length)

Parameters:
    value : float - Value of all elements.
    length : int - Length of the vector.

Returns: IROVector<float> Read-only vector with all elements equal to the provided value.

Gets a vector with all elements equal to a provided value.

value : float

Value of all elements.

length : int

Length of the vector.

Returns: IROVector<float>

Read-only vector with all elements equal to the provided value.

VectorMath.GetConstantVector(value, length)

Full Usage: VectorMath.GetConstantVector(value, length)

Parameters:
    value : float32 - Value of all elements.
    length : int - Length of the vector.

Returns: IROVector<float32> Read-only vector with all elements equal to the provided value.

Gets a vector with all elements equal to a provided value.

value : float32

Value of all elements.

length : int

Length of the vector.

Returns: IROVector<float32>

Read-only vector with all elements equal to the provided value.

VectorMath.GetConstantVector(value, length)

Full Usage: VectorMath.GetConstantVector(value, length)

Parameters:
    value : int - Value of all elements.
    length : int - Length of the vector.

Returns: IROVector<int> Read-only vector with all elements equal to the provided value.

Gets a vector with all elements equal to a provided value.

value : int

Value of all elements.

length : int

Length of the vector.

Returns: IROVector<int>

Read-only vector with all elements equal to the provided value.

VectorMath.GetConstantVector(value, length)

Full Usage: VectorMath.GetConstantVector(value, length)

Parameters:
    value : int16 - Value of all elements.
    length : int - Length of the vector.

Returns: IROVector<int16> Read-only vector with all elements equal to the provided value.

Gets a vector with all elements equal to a provided value.

value : int16

Value of all elements.

length : int

Length of the vector.

Returns: IROVector<int16>

Read-only vector with all elements equal to the provided value.

VectorMath.GetConstantVector(value, length)

Full Usage: VectorMath.GetConstantVector(value, length)

Parameters:
    value : sbyte - Value of all elements.
    length : int - Length of the vector.

Returns: IROVector<sbyte> Read-only vector with all elements equal to the provided value.

Gets a vector with all elements equal to a provided value.

value : sbyte

Value of all elements.

length : int

Length of the vector.

Returns: IROVector<sbyte>

Read-only vector with all elements equal to the provided value.

VectorMath.GetUsedLength(vector, currentLength)

Full Usage: VectorMath.GetUsedLength(vector, currentLength)

Parameters:
    vector : float[] - The vector for which the used length has to be determined.
    currentLength : int - The current length of the array. Normally values.Length, but you can provide a value less than this.

Returns: int The used length. Elements with indices greater or equal this until currentlength are NaNs.

Returns the used length of the vector. This is one more than the highest index of the element that is different from Double.NaN.

vector : float[]

The vector for which the used length has to be determined.

currentLength : int

The current length of the array. Normally values.Length, but you can provide a value less than this.

Returns: int

The used length. Elements with indices greater or equal this until currentlength are NaNs.

VectorMath.GetUsedLength(vector)

Full Usage: VectorMath.GetUsedLength(vector)

Parameters:
    vector : float[] - The vector for which the used length has to be determined.

Returns: int The used length. Elements with indices greater or equal this until the end of the array are NaNs.

Returns the used length of the vector. This is one more than the highest index of the element that is different from NaN.

vector : float[]

The vector for which the used length has to be determined.

Returns: int

The used length. Elements with indices greater or equal this until the end of the array are NaNs.

VectorMath.GetUsedLength(vector, currentLength)

Full Usage: VectorMath.GetUsedLength(vector, currentLength)

Parameters:
    vector : float32[] - The vector for which the used length has to be determined.
    currentLength : int - The current length of the array. Normally values.Length, but you can provide a value less than this.

Returns: int The used length. Elements with indices greater or equal this until currentlength are NaNs.

Returns the used length of the vector. This is one more than the highest index of the element that is different from Double.NaN.

vector : float32[]

The vector for which the used length has to be determined.

currentLength : int

The current length of the array. Normally values.Length, but you can provide a value less than this.

Returns: int

The used length. Elements with indices greater or equal this until currentlength are NaNs.

VectorMath.GetUsedLength(vector)

Full Usage: VectorMath.GetUsedLength(vector)

Parameters:
    vector : float32[] - The vector for which the used length has to be determined.

Returns: int The used length. Elements with indices greater or equal this until the end of the array are NaNs.

Returns the used length of the vector. This is one more than the highest index of the element that is different from NaN.

vector : float32[]

The vector for which the used length has to be determined.

Returns: int

The used length. Elements with indices greater or equal this until the end of the array are NaNs.

VectorMath.GetUsedLength(vector, currentLength)

Full Usage: VectorMath.GetUsedLength(vector, currentLength)

Parameters:
    vector : IReadOnlyList<float> - The vector for which the used length has to be determined.
    currentLength : int - The current length of the array. Normally values.Length, but you can provide a value less than this.

Returns: int The used length. Elements with indices greater or equal this until currentlength are NaNs.

Returns the used length of the vector. This is one more than the highest index of the element that is different from Double.NaN.

vector : IReadOnlyList<float>

The vector for which the used length has to be determined.

currentLength : int

The current length of the array. Normally values.Length, but you can provide a value less than this.

Returns: int

The used length. Elements with indices greater or equal this until currentlength are NaNs.

VectorMath.GetUsedLength(vector)

Full Usage: VectorMath.GetUsedLength(vector)

Parameters:
    vector : IReadOnlyList<float> - The vector for which the used length has to be determined.

Returns: int The used length. Elements with indices greater or equal this until the end of the array are NaNs.

Returns the used length of the vector. This is one more than the highest index of the element that is different from NaN.

vector : IReadOnlyList<float>

The vector for which the used length has to be determined.

Returns: int

The used length. Elements with indices greater or equal this until the end of the array are NaNs.

VectorMath.GetUsedLength(vector, currentLength)

Full Usage: VectorMath.GetUsedLength(vector, currentLength)

Parameters:
    vector : IReadOnlyList<float32> - The vector for which the used length has to be determined.
    currentLength : int - The current length of the array. Normally values.Length, but you can provide a value less than this.

Returns: int The used length. Elements with indices greater or equal this until currentlength are NaNs.

Returns the used length of the vector. This is one more than the highest index of the element that is different from Double.NaN.

vector : IReadOnlyList<float32>

The vector for which the used length has to be determined.

currentLength : int

The current length of the array. Normally values.Length, but you can provide a value less than this.

Returns: int

The used length. Elements with indices greater or equal this until currentlength are NaNs.

VectorMath.GetUsedLength(vector)

Full Usage: VectorMath.GetUsedLength(vector)

Parameters:
    vector : IReadOnlyList<float32> - The vector for which the used length has to be determined.

Returns: int The used length. Elements with indices greater or equal this until the end of the array are NaNs.

Returns the used length of the vector. This is one more than the highest index of the element that is different from NaN.

vector : IReadOnlyList<float32>

The vector for which the used length has to be determined.

Returns: int

The used length. Elements with indices greater or equal this until the end of the array are NaNs.

VectorMath.IndexOfMaxAbsoluteValue(vector)

Full Usage: VectorMath.IndexOfMaxAbsoluteValue(vector)

Parameters:
    vector : float[] - The input vector.

Returns: int The index of the first element with the maximum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the maximum absolute value in a vector

vector : float[]

The input vector.

Returns: int

The index of the first element with the maximum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMaxAbsoluteValue(vector)

Full Usage: VectorMath.IndexOfMaxAbsoluteValue(vector)

Parameters:
    vector : float32[] - The input vector.

Returns: int The index of the first element with the maximum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the maximum absolute value in a vector

vector : float32[]

The input vector.

Returns: int

The index of the first element with the maximum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMaxAbsoluteValue(vector)

Full Usage: VectorMath.IndexOfMaxAbsoluteValue(vector)

Parameters:
    vector : int[] - The input vector.

Returns: int The index of the first element with the maximum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the maximum absolute value in a vector

vector : int[]

The input vector.

Returns: int

The index of the first element with the maximum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMaxAbsoluteValue(vector)

Full Usage: VectorMath.IndexOfMaxAbsoluteValue(vector)

Parameters:
Returns: int The index of the first element with the maximum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the maximum absolute value in a vector

vector : IReadOnlyList<float>

The input vector.

Returns: int

The index of the first element with the maximum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMaxAbsoluteValue(vector)

Full Usage: VectorMath.IndexOfMaxAbsoluteValue(vector)

Parameters:
Returns: int The index of the first element with the maximum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the maximum absolute value in a vector

vector : IReadOnlyList<float32>

The input vector.

Returns: int

The index of the first element with the maximum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMaxValue(vector)

Full Usage: VectorMath.IndexOfMaxValue(vector)

Parameters:
    vector : float[] - The input vector.

Returns: int The index of the first element with the maximum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the maximum value in a vector

vector : float[]

The input vector.

Returns: int

The index of the first element with the maximum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMaxValue(vector)

Full Usage: VectorMath.IndexOfMaxValue(vector)

Parameters:
    vector : float32[] - The input vector.

Returns: int The index of the first element with the maximum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the maximum value in a vector

vector : float32[]

The input vector.

Returns: int

The index of the first element with the maximum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMaxValue(vector)

Full Usage: VectorMath.IndexOfMaxValue(vector)

Parameters:
    vector : int[] - The input vector.

Returns: int The index of the first element with the maximum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the maximum value in a vector

vector : int[]

The input vector.

Returns: int

The index of the first element with the maximum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMaxValue(vector)

Full Usage: VectorMath.IndexOfMaxValue(vector)

Parameters:
Returns: int The index of the first element with the maximum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the maximum value in a vector

vector : IReadOnlyList<float>

The input vector.

Returns: int

The index of the first element with the maximum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMaxValue(vector)

Full Usage: VectorMath.IndexOfMaxValue(vector)

Parameters:
Returns: int The index of the first element with the maximum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the maximum value in a vector

vector : IReadOnlyList<float32>

The input vector.

Returns: int

The index of the first element with the maximum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMinAbsoluteValue(vector)

Full Usage: VectorMath.IndexOfMinAbsoluteValue(vector)

Parameters:
    vector : float[] - The input vector.

Returns: int The index of the first element with the minimum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the minimum absolute value in a vector

vector : float[]

The input vector.

Returns: int

The index of the first element with the minimum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMinAbsoluteValue(vector)

Full Usage: VectorMath.IndexOfMinAbsoluteValue(vector)

Parameters:
    vector : float32[] - The input vector.

Returns: int The index of the first element with the minimum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the minimum absolute value in a vector

vector : float32[]

The input vector.

Returns: int

The index of the first element with the minimum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMinAbsoluteValue(vector)

Full Usage: VectorMath.IndexOfMinAbsoluteValue(vector)

Parameters:
    vector : int[] - The input vector.

Returns: int The index of the first element with the minimum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the minimum absolute value in a vector

vector : int[]

The input vector.

Returns: int

The index of the first element with the minimum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMinAbsoluteValue(vector)

Full Usage: VectorMath.IndexOfMinAbsoluteValue(vector)

Parameters:
Returns: int The index of the first element with the minimum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the minimum absolute value in a vector

vector : IReadOnlyList<float>

The input vector.

Returns: int

The index of the first element with the minimum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMinAbsoluteValue(vector)

Full Usage: VectorMath.IndexOfMinAbsoluteValue(vector)

Parameters:
Returns: int The index of the first element with the minimum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the minimum absolute value in a vector

vector : IReadOnlyList<float32>

The input vector.

Returns: int

The index of the first element with the minimum absolute value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMinValue(vector)

Full Usage: VectorMath.IndexOfMinValue(vector)

Parameters:
    vector : float[] - The input vector.

Returns: int The index of the first element with the minimum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the minimum value in a vector

vector : float[]

The input vector.

Returns: int

The index of the first element with the minimum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMinValue(vector)

Full Usage: VectorMath.IndexOfMinValue(vector)

Parameters:
    vector : float32[] - The input vector.

Returns: int The index of the first element with the minimum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the minimum value in a vector

vector : float32[]

The input vector.

Returns: int

The index of the first element with the minimum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMinValue(vector)

Full Usage: VectorMath.IndexOfMinValue(vector)

Parameters:
    vector : int[] - The input vector.

Returns: int The index of the first element with the minimum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the minimum value in a vector

vector : int[]

The input vector.

Returns: int

The index of the first element with the minimum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMinValue(vector)

Full Usage: VectorMath.IndexOfMinValue(vector)

Parameters:
Returns: int The index of the first element with the minimum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the minimum value in a vector

vector : IReadOnlyList<float>

The input vector.

Returns: int

The index of the first element with the minimum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IndexOfMinValue(vector)

Full Usage: VectorMath.IndexOfMinValue(vector)

Parameters:
Returns: int The index of the first element with the minimum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

Return the index of the first element with the minimum value in a vector

vector : IReadOnlyList<float32>

The input vector.

Returns: int

The index of the first element with the minimum value. Returns -1 if the vector is empty or contains only nonvalid elements (NaN).

VectorMath.IsStrictlyDecreasing(vector)

Full Usage: VectorMath.IsStrictlyDecreasing(vector)

Parameters:
    vector : float[] - Vector (sequence) to test.

Returns: bool True if the sequence is strictly decreasing.

Returns true if the sequence given by the vector argument is strictly decreasing.

vector : float[]

Vector (sequence) to test.

Returns: bool

True if the sequence is strictly decreasing.

VectorMath.IsStrictlyDecreasing(vector)

Full Usage: VectorMath.IsStrictlyDecreasing(vector)

Parameters:
    vector : float32[] - Vector (sequence) to test.

Returns: bool True if the sequence is strictly decreasing.

Returns true if the sequence given by the vector argument is strictly decreasing.

vector : float32[]

Vector (sequence) to test.

Returns: bool

True if the sequence is strictly decreasing.

VectorMath.IsStrictlyDecreasing(vector)

Full Usage: VectorMath.IsStrictlyDecreasing(vector)

Parameters:
    vector : int[] - Vector (sequence) to test.

Returns: bool True if the sequence is strictly decreasing.

Returns true if the sequence given by the vector argument is strictly decreasing.

vector : int[]

Vector (sequence) to test.

Returns: bool

True if the sequence is strictly decreasing.

VectorMath.IsStrictlyDecreasing(vector)

Full Usage: VectorMath.IsStrictlyDecreasing(vector)

Parameters:
Returns: bool True if the sequence is strictly decreasing.

Returns true if the sequence given by the vector argument is strictly decreasing.

vector : IReadOnlyList<float>

Vector (sequence) to test.

Returns: bool

True if the sequence is strictly decreasing.

VectorMath.IsStrictlyDecreasing(vector)

Full Usage: VectorMath.IsStrictlyDecreasing(vector)

Parameters:
Returns: bool True if the sequence is strictly decreasing.

Returns true if the sequence given by the vector argument is strictly decreasing.

vector : IReadOnlyList<float32>

Vector (sequence) to test.

Returns: bool

True if the sequence is strictly decreasing.

VectorMath.IsStrictlyIncreasing(vector)

Full Usage: VectorMath.IsStrictlyIncreasing(vector)

Parameters:
    vector : float[] - Vector (sequence) to test.

Returns: bool True if the sequence is strictly increasing.

Returns true if the sequence given by the vector argument is strictly increasing.

vector : float[]

Vector (sequence) to test.

Returns: bool

True if the sequence is strictly increasing.

VectorMath.IsStrictlyIncreasing(vector)

Full Usage: VectorMath.IsStrictlyIncreasing(vector)

Parameters:
    vector : float32[] - Vector (sequence) to test.

Returns: bool True if the sequence is strictly increasing.

Returns true if the sequence given by the vector argument is strictly increasing.

vector : float32[]

Vector (sequence) to test.

Returns: bool

True if the sequence is strictly increasing.

VectorMath.IsStrictlyIncreasing(vector)

Full Usage: VectorMath.IsStrictlyIncreasing(vector)

Parameters:
    vector : int[] - Vector (sequence) to test.

Returns: bool True if the sequence is strictly increasing.

Returns true if the sequence given by the vector argument is strictly increasing.

vector : int[]

Vector (sequence) to test.

Returns: bool

True if the sequence is strictly increasing.

VectorMath.IsStrictlyIncreasing(vector)

Full Usage: VectorMath.IsStrictlyIncreasing(vector)

Parameters:
Returns: bool True if the sequence is strictly increasing.

Returns true if the sequence given by the vector argument is strictly increasing.

vector : IReadOnlyList<float>

Vector (sequence) to test.

Returns: bool

True if the sequence is strictly increasing.

VectorMath.IsStrictlyIncreasing(vector)

Full Usage: VectorMath.IsStrictlyIncreasing(vector)

Parameters:
Returns: bool True if the sequence is strictly increasing.

Returns true if the sequence given by the vector argument is strictly increasing.

vector : IReadOnlyList<float32>

Vector (sequence) to test.

Returns: bool

True if the sequence is strictly increasing.

VectorMath.IsStrictlyIncreasingOrDecreasing(vector, isDecreasing)

Full Usage: VectorMath.IsStrictlyIncreasingOrDecreasing(vector, isDecreasing)

Parameters:
    vector : float[] - Vector (sequence) to test.
    isDecreasing : byref<bool> - On return, this argument is set to true if the sequence is strictly decreasing. If increasing, this argument is set to false.

Returns: bool True if the sequence is strictly increasing or decreasing.

Returns true if the sequence given by the vector argument is strictly increasing or decreasing.

vector : float[]

Vector (sequence) to test.

isDecreasing : byref<bool>

On return, this argument is set to true if the sequence is strictly decreasing. If increasing, this argument is set to false.

Returns: bool

True if the sequence is strictly increasing or decreasing.

VectorMath.IsStrictlyIncreasingOrDecreasing(vector)

Full Usage: VectorMath.IsStrictlyIncreasingOrDecreasing(vector)

Parameters:
    vector : float[] - Vector (sequence) to test.

Returns: bool True if the sequence is strictly increasing or decreasing.

Returns true if the sequence given by the vector argument is strictly increasing or decreasing.

vector : float[]

Vector (sequence) to test.

Returns: bool

True if the sequence is strictly increasing or decreasing.

VectorMath.IsStrictlyIncreasingOrDecreasing(vector, isDecreasing)

Full Usage: VectorMath.IsStrictlyIncreasingOrDecreasing(vector, isDecreasing)

Parameters:
    vector : float32[] - Vector (sequence) to test.
    isDecreasing : byref<bool> - On return, this argument is set to true if the sequence is strictly decreasing. If increasing, this argument is set to false.

Returns: bool True if the sequence is strictly increasing or decreasing.

Returns true if the sequence given by the vector argument is strictly increasing or decreasing.

vector : float32[]

Vector (sequence) to test.

isDecreasing : byref<bool>

On return, this argument is set to true if the sequence is strictly decreasing. If increasing, this argument is set to false.

Returns: bool

True if the sequence is strictly increasing or decreasing.

VectorMath.IsStrictlyIncreasingOrDecreasing(vector)

Full Usage: VectorMath.IsStrictlyIncreasingOrDecreasing(vector)

Parameters:
    vector : float32[] - Vector (sequence) to test.

Returns: bool True if the sequence is strictly increasing or decreasing.

Returns true if the sequence given by the vector argument is strictly increasing or decreasing.

vector : float32[]

Vector (sequence) to test.

Returns: bool

True if the sequence is strictly increasing or decreasing.

VectorMath.IsStrictlyIncreasingOrDecreasing(vector, isDecreasing)

Full Usage: VectorMath.IsStrictlyIncreasingOrDecreasing(vector, isDecreasing)

Parameters:
    vector : int[] - Vector (sequence) to test.
    isDecreasing : byref<bool> - On return, this argument is set to true if the sequence is strictly decreasing. If increasing, this argument is set to false.

Returns: bool True if the sequence is strictly increasing or decreasing.

Returns true if the sequence given by the vector argument is strictly increasing or decreasing.

vector : int[]

Vector (sequence) to test.

isDecreasing : byref<bool>

On return, this argument is set to true if the sequence is strictly decreasing. If increasing, this argument is set to false.

Returns: bool

True if the sequence is strictly increasing or decreasing.

VectorMath.IsStrictlyIncreasingOrDecreasing(vector)

Full Usage: VectorMath.IsStrictlyIncreasingOrDecreasing(vector)

Parameters:
    vector : int[] - Vector (sequence) to test.

Returns: bool True if the sequence is strictly increasing or decreasing.

Returns true if the sequence given by the vector argument is strictly increasing or decreasing.

vector : int[]

Vector (sequence) to test.

Returns: bool

True if the sequence is strictly increasing or decreasing.

VectorMath.IsStrictlyIncreasingOrDecreasing(vector, isDecreasing)

Full Usage: VectorMath.IsStrictlyIncreasingOrDecreasing(vector, isDecreasing)

Parameters:
    vector : IReadOnlyList<float> - Vector (sequence) to test.
    isDecreasing : byref<bool> - On return, this argument is set to true if the sequence is strictly decreasing. If increasing, this argument is set to false.

Returns: bool True if the sequence is strictly increasing or decreasing.

Returns true if the sequence given by the vector argument is strictly increasing or decreasing.

vector : IReadOnlyList<float>

Vector (sequence) to test.

isDecreasing : byref<bool>

On return, this argument is set to true if the sequence is strictly decreasing. If increasing, this argument is set to false.

Returns: bool

True if the sequence is strictly increasing or decreasing.

VectorMath.IsStrictlyIncreasingOrDecreasing(vector)

Full Usage: VectorMath.IsStrictlyIncreasingOrDecreasing(vector)

Parameters:
Returns: bool True if the sequence is strictly increasing or decreasing.

Returns true if the sequence given by the vector argument is strictly increasing or decreasing.

vector : IReadOnlyList<float>

Vector (sequence) to test.

Returns: bool

True if the sequence is strictly increasing or decreasing.

VectorMath.IsStrictlyIncreasingOrDecreasing(vector, isDecreasing)

Full Usage: VectorMath.IsStrictlyIncreasingOrDecreasing(vector, isDecreasing)

Parameters:
    vector : IReadOnlyList<float32> - Vector (sequence) to test.
    isDecreasing : byref<bool> - On return, this argument is set to true if the sequence is strictly decreasing. If increasing, this argument is set to false.

Returns: bool True if the sequence is strictly increasing or decreasing.

Returns true if the sequence given by the vector argument is strictly increasing or decreasing.

vector : IReadOnlyList<float32>

Vector (sequence) to test.

isDecreasing : byref<bool>

On return, this argument is set to true if the sequence is strictly decreasing. If increasing, this argument is set to false.

Returns: bool

True if the sequence is strictly increasing or decreasing.

VectorMath.IsStrictlyIncreasingOrDecreasing(vector)

Full Usage: VectorMath.IsStrictlyIncreasingOrDecreasing(vector)

Parameters:
Returns: bool True if the sequence is strictly increasing or decreasing.

Returns true if the sequence given by the vector argument is strictly increasing or decreasing.

vector : IReadOnlyList<float32>

Vector (sequence) to test.

Returns: bool

True if the sequence is strictly increasing or decreasing.

VectorMath.Kurtosis(vector)

Full Usage: VectorMath.Kurtosis(vector)

Parameters:
    vector : float[] - The vector.

Returns: float The kurtosis of the elements in vector.

Returns the kurtosis of the elements in vector. The kurtosis is defined as kurtosis(X) = E{(X-µ)^4}/((E{(X-µ)²})².

vector : float[]

The vector.

Returns: float

The kurtosis of the elements in vector.

VectorMath.Kurtosis(vector)

Full Usage: VectorMath.Kurtosis(vector)

Parameters:
    vector : float32[] - The vector.

Returns: float The kurtosis of the elements in vector.

Returns the kurtosis of the elements in vector. The kurtosis is defined as kurtosis(X) = E{(X-µ)^4}/((E{(X-µ)²})².

vector : float32[]

The vector.

Returns: float

The kurtosis of the elements in vector.

VectorMath.Kurtosis(vector)

Full Usage: VectorMath.Kurtosis(vector)

Parameters:
    vector : int[] - The vector.

Returns: float The kurtosis of the elements in vector.

Returns the kurtosis of the elements in vector. The kurtosis is defined as kurtosis(X) = E{(X-µ)^4}/((E{(X-µ)²})².

vector : int[]

The vector.

Returns: float

The kurtosis of the elements in vector.

VectorMath.Kurtosis(vector)

Full Usage: VectorMath.Kurtosis(vector)

Parameters:
Returns: float The kurtosis of the elements in vector.

Returns the kurtosis of the elements in vector. The kurtosis is defined as kurtosis(X) = E{(X-µ)^4}/((E{(X-µ)²})².

vector : IReadOnlyList<float>

The vector.

Returns: float

The kurtosis of the elements in vector.

VectorMath.Kurtosis(vector)

Full Usage: VectorMath.Kurtosis(vector)

Parameters:
Returns: float The kurtosis of the elements in vector.

Returns the kurtosis of the elements in vector. The kurtosis is defined as kurtosis(X) = E{(X-µ)^4}/((E{(X-µ)²})².

vector : IReadOnlyList<float32>

The vector.

Returns: float

The kurtosis of the elements in vector.

VectorMath.L1Norm(vector)

Full Usage: VectorMath.L1Norm(vector)

Parameters:
    vector : float[] - The vector.

Returns: float L1 norm of the vector (sum of the absolute values of the elements).

Calculates the L1 norm of the vector (as the sum of the absolute values of the elements).

vector : float[]

The vector.

Returns: float

L1 norm of the vector (sum of the absolute values of the elements).

VectorMath.L1Norm(vector)

Full Usage: VectorMath.L1Norm(vector)

Parameters:
    vector : float32[] - The vector.

Returns: float32 L1 norm of the vector (sum of the absolute values of the elements).

Calculates the L1 norm of the vector (as the sum of the absolute values of the elements).

vector : float32[]

The vector.

Returns: float32

L1 norm of the vector (sum of the absolute values of the elements).

VectorMath.L1Norm(vector)

Full Usage: VectorMath.L1Norm(vector)

Parameters:
    vector : int[] - The vector.

Returns: int64 L1 norm of the vector (sum of the absolute values of the elements).

Calculates the L1 norm of the vector (as the sum of the absolute values of the elements).

vector : int[]

The vector.

Returns: int64

L1 norm of the vector (sum of the absolute values of the elements).

VectorMath.L1Norm(vector)

Full Usage: VectorMath.L1Norm(vector)

Parameters:
Returns: float L1 norm of the vector (sum of the absolute values of the elements).

Calculates the L1 norm of the vector (as the sum of the absolute values of the elements).

vector : IReadOnlyList<float>

The vector.

Returns: float

L1 norm of the vector (sum of the absolute values of the elements).

VectorMath.L1Norm(vector)

Full Usage: VectorMath.L1Norm(vector)

Parameters:
Returns: float32 L1 norm of the vector (sum of the absolute values of the elements).

Calculates the L1 norm of the vector (as the sum of the absolute values of the elements).

vector : IReadOnlyList<float32>

The vector.

Returns: float32

L1 norm of the vector (sum of the absolute values of the elements).

VectorMath.L2Norm(vector, startIndex, count)

Full Usage: VectorMath.L2Norm(vector, startIndex, count)

Parameters:
    vector : float[] - An input array of length n.
    startIndex : int - The index of the first element in x to process.
    count : int - A positive integer input variable of the number of elements to process.

Returns: float The euclidian norm of the vector of length n, i.e. the square root of the sum of squares of the elements.

Given an n-vector x, this function calculates the euclidean norm of x.

the euclidean norm is computed by accumulating the sum of squares in three different sums. the sums of squares for the small and large components are scaled so that no overflows occur. non-destructive underflows are permitted. underflows and overflows do not occur in the computation of the unscaled sum of squares for the intermediate components. the definitions of small, intermediate and large components depend on two constants, rdwarf and rgiant. the main restrictions on these constants are that rdwarf**2 not underflow and rgiant**2 not overflow. the constants given here are suitable for every known computer.

burton s. garbow, kenneth e. hillstrom, jorge j. more

vector : float[]

An input array of length n.

startIndex : int

The index of the first element in x to process.

count : int

A positive integer input variable of the number of elements to process.

Returns: float

The euclidian norm of the vector of length n, i.e. the square root of the sum of squares of the elements.

VectorMath.L2Norm(vector)

Full Usage: VectorMath.L2Norm(vector)

Parameters:
    vector : float[] - An input array of length n.

Returns: float The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

Given an n-vector x, this function calculates the euclidean norm of x.

the euclidean norm is computed by accumulating the sum of squares in three different sums. the sums of squares for the small and large components are scaled so that no overflows occur. non-destructive underflows are permitted. underflows and overflows do not occur in the computation of the unscaled sum of squares for the intermediate components. the definitions of small, intermediate and large components depend on two constants, rdwarf and rgiant. the main restrictions on these constants are that rdwarf**2 not underflow and rgiant**2 not overflow. the constants given here are suitable for every known computer.

burton s. garbow, kenneth e. hillstrom, jorge j. more

vector : float[]

An input array of length n.

Returns: float

The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

VectorMath.L2Norm(vector, startIndex, count)

Full Usage: VectorMath.L2Norm(vector, startIndex, count)

Parameters:
    vector : float32[] - An input array of length n.
    startIndex : int - The index of the first element in x to process.
    count : int - A positive integer input variable of the number of elements to process.

Returns: float The euclidian norm of the vector of length n, i.e. the square root of the sum of squares of the elements.

Given an n-vector x, this function calculates the euclidean norm of x.

the euclidean norm is computed by accumulating the sum of squares in three different sums. the sums of squares for the small and large components are scaled so that no overflows occur. non-destructive underflows are permitted. underflows and overflows do not occur in the computation of the unscaled sum of squares for the intermediate components. the definitions of small, intermediate and large components depend on two constants, rdwarf and rgiant. the main restrictions on these constants are that rdwarf**2 not underflow and rgiant**2 not overflow. the constants given here are suitable for every known computer.

burton s. garbow, kenneth e. hillstrom, jorge j. more

vector : float32[]

An input array of length n.

startIndex : int

The index of the first element in x to process.

count : int

A positive integer input variable of the number of elements to process.

Returns: float

The euclidian norm of the vector of length n, i.e. the square root of the sum of squares of the elements.

VectorMath.L2Norm(vector)

Full Usage: VectorMath.L2Norm(vector)

Parameters:
    vector : float32[] - An input array of length n.

Returns: float The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

Given an n-vector x, this function calculates the euclidean norm of x.

the euclidean norm is computed by accumulating the sum of squares in three different sums. the sums of squares for the small and large components are scaled so that no overflows occur. non-destructive underflows are permitted. underflows and overflows do not occur in the computation of the unscaled sum of squares for the intermediate components. the definitions of small, intermediate and large components depend on two constants, rdwarf and rgiant. the main restrictions on these constants are that rdwarf**2 not underflow and rgiant**2 not overflow. the constants given here are suitable for every known computer.

burton s. garbow, kenneth e. hillstrom, jorge j. more

vector : float32[]

An input array of length n.

Returns: float

The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

VectorMath.L2Norm(vector, startIndex, count)

Full Usage: VectorMath.L2Norm(vector, startIndex, count)

Parameters:
    vector : int[] - An input array of length n.
    startIndex : int - The index of the first element in x to process.
    count : int - A positive integer input variable of the number of elements to process.

Returns: float The euclidian norm of the vector of length n, i.e. the square root of the sum of squares of the elements.

Given an n-vector x, this function calculates the euclidean norm of x.

the euclidean norm is computed by accumulating the sum of squares in three different sums. the sums of squares for the small and large components are scaled so that no overflows occur. non-destructive underflows are permitted. underflows and overflows do not occur in the computation of the unscaled sum of squares for the intermediate components. the definitions of small, intermediate and large components depend on two constants, rdwarf and rgiant. the main restrictions on these constants are that rdwarf**2 not underflow and rgiant**2 not overflow. the constants given here are suitable for every known computer.

burton s. garbow, kenneth e. hillstrom, jorge j. more

vector : int[]

An input array of length n.

startIndex : int

The index of the first element in x to process.

count : int

A positive integer input variable of the number of elements to process.

Returns: float

The euclidian norm of the vector of length n, i.e. the square root of the sum of squares of the elements.

VectorMath.L2Norm(vector)

Full Usage: VectorMath.L2Norm(vector)

Parameters:
    vector : int[] - An input array of length n.

Returns: float The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

Given an n-vector x, this function calculates the euclidean norm of x.

the euclidean norm is computed by accumulating the sum of squares in three different sums. the sums of squares for the small and large components are scaled so that no overflows occur. non-destructive underflows are permitted. underflows and overflows do not occur in the computation of the unscaled sum of squares for the intermediate components. the definitions of small, intermediate and large components depend on two constants, rdwarf and rgiant. the main restrictions on these constants are that rdwarf**2 not underflow and rgiant**2 not overflow. the constants given here are suitable for every known computer.

burton s. garbow, kenneth e. hillstrom, jorge j. more

vector : int[]

An input array of length n.

Returns: float

The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

VectorMath.L2Norm(vector, startIndex, count)

Full Usage: VectorMath.L2Norm(vector, startIndex, count)

Parameters:
    vector : IReadOnlyList<float> - An input array of length n.
    startIndex : int - The index of the first element in x to process.
    count : int - A positive integer input variable of the number of elements to process.

Returns: float The euclidian norm of the vector of length n, i.e. the square root of the sum of squares of the elements.

Given an n-vector x, this function calculates the euclidean norm of x.

the euclidean norm is computed by accumulating the sum of squares in three different sums. the sums of squares for the small and large components are scaled so that no overflows occur. non-destructive underflows are permitted. underflows and overflows do not occur in the computation of the unscaled sum of squares for the intermediate components. the definitions of small, intermediate and large components depend on two constants, rdwarf and rgiant. the main restrictions on these constants are that rdwarf**2 not underflow and rgiant**2 not overflow. the constants given here are suitable for every known computer.

burton s. garbow, kenneth e. hillstrom, jorge j. more

vector : IReadOnlyList<float>

An input array of length n.

startIndex : int

The index of the first element in x to process.

count : int

A positive integer input variable of the number of elements to process.

Returns: float

The euclidian norm of the vector of length n, i.e. the square root of the sum of squares of the elements.

VectorMath.L2Norm(vector)

Full Usage: VectorMath.L2Norm(vector)

Parameters:
Returns: float The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

Given an n-vector x, this function calculates the euclidean norm of x.

the euclidean norm is computed by accumulating the sum of squares in three different sums. the sums of squares for the small and large components are scaled so that no overflows occur. non-destructive underflows are permitted. underflows and overflows do not occur in the computation of the unscaled sum of squares for the intermediate components. the definitions of small, intermediate and large components depend on two constants, rdwarf and rgiant. the main restrictions on these constants are that rdwarf**2 not underflow and rgiant**2 not overflow. the constants given here are suitable for every known computer.

burton s. garbow, kenneth e. hillstrom, jorge j. more

vector : IReadOnlyList<float>

An input array of length n.

Returns: float

The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

VectorMath.L2Norm(vector, startIndex, count)

Full Usage: VectorMath.L2Norm(vector, startIndex, count)

Parameters:
    vector : IReadOnlyList<float32> - An input array of length n.
    startIndex : int - The index of the first element in x to process.
    count : int - A positive integer input variable of the number of elements to process.

Returns: float The euclidian norm of the vector of length n, i.e. the square root of the sum of squares of the elements.

Given an n-vector x, this function calculates the euclidean norm of x.

the euclidean norm is computed by accumulating the sum of squares in three different sums. the sums of squares for the small and large components are scaled so that no overflows occur. non-destructive underflows are permitted. underflows and overflows do not occur in the computation of the unscaled sum of squares for the intermediate components. the definitions of small, intermediate and large components depend on two constants, rdwarf and rgiant. the main restrictions on these constants are that rdwarf**2 not underflow and rgiant**2 not overflow. the constants given here are suitable for every known computer.

burton s. garbow, kenneth e. hillstrom, jorge j. more

vector : IReadOnlyList<float32>

An input array of length n.

startIndex : int

The index of the first element in x to process.

count : int

A positive integer input variable of the number of elements to process.

Returns: float

The euclidian norm of the vector of length n, i.e. the square root of the sum of squares of the elements.

VectorMath.L2Norm(vector)

Full Usage: VectorMath.L2Norm(vector)

Parameters:
Returns: float The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

Given an n-vector x, this function calculates the euclidean norm of x.

the euclidean norm is computed by accumulating the sum of squares in three different sums. the sums of squares for the small and large components are scaled so that no overflows occur. non-destructive underflows are permitted. underflows and overflows do not occur in the computation of the unscaled sum of squares for the intermediate components. the definitions of small, intermediate and large components depend on two constants, rdwarf and rgiant. the main restrictions on these constants are that rdwarf**2 not underflow and rgiant**2 not overflow. the constants given here are suitable for every known computer.

burton s. garbow, kenneth e. hillstrom, jorge j. more

vector : IReadOnlyList<float32>

An input array of length n.

Returns: float

The euclidian norm of the vector, i.e. the square root of the sum of squares of the elements.

VectorMath.LInfinityNorm(vector)

Full Usage: VectorMath.LInfinityNorm(vector)

Parameters:
    vector : float[] - The vector.

Returns: float The L-infinity norm of the provided vector (as is the maximum of the absolute value of the elements).

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).

vector : float[]

The vector.

Returns: float

The L-infinity norm of the provided vector (as is the maximum of the absolute value of the elements).

VectorMath.LInfinityNorm(vector1, vector2)

Full Usage: VectorMath.LInfinityNorm(vector1, vector2)

Parameters:
    vector1 : float[] - The first vector.
    vector2 : float[] - The second vector. Must have same length as the first vector.

Returns: float The L-infinity norm of the element-wise differences of the provided vectors (as is the maximum of the absolute value of the differences).

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).

vector1 : float[]

The first vector.

vector2 : float[]

The second vector. Must have same length as the first vector.

Returns: float

The L-infinity norm of the element-wise differences of the provided vectors (as is the maximum of the absolute value of the differences).

VectorMath.LInfinityNorm(vector)

Full Usage: VectorMath.LInfinityNorm(vector)

Parameters:
    vector : float32[] - The vector.

Returns: float32 The L-infinity norm of the provided vector (as is the maximum of the absolute value of the elements).

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).

vector : float32[]

The vector.

Returns: float32

The L-infinity norm of the provided vector (as is the maximum of the absolute value of the elements).

VectorMath.LInfinityNorm(vector1, vector2)

Full Usage: VectorMath.LInfinityNorm(vector1, vector2)

Parameters:
    vector1 : float32[] - The first vector.
    vector2 : float32[] - The second vector. Must have same length as the first vector.

Returns: float32 The L-infinity norm of the element-wise differences of the provided vectors (as is the maximum of the absolute value of the differences).

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).

vector1 : float32[]

The first vector.

vector2 : float32[]

The second vector. Must have same length as the first vector.

Returns: float32

The L-infinity norm of the element-wise differences of the provided vectors (as is the maximum of the absolute value of the differences).

VectorMath.LInfinityNorm(vector)

Full Usage: VectorMath.LInfinityNorm(vector)

Parameters:
    vector : int[] - The vector.

Returns: int64 The L-infinity norm of the provided vector (as is the maximum of the absolute value of the elements).

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).

vector : int[]

The vector.

Returns: int64

The L-infinity norm of the provided vector (as is the maximum of the absolute value of the elements).

VectorMath.LInfinityNorm(vector1, vector2)

Full Usage: VectorMath.LInfinityNorm(vector1, vector2)

Parameters:
    vector1 : int[] - The first vector.
    vector2 : int[] - The second vector. Must have same length as the first vector.

Returns: int64 The L-infinity norm of the element-wise differences of the provided vectors (as is the maximum of the absolute value of the differences).

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).

vector1 : int[]

The first vector.

vector2 : int[]

The second vector. Must have same length as the first vector.

Returns: int64

The L-infinity norm of the element-wise differences of the provided vectors (as is the maximum of the absolute value of the differences).

VectorMath.LInfinityNorm(vector)

Full Usage: VectorMath.LInfinityNorm(vector)

Parameters:
Returns: float The L-infinity norm of the provided vector (as is the maximum of the absolute value of the elements).

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).

vector : IReadOnlyList<float>

The vector.

Returns: float

The L-infinity norm of the provided vector (as is the maximum of the absolute value of the elements).

VectorMath.LInfinityNorm(vector1, vector2)

Full Usage: VectorMath.LInfinityNorm(vector1, vector2)

Parameters:
    vector1 : IReadOnlyList<float> - The first vector.
    vector2 : IReadOnlyList<float> - The second vector. Must have same length as the first vector.

Returns: float The L-infinity norm of the element-wise differences of the provided vectors (as is the maximum of the absolute value of the differences).

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).

vector1 : IReadOnlyList<float>

The first vector.

vector2 : IReadOnlyList<float>

The second vector. Must have same length as the first vector.

Returns: float

The L-infinity norm of the element-wise differences of the provided vectors (as is the maximum of the absolute value of the differences).

VectorMath.LInfinityNorm(vector)

Full Usage: VectorMath.LInfinityNorm(vector)

Parameters:
Returns: float32 The L-infinity norm of the provided vector (as is the maximum of the absolute value of the elements).

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).

vector : IReadOnlyList<float32>

The vector.

Returns: float32

The L-infinity norm of the provided vector (as is the maximum of the absolute value of the elements).

VectorMath.LInfinityNorm(vector1, vector2)

Full Usage: VectorMath.LInfinityNorm(vector1, vector2)

Parameters:
    vector1 : IReadOnlyList<float32> - The first vector.
    vector2 : IReadOnlyList<float32> - The second vector. Must have same length as the first vector.

Returns: float32 The L-infinity norm of the element-wise differences of the provided vectors (as is the maximum of the absolute value of the differences).

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).

vector1 : IReadOnlyList<float32>

The first vector.

vector2 : IReadOnlyList<float32>

The second vector. Must have same length as the first vector.

Returns: float32

The L-infinity norm of the element-wise differences of the provided vectors (as is the maximum of the absolute value of the differences).

VectorMath.Lerp(t, t0, v0, t1, v1, destinationVector)

Full Usage: VectorMath.Lerp(t, t0, v0, t1, v1, destinationVector)

Parameters:
    t : float - Scalar parameter of interpolation
    t0 : float - Scalar parameter corresponding to first vector v0.
    v0 : float[] - Vector at first parameter point.
    t1 : float - Scalar parameter corresponding to the second vector v1.
    v1 : float[] - Vector at second parameter point.
    destinationVector : float[] - Intepolated vector value at point t

Performs linear interpolation between two vectors at specified points.

t : float

Scalar parameter of interpolation

t0 : float

Scalar parameter corresponding to first vector v0.

v0 : float[]

Vector at first parameter point.

t1 : float

Scalar parameter corresponding to the second vector v1.

v1 : float[]

Vector at second parameter point.

destinationVector : float[]

Intepolated vector value at point t

VectorMath.Lerp(t, t0, v0, t1, v1, destinationVector)

Full Usage: VectorMath.Lerp(t, t0, v0, t1, v1, destinationVector)

Parameters:
    t : float - Scalar parameter of interpolation
    t0 : float - Scalar parameter corresponding to first vector v0.
    v0 : float32[] - Vector at first parameter point.
    t1 : float - Scalar parameter corresponding to the second vector v1.
    v1 : float32[] - Vector at second parameter point.
    destinationVector : float32[] - Intepolated vector value at point t

Performs linear interpolation between two vectors at specified points.

t : float

Scalar parameter of interpolation

t0 : float

Scalar parameter corresponding to first vector v0.

v0 : float32[]

Vector at first parameter point.

t1 : float

Scalar parameter corresponding to the second vector v1.

v1 : float32[]

Vector at second parameter point.

destinationVector : float32[]

Intepolated vector value at point t

VectorMath.Lerp(t, t0, v0, t1, v1, destinationVector)

Full Usage: VectorMath.Lerp(t, t0, v0, t1, v1, destinationVector)

Parameters:
    t : float - Scalar parameter of interpolation
    t0 : float - Scalar parameter corresponding to first vector v0.
    v0 : int[] - Vector at first parameter point.
    t1 : float - Scalar parameter corresponding to the second vector v1.
    v1 : int[] - Vector at second parameter point.
    destinationVector : int[] - Intepolated vector value at point t

Performs linear interpolation between two vectors at specified points.

t : float

Scalar parameter of interpolation

t0 : float

Scalar parameter corresponding to first vector v0.

v0 : int[]

Vector at first parameter point.

t1 : float

Scalar parameter corresponding to the second vector v1.

v1 : int[]

Vector at second parameter point.

destinationVector : int[]

Intepolated vector value at point t

VectorMath.Lerp(t, t0, v0, t1, v1, destinationVector)

Full Usage: VectorMath.Lerp(t, t0, v0, t1, v1, destinationVector)

Parameters:
    t : float - Scalar parameter of interpolation
    t0 : float - Scalar parameter corresponding to first vector v0.
    v0 : IReadOnlyList<float> - Vector at first parameter point.
    t1 : float - Scalar parameter corresponding to the second vector v1.
    v1 : IReadOnlyList<float> - Vector at second parameter point.
    destinationVector : IVector<float> - Intepolated vector value at point t

Performs linear interpolation between two vectors at specified points.

t : float

Scalar parameter of interpolation

t0 : float

Scalar parameter corresponding to first vector v0.

v0 : IReadOnlyList<float>

Vector at first parameter point.

t1 : float

Scalar parameter corresponding to the second vector v1.

v1 : IReadOnlyList<float>

Vector at second parameter point.

destinationVector : IVector<float>

Intepolated vector value at point t

VectorMath.Lerp(t, t0, v0, t1, v1, destinationVector)

Full Usage: VectorMath.Lerp(t, t0, v0, t1, v1, destinationVector)

Parameters:
    t : float - Scalar parameter of interpolation
    t0 : float - Scalar parameter corresponding to first vector v0.
    v0 : IReadOnlyList<float32> - Vector at first parameter point.
    t1 : float - Scalar parameter corresponding to the second vector v1.
    v1 : IReadOnlyList<float32> - Vector at second parameter point.
    destinationVector : IVector<float32> - Intepolated vector value at point t

Performs linear interpolation between two vectors at specified points.

t : float

Scalar parameter of interpolation

t0 : float

Scalar parameter corresponding to first vector v0.

v0 : IReadOnlyList<float32>

Vector at first parameter point.

t1 : float

Scalar parameter corresponding to the second vector v1.

v1 : IReadOnlyList<float32>

Vector at second parameter point.

destinationVector : IVector<float32>

Intepolated vector value at point t

VectorMath.LpNorm(vector, p)

Full Usage: VectorMath.LpNorm(vector, p)

Parameters:
    vector : float[] - The vector.
    p : float - Order of the norm.

Returns: float The p norm of the vector.

Compute the p Norm of this vector.

p > 0, if p < 0, ABS(p) is used. If p = 0 or positive infinity, the infinity norm is returned.

vector : float[]

The vector.

p : float

Order of the norm.

Returns: float

The p norm of the vector.

VectorMath.LpNorm(vector, p)

Full Usage: VectorMath.LpNorm(vector, p)

Parameters:
    vector : float32[] - The vector.
    p : float - Order of the norm.

Returns: float The p norm of the vector.

Compute the p Norm of this vector.

p > 0, if p < 0, ABS(p) is used. If p = 0 or positive infinity, the infinity norm is returned.

vector : float32[]

The vector.

p : float

Order of the norm.

Returns: float

The p norm of the vector.

VectorMath.LpNorm(vector, p)

Full Usage: VectorMath.LpNorm(vector, p)

Parameters:
    vector : int[] - The vector.
    p : float - Order of the norm.

Returns: float The p norm of the vector.

Compute the p Norm of this vector.

p > 0, if p < 0, ABS(p) is used. If p = 0 or positive infinity, the infinity norm is returned.

vector : int[]

The vector.

p : float

Order of the norm.

Returns: float

The p norm of the vector.

VectorMath.LpNorm(vector, p)

Full Usage: VectorMath.LpNorm(vector, p)

Parameters:
    vector : IReadOnlyList<float> - The vector.
    p : float - Order of the norm.

Returns: float The p norm of the vector.

Compute the p Norm of this vector.

p > 0, if p < 0, ABS(p) is used. If p = 0 or positive infinity, the infinity norm is returned.

vector : IReadOnlyList<float>

The vector.

p : float

Order of the norm.

Returns: float

The p norm of the vector.

VectorMath.LpNorm(vector, p)

Full Usage: VectorMath.LpNorm(vector, p)

Parameters:
    vector : IReadOnlyList<float32> - The vector.
    p : float - Order of the norm.

Returns: float The p norm of the vector.

Compute the p Norm of this vector.

p > 0, if p < 0, ABS(p) is used. If p = 0 or positive infinity, the infinity norm is returned.

vector : IReadOnlyList<float32>

The vector.

p : float

Order of the norm.

Returns: float

The p norm of the vector.

VectorMath.Map(src1, function, result)

Full Usage: VectorMath.Map(src1, function, result)

Parameters:
    src1 : float[] - The source vector.
    function : Func<float, float> - The function to apply to every element.
    result : float[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector.

src1 : float[]

The source vector.

function : Func<float, float>

The function to apply to every element.

result : float[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, function, result)

Full Usage: VectorMath.Map(src1, src2, function, result)

Parameters:
    src1 : float[] - First source vector.
    src2 : float[] - Second source vector.
    function : Func<float, float, float> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2.
    result : float[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector.

src1 : float[]

First source vector.

src2 : float[]

Second source vector.

function : Func<float, float, float>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2.

result : float[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, src3, function, result)

Full Usage: VectorMath.Map(src1, src2, src3, function, result)

Parameters:
    src1 : float[] - First source vector.
    src2 : float[] - Second source vector.
    src3 : float[] - Third source vector.
    function : Func<float, float, float, float> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3.
    result : float[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector.

src1 : float[]

First source vector.

src2 : float[]

Second source vector.

src3 : float[]

Third source vector.

function : Func<float, float, float, float>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3.

result : float[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, parameter1, function, result)

Full Usage: VectorMath.Map(src1, parameter1, function, result)

Parameters:
    src1 : float[] - The source vector.
    parameter1 : 'T1 - An auxillary parameter.
    function : Func<float, 'T1, float> - The function to apply to every element. 1st arg is the element of vector src1, 2nd argument is the auxillary parameter1.
    result : float[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector.

src1 : float[]

The source vector.

parameter1 : 'T1

An auxillary parameter.

function : Func<float, 'T1, float>

The function to apply to every element. 1st arg is the element of vector src1, 2nd argument is the auxillary parameter1.

result : float[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, parameter1, function, result)

Full Usage: VectorMath.Map(src1, src2, parameter1, function, result)

Parameters:
    src1 : float[] - First source vector.
    src2 : float[] - Second source vector.
    parameter1 : 'T1 - An auxillary parameter.
    function : Func<float, float, 'T1, float> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the auxillary parameter1.
    result : float[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector.

src1 : float[]

First source vector.

src2 : float[]

Second source vector.

parameter1 : 'T1

An auxillary parameter.

function : Func<float, float, 'T1, float>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the auxillary parameter1.

result : float[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, src3, parameter1, function, result)

Full Usage: VectorMath.Map(src1, src2, src3, parameter1, function, result)

Parameters:
    src1 : float[] - First source vector.
    src2 : float[] - Second source vector.
    src3 : float[] - Third source vector.
    parameter1 : 'T1 - An auxillary parameter.
    function : Func<float, float, float, 'T1, float> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the auxillary parameter1.
    result : float[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector.

src1 : float[]

First source vector.

src2 : float[]

Second source vector.

src3 : float[]

Third source vector.

parameter1 : 'T1

An auxillary parameter.

function : Func<float, float, float, 'T1, float>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the auxillary parameter1.

result : float[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, function, result)

Full Usage: VectorMath.Map(src1, function, result)

Parameters:
    src1 : float32[] - The source vector.
    function : Func<float32, float32> - The function to apply to every element.
    result : float32[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector.

src1 : float32[]

The source vector.

function : Func<float32, float32>

The function to apply to every element.

result : float32[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, function, result)

Full Usage: VectorMath.Map(src1, src2, function, result)

Parameters:
    src1 : float32[] - First source vector.
    src2 : float32[] - Second source vector.
    function : Func<float32, float32, float32> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2.
    result : float32[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector.

src1 : float32[]

First source vector.

src2 : float32[]

Second source vector.

function : Func<float32, float32, float32>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2.

result : float32[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, src3, function, result)

Full Usage: VectorMath.Map(src1, src2, src3, function, result)

Parameters:
    src1 : float32[] - First source vector.
    src2 : float32[] - Second source vector.
    src3 : float32[] - Third source vector.
    function : Func<float32, float32, float32, float32> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3.
    result : float32[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector.

src1 : float32[]

First source vector.

src2 : float32[]

Second source vector.

src3 : float32[]

Third source vector.

function : Func<float32, float32, float32, float32>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3.

result : float32[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, parameter1, function, result)

Full Usage: VectorMath.Map(src1, parameter1, function, result)

Parameters:
    src1 : float32[] - The source vector.
    parameter1 : 'T1 - An auxillary parameter.
    function : Func<float32, 'T1, float32> - The function to apply to every element. 1st arg is the element of vector src1, 2nd argument is the auxillary parameter1.
    result : float32[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector.

src1 : float32[]

The source vector.

parameter1 : 'T1

An auxillary parameter.

function : Func<float32, 'T1, float32>

The function to apply to every element. 1st arg is the element of vector src1, 2nd argument is the auxillary parameter1.

result : float32[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, parameter1, function, result)

Full Usage: VectorMath.Map(src1, src2, parameter1, function, result)

Parameters:
    src1 : float32[] - First source vector.
    src2 : float32[] - Second source vector.
    parameter1 : 'T1 - An auxillary parameter.
    function : Func<float32, float32, 'T1, float32> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the auxillary parameter1.
    result : float32[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector.

src1 : float32[]

First source vector.

src2 : float32[]

Second source vector.

parameter1 : 'T1

An auxillary parameter.

function : Func<float32, float32, 'T1, float32>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the auxillary parameter1.

result : float32[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, src3, parameter1, function, result)

Full Usage: VectorMath.Map(src1, src2, src3, parameter1, function, result)

Parameters:
    src1 : float32[] - First source vector.
    src2 : float32[] - Second source vector.
    src3 : float32[] - Third source vector.
    parameter1 : 'T1 - An auxillary parameter.
    function : Func<float32, float32, float32, 'T1, float32> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the auxillary parameter1.
    result : float32[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector.

src1 : float32[]

First source vector.

src2 : float32[]

Second source vector.

src3 : float32[]

Third source vector.

parameter1 : 'T1

An auxillary parameter.

function : Func<float32, float32, float32, 'T1, float32>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the auxillary parameter1.

result : float32[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, function, result)

Full Usage: VectorMath.Map(src1, function, result)

Parameters:
    src1 : int[] - The source vector.
    function : Func<int, int> - The function to apply to every element.
    result : int[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector.

src1 : int[]

The source vector.

function : Func<int, int>

The function to apply to every element.

result : int[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, function, result)

Full Usage: VectorMath.Map(src1, src2, function, result)

Parameters:
    src1 : int[] - First source vector.
    src2 : int[] - Second source vector.
    function : Func<int, int, int> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2.
    result : int[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector.

src1 : int[]

First source vector.

src2 : int[]

Second source vector.

function : Func<int, int, int>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2.

result : int[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, src3, function, result)

Full Usage: VectorMath.Map(src1, src2, src3, function, result)

Parameters:
    src1 : int[] - First source vector.
    src2 : int[] - Second source vector.
    src3 : int[] - Third source vector.
    function : Func<int, int, int, int> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3.
    result : int[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector.

src1 : int[]

First source vector.

src2 : int[]

Second source vector.

src3 : int[]

Third source vector.

function : Func<int, int, int, int>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3.

result : int[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, parameter1, function, result)

Full Usage: VectorMath.Map(src1, parameter1, function, result)

Parameters:
    src1 : int[] - The source vector.
    parameter1 : 'T1 - An auxillary parameter.
    function : Func<int, 'T1, int> - The function to apply to every element. 1st arg is the element of vector src1, 2nd argument is the auxillary parameter1.
    result : int[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector.

src1 : int[]

The source vector.

parameter1 : 'T1

An auxillary parameter.

function : Func<int, 'T1, int>

The function to apply to every element. 1st arg is the element of vector src1, 2nd argument is the auxillary parameter1.

result : int[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, parameter1, function, result)

Full Usage: VectorMath.Map(src1, src2, parameter1, function, result)

Parameters:
    src1 : int[] - First source vector.
    src2 : int[] - Second source vector.
    parameter1 : 'T1 - An auxillary parameter.
    function : Func<int, int, 'T1, int> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the auxillary parameter1.
    result : int[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector.

src1 : int[]

First source vector.

src2 : int[]

Second source vector.

parameter1 : 'T1

An auxillary parameter.

function : Func<int, int, 'T1, int>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the auxillary parameter1.

result : int[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, src3, parameter1, function, result)

Full Usage: VectorMath.Map(src1, src2, src3, parameter1, function, result)

Parameters:
    src1 : int[] - First source vector.
    src2 : int[] - Second source vector.
    src3 : int[] - Third source vector.
    parameter1 : 'T1 - An auxillary parameter.
    function : Func<int, int, int, 'T1, int> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the auxillary parameter1.
    result : int[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector.

src1 : int[]

First source vector.

src2 : int[]

Second source vector.

src3 : int[]

Third source vector.

parameter1 : 'T1

An auxillary parameter.

function : Func<int, int, int, 'T1, int>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the auxillary parameter1.

result : int[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, function, result)

Full Usage: VectorMath.Map(src1, function, result)

Parameters:
    src1 : IReadOnlyList<float> - The source vector.
    function : Func<float, float> - The function to apply to every element.
    result : IVector<float> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float>

The source vector.

function : Func<float, float>

The function to apply to every element.

result : IVector<float>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, function, result)

Full Usage: VectorMath.Map(src1, src2, function, result)

Parameters:
    src1 : IReadOnlyList<float> - First source vector.
    src2 : IReadOnlyList<float> - Second source vector.
    function : Func<float, float, float> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2.
    result : IVector<float> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float>

First source vector.

src2 : IReadOnlyList<float>

Second source vector.

function : Func<float, float, float>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2.

result : IVector<float>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, src3, function, result)

Full Usage: VectorMath.Map(src1, src2, src3, function, result)

Parameters:
    src1 : IReadOnlyList<float> - First source vector.
    src2 : IReadOnlyList<float> - Second source vector.
    src3 : IReadOnlyList<float> - Third source vector.
    function : Func<float, float, float, float> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3.
    result : IVector<float> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float>

First source vector.

src2 : IReadOnlyList<float>

Second source vector.

src3 : IReadOnlyList<float>

Third source vector.

function : Func<float, float, float, float>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3.

result : IVector<float>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, parameter1, function, result)

Full Usage: VectorMath.Map(src1, parameter1, function, result)

Parameters:
    src1 : IReadOnlyList<float> - The source vector.
    parameter1 : 'T1 - An auxillary parameter.
    function : Func<float, 'T1, float> - The function to apply to every element. 1st arg is the element of vector src1, 2nd argument is the auxillary parameter1.
    result : IVector<float> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float>

The source vector.

parameter1 : 'T1

An auxillary parameter.

function : Func<float, 'T1, float>

The function to apply to every element. 1st arg is the element of vector src1, 2nd argument is the auxillary parameter1.

result : IVector<float>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, parameter1, function, result)

Full Usage: VectorMath.Map(src1, src2, parameter1, function, result)

Parameters:
    src1 : IReadOnlyList<float> - First source vector.
    src2 : IReadOnlyList<float> - Second source vector.
    parameter1 : 'T1 - An auxillary parameter.
    function : Func<float, float, 'T1, float> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the auxillary parameter1.
    result : IVector<float> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float>

First source vector.

src2 : IReadOnlyList<float>

Second source vector.

parameter1 : 'T1

An auxillary parameter.

function : Func<float, float, 'T1, float>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the auxillary parameter1.

result : IVector<float>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, src3, parameter1, function, result)

Full Usage: VectorMath.Map(src1, src2, src3, parameter1, function, result)

Parameters:
    src1 : IReadOnlyList<float> - First source vector.
    src2 : IReadOnlyList<float> - Second source vector.
    src3 : IReadOnlyList<float> - Third source vector.
    parameter1 : 'T1 - An auxillary parameter.
    function : Func<float, float, float, 'T1, float> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the auxillary parameter1.
    result : IVector<float> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float>

First source vector.

src2 : IReadOnlyList<float>

Second source vector.

src3 : IReadOnlyList<float>

Third source vector.

parameter1 : 'T1

An auxillary parameter.

function : Func<float, float, float, 'T1, float>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the auxillary parameter1.

result : IVector<float>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, function, result)

Full Usage: VectorMath.Map(src1, function, result)

Parameters:
    src1 : IReadOnlyList<float32> - The source vector.
    function : Func<float32, float32> - The function to apply to every element.
    result : IVector<float32> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float32>

The source vector.

function : Func<float32, float32>

The function to apply to every element.

result : IVector<float32>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, function, result)

Full Usage: VectorMath.Map(src1, src2, function, result)

Parameters:
    src1 : IReadOnlyList<float32> - First source vector.
    src2 : IReadOnlyList<float32> - Second source vector.
    function : Func<float32, float32, float32> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2.
    result : IVector<float32> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float32>

First source vector.

src2 : IReadOnlyList<float32>

Second source vector.

function : Func<float32, float32, float32>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2.

result : IVector<float32>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, src3, function, result)

Full Usage: VectorMath.Map(src1, src2, src3, function, result)

Parameters:
    src1 : IReadOnlyList<float32> - First source vector.
    src2 : IReadOnlyList<float32> - Second source vector.
    src3 : IReadOnlyList<float32> - Third source vector.
    function : Func<float32, float32, float32, float32> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3.
    result : IVector<float32> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float32>

First source vector.

src2 : IReadOnlyList<float32>

Second source vector.

src3 : IReadOnlyList<float32>

Third source vector.

function : Func<float32, float32, float32, float32>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3.

result : IVector<float32>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, parameter1, function, result)

Full Usage: VectorMath.Map(src1, parameter1, function, result)

Parameters:
    src1 : IReadOnlyList<float32> - The source vector.
    parameter1 : 'T1 - An auxillary parameter.
    function : Func<float32, 'T1, float32> - The function to apply to every element. 1st arg is the element of vector src1, 2nd argument is the auxillary parameter1.
    result : IVector<float32> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to each element of a vector. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float32>

The source vector.

parameter1 : 'T1

An auxillary parameter.

function : Func<float32, 'T1, float32>

The function to apply to every element. 1st arg is the element of vector src1, 2nd argument is the auxillary parameter1.

result : IVector<float32>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, parameter1, function, result)

Full Usage: VectorMath.Map(src1, src2, parameter1, function, result)

Parameters:
    src1 : IReadOnlyList<float32> - First source vector.
    src2 : IReadOnlyList<float32> - Second source vector.
    parameter1 : 'T1 - An auxillary parameter.
    function : Func<float32, float32, 'T1, float32> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the auxillary parameter1.
    result : IVector<float32> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float32>

First source vector.

src2 : IReadOnlyList<float32>

Second source vector.

parameter1 : 'T1

An auxillary parameter.

function : Func<float32, float32, 'T1, float32>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the auxillary parameter1.

result : IVector<float32>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(src1, src2, src3, parameter1, function, result)

Full Usage: VectorMath.Map(src1, src2, src3, parameter1, function, result)

Parameters:
    src1 : IReadOnlyList<float32> - First source vector.
    src2 : IReadOnlyList<float32> - Second source vector.
    src3 : IReadOnlyList<float32> - Third source vector.
    parameter1 : 'T1 - An auxillary parameter.
    function : Func<float32, float32, float32, 'T1, float32> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the auxillary parameter1.
    result : IVector<float32> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float32>

First source vector.

src2 : IReadOnlyList<float32>

Second source vector.

src3 : IReadOnlyList<float32>

Third source vector.

parameter1 : 'T1

An auxillary parameter.

function : Func<float32, float32, float32, 'T1, float32>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the auxillary parameter1.

result : IVector<float32>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Map(vector, function)

Full Usage: VectorMath.Map(vector, function)

Parameters:
    vector : float[] - The vector.
    function : Func<float, float> - The function to apply to every element.

Elementwise application of a function to each element of a vector.

vector : float[]

The vector.

function : Func<float, float>

The function to apply to every element.

VectorMath.Map(vector, function)

Full Usage: VectorMath.Map(vector, function)

Parameters:
    vector : float32[] - The vector.
    function : Func<float32, float32> - The function to apply to every element.

Elementwise application of a function to each element of a vector.

vector : float32[]

The vector.

function : Func<float32, float32>

The function to apply to every element.

VectorMath.Map(vector, function)

Full Usage: VectorMath.Map(vector, function)

Parameters:
    vector : int[] - The vector.
    function : Func<int, int> - The function to apply to every element.

Elementwise application of a function to each element of a vector.

vector : int[]

The vector.

function : Func<int, int>

The function to apply to every element.

VectorMath.Map(vector, function)

Full Usage: VectorMath.Map(vector, function)

Parameters:
    vector : IVector<float> - The vector.
    function : Func<float, float> - The function to apply to every element.

Elementwise application of a function to each element of a vector.

vector : IVector<float>

The vector.

function : Func<float, float>

The function to apply to every element.

VectorMath.Map(vector, function)

Full Usage: VectorMath.Map(vector, function)

Parameters:
    vector : IVector<float32> - The vector.
    function : Func<float32, float32> - The function to apply to every element.

Elementwise application of a function to each element of a vector.

vector : IVector<float32>

The vector.

function : Func<float32, float32>

The function to apply to every element.

VectorMath.MapIndexed(src1, function, result)

Full Usage: VectorMath.MapIndexed(src1, function, result)

Parameters:
    src1 : float[] - The source vector.
    function : Func<int, float, float> - The function to apply to every element. 1st argument is the element, 2nd argument is the element's index.
    result : float[] - The vector to store the results. This may be the same instance as the source vector.

Elementwise application of a function to each element of a vector.

src1 : float[]

The source vector.

function : Func<int, float, float>

The function to apply to every element. 1st argument is the element, 2nd argument is the element's index.

result : float[]

The vector to store the results. This may be the same instance as the source vector.

VectorMath.MapIndexed(src1, src2, function, result)

Full Usage: VectorMath.MapIndexed(src1, src2, function, result)

Parameters:
    src1 : float[] - First source vector.
    src2 : float[] - Second source vector.
    function : Func<int, float, float, float> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element's index.
    result : float[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector.

src1 : float[]

First source vector.

src2 : float[]

Second source vector.

function : Func<int, float, float, float>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element's index.

result : float[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.MapIndexed(src1, src2, src3, function, result)

Full Usage: VectorMath.MapIndexed(src1, src2, src3, function, result)

Parameters:
    src1 : float[] - First source vector.
    src2 : float[] - Second source vector.
    src3 : float[] - Third source vector.
    function : Func<int, float, float, float, float> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the element's index.
    result : float[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector.

src1 : float[]

First source vector.

src2 : float[]

Second source vector.

src3 : float[]

Third source vector.

function : Func<int, float, float, float, float>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the element's index.

result : float[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.MapIndexed(src1, function, result)

Full Usage: VectorMath.MapIndexed(src1, function, result)

Parameters:
    src1 : float32[] - The source vector.
    function : Func<int, float32, float32> - The function to apply to every element. 1st argument is the element, 2nd argument is the element's index.
    result : float32[] - The vector to store the results. This may be the same instance as the source vector.

Elementwise application of a function to each element of a vector.

src1 : float32[]

The source vector.

function : Func<int, float32, float32>

The function to apply to every element. 1st argument is the element, 2nd argument is the element's index.

result : float32[]

The vector to store the results. This may be the same instance as the source vector.

VectorMath.MapIndexed(src1, src2, function, result)

Full Usage: VectorMath.MapIndexed(src1, src2, function, result)

Parameters:
    src1 : float32[] - First source vector.
    src2 : float32[] - Second source vector.
    function : Func<int, float32, float32, float32> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element's index.
    result : float32[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector.

src1 : float32[]

First source vector.

src2 : float32[]

Second source vector.

function : Func<int, float32, float32, float32>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element's index.

result : float32[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.MapIndexed(src1, src2, src3, function, result)

Full Usage: VectorMath.MapIndexed(src1, src2, src3, function, result)

Parameters:
    src1 : float32[] - First source vector.
    src2 : float32[] - Second source vector.
    src3 : float32[] - Third source vector.
    function : Func<int, float32, float32, float32, float32> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the element's index.
    result : float32[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector.

src1 : float32[]

First source vector.

src2 : float32[]

Second source vector.

src3 : float32[]

Third source vector.

function : Func<int, float32, float32, float32, float32>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the element's index.

result : float32[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.MapIndexed(src1, function, result)

Full Usage: VectorMath.MapIndexed(src1, function, result)

Parameters:
    src1 : int[] - The source vector.
    function : Func<int, int, int> - The function to apply to every element. 1st argument is the element, 2nd argument is the element's index.
    result : int[] - The vector to store the results. This may be the same instance as the source vector.

Elementwise application of a function to each element of a vector.

src1 : int[]

The source vector.

function : Func<int, int, int>

The function to apply to every element. 1st argument is the element, 2nd argument is the element's index.

result : int[]

The vector to store the results. This may be the same instance as the source vector.

VectorMath.MapIndexed(src1, src2, function, result)

Full Usage: VectorMath.MapIndexed(src1, src2, function, result)

Parameters:
    src1 : int[] - First source vector.
    src2 : int[] - Second source vector.
    function : Func<int, int, int, int> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element's index.
    result : int[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector.

src1 : int[]

First source vector.

src2 : int[]

Second source vector.

function : Func<int, int, int, int>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element's index.

result : int[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.MapIndexed(src1, src2, src3, function, result)

Full Usage: VectorMath.MapIndexed(src1, src2, src3, function, result)

Parameters:
    src1 : int[] - First source vector.
    src2 : int[] - Second source vector.
    src3 : int[] - Third source vector.
    function : Func<int, int, int, int, int> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the element's index.
    result : int[] - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector.

src1 : int[]

First source vector.

src2 : int[]

Second source vector.

src3 : int[]

Third source vector.

function : Func<int, int, int, int, int>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the element's index.

result : int[]

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.MapIndexed(src1, function, result)

Full Usage: VectorMath.MapIndexed(src1, function, result)

Parameters:
    src1 : IReadOnlyList<float> - The source vector.
    function : Func<int, float, float> - The function to apply to every element. 1st argument is the element, 2nd argument is the element's index.
    result : IVector<float> - The vector to store the results. This may be the same instance as the source vector.

Elementwise application of a function to each element of a vector.

src1 : IReadOnlyList<float>

The source vector.

function : Func<int, float, float>

The function to apply to every element. 1st argument is the element, 2nd argument is the element's index.

result : IVector<float>

The vector to store the results. This may be the same instance as the source vector.

VectorMath.MapIndexed(src1, src2, function, result)

Full Usage: VectorMath.MapIndexed(src1, src2, function, result)

Parameters:
    src1 : IReadOnlyList<float> - First source vector.
    src2 : IReadOnlyList<float> - Second source vector.
    function : Func<int, float, float, float> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element's index.
    result : IVector<float> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float>

First source vector.

src2 : IReadOnlyList<float>

Second source vector.

function : Func<int, float, float, float>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element's index.

result : IVector<float>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.MapIndexed(src1, src2, src3, function, result)

Full Usage: VectorMath.MapIndexed(src1, src2, src3, function, result)

Parameters:
    src1 : IReadOnlyList<float> - First source vector.
    src2 : IReadOnlyList<float> - Second source vector.
    src3 : IReadOnlyList<float> - Third source vector.
    function : Func<int, float, float, float, float> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the element's index.
    result : IVector<float> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float>

First source vector.

src2 : IReadOnlyList<float>

Second source vector.

src3 : IReadOnlyList<float>

Third source vector.

function : Func<int, float, float, float, float>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the element's index.

result : IVector<float>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.MapIndexed(src1, function, result)

Full Usage: VectorMath.MapIndexed(src1, function, result)

Parameters:
    src1 : IReadOnlyList<float32> - The source vector.
    function : Func<int, float32, float32> - The function to apply to every element. 1st argument is the element, 2nd argument is the element's index.
    result : IVector<float32> - The vector to store the results. This may be the same instance as the source vector.

Elementwise application of a function to each element of a vector.

src1 : IReadOnlyList<float32>

The source vector.

function : Func<int, float32, float32>

The function to apply to every element. 1st argument is the element, 2nd argument is the element's index.

result : IVector<float32>

The vector to store the results. This may be the same instance as the source vector.

VectorMath.MapIndexed(src1, src2, function, result)

Full Usage: VectorMath.MapIndexed(src1, src2, function, result)

Parameters:
    src1 : IReadOnlyList<float32> - First source vector.
    src2 : IReadOnlyList<float32> - Second source vector.
    function : Func<int, float32, float32, float32> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element's index.
    result : IVector<float32> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of two vectors. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float32>

First source vector.

src2 : IReadOnlyList<float32>

Second source vector.

function : Func<int, float32, float32, float32>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element's index.

result : IVector<float32>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.MapIndexed(src1, src2, src3, function, result)

Full Usage: VectorMath.MapIndexed(src1, src2, src3, function, result)

Parameters:
    src1 : IReadOnlyList<float32> - First source vector.
    src2 : IReadOnlyList<float32> - Second source vector.
    src3 : IReadOnlyList<float32> - Third source vector.
    function : Func<int, float32, float32, float32, float32> - The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the element's index.
    result : IVector<float32> - The vector to store the results. This may or may not be the same instance as the source vector.

Elementwise application of a function to corresponding elements of three vectors. The result is stored in another vector or in the same vector.

src1 : IReadOnlyList<float32>

First source vector.

src2 : IReadOnlyList<float32>

Second source vector.

src3 : IReadOnlyList<float32>

Third source vector.

function : Func<int, float32, float32, float32, float32>

The function to apply to every element. 1st argument is the element from src1, 2nd argument is the element from src2, 3rd argument is the element from src3, 4th argument is the element's index.

result : IVector<float32>

The vector to store the results. This may or may not be the same instance as the source vector.

VectorMath.Max(vector)

Full Usage: VectorMath.Max(vector)

Parameters:
    vector : float[] - The vector.

Returns: float The maximum of all elements in vector.

Returns the maximum of the elements in vector.

vector : float[]

The vector.

Returns: float

The maximum of all elements in vector.

VectorMath.Max(vector, start, count)

Full Usage: VectorMath.Max(vector, start, count)

Parameters:
    vector : float[] - The vector.
    start : int - First element of the vector to include in the evaluation.
    count : int - Number of elements of the vector to include in the evaluation.

Returns: float The maximum of all elements in vector.

Returns the maximum of the elements in vector.

vector : float[]

The vector.

start : int

First element of the vector to include in the evaluation.

count : int

Number of elements of the vector to include in the evaluation.

Returns: float

The maximum of all elements in vector.

VectorMath.Max(vector)

Full Usage: VectorMath.Max(vector)

Parameters:
    vector : float32[] - The vector.

Returns: float32 The maximum of all elements in vector.

Returns the maximum of the elements in vector.

vector : float32[]

The vector.

Returns: float32

The maximum of all elements in vector.

VectorMath.Max(vector, start, count)

Full Usage: VectorMath.Max(vector, start, count)

Parameters:
    vector : float32[] - The vector.
    start : int - First element of the vector to include in the evaluation.
    count : int - Number of elements of the vector to include in the evaluation.

Returns: float32 The maximum of all elements in vector.

Returns the maximum of the elements in vector.

vector : float32[]

The vector.

start : int

First element of the vector to include in the evaluation.

count : int

Number of elements of the vector to include in the evaluation.

Returns: float32

The maximum of all elements in vector.

VectorMath.Max(vector)

Full Usage: VectorMath.Max(vector)

Parameters:
    vector : int[] - The vector.

Returns: int The maximum of all elements in vector.

Returns the maximum of the elements in vector.

vector : int[]

The vector.

Returns: int

The maximum of all elements in vector.

VectorMath.Max(vector, start, count)

Full Usage: VectorMath.Max(vector, start, count)

Parameters:
    vector : int[] - The vector.
    start : int - First element of the vector to include in the evaluation.
    count : int - Number of elements of the vector to include in the evaluation.

Returns: int The maximum of all elements in vector.

Returns the maximum of the elements in vector.

vector : int[]

The vector.

start : int

First element of the vector to include in the evaluation.

count : int

Number of elements of the vector to include in the evaluation.

Returns: int

The maximum of all elements in vector.

VectorMath.Max(vector)

Full Usage: VectorMath.Max(vector)

Parameters:
Returns: float The maximum of all elements in vector.

Returns the maximum of the elements in vector.

vector : IReadOnlyList<float>

The vector.

Returns: float

The maximum of all elements in vector.

VectorMath.Max(vector, start, count)

Full Usage: VectorMath.Max(vector, start, count)

Parameters:
    vector : IReadOnlyList<float> - The vector.
    start : int - First element of the vector to include in the evaluation.
    count : int - Number of elements of the vector to include in the evaluation.

Returns: float The maximum of all elements in vector.

Returns the maximum of the elements in vector.

vector : IReadOnlyList<float>

The vector.

start : int

First element of the vector to include in the evaluation.

count : int

Number of elements of the vector to include in the evaluation.

Returns: float

The maximum of all elements in vector.

VectorMath.Max(vector)

Full Usage: VectorMath.Max(vector)

Parameters:
Returns: float32 The maximum of all elements in vector.

Returns the maximum of the elements in vector.

vector : IReadOnlyList<float32>

The vector.

Returns: float32

The maximum of all elements in vector.

VectorMath.Max(vector, start, count)

Full Usage: VectorMath.Max(vector, start, count)

Parameters:
    vector : IReadOnlyList<float32> - The vector.
    start : int - First element of the vector to include in the evaluation.
    count : int - Number of elements of the vector to include in the evaluation.

Returns: float32 The maximum of all elements in vector.

Returns the maximum of the elements in vector.

vector : IReadOnlyList<float32>

The vector.

start : int

First element of the vector to include in the evaluation.

count : int

Number of elements of the vector to include in the evaluation.

Returns: float32

The maximum of all elements in vector.

VectorMath.MaxOf(a, b, result)

Full Usage: VectorMath.MaxOf(a, b, result)

Parameters:
    a : float[] - First vector.
    b : float[] - Second vector.
    result : float[] - The resulting vector.

Returns: float[] The same instance as provided by result. Each element result[i] is the maximum of a[i] and b[i].

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.

a : float[]

First vector.

b : float[]

Second vector.

result : float[]

The resulting vector.

Returns: float[]

The same instance as provided by result. Each element result[i] is the maximum of a[i] and b[i].

VectorMath.MaxOf(vector1, scalar, result)

Full Usage: VectorMath.MaxOf(vector1, scalar, result)

Parameters:
    vector1 : float[] - Input vector.
    scalar : float - Number.
    result : float[] - Provide a vector whose elements are filled with the result. If null is provided, then a new vector will be allocated and returned.

Returns: float[] The same instance as provided by result. Each element r[i] is the maximum of v[i] and b.

Creates a new vector, whose elements are the maximum of the elements of a given input vector and a given number.

vector1 : float[]

Input vector.

scalar : float

Number.

result : float[]

Provide a vector whose elements are filled with the result. If null is provided, then a new vector will be allocated and returned.

Returns: float[]

The same instance as provided by result. Each element r[i] is the maximum of v[i] and b.

VectorMath.MaxOf(a, b, result)

Full Usage: VectorMath.MaxOf(a, b, result)

Parameters:
    a : float32[] - First vector.
    b : float32[] - Second vector.
    result : float32[] - The resulting vector.

Returns: float32[] The same instance as provided by result. Each element result[i] is the maximum of a[i] and b[i].

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.

a : float32[]

First vector.

b : float32[]

Second vector.

result : float32[]

The resulting vector.

Returns: float32[]

The same instance as provided by result. Each element result[i] is the maximum of a[i] and b[i].

VectorMath.MaxOf(vector1, scalar, result)

Full Usage: VectorMath.MaxOf(vector1, scalar, result)

Parameters:
    vector1 : float32[] - Input vector.
    scalar : float32 - Number.
    result : float32[] - Provide a vector whose elements are filled with the result. If null is provided, then a new vector will be allocated and returned.

Returns: float32[] The same instance as provided by result. Each element r[i] is the maximum of v[i] and b.

Creates a new vector, whose elements are the maximum of the elements of a given input vector and a given number.

vector1 : float32[]

Input vector.

scalar : float32

Number.

result : float32[]

Provide a vector whose elements are filled with the result. If null is provided, then a new vector will be allocated and returned.

Returns: float32[]

The same instance as provided by result. Each element r[i] is the maximum of v[i] and b.

VectorMath.MaxOf(a, b, result)

Full Usage: VectorMath.MaxOf(a, b, result)

Parameters:
    a : int[] - First vector.
    b : int[] - Second vector.
    result : int[] - The resulting vector.

Returns: int[] The same instance as provided by result. Each element result[i] is the maximum of a[i] and b[i].

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.

a : int[]

First vector.

b : int[]

Second vector.

result : int[]

The resulting vector.

Returns: int[]

The same instance as provided by result. Each element result[i] is the maximum of a[i] and b[i].

VectorMath.MaxOf(vector1, scalar, result)

Full Usage: VectorMath.MaxOf(vector1, scalar, result)

Parameters:
    vector1 : int[] - Input vector.
    scalar : int - Number.
    result : int[] - Provide a vector whose elements are filled with the result. If null is provided, then a new vector will be allocated and returned.

Returns: int[] The same instance as provided by result. Each element r[i] is the maximum of v[i] and b.

Creates a new vector, whose elements are the maximum of the elements of a given input vector and a given number.

vector1 : int[]

Input vector.

scalar : int

Number.

result : int[]

Provide a vector whose elements are filled with the result. If null is provided, then a new vector will be allocated and returned.

Returns: int[]

The same instance as provided by result. Each element r[i] is the maximum of v[i] and b.

VectorMath.MaxOf(a, b, result)

Full Usage: VectorMath.MaxOf(a, b, result)

Parameters:
Returns: IVector<float> The same instance as provided by result. Each element result[i] is the maximum of a[i] and b[i].

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.

a : IReadOnlyList<float>

First vector.

b : IReadOnlyList<float>

Second vector.

result : IVector<float>

The resulting vector.

Returns: IVector<float>

The same instance as provided by result. Each element result[i] is the maximum of a[i] and b[i].

VectorMath.MaxOf(vector1, scalar, result)

Full Usage: VectorMath.MaxOf(vector1, scalar, result)

Parameters:
    vector1 : IReadOnlyList<float> - Input vector.
    scalar : float - Number.
    result : IVector<float> - Provide a vector whose elements are filled with the result. If null is provided, then a new vector will be allocated and returned.

Returns: IVector<float> The same instance as provided by result. Each element r[i] is the maximum of v[i] and b.

Creates a new vector, whose elements are the maximum of the elements of a given input vector and a given number.

vector1 : IReadOnlyList<float>

Input vector.

scalar : float

Number.

result : IVector<float>

Provide a vector whose elements are filled with the result. If null is provided, then a new vector will be allocated and returned.

Returns: IVector<float>

The same instance as provided by result. Each element r[i] is the maximum of v[i] and b.

VectorMath.MaxOf(a, b, result)

Full Usage: VectorMath.MaxOf(a, b, result)

Parameters:
Returns: IVector<float32> The same instance as provided by result. Each element result[i] is the maximum of a[i] and b[i].

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.

a : IReadOnlyList<float32>

First vector.

b : IReadOnlyList<float32>

Second vector.

result : IVector<float32>

The resulting vector.

Returns: IVector<float32>

The same instance as provided by result. Each element result[i] is the maximum of a[i] and b[i].

VectorMath.MaxOf(vector1, scalar, result)

Full Usage: VectorMath.MaxOf(vector1, scalar, result)

Parameters:
    vector1 : IReadOnlyList<float32> - Input vector.
    scalar : float32 - Number.
    result : IVector<float32> - Provide a vector whose elements are filled with the result. If null is provided, then a new vector will be allocated and returned.

Returns: IVector<float32> The same instance as provided by result. Each element r[i] is the maximum of v[i] and b.

Creates a new vector, whose elements are the maximum of the elements of a given input vector and a given number.

vector1 : IReadOnlyList<float32>

Input vector.

scalar : float32

Number.

result : IVector<float32>

Provide a vector whose elements are filled with the result. If null is provided, then a new vector will be allocated and returned.

Returns: IVector<float32>

The same instance as provided by result. Each element r[i] is the maximum of v[i] and b.

VectorMath.MaxOfValidElements(vector)

Full Usage: VectorMath.MaxOfValidElements(vector)

Parameters:
    vector : float[] - The vector to search for maximum element.

Returns: float Maximum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

Returns the maximum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered).

vector : float[]

The vector to search for maximum element.

Returns: float

Maximum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

VectorMath.MaxOfValidElements(vector)

Full Usage: VectorMath.MaxOfValidElements(vector)

Parameters:
    vector : float32[] - The vector to search for maximum element.

Returns: float Maximum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

Returns the maximum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered).

vector : float32[]

The vector to search for maximum element.

Returns: float

Maximum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

VectorMath.MaxOfValidElements(vector)

Full Usage: VectorMath.MaxOfValidElements(vector)

Parameters:
    vector : IReadOnlyList<float> - The vector to search for maximum element.

Returns: float Maximum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

Returns the maximum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered).

vector : IReadOnlyList<float>

The vector to search for maximum element.

Returns: float

Maximum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

VectorMath.MaxOfValidElements(vector)

Full Usage: VectorMath.MaxOfValidElements(vector)

Parameters:
    vector : IReadOnlyList<float32> - The vector to search for maximum element.

Returns: float Maximum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

Returns the maximum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered).

vector : IReadOnlyList<float32>

The vector to search for maximum element.

Returns: float

Maximum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

VectorMath.Mean(vector)

Full Usage: VectorMath.Mean(vector)

Parameters:
    vector : float[] - The vector.

Returns: float The average of all elements in vector.

Returns the average (=sum/N) of the elements in vector.

vector : float[]

The vector.

Returns: float

The average of all elements in vector.

VectorMath.Mean(vector)

Full Usage: VectorMath.Mean(vector)

Parameters:
    vector : float32[] - The vector.

Returns: float The average of all elements in vector.

Returns the average (=sum/N) of the elements in vector.

vector : float32[]

The vector.

Returns: float

The average of all elements in vector.

VectorMath.Mean(vector)

Full Usage: VectorMath.Mean(vector)

Parameters:
    vector : int[] - The vector.

Returns: float The average of all elements in vector.

Returns the average (=sum/N) of the elements in vector.

vector : int[]

The vector.

Returns: float

The average of all elements in vector.

VectorMath.Mean(vector)

Full Usage: VectorMath.Mean(vector)

Parameters:
Returns: float The average of all elements in vector.

Returns the average (=sum/N) of the elements in vector.

vector : IReadOnlyList<float>

The vector.

Returns: float

The average of all elements in vector.

VectorMath.Mean(vector)

Full Usage: VectorMath.Mean(vector)

Parameters:
Returns: float The average of all elements in vector.

Returns the average (=sum/N) of the elements in vector.

vector : IReadOnlyList<float32>

The vector.

Returns: float

The average of all elements in vector.

VectorMath.MeanAndVariance(vector)

Full Usage: VectorMath.MeanAndVariance(vector)

Parameters:
    vector : float[] - The vector.

Returns: float * float The mean and variance of all elements in vector.

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).

vector : float[]

The vector.

Returns: float * float

The mean and variance of all elements in vector.

VectorMath.MeanAndVariance(vector)

Full Usage: VectorMath.MeanAndVariance(vector)

Parameters:
    vector : float32[] - The vector.

Returns: float * float The mean and variance of all elements in vector.

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).

vector : float32[]

The vector.

Returns: float * float

The mean and variance of all elements in vector.

VectorMath.MeanAndVariance(vector)

Full Usage: VectorMath.MeanAndVariance(vector)

Parameters:
    vector : int[] - The vector.

Returns: float * float The mean and variance of all elements in vector.

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).

vector : int[]

The vector.

Returns: float * float

The mean and variance of all elements in vector.

VectorMath.MeanAndVariance(vector)

Full Usage: VectorMath.MeanAndVariance(vector)

Parameters:
Returns: float * float The mean and variance of all elements in vector.

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).

vector : IReadOnlyList<float>

The vector.

Returns: float * float

The mean and variance of all elements in vector.

VectorMath.MeanAndVariance(vector)

Full Usage: VectorMath.MeanAndVariance(vector)

Parameters:
Returns: float * float The mean and variance of all elements in vector.

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).

vector : IReadOnlyList<float32>

The vector.

Returns: float * float

The mean and variance of all elements in vector.

VectorMath.Min(vector)

Full Usage: VectorMath.Min(vector)

Parameters:
    vector : float[] - The vector.

Returns: float The minimum of all elements in vector.

Returns the minimum of the elements in vector.

vector : float[]

The vector.

Returns: float

The minimum of all elements in vector.

VectorMath.Min(vector, start, count)

Full Usage: VectorMath.Min(vector, start, count)

Parameters:
    vector : float[] - The vector.
    start : int - First element of the vector to include in the evaluation.
    count : int - Number of elements of the vector to include in the evaluation.

Returns: float The minimum of all elements in vector.

Returns the minimum of the elements in vector.

vector : float[]

The vector.

start : int

First element of the vector to include in the evaluation.

count : int

Number of elements of the vector to include in the evaluation.

Returns: float

The minimum of all elements in vector.

VectorMath.Min(vector)

Full Usage: VectorMath.Min(vector)

Parameters:
    vector : float32[] - The vector.

Returns: float32 The minimum of all elements in vector.

Returns the minimum of the elements in vector.

vector : float32[]

The vector.

Returns: float32

The minimum of all elements in vector.

VectorMath.Min(vector, start, count)

Full Usage: VectorMath.Min(vector, start, count)

Parameters:
    vector : float32[] - The vector.
    start : int - First element of the vector to include in the evaluation.
    count : int - Number of elements of the vector to include in the evaluation.

Returns: float32 The minimum of all elements in vector.

Returns the minimum of the elements in vector.

vector : float32[]

The vector.

start : int

First element of the vector to include in the evaluation.

count : int

Number of elements of the vector to include in the evaluation.

Returns: float32

The minimum of all elements in vector.

VectorMath.Min(vector)

Full Usage: VectorMath.Min(vector)

Parameters:
    vector : int[] - The vector.

Returns: int The minimum of all elements in vector.

Returns the minimum of the elements in vector.

vector : int[]

The vector.

Returns: int

The minimum of all elements in vector.

VectorMath.Min(vector, start, count)

Full Usage: VectorMath.Min(vector, start, count)

Parameters:
    vector : int[] - The vector.
    start : int - First element of the vector to include in the evaluation.
    count : int - Number of elements of the vector to include in the evaluation.

Returns: int The minimum of all elements in vector.

Returns the minimum of the elements in vector.

vector : int[]

The vector.

start : int

First element of the vector to include in the evaluation.

count : int

Number of elements of the vector to include in the evaluation.

Returns: int

The minimum of all elements in vector.

VectorMath.Min(vector)

Full Usage: VectorMath.Min(vector)

Parameters:
Returns: float The minimum of all elements in vector.

Returns the minimum of the elements in vector.

vector : IReadOnlyList<float>

The vector.

Returns: float

The minimum of all elements in vector.

VectorMath.Min(vector, start, count)

Full Usage: VectorMath.Min(vector, start, count)

Parameters:
    vector : IReadOnlyList<float> - The vector.
    start : int - First element of the vector to include in the evaluation.
    count : int - Number of elements of the vector to include in the evaluation.

Returns: float The minimum of all elements in vector.

Returns the minimum of the elements in vector.

vector : IReadOnlyList<float>

The vector.

start : int

First element of the vector to include in the evaluation.

count : int

Number of elements of the vector to include in the evaluation.

Returns: float

The minimum of all elements in vector.

VectorMath.Min(vector)

Full Usage: VectorMath.Min(vector)

Parameters:
Returns: float32 The minimum of all elements in vector.

Returns the minimum of the elements in vector.

vector : IReadOnlyList<float32>

The vector.

Returns: float32

The minimum of all elements in vector.

VectorMath.Min(vector, start, count)

Full Usage: VectorMath.Min(vector, start, count)

Parameters:
    vector : IReadOnlyList<float32> - The vector.
    start : int - First element of the vector to include in the evaluation.
    count : int - Number of elements of the vector to include in the evaluation.

Returns: float32 The minimum of all elements in vector.

Returns the minimum of the elements in vector.

vector : IReadOnlyList<float32>

The vector.

start : int

First element of the vector to include in the evaluation.

count : int

Number of elements of the vector to include in the evaluation.

Returns: float32

The minimum of all elements in vector.

VectorMath.MinOfValidElements(vector)

Full Usage: VectorMath.MinOfValidElements(vector)

Parameters:
    vector : float[] - The vector to search for maximum element.

Returns: float Minimum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

Returns the minimum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered).

vector : float[]

The vector to search for maximum element.

Returns: float

Minimum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

VectorMath.MinOfValidElements(vector)

Full Usage: VectorMath.MinOfValidElements(vector)

Parameters:
    vector : float32[] - The vector to search for maximum element.

Returns: float Minimum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

Returns the minimum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered).

vector : float32[]

The vector to search for maximum element.

Returns: float

Minimum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

VectorMath.MinOfValidElements(vector)

Full Usage: VectorMath.MinOfValidElements(vector)

Parameters:
    vector : IReadOnlyList<float> - The vector to search for maximum element.

Returns: float Minimum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

Returns the minimum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered).

vector : IReadOnlyList<float>

The vector to search for maximum element.

Returns: float

Minimum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

VectorMath.MinOfValidElements(vector)

Full Usage: VectorMath.MinOfValidElements(vector)

Parameters:
    vector : IReadOnlyList<float32> - The vector to search for maximum element.

Returns: float Minimum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

Returns the minimum value of all the valid elements in x (nonvalid elements, i.e. NaN values are not considered).

vector : IReadOnlyList<float32>

The vector to search for maximum element.

Returns: float

Minimum valid element of x. Returns NaN if the array is empty or contains NaN elements only.

VectorMath.Multiply(a, b, c)

Full Usage: VectorMath.Multiply(a, b, c)

Parameters:
    a : float[] - First summand.
    b : float[] - Second summand.
    c : float[] - The resulting vector.

Multiplies (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length.

a : float[]

First summand.

b : float[]

Second summand.

c : float[]

The resulting vector.

VectorMath.Multiply(a, b, c)

Full Usage: VectorMath.Multiply(a, b, c)

Parameters:
    a : float32[] - First summand.
    b : float32[] - Second summand.
    c : float32[] - The resulting vector.

Multiplies (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length.

a : float32[]

First summand.

b : float32[]

Second summand.

c : float32[]

The resulting vector.

VectorMath.Multiply(a, b, c)

Full Usage: VectorMath.Multiply(a, b, c)

Parameters:
    a : int[] - First summand.
    b : int[] - Second summand.
    c : int[] - The resulting vector.

Multiplies (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length.

a : int[]

First summand.

b : int[]

Second summand.

c : int[]

The resulting vector.

VectorMath.Multiply(a, b, c)

Full Usage: VectorMath.Multiply(a, b, c)

Parameters:

Multiplies (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length.

a : IReadOnlyList<float>

First summand.

b : IReadOnlyList<float>

Second summand.

c : IVector<float>

The resulting vector.

VectorMath.Multiply(a, b, c)

Full Usage: VectorMath.Multiply(a, b, c)

Parameters:

Multiplies (elementwise) two vectors a and b and stores the result in c. All vectors must have the same length.

a : IReadOnlyList<float32>

First summand.

b : IReadOnlyList<float32>

Second summand.

c : IVector<float32>

The resulting vector.

VectorMath.Multiply(v, a)

Full Usage: VectorMath.Multiply(v, a)

Parameters:
    v : float[] - The vector.
    a : float - The constant to multiply with.

Multiplies all vector elements with a constant.

v : float[]

The vector.

a : float

The constant to multiply with.

VectorMath.Multiply(v, a)

Full Usage: VectorMath.Multiply(v, a)

Parameters:
    v : float32[] - The vector.
    a : float32 - The constant to multiply with.

Multiplies all vector elements with a constant.

v : float32[]

The vector.

a : float32

The constant to multiply with.

VectorMath.Multiply(v, a)

Full Usage: VectorMath.Multiply(v, a)

Parameters:
    v : int[] - The vector.
    a : int - The constant to multiply with.

Multiplies all vector elements with a constant.

v : int[]

The vector.

a : int

The constant to multiply with.

VectorMath.Multiply(v, a)

Full Usage: VectorMath.Multiply(v, a)

Parameters:
    v : IVector<float> - The vector.
    a : float - The constant to multiply with.

Multiplies all vector elements with a constant.

v : IVector<float>

The vector.

a : float

The constant to multiply with.

VectorMath.Multiply(v, a)

Full Usage: VectorMath.Multiply(v, a)

Parameters:
    v : IVector<float32> - The vector.
    a : float32 - The constant to multiply with.

Multiplies all vector elements with a constant.

v : IVector<float32>

The vector.

a : float32

The constant to multiply with.

VectorMath.Reverse(vector)

Full Usage: VectorMath.Reverse(vector)

Parameters:
    vector : float[] - Vector. On return, the elements of this vector are in reverse order.

Reverses the order of elements in the provided vector.

vector : float[]

Vector. On return, the elements of this vector are in reverse order.

VectorMath.Reverse(vector)

Full Usage: VectorMath.Reverse(vector)

Parameters:
    vector : float32[] - Vector. On return, the elements of this vector are in reverse order.

Reverses the order of elements in the provided vector.

vector : float32[]

Vector. On return, the elements of this vector are in reverse order.

VectorMath.Reverse(vector)

Full Usage: VectorMath.Reverse(vector)

Parameters:
    vector : int[] - Vector. On return, the elements of this vector are in reverse order.

Reverses the order of elements in the provided vector.

vector : int[]

Vector. On return, the elements of this vector are in reverse order.

VectorMath.Reverse(vector)

Full Usage: VectorMath.Reverse(vector)

Parameters:
    vector : IVector<float> - Vector. On return, the elements of this vector are in reverse order.

Reverses the order of elements in the provided vector.

vector : IVector<float>

Vector. On return, the elements of this vector are in reverse order.

VectorMath.Reverse(vector)

Full Usage: VectorMath.Reverse(vector)

Parameters:
    vector : IVector<float32> - Vector. On return, the elements of this vector are in reverse order.

Reverses the order of elements in the provided vector.

vector : IVector<float32>

Vector. On return, the elements of this vector are in reverse order.

VectorMath.Rotate(vector, increment)

Full Usage: VectorMath.Rotate(vector, increment)

Parameters:
    vector : float[] - The vector to rotate.
    increment : int - Offset value.

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.

vector : float[]

The vector to rotate.

increment : int

Offset value.

VectorMath.Rotate(vector, increment)

Full Usage: VectorMath.Rotate(vector, increment)

Parameters:
    vector : float32[] - The vector to rotate.
    increment : int - Offset value.

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.

vector : float32[]

The vector to rotate.

increment : int

Offset value.

VectorMath.Rotate(vector, increment)

Full Usage: VectorMath.Rotate(vector, increment)

Parameters:
    vector : int[] - The vector to rotate.
    increment : int - Offset value.

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.

vector : int[]

The vector to rotate.

increment : int

Offset value.

VectorMath.Rotate(vector, increment)

Full Usage: VectorMath.Rotate(vector, increment)

Parameters:
    vector : IVector<float> - The vector to rotate.
    increment : int - Offset value.

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.

vector : IVector<float>

The vector to rotate.

increment : int

Offset value.

VectorMath.Rotate(vector, increment)

Full Usage: VectorMath.Rotate(vector, increment)

Parameters:
    vector : IVector<float32> - The vector to rotate.
    increment : int - Offset value.

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.

vector : IVector<float32>

The vector to rotate.

increment : int

Offset value.

VectorMath.Sum(vector)

Full Usage: VectorMath.Sum(vector)

Parameters:
    vector : float[] - The vector.

Returns: float The sum of all elements in vector.

Returns the sum of the elements in vector.

vector : float[]

The vector.

Returns: float

The sum of all elements in vector.

VectorMath.Sum(vector)

Full Usage: VectorMath.Sum(vector)

Parameters:
    vector : float32[] - The vector.

Returns: float32 The sum of all elements in vector.

Returns the sum of the elements in vector.

vector : float32[]

The vector.

Returns: float32

The sum of all elements in vector.

VectorMath.Sum(vector)

Full Usage: VectorMath.Sum(vector)

Parameters:
    vector : int[] - The vector.

Returns: int64 The sum of all elements in vector.

Returns the sum of the elements in vector.

vector : int[]

The vector.

Returns: int64

The sum of all elements in vector.

VectorMath.Sum(vector)

Full Usage: VectorMath.Sum(vector)

Parameters:
Returns: float The sum of all elements in vector.

Returns the sum of the elements in vector.

vector : IReadOnlyList<float>

The vector.

Returns: float

The sum of all elements in vector.

VectorMath.Sum(vector)

Full Usage: VectorMath.Sum(vector)

Parameters:
Returns: float32 The sum of all elements in vector.

Returns the sum of the elements in vector.

vector : IReadOnlyList<float32>

The vector.

Returns: float32

The sum of all elements in vector.

VectorMath.SumOfSquaredDifferences(vector1, vector2)

Full Usage: VectorMath.SumOfSquaredDifferences(vector1, vector2)

Parameters:
    vector1 : float[] - The first array.
    vector2 : float[] - The other array.

Returns: float The sum of squared differences all elements of xarray and yarray.

Returns the sum of squared differences of the elements of xarray and yarray.

vector1 : float[]

The first array.

vector2 : float[]

The other array.

Returns: float

The sum of squared differences all elements of xarray and yarray.

VectorMath.SumOfSquaredDifferences(vector1, vector2)

Full Usage: VectorMath.SumOfSquaredDifferences(vector1, vector2)

Parameters:
    vector1 : float32[] - The first array.
    vector2 : float32[] - The other array.

Returns: float The sum of squared differences all elements of xarray and yarray.

Returns the sum of squared differences of the elements of xarray and yarray.

vector1 : float32[]

The first array.

vector2 : float32[]

The other array.

Returns: float

The sum of squared differences all elements of xarray and yarray.

VectorMath.SumOfSquaredDifferences(vector1, vector2)

Full Usage: VectorMath.SumOfSquaredDifferences(vector1, vector2)

Parameters:
    vector1 : int[] - The first array.
    vector2 : int[] - The other array.

Returns: float The sum of squared differences all elements of xarray and yarray.

Returns the sum of squared differences of the elements of xarray and yarray.

vector1 : int[]

The first array.

vector2 : int[]

The other array.

Returns: float

The sum of squared differences all elements of xarray and yarray.

VectorMath.SumOfSquaredDifferences(vector1, vector2)

Full Usage: VectorMath.SumOfSquaredDifferences(vector1, vector2)

Parameters:
Returns: float The sum of squared differences all elements of xarray and yarray.

Returns the sum of squared differences of the elements of xarray and yarray.

vector1 : IReadOnlyList<float>

The first array.

vector2 : IReadOnlyList<float>

The other array.

Returns: float

The sum of squared differences all elements of xarray and yarray.

VectorMath.SumOfSquaredDifferences(vector1, vector2)

Full Usage: VectorMath.SumOfSquaredDifferences(vector1, vector2)

Parameters:
Returns: float The sum of squared differences all elements of xarray and yarray.

Returns the sum of squared differences of the elements of xarray and yarray.

vector1 : IReadOnlyList<float32>

The first array.

vector2 : IReadOnlyList<float32>

The other array.

Returns: float

The sum of squared differences all elements of xarray and yarray.

VectorMath.ToInverseROVector(array)

Full Usage: VectorMath.ToInverseROVector(array)

Parameters:
Returns: IROVector<float> A wrapper objects with the IROVector returning elements that are inverse to those of the original vector.

Wraps a Double[] array to get an IROVector with elements = 1 / elements of the original vector.

array : IReadOnlyList<float>

The array to wrap.

Returns: IROVector<float>

A wrapper objects with the IROVector returning elements that are inverse to those of the original vector.

VectorMath.ToInverseROVector(array, usedlength)

Full Usage: VectorMath.ToInverseROVector(array, usedlength)

Parameters:
    array : IReadOnlyList<float> - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array returning elements that are inverse to those of the original vector..

Wraps a Double[] array till a given length to get an IROVector with elements = 1 / elements of the original vector.

array : IReadOnlyList<float>

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array returning elements that are inverse to those of the original vector..

VectorMath.ToInverseROVector(array)

Full Usage: VectorMath.ToInverseROVector(array)

Parameters:
Returns: IROVector<float32> A wrapper objects with the IROVector returning elements that are inverse to those of the original vector.

Wraps a Single[] array to get an IROVector with elements = 1 / elements of the original vector.

array : IReadOnlyList<float32>

The array to wrap.

Returns: IROVector<float32>

A wrapper objects with the IROVector returning elements that are inverse to those of the original vector.

VectorMath.ToInverseROVector(array, usedlength)

Full Usage: VectorMath.ToInverseROVector(array, usedlength)

Parameters:
    array : IReadOnlyList<float32> - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float32> A wrapper objects with the IROVector interface that wraps the provided array returning elements that are inverse to those of the original vector..

Wraps a Single[] array till a given length to get an IROVector with elements = 1 / elements of the original vector.

array : IReadOnlyList<float32>

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float32>

A wrapper objects with the IROVector interface that wraps the provided array returning elements that are inverse to those of the original vector..

VectorMath.ToInverseROVector(array)

Full Usage: VectorMath.ToInverseROVector(array)

Parameters:
Returns: IROVector<float> A wrapper objects with the IROVector returning elements that are inverse to those of the original vector.

Wraps a Int32[] array to get an IROVector with elements = 1 / elements of the original vector.

array : IReadOnlyList<int>

The array to wrap.

Returns: IROVector<float>

A wrapper objects with the IROVector returning elements that are inverse to those of the original vector.

VectorMath.ToInverseROVector(array, usedlength)

Full Usage: VectorMath.ToInverseROVector(array, usedlength)

Parameters:
    array : IReadOnlyList<int> - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array returning elements that are inverse to those of the original vector..

Wraps a Int32[] array till a given length to get an IROVector with elements = 1 / elements of the original vector.

array : IReadOnlyList<int>

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array returning elements that are inverse to those of the original vector..

VectorMath.ToInverseROVector(array)

Full Usage: VectorMath.ToInverseROVector(array)

Parameters:
Returns: IROVector<float> A wrapper objects with the IROVector returning elements that are inverse to those of the original vector.

Wraps a Int16[] array to get an IROVector with elements = 1 / elements of the original vector.

array : IReadOnlyList<int16>

The array to wrap.

Returns: IROVector<float>

A wrapper objects with the IROVector returning elements that are inverse to those of the original vector.

VectorMath.ToInverseROVector(array, usedlength)

Full Usage: VectorMath.ToInverseROVector(array, usedlength)

Parameters:
    array : IReadOnlyList<int16> - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array returning elements that are inverse to those of the original vector..

Wraps a Int16[] array till a given length to get an IROVector with elements = 1 / elements of the original vector.

array : IReadOnlyList<int16>

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array returning elements that are inverse to those of the original vector..

VectorMath.ToInverseROVector(array)

Full Usage: VectorMath.ToInverseROVector(array)

Parameters:
Returns: IROVector<float> A wrapper objects with the IROVector returning elements that are inverse to those of the original vector.

Wraps a SByte[] array to get an IROVector with elements = 1 / elements of the original vector.

array : IReadOnlyList<sbyte>

The array to wrap.

Returns: IROVector<float>

A wrapper objects with the IROVector returning elements that are inverse to those of the original vector.

VectorMath.ToInverseROVector(array, usedlength)

Full Usage: VectorMath.ToInverseROVector(array, usedlength)

Parameters:
    array : IReadOnlyList<sbyte> - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array returning elements that are inverse to those of the original vector..

Wraps a SByte[] array till a given length to get an IROVector with elements = 1 / elements of the original vector.

array : IReadOnlyList<sbyte>

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array returning elements that are inverse to those of the original vector..

VectorMath.ToRODoubleVector(array)

Full Usage: VectorMath.ToRODoubleVector(array)

Parameters:
    array : float[] - The array to wrap.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Double[] array to get an IROVector.

array : float[]

The array to wrap.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToRODoubleVector(array, usedlength)

Full Usage: VectorMath.ToRODoubleVector(array, usedlength)

Parameters:
    array : float[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Double[] array till a given length to get an IROVector.

array : float[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToRODoubleVector(array)

Full Usage: VectorMath.ToRODoubleVector(array)

Parameters:
    array : float32[] - The array to wrap.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Single[] array to get an IROVector.

array : float32[]

The array to wrap.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToRODoubleVector(array, usedlength)

Full Usage: VectorMath.ToRODoubleVector(array, usedlength)

Parameters:
    array : float32[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Single[] array till a given length to get an IROVector.

array : float32[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToRODoubleVector(array)

Full Usage: VectorMath.ToRODoubleVector(array)

Parameters:
    array : int[] - The array to wrap.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Int32[] array to get an IROVector.

array : int[]

The array to wrap.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToRODoubleVector(array, usedlength)

Full Usage: VectorMath.ToRODoubleVector(array, usedlength)

Parameters:
    array : int[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Int32[] array till a given length to get an IROVector.

array : int[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToRODoubleVector(array)

Full Usage: VectorMath.ToRODoubleVector(array)

Parameters:
    array : int16[] - The array to wrap.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Int16[] array to get an IROVector.

array : int16[]

The array to wrap.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToRODoubleVector(array, usedlength)

Full Usage: VectorMath.ToRODoubleVector(array, usedlength)

Parameters:
    array : int16[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Int16[] array till a given length to get an IROVector.

array : int16[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToRODoubleVector(array)

Full Usage: VectorMath.ToRODoubleVector(array)

Parameters:
    array : sbyte[] - The array to wrap.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a SByte[] array to get an IROVector.

array : sbyte[]

The array to wrap.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToRODoubleVector(array, usedlength)

Full Usage: VectorMath.ToRODoubleVector(array, usedlength)

Parameters:
    array : sbyte[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a SByte[] array till a given length to get an IROVector.

array : sbyte[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(array)

Full Usage: VectorMath.ToROVector(array)

Parameters:
    array : float[] - The array to wrap.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Double[] array to get an IROVector.

array : float[]

The array to wrap.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(array, usedlength)

Full Usage: VectorMath.ToROVector(array, usedlength)

Parameters:
    array : float[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Double[] array till a given length to get an IROVector.

array : float[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(array, start, usedlength)

Full Usage: VectorMath.ToROVector(array, start, usedlength)

Parameters:
    array : float[] - The array to wrap.
    start : int - Index of the element in array used as the first element of the vector.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float> A wrapper object with the IROVector interface that wraps the provided array.

Wraps an array to an IROVector. Start and length of the used section of the array are specified in the parameters.

array : float[]

The array to wrap.

start : int

Index of the element in array used as the first element of the vector.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float>

A wrapper object with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(vector, start, usedLength)

Full Usage: VectorMath.ToROVector(vector, start, usedLength)

Parameters:
    vector : IReadOnlyList<float> - Original vector.
    start : int - Index of the start of the section to wrap.
    usedLength : int - Length (=number of elements) of the section to wrap.

Returns: IROVector<float> An IROVector that contains the section from start to start+len-1 of the original vector.

Wraps a section of an original vector into a new vector.

vector : IReadOnlyList<float>

Original vector.

start : int

Index of the start of the section to wrap.

usedLength : int

Length (=number of elements) of the section to wrap.

Returns: IROVector<float>

An IROVector that contains the section from start to start+len-1 of the original vector.

VectorMath.ToROVector(array)

Full Usage: VectorMath.ToROVector(array)

Parameters:
    array : float32[] - The array to wrap.

Returns: IROVector<float32> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Single[] array to get an IROVector.

array : float32[]

The array to wrap.

Returns: IROVector<float32>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(array, usedlength)

Full Usage: VectorMath.ToROVector(array, usedlength)

Parameters:
    array : float32[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float32> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Single[] array till a given length to get an IROVector.

array : float32[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float32>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(array, start, usedlength)

Full Usage: VectorMath.ToROVector(array, start, usedlength)

Parameters:
    array : float32[] - The array to wrap.
    start : int - Index of the element in array used as the first element of the vector.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float32> A wrapper object with the IROVector interface that wraps the provided array.

Wraps an array to an IROVector. Start and length of the used section of the array are specified in the parameters.

array : float32[]

The array to wrap.

start : int

Index of the element in array used as the first element of the vector.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<float32>

A wrapper object with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(vector, start, usedLength)

Full Usage: VectorMath.ToROVector(vector, start, usedLength)

Parameters:
    vector : IReadOnlyList<float32> - Original vector.
    start : int - Index of the start of the section to wrap.
    usedLength : int - Length (=number of elements) of the section to wrap.

Returns: IROVector<float32> An IROVector that contains the section from start to start+len-1 of the original vector.

Wraps a section of an original vector into a new vector.

vector : IReadOnlyList<float32>

Original vector.

start : int

Index of the start of the section to wrap.

usedLength : int

Length (=number of elements) of the section to wrap.

Returns: IROVector<float32>

An IROVector that contains the section from start to start+len-1 of the original vector.

VectorMath.ToROVector(array)

Full Usage: VectorMath.ToROVector(array)

Parameters:
    array : int[] - The array to wrap.

Returns: IROVector<int> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Int32[] array to get an IROVector.

array : int[]

The array to wrap.

Returns: IROVector<int>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(array, usedlength)

Full Usage: VectorMath.ToROVector(array, usedlength)

Parameters:
    array : int[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<int> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Int32[] array till a given length to get an IROVector.

array : int[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<int>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(array, start, usedlength)

Full Usage: VectorMath.ToROVector(array, start, usedlength)

Parameters:
    array : int[] - The array to wrap.
    start : int - Index of the element in array used as the first element of the vector.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<int> A wrapper object with the IROVector interface that wraps the provided array.

Wraps an array to an IROVector. Start and length of the used section of the array are specified in the parameters.

array : int[]

The array to wrap.

start : int

Index of the element in array used as the first element of the vector.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<int>

A wrapper object with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(vector, start, usedLength)

Full Usage: VectorMath.ToROVector(vector, start, usedLength)

Parameters:
    vector : IReadOnlyList<int> - Original vector.
    start : int - Index of the start of the section to wrap.
    usedLength : int - Length (=number of elements) of the section to wrap.

Returns: IROVector<int> An IROVector that contains the section from start to start+len-1 of the original vector.

Wraps a section of an original vector into a new vector.

vector : IReadOnlyList<int>

Original vector.

start : int

Index of the start of the section to wrap.

usedLength : int

Length (=number of elements) of the section to wrap.

Returns: IROVector<int>

An IROVector that contains the section from start to start+len-1 of the original vector.

VectorMath.ToROVector(array)

Full Usage: VectorMath.ToROVector(array)

Parameters:
    array : int16[] - The array to wrap.

Returns: IROVector<int16> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Int16[] array to get an IROVector.

array : int16[]

The array to wrap.

Returns: IROVector<int16>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(array, usedlength)

Full Usage: VectorMath.ToROVector(array, usedlength)

Parameters:
    array : int16[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<int16> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Int16[] array till a given length to get an IROVector.

array : int16[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<int16>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(array, start, usedlength)

Full Usage: VectorMath.ToROVector(array, start, usedlength)

Parameters:
    array : int16[] - The array to wrap.
    start : int - Index of the element in array used as the first element of the vector.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<int16> A wrapper object with the IROVector interface that wraps the provided array.

Wraps an array to an IROVector. Start and length of the used section of the array are specified in the parameters.

array : int16[]

The array to wrap.

start : int

Index of the element in array used as the first element of the vector.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<int16>

A wrapper object with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(vector, start, usedLength)

Full Usage: VectorMath.ToROVector(vector, start, usedLength)

Parameters:
    vector : IReadOnlyList<int16> - Original vector.
    start : int - Index of the start of the section to wrap.
    usedLength : int - Length (=number of elements) of the section to wrap.

Returns: IROVector<int16> An IROVector that contains the section from start to start+len-1 of the original vector.

Wraps a section of an original vector into a new vector.

vector : IReadOnlyList<int16>

Original vector.

start : int

Index of the start of the section to wrap.

usedLength : int

Length (=number of elements) of the section to wrap.

Returns: IROVector<int16>

An IROVector that contains the section from start to start+len-1 of the original vector.

VectorMath.ToROVector(array)

Full Usage: VectorMath.ToROVector(array)

Parameters:
    array : sbyte[] - The array to wrap.

Returns: IROVector<sbyte> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a SByte[] array to get an IROVector.

array : sbyte[]

The array to wrap.

Returns: IROVector<sbyte>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(array, usedlength)

Full Usage: VectorMath.ToROVector(array, usedlength)

Parameters:
    array : sbyte[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<sbyte> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a SByte[] array till a given length to get an IROVector.

array : sbyte[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<sbyte>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(array, start, usedlength)

Full Usage: VectorMath.ToROVector(array, start, usedlength)

Parameters:
    array : sbyte[] - The array to wrap.
    start : int - Index of the element in array used as the first element of the vector.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<sbyte> A wrapper object with the IROVector interface that wraps the provided array.

Wraps an array to an IROVector. Start and length of the used section of the array are specified in the parameters.

array : sbyte[]

The array to wrap.

start : int

Index of the element in array used as the first element of the vector.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array.

Returns: IROVector<sbyte>

A wrapper object with the IROVector interface that wraps the provided array.

VectorMath.ToROVector(vector, start, usedLength)

Full Usage: VectorMath.ToROVector(vector, start, usedLength)

Parameters:
    vector : IReadOnlyList<sbyte> - Original vector.
    start : int - Index of the start of the section to wrap.
    usedLength : int - Length (=number of elements) of the section to wrap.

Returns: IROVector<sbyte> An IROVector that contains the section from start to start+len-1 of the original vector.

Wraps a section of an original vector into a new vector.

vector : IReadOnlyList<sbyte>

Original vector.

start : int

Index of the start of the section to wrap.

usedLength : int

Length (=number of elements) of the section to wrap.

Returns: IROVector<sbyte>

An IROVector that contains the section from start to start+len-1 of the original vector.

VectorMath.ToROVectorAmendedShifted(array, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Full Usage: VectorMath.ToROVectorAmendedShifted(array, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Parameters:
    array : float[] - The array to wrap. The first element of the array has index amendedValuesAtStartCount in the returned vector.
    amendedValueAtStart : float - Value of the vector at the first amendedValuesAtStartCount indices
    amendedValuesAtStartCount : int - Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.
    amendedValueAtEnd : float - Value of the vector at the last amendedValuesAtEndCount indices
    amendedValuesAtEndCount : int - Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Double[] array to get an IROVector.

array : float[]

The array to wrap. The first element of the array has index amendedValuesAtStartCount in the returned vector.

amendedValueAtStart : float

Value of the vector at the first amendedValuesAtStartCount indices

amendedValuesAtStartCount : int

Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.

amendedValueAtEnd : float

Value of the vector at the last amendedValuesAtEndCount indices

amendedValuesAtEndCount : int

Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVectorAmendedShifted(array, usedlength, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Full Usage: VectorMath.ToROVectorAmendedShifted(array, usedlength, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Parameters:
    array : float[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index amendedValuesAtStartCount in the returned vector.
    amendedValueAtStart : float - Value of the vector at the first amendedValuesAtStartCount indices
    amendedValuesAtStartCount : int - Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.
    amendedValueAtEnd : float - Value of the vector at the last amendedValuesAtEndCount indices
    amendedValuesAtEndCount : int - Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<float> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Double[] array till a given length to get an IROVector.

array : float[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index amendedValuesAtStartCount in the returned vector.

amendedValueAtStart : float

Value of the vector at the first amendedValuesAtStartCount indices

amendedValuesAtStartCount : int

Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.

amendedValueAtEnd : float

Value of the vector at the last amendedValuesAtEndCount indices

amendedValuesAtEndCount : int

Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<float>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVectorAmendedShifted(array, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Full Usage: VectorMath.ToROVectorAmendedShifted(array, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Parameters:
    array : float32[] - The array to wrap. The first element of the array has index amendedValuesAtStartCount in the returned vector.
    amendedValueAtStart : float32 - Value of the vector at the first amendedValuesAtStartCount indices
    amendedValuesAtStartCount : int - Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.
    amendedValueAtEnd : float32 - Value of the vector at the last amendedValuesAtEndCount indices
    amendedValuesAtEndCount : int - Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<float32> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Single[] array to get an IROVector.

array : float32[]

The array to wrap. The first element of the array has index amendedValuesAtStartCount in the returned vector.

amendedValueAtStart : float32

Value of the vector at the first amendedValuesAtStartCount indices

amendedValuesAtStartCount : int

Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.

amendedValueAtEnd : float32

Value of the vector at the last amendedValuesAtEndCount indices

amendedValuesAtEndCount : int

Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<float32>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVectorAmendedShifted(array, usedlength, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Full Usage: VectorMath.ToROVectorAmendedShifted(array, usedlength, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Parameters:
    array : float32[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index amendedValuesAtStartCount in the returned vector.
    amendedValueAtStart : float32 - Value of the vector at the first amendedValuesAtStartCount indices
    amendedValuesAtStartCount : int - Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.
    amendedValueAtEnd : float32 - Value of the vector at the last amendedValuesAtEndCount indices
    amendedValuesAtEndCount : int - Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<float32> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Single[] array till a given length to get an IROVector.

array : float32[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index amendedValuesAtStartCount in the returned vector.

amendedValueAtStart : float32

Value of the vector at the first amendedValuesAtStartCount indices

amendedValuesAtStartCount : int

Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.

amendedValueAtEnd : float32

Value of the vector at the last amendedValuesAtEndCount indices

amendedValuesAtEndCount : int

Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<float32>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVectorAmendedShifted(array, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Full Usage: VectorMath.ToROVectorAmendedShifted(array, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Parameters:
    array : int[] - The array to wrap. The first element of the array has index amendedValuesAtStartCount in the returned vector.
    amendedValueAtStart : int - Value of the vector at the first amendedValuesAtStartCount indices
    amendedValuesAtStartCount : int - Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.
    amendedValueAtEnd : int - Value of the vector at the last amendedValuesAtEndCount indices
    amendedValuesAtEndCount : int - Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<int> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Int32[] array to get an IROVector.

array : int[]

The array to wrap. The first element of the array has index amendedValuesAtStartCount in the returned vector.

amendedValueAtStart : int

Value of the vector at the first amendedValuesAtStartCount indices

amendedValuesAtStartCount : int

Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.

amendedValueAtEnd : int

Value of the vector at the last amendedValuesAtEndCount indices

amendedValuesAtEndCount : int

Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<int>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVectorAmendedShifted(array, usedlength, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Full Usage: VectorMath.ToROVectorAmendedShifted(array, usedlength, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Parameters:
    array : int[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index amendedValuesAtStartCount in the returned vector.
    amendedValueAtStart : int - Value of the vector at the first amendedValuesAtStartCount indices
    amendedValuesAtStartCount : int - Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.
    amendedValueAtEnd : int - Value of the vector at the last amendedValuesAtEndCount indices
    amendedValuesAtEndCount : int - Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<int> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Int32[] array till a given length to get an IROVector.

array : int[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index amendedValuesAtStartCount in the returned vector.

amendedValueAtStart : int

Value of the vector at the first amendedValuesAtStartCount indices

amendedValuesAtStartCount : int

Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.

amendedValueAtEnd : int

Value of the vector at the last amendedValuesAtEndCount indices

amendedValuesAtEndCount : int

Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<int>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVectorAmendedShifted(array, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Full Usage: VectorMath.ToROVectorAmendedShifted(array, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Parameters:
    array : int16[] - The array to wrap. The first element of the array has index amendedValuesAtStartCount in the returned vector.
    amendedValueAtStart : int16 - Value of the vector at the first amendedValuesAtStartCount indices
    amendedValuesAtStartCount : int - Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.
    amendedValueAtEnd : int16 - Value of the vector at the last amendedValuesAtEndCount indices
    amendedValuesAtEndCount : int - Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<int16> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Int16[] array to get an IROVector.

array : int16[]

The array to wrap. The first element of the array has index amendedValuesAtStartCount in the returned vector.

amendedValueAtStart : int16

Value of the vector at the first amendedValuesAtStartCount indices

amendedValuesAtStartCount : int

Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.

amendedValueAtEnd : int16

Value of the vector at the last amendedValuesAtEndCount indices

amendedValuesAtEndCount : int

Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<int16>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVectorAmendedShifted(array, usedlength, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Full Usage: VectorMath.ToROVectorAmendedShifted(array, usedlength, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Parameters:
    array : int16[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index amendedValuesAtStartCount in the returned vector.
    amendedValueAtStart : int16 - Value of the vector at the first amendedValuesAtStartCount indices
    amendedValuesAtStartCount : int - Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.
    amendedValueAtEnd : int16 - Value of the vector at the last amendedValuesAtEndCount indices
    amendedValuesAtEndCount : int - Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<int16> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a Int16[] array till a given length to get an IROVector.

array : int16[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index amendedValuesAtStartCount in the returned vector.

amendedValueAtStart : int16

Value of the vector at the first amendedValuesAtStartCount indices

amendedValuesAtStartCount : int

Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.

amendedValueAtEnd : int16

Value of the vector at the last amendedValuesAtEndCount indices

amendedValuesAtEndCount : int

Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<int16>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVectorAmendedShifted(array, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Full Usage: VectorMath.ToROVectorAmendedShifted(array, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Parameters:
    array : sbyte[] - The array to wrap. The first element of the array has index amendedValuesAtStartCount in the returned vector.
    amendedValueAtStart : sbyte - Value of the vector at the first amendedValuesAtStartCount indices
    amendedValuesAtStartCount : int - Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.
    amendedValueAtEnd : sbyte - Value of the vector at the last amendedValuesAtEndCount indices
    amendedValuesAtEndCount : int - Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<sbyte> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a SByte[] array to get an IROVector.

array : sbyte[]

The array to wrap. The first element of the array has index amendedValuesAtStartCount in the returned vector.

amendedValueAtStart : sbyte

Value of the vector at the first amendedValuesAtStartCount indices

amendedValuesAtStartCount : int

Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.

amendedValueAtEnd : sbyte

Value of the vector at the last amendedValuesAtEndCount indices

amendedValuesAtEndCount : int

Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<sbyte>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVectorAmendedShifted(array, usedlength, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Full Usage: VectorMath.ToROVectorAmendedShifted(array, usedlength, amendedValueAtStart, amendedValuesAtStartCount, amendedValueAtEnd, amendedValuesAtEndCount)

Parameters:
    array : sbyte[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index amendedValuesAtStartCount in the returned vector.
    amendedValueAtStart : sbyte - Value of the vector at the first amendedValuesAtStartCount indices
    amendedValuesAtStartCount : int - Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.
    amendedValueAtEnd : sbyte - Value of the vector at the last amendedValuesAtEndCount indices
    amendedValuesAtEndCount : int - Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<sbyte> A wrapper objects with the IROVector interface that wraps the provided array.

Wraps a SByte[] array till a given length to get an IROVector.

array : sbyte[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index amendedValuesAtStartCount in the returned vector.

amendedValueAtStart : sbyte

Value of the vector at the first amendedValuesAtStartCount indices

amendedValuesAtStartCount : int

Number of indices at the start of the vector that take the value of amendedValueAtStart. The first element of the wrapped array starts at index amendedValuesAtStartCount.

amendedValueAtEnd : sbyte

Value of the vector at the last amendedValuesAtEndCount indices

amendedValuesAtEndCount : int

Number of indices at the end of the vector that take the value of amendedValueAtEnd.

Returns: IROVector<sbyte>

A wrapper objects with the IROVector interface that wraps the provided array.

VectorMath.ToROVectorStructAmendedUnshifted(array, amendedValueAtStart, amendedValueAtEnd)

Full Usage: VectorMath.ToROVectorStructAmendedUnshifted(array, amendedValueAtStart, amendedValueAtEnd)

Parameters:
    array : float[] - The array to wrap. The first element of the array has index 0 in the returned vector.
    amendedValueAtStart : float - Value of the vector at indices less than zero.
    amendedValueAtEnd : float - Value of the vector at indices greater than or equal to array.Length.

Returns: RODoubleArrayWrapperStructAmendedUnshifted A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

Wraps a Double[] array to get a struct with an IROVector 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.

array : float[]

The array to wrap. The first element of the array has index 0 in the returned vector.

amendedValueAtStart : float

Value of the vector at indices less than zero.

amendedValueAtEnd : float

Value of the vector at indices greater than or equal to array.Length.

Returns: RODoubleArrayWrapperStructAmendedUnshifted

A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

VectorMath.ToROVectorStructAmendedUnshifted(array, usedlength, amendedValueAtStart, amendedValueAtEnd)

Full Usage: VectorMath.ToROVectorStructAmendedUnshifted(array, usedlength, amendedValueAtStart, amendedValueAtEnd)

Parameters:
    array : float[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index 0 in the returned vector.
    amendedValueAtStart : float - Value of the vector at indices less than zero.
    amendedValueAtEnd : float - Value of the vector at indices greater then or equal to usedlength.

Returns: RODoubleArrayWrapperStructAmendedUnshifted A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

Wraps a Double[] array till a given length to get a struct with an IROVector 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.

array : float[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index 0 in the returned vector.

amendedValueAtStart : float

Value of the vector at indices less than zero.

amendedValueAtEnd : float

Value of the vector at indices greater then or equal to usedlength.

Returns: RODoubleArrayWrapperStructAmendedUnshifted

A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

VectorMath.ToROVectorStructAmendedUnshifted(array, amendedValueAtStart, amendedValueAtEnd)

Full Usage: VectorMath.ToROVectorStructAmendedUnshifted(array, amendedValueAtStart, amendedValueAtEnd)

Parameters:
    array : float32[] - The array to wrap. The first element of the array has index 0 in the returned vector.
    amendedValueAtStart : float32 - Value of the vector at indices less than zero.
    amendedValueAtEnd : float32 - Value of the vector at indices greater than or equal to array.Length.

Returns: ROFloatArrayWrapperStructAmendedUnshifted A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

Wraps a Single[] array to get a struct with an IROVector 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.

array : float32[]

The array to wrap. The first element of the array has index 0 in the returned vector.

amendedValueAtStart : float32

Value of the vector at indices less than zero.

amendedValueAtEnd : float32

Value of the vector at indices greater than or equal to array.Length.

Returns: ROFloatArrayWrapperStructAmendedUnshifted

A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

VectorMath.ToROVectorStructAmendedUnshifted(array, usedlength, amendedValueAtStart, amendedValueAtEnd)

Full Usage: VectorMath.ToROVectorStructAmendedUnshifted(array, usedlength, amendedValueAtStart, amendedValueAtEnd)

Parameters:
    array : float32[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index 0 in the returned vector.
    amendedValueAtStart : float32 - Value of the vector at indices less than zero.
    amendedValueAtEnd : float32 - Value of the vector at indices greater then or equal to usedlength.

Returns: ROFloatArrayWrapperStructAmendedUnshifted A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

Wraps a Single[] array till a given length to get a struct with an IROVector 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.

array : float32[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index 0 in the returned vector.

amendedValueAtStart : float32

Value of the vector at indices less than zero.

amendedValueAtEnd : float32

Value of the vector at indices greater then or equal to usedlength.

Returns: ROFloatArrayWrapperStructAmendedUnshifted

A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

VectorMath.ToROVectorStructAmendedUnshifted(array, amendedValueAtStart, amendedValueAtEnd)

Full Usage: VectorMath.ToROVectorStructAmendedUnshifted(array, amendedValueAtStart, amendedValueAtEnd)

Parameters:
    array : int[] - The array to wrap. The first element of the array has index 0 in the returned vector.
    amendedValueAtStart : int - Value of the vector at indices less than zero.
    amendedValueAtEnd : int - Value of the vector at indices greater than or equal to array.Length.

Returns: ROIntArrayWrapperStructAmendedUnshifted A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

Wraps a Int32[] array to get a struct with an IROVector 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.

array : int[]

The array to wrap. The first element of the array has index 0 in the returned vector.

amendedValueAtStart : int

Value of the vector at indices less than zero.

amendedValueAtEnd : int

Value of the vector at indices greater than or equal to array.Length.

Returns: ROIntArrayWrapperStructAmendedUnshifted

A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

VectorMath.ToROVectorStructAmendedUnshifted(array, usedlength, amendedValueAtStart, amendedValueAtEnd)

Full Usage: VectorMath.ToROVectorStructAmendedUnshifted(array, usedlength, amendedValueAtStart, amendedValueAtEnd)

Parameters:
    array : int[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index 0 in the returned vector.
    amendedValueAtStart : int - Value of the vector at indices less than zero.
    amendedValueAtEnd : int - Value of the vector at indices greater then or equal to usedlength.

Returns: ROIntArrayWrapperStructAmendedUnshifted A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

Wraps a Int32[] array till a given length to get a struct with an IROVector 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.

array : int[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index 0 in the returned vector.

amendedValueAtStart : int

Value of the vector at indices less than zero.

amendedValueAtEnd : int

Value of the vector at indices greater then or equal to usedlength.

Returns: ROIntArrayWrapperStructAmendedUnshifted

A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

VectorMath.ToROVectorStructAmendedUnshifted(array, amendedValueAtStart, amendedValueAtEnd)

Full Usage: VectorMath.ToROVectorStructAmendedUnshifted(array, amendedValueAtStart, amendedValueAtEnd)

Parameters:
    array : int16[] - The array to wrap. The first element of the array has index 0 in the returned vector.
    amendedValueAtStart : int16 - Value of the vector at indices less than zero.
    amendedValueAtEnd : int16 - Value of the vector at indices greater than or equal to array.Length.

Returns: ROShortArrayWrapperStructAmendedUnshifted A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

Wraps a Int16[] array to get a struct with an IROVector 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.

array : int16[]

The array to wrap. The first element of the array has index 0 in the returned vector.

amendedValueAtStart : int16

Value of the vector at indices less than zero.

amendedValueAtEnd : int16

Value of the vector at indices greater than or equal to array.Length.

Returns: ROShortArrayWrapperStructAmendedUnshifted

A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

VectorMath.ToROVectorStructAmendedUnshifted(array, usedlength, amendedValueAtStart, amendedValueAtEnd)

Full Usage: VectorMath.ToROVectorStructAmendedUnshifted(array, usedlength, amendedValueAtStart, amendedValueAtEnd)

Parameters:
    array : int16[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index 0 in the returned vector.
    amendedValueAtStart : int16 - Value of the vector at indices less than zero.
    amendedValueAtEnd : int16 - Value of the vector at indices greater then or equal to usedlength.

Returns: ROShortArrayWrapperStructAmendedUnshifted A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

Wraps a Int16[] array till a given length to get a struct with an IROVector 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.

array : int16[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index 0 in the returned vector.

amendedValueAtStart : int16

Value of the vector at indices less than zero.

amendedValueAtEnd : int16

Value of the vector at indices greater then or equal to usedlength.

Returns: ROShortArrayWrapperStructAmendedUnshifted

A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

VectorMath.ToROVectorStructAmendedUnshifted(array, amendedValueAtStart, amendedValueAtEnd)

Full Usage: VectorMath.ToROVectorStructAmendedUnshifted(array, amendedValueAtStart, amendedValueAtEnd)

Parameters:
    array : sbyte[] - The array to wrap. The first element of the array has index 0 in the returned vector.
    amendedValueAtStart : sbyte - Value of the vector at indices less than zero.
    amendedValueAtEnd : sbyte - Value of the vector at indices greater than or equal to array.Length.

Returns: ROSByteArrayWrapperStructAmendedUnshifted A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

Wraps a SByte[] array to get a struct with an IROVector 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.

array : sbyte[]

The array to wrap. The first element of the array has index 0 in the returned vector.

amendedValueAtStart : sbyte

Value of the vector at indices less than zero.

amendedValueAtEnd : sbyte

Value of the vector at indices greater than or equal to array.Length.

Returns: ROSByteArrayWrapperStructAmendedUnshifted

A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

VectorMath.ToROVectorStructAmendedUnshifted(array, usedlength, amendedValueAtStart, amendedValueAtEnd)

Full Usage: VectorMath.ToROVectorStructAmendedUnshifted(array, usedlength, amendedValueAtStart, amendedValueAtEnd)

Parameters:
    array : sbyte[] - The array to wrap.
    usedlength : int - Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index 0 in the returned vector.
    amendedValueAtStart : sbyte - Value of the vector at indices less than zero.
    amendedValueAtEnd : sbyte - Value of the vector at indices greater then or equal to usedlength.

Returns: ROSByteArrayWrapperStructAmendedUnshifted A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

Wraps a SByte[] array till a given length to get a struct with an IROVector 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.

array : sbyte[]

The array to wrap.

usedlength : int

Length of the resulting vector. Can be equal or less the length of the array. The first element of the array has index 0 in the returned vector.

amendedValueAtStart : sbyte

Value of the vector at indices less than zero.

amendedValueAtEnd : sbyte

Value of the vector at indices greater then or equal to usedlength.

Returns: ROSByteArrayWrapperStructAmendedUnshifted

A wrapper struct with the IROVector interface that wraps the provided array, and allows access to elements below and above the valid indices of the array.

VectorMath.ToVector(array)

Full Usage: VectorMath.ToVector(array)

Parameters:
    array : float[] - The array to wrap.

Returns: IVector<float> A wrapper objects with the IVector interface that wraps the provided array.

Wraps an array to get an IVector

array : float[]

The array to wrap.

Returns: IVector<float>

A wrapper objects with the IVector interface that wraps the provided array.

VectorMath.ToVector(array, usedlength)

Full Usage: VectorMath.ToVector(array, usedlength)

Parameters:
    array : float[] - The array to wrap.
    usedlength : int - Used length of the array to get the wrapped vector (i.e. the vector wraps around array[0..usedLength-1]).

Returns: IVector<float> A wrapper objects with the IVector interface that wraps the provided array.

Wraps an array to get an IVector.

array : float[]

The array to wrap.

usedlength : int

Used length of the array to get the wrapped vector (i.e. the vector wraps around array[0..usedLength-1]).

Returns: IVector<float>

A wrapper objects with the IVector interface that wraps the provided array.

VectorMath.ToVector(array, start, count)

Full Usage: VectorMath.ToVector(array, start, count)

Parameters:
    array : float[] - The array to wrap.
    start : int - Index of first element of array to use.
    count : int - Number of elements of array to use.

Returns: IVector<float> A wrapper objects with the IVector interface that wraps a section of the provided array.

Wraps a section of an array to get a IVector.

array : float[]

The array to wrap.

start : int

Index of first element of array to use.

count : int

Number of elements of array to use.

Returns: IVector<float>

A wrapper objects with the IVector interface that wraps a section of the provided array.

VectorMath.ToVector(vector, start, len)

Full Usage: VectorMath.ToVector(vector, start, len)

Parameters:
    vector : IVector<float> - Original vector.
    start : int - Index of the start of the section to wrap.
    len : int - Length (=number of elements) of the section to wrap.

Returns: IVector<float> A IVector that contains the section from start to start+len-1 of the original vector.

Wraps a section of an original vector into a new vector.

vector : IVector<float>

Original vector.

start : int

Index of the start of the section to wrap.

len : int

Length (=number of elements) of the section to wrap.

Returns: IVector<float>

A IVector that contains the section from start to start+len-1 of the original vector.

VectorMath.ToVector(array)

Full Usage: VectorMath.ToVector(array)

Parameters:
    array : float32[] - The array to wrap.

Returns: IVector<float32> A wrapper objects with the IVector interface that wraps the provided array.

Wraps an array to get an IVector

array : float32[]

The array to wrap.

Returns: IVector<float32>

A wrapper objects with the IVector interface that wraps the provided array.

VectorMath.ToVector(array, usedlength)

Full Usage: VectorMath.ToVector(array, usedlength)

Parameters:
    array : float32[] - The array to wrap.
    usedlength : int - Used length of the array to get the wrapped vector (i.e. the vector wraps around array[0..usedLength-1]).

Returns: IVector<float32> A wrapper objects with the IVector interface that wraps the provided array.

Wraps an array to get an IVector.

array : float32[]

The array to wrap.

usedlength : int

Used length of the array to get the wrapped vector (i.e. the vector wraps around array[0..usedLength-1]).

Returns: IVector<float32>

A wrapper objects with the IVector interface that wraps the provided array.

VectorMath.ToVector(array, start, count)

Full Usage: VectorMath.ToVector(array, start, count)

Parameters:
    array : float32[] - The array to wrap.
    start : int - Index of first element of array to use.
    count : int - Number of elements of array to use.

Returns: IVector<float32> A wrapper objects with the IVector interface that wraps a section of the provided array.

Wraps a section of an array to get a IVector.

array : float32[]

The array to wrap.

start : int

Index of first element of array to use.

count : int

Number of elements of array to use.

Returns: IVector<float32>

A wrapper objects with the IVector interface that wraps a section of the provided array.

VectorMath.ToVector(vector, start, len)

Full Usage: VectorMath.ToVector(vector, start, len)

Parameters:
    vector : IVector<float32> - Original vector.
    start : int - Index of the start of the section to wrap.
    len : int - Length (=number of elements) of the section to wrap.

Returns: IVector<float32> A IVector that contains the section from start to start+len-1 of the original vector.

Wraps a section of an original vector into a new vector.

vector : IVector<float32>

Original vector.

start : int

Index of the start of the section to wrap.

len : int

Length (=number of elements) of the section to wrap.

Returns: IVector<float32>

A IVector that contains the section from start to start+len-1 of the original vector.

VectorMath.ToVector(array)

Full Usage: VectorMath.ToVector(array)

Parameters:
    array : int[] - The array to wrap.

Returns: IVector<int> A wrapper objects with the IVector interface that wraps the provided array.

Wraps an array to get an IVector

array : int[]

The array to wrap.

Returns: IVector<int>

A wrapper objects with the IVector interface that wraps the provided array.

VectorMath.ToVector(array, usedlength)

Full Usage: VectorMath.ToVector(array, usedlength)

Parameters:
    array : int[] - The array to wrap.
    usedlength : int - Used length of the array to get the wrapped vector (i.e. the vector wraps around array[0..usedLength-1]).

Returns: IVector<int> A wrapper objects with the IVector interface that wraps the provided array.

Wraps an array to get an IVector.

array : int[]

The array to wrap.

usedlength : int

Used length of the array to get the wrapped vector (i.e. the vector wraps around array[0..usedLength-1]).

Returns: IVector<int>

A wrapper objects with the IVector interface that wraps the provided array.

VectorMath.ToVector(array, start, count)

Full Usage: VectorMath.ToVector(array, start, count)

Parameters:
    array : int[] - The array to wrap.
    start : int - Index of first element of array to use.
    count : int - Number of elements of array to use.

Returns: IVector<int> A wrapper objects with the IVector interface that wraps a section of the provided array.

Wraps a section of an array to get a IVector.

array : int[]

The array to wrap.

start : int

Index of first element of array to use.

count : int

Number of elements of array to use.

Returns: IVector<int>

A wrapper objects with the IVector interface that wraps a section of the provided array.

VectorMath.ToVector(vector, start, len)

Full Usage: VectorMath.ToVector(vector, start, len)

Parameters:
    vector : IVector<int> - Original vector.
    start : int - Index of the start of the section to wrap.
    len : int - Length (=number of elements) of the section to wrap.

Returns: IVector<int> A IVector that contains the section from start to start+len-1 of the original vector.

Wraps a section of an original vector into a new vector.

vector : IVector<int>

Original vector.

start : int

Index of the start of the section to wrap.

len : int

Length (=number of elements) of the section to wrap.

Returns: IVector<int>

A IVector that contains the section from start to start+len-1 of the original vector.

VectorMath.ToVector(array)

Full Usage: VectorMath.ToVector(array)

Parameters:
    array : int16[] - The array to wrap.

Returns: IVector<int16> A wrapper objects with the IVector interface that wraps the provided array.

Wraps an array to get an IVector

array : int16[]

The array to wrap.

Returns: IVector<int16>

A wrapper objects with the IVector interface that wraps the provided array.

VectorMath.ToVector(array, usedlength)

Full Usage: VectorMath.ToVector(array, usedlength)

Parameters:
    array : int16[] - The array to wrap.
    usedlength : int - Used length of the array to get the wrapped vector (i.e. the vector wraps around array[0..usedLength-1]).

Returns: IVector<int16> A wrapper objects with the IVector interface that wraps the provided array.

Wraps an array to get an IVector.

array : int16[]

The array to wrap.

usedlength : int

Used length of the array to get the wrapped vector (i.e. the vector wraps around array[0..usedLength-1]).

Returns: IVector<int16>

A wrapper objects with the IVector interface that wraps the provided array.

VectorMath.ToVector(array, start, count)

Full Usage: VectorMath.ToVector(array, start, count)

Parameters:
    array : int16[] - The array to wrap.
    start : int - Index of first element of array to use.
    count : int - Number of elements of array to use.

Returns: IVector<int16> A wrapper objects with the IVector interface that wraps a section of the provided array.

Wraps a section of an array to get a IVector.

array : int16[]

The array to wrap.

start : int

Index of first element of array to use.

count : int

Number of elements of array to use.

Returns: IVector<int16>

A wrapper objects with the IVector interface that wraps a section of the provided array.

VectorMath.ToVector(vector, start, len)

Full Usage: VectorMath.ToVector(vector, start, len)

Parameters:
    vector : IVector<int16> - Original vector.
    start : int - Index of the start of the section to wrap.
    len : int - Length (=number of elements) of the section to wrap.

Returns: IVector<int16> A IVector that contains the section from start to start+len-1 of the original vector.

Wraps a section of an original vector into a new vector.

vector : IVector<int16>

Original vector.

start : int

Index of the start of the section to wrap.

len : int

Length (=number of elements) of the section to wrap.

Returns: IVector<int16>

A IVector that contains the section from start to start+len-1 of the original vector.

VectorMath.ToVector(array)

Full Usage: VectorMath.ToVector(array)

Parameters:
    array : sbyte[] - The array to wrap.

Returns: IVector<sbyte> A wrapper objects with the IVector interface that wraps the provided array.

Wraps an array to get an IVector

array : sbyte[]

The array to wrap.

Returns: IVector<sbyte>

A wrapper objects with the IVector interface that wraps the provided array.

VectorMath.ToVector(array, usedlength)

Full Usage: VectorMath.ToVector(array, usedlength)

Parameters:
    array : sbyte[] - The array to wrap.
    usedlength : int - Used length of the array to get the wrapped vector (i.e. the vector wraps around array[0..usedLength-1]).

Returns: IVector<sbyte> A wrapper objects with the IVector interface that wraps the provided array.

Wraps an array to get an IVector.

array : sbyte[]

The array to wrap.

usedlength : int

Used length of the array to get the wrapped vector (i.e. the vector wraps around array[0..usedLength-1]).

Returns: IVector<sbyte>

A wrapper objects with the IVector interface that wraps the provided array.

VectorMath.ToVector(array, start, count)

Full Usage: VectorMath.ToVector(array, start, count)

Parameters:
    array : sbyte[] - The array to wrap.
    start : int - Index of first element of array to use.
    count : int - Number of elements of array to use.

Returns: IVector<sbyte> A wrapper objects with the IVector interface that wraps a section of the provided array.

Wraps a section of an array to get a IVector.

array : sbyte[]

The array to wrap.

start : int

Index of first element of array to use.

count : int

Number of elements of array to use.

Returns: IVector<sbyte>

A wrapper objects with the IVector interface that wraps a section of the provided array.

VectorMath.ToVector(vector, start, len)

Full Usage: VectorMath.ToVector(vector, start, len)

Parameters:
    vector : IVector<sbyte> - Original vector.
    start : int - Index of the start of the section to wrap.
    len : int - Length (=number of elements) of the section to wrap.

Returns: IVector<sbyte> A IVector that contains the section from start to start+len-1 of the original vector.

Wraps a section of an original vector into a new vector.

vector : IVector<sbyte>

Original vector.

start : int

Index of the start of the section to wrap.

len : int

Length (=number of elements) of the section to wrap.

Returns: IVector<sbyte>

A IVector that contains the section from start to start+len-1 of the original vector.

VectorMath.ToZeroMean(v)

Full Usage: VectorMath.ToZeroMean(v)

Parameters:
    v : float[] - The vector.

Normalizes the vector elements so that the mean of the elements is zero.

v : float[]

The vector.

VectorMath.ToZeroMean(v)

Full Usage: VectorMath.ToZeroMean(v)

Parameters:
    v : float32[] - The vector.

Normalizes the vector elements so that the mean of the elements is zero.

v : float32[]

The vector.

VectorMath.ToZeroMean(v)

Full Usage: VectorMath.ToZeroMean(v)

Parameters:
    v : int[] - The vector.

Normalizes the vector elements so that the mean of the elements is zero.

v : int[]

The vector.

VectorMath.ToZeroMean(v)

Full Usage: VectorMath.ToZeroMean(v)

Parameters:

Normalizes the vector elements so that the mean of the elements is zero.

v : IVector<float>

The vector.

VectorMath.ToZeroMean(v)

Full Usage: VectorMath.ToZeroMean(v)

Parameters:
    v : IVector<float32> - The vector.

Normalizes the vector elements so that the mean of the elements is zero.

v : IVector<float32>

The vector.

VectorMath.ToZeroMeanAndUnitVariance(v)

Full Usage: VectorMath.ToZeroMeanAndUnitVariance(v)

Parameters:
    v : float[] - The vector.

Normalizes the vector elements so that the mean of the elements is zero.

v : float[]

The vector.

VectorMath.ToZeroMeanAndUnitVariance(v)

Full Usage: VectorMath.ToZeroMeanAndUnitVariance(v)

Parameters:
    v : float32[] - The vector.

Normalizes the vector elements so that the mean of the elements is zero.

v : float32[]

The vector.

VectorMath.ToZeroMeanAndUnitVariance(v)

Full Usage: VectorMath.ToZeroMeanAndUnitVariance(v)

Parameters:
    v : int[] - The vector.

Normalizes the vector elements so that the mean of the elements is zero.

v : int[]

The vector.

VectorMath.ToZeroMeanAndUnitVariance(v)

Full Usage: VectorMath.ToZeroMeanAndUnitVariance(v)

Parameters:

Normalizes the vector elements so that the mean of the elements is zero.

v : IVector<float>

The vector.

VectorMath.ToZeroMeanAndUnitVariance(v)

Full Usage: VectorMath.ToZeroMeanAndUnitVariance(v)

Parameters:
    v : IVector<float32> - The vector.

Normalizes the vector elements so that the mean of the elements is zero.

v : IVector<float32>

The vector.