 Name  Description 

 Abs(Vector) 
Returns a vector whose components are the absolute values of the components of another vector.

 AbsT(VectorT) 
Returns a vector whose elements are the absolute values of the components of another vector.

 AbsIntoT 
Computes the absolute values of the elements of a vector.

 AbsoluteMax(Vector) 
Returns the largest absolute value of a component of a vector.

 AbsoluteMaxT(VectorComplexT) 
Returns the value of the element in this
vector that has the largest absolute
value.

 AbsoluteMaxT(VectorT) 
Returns the value of the element in this
vector that has the largest absolute
value.

 AbsoluteMaxT(VectorComplexT, Int32) 
Returns the value of the element in this
vector that has the largest absolute
value.

 AbsoluteMaxT(VectorT, Int32) 
Returns the value of the element in this
vector that has the largest absolute
value.

 AbsoluteMaxIndex(Vector) 
Returns the index of the component of a vector with the largest absolute value.

 AbsoluteMaxIndexT(VectorT) 
Returns the index of the component of a vector with the largest absolute value.

 AbsoluteMin(Vector) 
Returns the smallest absolute value of a component of a vector.

 AbsoluteMinT(VectorComplexT) 
Returns the value of the element in this
vector that has the smallest absolute
value.

 AbsoluteMinT(VectorT) 
Returns the value of the element in this
vector that has the smallest absolute
value.

 AbsoluteMinT(VectorComplexT, Int32) 
Returns the value of the element in this
vector that has the smallest absolute
value.

 AbsoluteMinT(VectorT, Int32) 
Returns the value of the element in this
vector that has the smallest absolute
value.

 AbsoluteMinIndex(Vector) 
Returns the index of the component of a vector with the largest absolute value.

 AbsoluteMinIndexT(VectorT) 
Returns the index of the component of a vector with the largest absolute value.

 Acos(Vector) 
Returns a vector whose components are the inverse cosine of the components of another vector.

 AcosT(VectorT) 
Computes the inverse cosine of the elements of a vector.

 AcoshT 
Computes the inverse hyperbolic cosine of the elements of a vector.

 AcoshIntoT 
Computes the inverse hyperbolic cosine of the elements of a vector.

 AcosIntoT 
Computes the inverse cosine of the elements of a vector.

 Add(Double, Vector) 
Adds a vector and a constant.

 Add(Vector, Vector) 
Adds two vector values.

 Add(Vector, Double) 
Adds a vector and a constant.

 AddT(T, VectorT) 
Adds a vector and a constant.

 AddT(VectorT, VectorT) 
Adds two vectors.

 AddT(VectorT, T) 
Adds a vector and a constant.

 AddInto(Vector, Vector, Vector) 
Adds two vector values.

 AddIntoT(T, VectorT, VectorT) 
Adds a vector and a constant.

 AddIntoT(VectorT, VectorT, VectorT) 
Adds two vectors.

 AddIntoT(VectorT, T, VectorT) 
Adds a vector and a constant.

 AddProductT(VectorT, LinearOperatorT, VectorT) 
Adds the product of a matrix and a vector to a vector.

 AddProductT(VectorT, LinearOperatorT, TransposeOperation, VectorT) 
Adds the product of a matrix and a vector to a vector.

 AddProductIntoT 
Adds the scaled product of a matrix and a vector to a vector.

 AddScaledT 
Adds two vectors.

 AddScaledIntoT 
Adds two vectors.

 AddScaledProductT(VectorT, T, LinearOperatorT, VectorT) 
Adds the scaled product of a matrix and a vector to a vector.

 AddScaledProductT(VectorT, T, LinearOperatorT, TransposeOperation, VectorT) 
Adds the scaled product of a matrix and a vector to a vector.

 AddScaledProductIntoT 
Adds the scaled product of a matrix and a vector to a vector.

 All(VectorBoolean) 
Returns whether all values in a vector are .

 AllT(VectorT, FuncT, Boolean) 
Returns whether all values in a vector satisfy the specified
predicate.

 AllT1, T2(VectorT1, VectorT2, FuncT1, T2, Boolean) 
Returns whether all pairs of corresponding values in two vector satisfy
the specified predicate.

 And 
Computes the logical conjunction of two boolean vectors.

 Angle(Vector, Vector) 
Returns the angle between two vectors.

 AngleT(VectorT, VectorT) 
Returns the angle between two vectors.

 Any(VectorBoolean) 
Returns whether at least one value in a vector is .

 AnyT(VectorT, FuncT, Boolean) 
Returns whether at least one value in a vector satisfies a predicate.

 AnyT1, T2(VectorT1, VectorT2, FuncT1, T2, Boolean) 
Returns whether all pairs of corresponding values in two vector satisfy
the specified predicate.

 Apply(FuncDouble, Double, Vector) 
Applies a function to the elements of a vector
and returns the result in a new vector.

 Asin(Vector) 
Returns a vector whose components are the inverse sine of the components of another vector.

 AsinT(VectorT) 
Computes the inverse sine of the elements of a vector.

 AsinhT 
Computes the inverse hyperbolic sine of the elements of a vector.

 AsinhIntoT 
Computes the inverse hyperbolic sine of the elements of a vector.

 AsinIntoT 
Computes the inverse sine of the elements of a vector.

 Atan(Vector) 
Returns a vector whose components are the inverse tangent of the components of another vector.

 AtanT(VectorT) 
Computes the inverse tangent of the elements of a vector.

 Atan2(Vector, Vector) 
Returns a vector whose components are the inverse tangent of the components of another vector.

 Atan2T(VectorT, VectorT) 
Computes the fourquadrant inverse tangent of the corresponding elements
of two matrices.

 Atan2IntoT 
Computes the fourquadrant inverse tangent of the corresponding elements
of two matrices.

 AtanhT 
Computes the inverse hyperbolic tangent of the elements of a vector.

 AtanhIntoT 
Computes the inverse hyperbolic tangent of the elements of a vector.

 AtanIntoT 
Computes the inverse tangent of the elements of a vector.

 BinT(IVector, IntervalIndexT) 
Sorts values into bins and returns the result as a categorical vector.

 BinT(VectorT, IntervalIndexT) 
Sorts values into bins and returns the result as a categorical vector.

 BinT(IVector, IListT, SpecialBins) 
Sorts values into bins and returns the result as a categorical vector.

 BinT(VectorT, IListT, SpecialBins) 
Sorts values into bins and returns the result as a categorical vector.

 BinT(VectorT, Int32, SpecialBins) 
Sorts values into bins and returns the result as a categorical vector.

 BrayCurtisDistance(Vector, Vector) 
Returns the BrayCurtis distance between two vectors.

 BrayCurtisDistanceT(VectorT, VectorT) 
Returns the BrayCurtis distance between two vectors.

 CanberraDistance(Vector, Vector) 
Returns the Canberra distance between two vectors.

 CanberraDistanceT(VectorT, VectorT) 
Returns the Canberra distance between two vectors.

 Ceiling(Vector) 
Returns a vector whose components are the components of another vector
rounded up to the nearest integer.

 CeilingT(VectorT) 
Returns a vector whose elements are the components of another vector
rounded up to the nearest integer.

 CeilingIntoT 
Computes the smallest integers greater than the elements of a vector.

 Clip(Vector, Double, Double) 
Returns a vector whose components are the components of a vector
constrained to be within the specified interval.

 ClipT(VectorT, T, T) 
Returns a vector whose elements are the components of a vector
constrained to be within the specified interval.

 ClipIntoT 
Returns a vector whose elements are the components of a vector
constrained to be within the specified interval.

 ComponentwiseDivide(Vector, Vector)  Obsolete.
Divides the elements of a vector by the corresponding
elements of another vector.

 ComponentwiseMultiply(Vector, Vector)  Obsolete.
Multiplies the elements of a vector by the corresponding
elements of another vector.

 ConjugateT 
Returns the conjugate of a vector.

 ConjugateIntoT 
Conjugates the elements of a vector.

 Convolution(Vector, Vector) 
Calculates the convolution of two vectors.

 ConvolutionT(VectorComplexT, VectorComplexT) 
Calculates the convolution of two vectors.

 ConvolutionT(VectorT, VectorT) 
Calculates the convolution of two vectors.

 CorrelationDistance(Vector, Vector) 
Returns a distance that is a function of the correlation between two vectors.

 CorrelationDistanceT(VectorT, VectorT) 
Returns a distance that is a function of the correlation between two vectors.

 Cos(Vector) 
Returns a vector whose components are the cosines of the components of another vector.

 CosT(VectorT) 
Computes the cosine of the elements of a vector.

 Cosh(Vector) 
Returns a vector whose components are the hyperbolic cosines of the components of another vector.

 CoshT(VectorT) 
Computes the hyperbolic cosine of the elements of a vector.

 CoshIntoT 
Computes the hyperbolic cosine of the elements of a vector.

 CosineDistance(Vector, Vector) 
Returns the cosine of the angle between two vectors.

 CosineDistanceT(VectorT, VectorT) 
Returns the cosine of the angle between two vectors.

 CosIntoT 
Computes the cosine of the elements of a vector.

 CountFalse 
Returns the number of elements in a boolean vector
that are .

 CountTrue 
Returns the number of elements in a boolean vector
that are .

 Create(IListDouble) 
Constructs a new vector with the specified
elements.

 Create(Double) 
Constructs a new vector with the specified
elements.

 Create(Int32) 
Constructs a new vector with the specified
length.

 Create(Double, Boolean) 
Constructs a new dense vector with the specified
elements.

 Create(Int32, ArraySliceDouble) 
Constructs a new dense vector.

 Create(Int32, FuncInt32, Double) 
Constructs a new dense vector.

 Create(Int32, Double, Boolean) 
Constructs a new dense vector with the specified
elements.

 Create(Int32, Double, Int32, Int32) 
Constructs a new dense vector.

 CreateT(Int32) 
Constructs a new vector with the specified
length.

 CreateT(T) 
Constructs a new vector with the specified
elements.

 CreateT(IListT, ArrayMutability) 
Constructs a new vector with the specified
elements.

 CreateT(Int32, ArraySliceT, ArrayMutability) 
Constructs a new dense vector.

 CreateT(Int32, FuncInt32, T, ArrayMutability) 
Constructs a new dense vector.

 CreateT(T, Boolean, ArrayMutability) 
Constructs a new dense vector with the specified elements.

 CreateT(Int32, T, Boolean, ArrayMutability) 
Constructs a new dense vector with the specified
elements.

 CreateT(Int32, T, Int32, Int32, ArrayMutability) 
Constructs a new dense vector.

 CreateT, K(IDictionaryK, T) 
Creates an indexed vector from a dictionary.

 CreateT, K(IDictionaryK, T, IListK) 
Creates an indexed vector from a dictionary.

 CreateT, K(Int32, IndexK) 
Creates an indexed vector of the specified length with the specified index.

 CreateT, K(IListT, IListK, ArrayMutability) 
Creates an indexed vector with the specified values and corresponding keys.

 CreateBanded(Int32, Int32, Vector) 
Constructs a new band vector.

 CreateBanded(Int32, Int32, Int32) 
Constructs a new band vector.

 CreateBandedT(Int32, Int32, Int32) 
Constructs a new BlockVectorT with the specified
length and nonzero range.

 CreateBandedT(Int32, Int32, Int32, T, Boolean, ArrayMutability) 
Constructs a new BlockVectorT with the specified
length and nonzero elements.

 CreateCategoricalT(IListT) 
Constructs a categorical vector from a list of values.

 CreateCategoricalT(Int32) 
Constructs a new categorical vector of the specified length.

 CreateCategoricalT(IListT, ArrayMutability) 
Constructs a categorical vector from a list of values.

 CreateCategoricalT(IListT, IndexT, ArrayMutability) 
Constructs a categorical vector from a list of values.

 CreateCategoricalT(IListT, SortOrder, ArrayMutability) 
Constructs a categorical vector from a list of values.

 CreateCategoricalT(IndexT, IListInt32, ArrayMutability) 
Constructs a categorical vector from an index and level indexes.

 CreateConstant(Int32, Double) 
Constructs a new constant vector.

 CreateConstantT(Int32, T) 
Constructs a new constant vector.

 CreateIndexedT(T, Int32, ArrayMutability) 
Constructs a new indexed vector.

 CreateIndexedT(Int32, T, Int32, Int32, Int32, ArrayMutability) 
Constructs a new vector whose elements are at the specified indexes in an array.

 CreateLogarithmicRange(Double, Int32, Int32) 
Constructs a new vector with elements evenly spaced in a logarithmic scale.

 CreateLogarithmicRange(Int32, Double, Double, Double, Boolean) 
Constructs a new vector with elements evenly spaced in a logarithmic scale.

 CreateLogarithmicRangeT(Int32, Int32, ArrayMutability) 
Constructs a new vector with elements evenly spaced in a base 10 logarithmic scale.

 CreateLogarithmicRangeT(T, Int32, Int32, ArrayMutability) 
Constructs a new vector with elements evenly spaced in a logarithmic scale.

 CreateLogarithmicRangeT(Int32, T, T, T, Boolean, ArrayMutability) 
Constructs a new vector with elements evenly spaced in a logarithmic scale.

 CreateRandom(Int32, ArrayMutability) 
Constructs a new vector with uniform random numbers between 0 and 1.

 CreateRandom(Int32, Random, ArrayMutability) 
Constructs a new vector with uniform random numbers between 0 and 1.

 CreateRandomNormal(Int32, ArrayMutability) 
Constructs a new vector with normal random numbers with zero mean and unit
standard deviation.

 CreateRandomNormal(Int32, Random, ArrayMutability) 
Constructs a new vector with normal random numbers with zero mean and unit
standard deviation.

 CreateRange(Double) 
Constructs a new vector with elements from 0 up to the specified value.

 CreateRange(Double, Double) 
Constructs a new vector with elements from the specified range..

 CreateRange(Double, Double, Int32) 
Constructs a new vector with elements from the specified range..

 CreateRangeT(T, ArrayMutability) 
Constructs a new vector with elements from 0 up to the specified value.

 CreateRangeT(T, T, ArrayMutability) 
Constructs a new vector with elements from the specified range..

 CreateRangeT(T, T, Int32, ArrayMutability) 
Constructs a new vector with elements from the specified range..

 CreateSparse(Int32) 
Constructs a new sparse vector of the specified length.

 CreateSparse(Int32, Double) 
Constructs a new sparse vector of the specified length.

 CreateSparse(Int32, Int32) 
Constructs a new sparse vector of the specified length.

 CreateSparse(Int32, Int32, Double) 
Constructs a new sparse vector with the specified elements.

 CreateSparseT(Int32) 
Constructs a new sparse vector of the specified length.

 CreateSparseT(Int32, Double) 
Constructs a new sparse vector of the specified length.

 CreateSparseT(Int32, Int32) 
Constructs a new sparse vector of the specified length.

 CreateSparseT(Int32, Int32, T, ArrayMutability) 
Constructs a new sparse vector with the specified elements.

 CreateSparseUnitVector(Int32, Int32) 
Constructs a new sparse vector of the specified length.

 CreateSparseUnitVectorT(Int32, Int32, ArrayMutability) 
Constructs a new sparse vector of the specified length.

 CrossProduct(Vector, Vector) 
Returns the cross product of two 3D vectors.

 CrossProductT(VectorT, VectorT) 
Returns the cross product of two 3D vectors.

 CumulativeProduct(Vector) 
Returns a vector containing the cumulative product
of the elements of the vector.

 CumulativeSum(Vector) 
Returns a vector containing the cumulative sum
of the elements of the vector.

 DifferenceT 
Computes the forward or backward difference of a vector.

 DifferenceIntoT 
Computes the forward or backward difference of a vector.

 Divide(Vector, Double) 
Divides a vector by a constant.

 DivideT(VectorT, T) 
Divides a vector by a constant.

 DotProduct(Vector, Vector) 
Returns the dot product of two vectors.

 DotProductT(VectorT, VectorT) 
Returns the dot product of two vectors.

 ElementwiseConjugateMultiplyT 
Multiplies the elements of a vector by the corresponding
elements of another vector.

 ElementwiseConjugateMultiplyIntoT 
Multiplies a vector elementwise by another vector.

 ElementwiseDivide(Vector, Vector) 
Divides the elements of a vector by the corresponding
elements of another vector.

 ElementwiseDivideT(T, VectorT) 
Divides a scalar by each element of a vector.

 ElementwiseDivideT(VectorT, VectorT) 
Divides a vector elementwise by another vector.

 ElementwiseDivideInto(Vector, Vector, Vector) 
Divides the elements of a vector by the corresponding
elements of another vector.

 ElementwiseDivideIntoT(T, VectorT, VectorT) 
Divides a scalar by each element of a vector.

 ElementwiseDivideIntoT(VectorT, VectorT, VectorT) 
Divides a vector elementwise by another vector.

 ElementwiseMultiply(Vector, Vector) 
Multiplies the elements of a vector by the corresponding
elements of another vector.

 ElementwiseMultiplyT(VectorT, VectorT) 
Multiplies the elements of a vector by the corresponding
elements of another vector.

 ElementwiseMultiplyInto(Vector, Vector, Vector) 
Multiplies the elements of a vector by the corresponding
elements of another vector.

 ElementwiseMultiplyIntoT(VectorT, VectorT, VectorT) 
Multiplies a vector elementwise by another vector.

 ElementwisePowT(VectorT, VectorInt32) 
Raises the elements of a vector to an integer power
from the corresponding elements in another vector.

 ElementwisePowT(VectorT, VectorT) 
Raises the elements of a vector to a power
from the corresponding elements in another vector.

 ElementwisePowT(VectorT, Int32) 
Raises the element of a vector to a constant power.

 ElementwisePowT(VectorT, T) 
Raises the element of a vector to a constant power.

 ElementwisePowIntoT(VectorT, VectorInt32, VectorT) 
Raises the elements of a vector to an integer power
from the corresponding elements in another vector.

 ElementwisePowIntoT(VectorT, VectorT, VectorT) 
Raises the elements of a vector to a power
from the corresponding elements in another vector.

 ElementwisePowIntoT(VectorT, Int32, VectorT) 
Raises the element of a vector to a constant power.

 ElementwisePowIntoT(VectorT, T, VectorT) 
Raises the element of a vector to a constant power.

 EqualToT(T, VectorT) 
Checks if the elements of one vector are equal to a constant.

 EqualToT(VectorT, VectorT) 
Checks if the elements of one vector are equal to the corresponding elements
of another vector.

 EqualToT(VectorT, T) 
Checks if the elements of one vector are equal to a constant.

 EqualToIntoT(T, VectorT, VectorBoolean) 
Checks if the elements of one vector are equal to a constant.

 EqualToIntoT(VectorT, VectorT, VectorBoolean) 
Checks if the elements of one vector are equal to the corresponding elements
of another vector.

 EqualToIntoT(VectorT, T, VectorBoolean) 
Checks if the elements of one vector are equal to a constant.

 EuclideanDistanceT 
Returns the classic Euclidean distance between two vectors.

 EuclidianDistance 
Returns the classic Euclidian distance between two vectors.

 Exp(Vector) 
Returns a vector whose components are the exponential of the components of another vector.

 ExpT(VectorT) 
Computes the exponential of the elements of a vector.

 ExpIntoT 
Computes the exponential of the elements of a vector.

 Floor(Vector) 
Returns a vector whose components are the components of another vector
rounded down to the nearest integer.

 FloorT(VectorT) 
Returns a vector whose elements are the components of another vector
rounded down to the nearest integer.

 FloorIntoT 
Computes the largest integers smaller than the elements of a vector.

 FourierTransform(Vector) 
Returns the Fourier transform of a vector.

 FourierTransformT(VectorComplexT) 
Returns the Fourier transform of a vector.

 FourierTransformT(VectorT) 
Returns the Fourier transform of a vector.

 GreaterThanT(T, VectorT) 
Checks if the elements of one vector are greater than a constant.

 GreaterThanT(VectorT, VectorT) 
Checks if the elements of one vector are greater than the corresponding elements
of another vector.

 GreaterThanT(VectorT, T) 
Checks if the elements of one vector are greater than a constant.

 GreaterThanIntoT(T, VectorT, VectorBoolean) 
Checks if the elements of one vector are greater than a constant.

 GreaterThanIntoT(VectorT, VectorT, VectorBoolean) 
Checks if the elements of one vector are greater than the corresponding elements
of another vector.

 GreaterThanIntoT(VectorT, T, VectorBoolean) 
Checks if the elements of one vector are greater than a constant.

 GreaterThanOrEqualToT(T, VectorT) 
Checks if the elements of one vector are greater than or equal to a constant.

 GreaterThanOrEqualToT(VectorT, VectorT) 
Checks if the elements of one vector are greater than or equal to the corresponding elements
of another vector.

 GreaterThanOrEqualToT(VectorT, T) 
Checks if the elements of one vector are greater than or equal to a constant.

 GreaterThanOrEqualToIntoT(T, VectorT, VectorBoolean) 
Checks if the elements of one vector are greater than or equal to a constant.

 GreaterThanOrEqualToIntoT(VectorT, VectorT, VectorBoolean) 
Checks if the elements of one vector are greater than or equal to
the corresponding elements of another vector.

 GreaterThanOrEqualToIntoT(VectorT, T, VectorBoolean) 
Checks if the elements of one vector are greater than or equal to a constant.

 HypotT 
Computes the square root of the sum of the squared corresponding elements
of two matrices.

 HypotIntoT 
Computes the square root of the sum of the squared corresponding elements
of two matrices.

 InverseComplexFourierTransformT 
Returns the inverse Fourier transform of a vector.

 InverseFourierTransform(ComplexVector) 
Returns the inverse Fourier transform of a vector.

 InverseFourierTransformT(VectorComplexT) 
Returns the inverse Fourier transform of a vector.

 Join(Vector) 
Joins vectors together to form one large vector.

 Join(Vector, Vector) 
Joins two vectors.

 JoinT(VectorT) 
Joins vectors together to form one large vector.

 JoinT(VectorT, VectorT) 
Joins two vectors.

 LessThanT(T, VectorT) 
Checks if the elements of one vector are less than a constant.

 LessThanT(VectorT, VectorT) 
Checks if the elements of one vector are less than the corresponding elements
of another vector.

 LessThanT(VectorT, T) 
Checks if the elements of one vector are less than a constant.

 LessThanIntoT(T, VectorT, VectorBoolean) 
Checks if the elements of one vector are less than a constant.

 LessThanIntoT(VectorT, VectorT, VectorBoolean) 
Checks if the elements of one vector are greater than the corresponding elements
of another vector.

 LessThanIntoT(VectorT, T, VectorBoolean) 
Checks if the elements of one vector are less than a constant.

 LessThanOrEqualToT(T, VectorT) 
Checks if the elements of one vector are less than or equal to a constant.

 LessThanOrEqualToT(VectorT, VectorT) 
Checks if the elements of one vector are less than or equal to the corresponding elements
of another vector.

 LessThanOrEqualToT(VectorT, T) 
Checks if the elements of one vector are less than or equal to a constant.

 LessThanOrEqualToIntoT(T, VectorT, VectorBoolean) 
Checks if the elements of one vector are less than or equal to a constant.

 LessThanOrEqualToIntoT(VectorT, VectorT, VectorBoolean) 
Checks if the elements of one vector are greater than or equal to
the corresponding elements of another vector.

 LessThanOrEqualToIntoT(VectorT, T, VectorBoolean) 
Checks if the elements of one vector are less than or equal to a constant.

 Log(Vector) 
Returns a vector whose components are the logarithms of the components of another vector.

 Log(Vector, Vector) 
Returns a vector whose components are the logarithms of the components of another vector.

 Log(Vector, Double) 
Returns a vector whose components are the logarithms of the components of another vector.

 LogT(VectorT) 
Returns a vector whose elements are the logarithms of the components of another vector.

 LogT(VectorT, T) 
Returns a vector whose elements are the logarithms of the components of another vector.

 Log10(Vector) 
Returns a vector whose components are the base 10 logarithms of the components of another vector.

 Log10T(VectorT) 
Returns a vector whose elements are the base 10 logarithms of the components of another vector.

 Log10IntoT 
Computes the base 10 logarithm of the elements of a vector.

 LogIntoT(VectorT, VectorT) 
Computes the logarithm of the elements of a vector.

 LogIntoT(VectorT, T, VectorT) 
Computes the logarithm of the elements of a vector.

 ManhattanDistance(Vector, Vector) 
Returns the Manhattan (city block) distance between two vectors.

 ManhattanDistanceT(VectorT, VectorT) 
Returns the Manhattan (city block) distance between two vectors.

 MapT, U(FuncT, U, VectorT) 
Applies a function to the elements of a vector
and returns the result in a new vector.

 MapT, U(FuncInt32, T, U, VectorT) 
Applies a function to the elements of a vector
and returns the result in a new vector.

 MapT, U, V(FuncT, U, V, VectorT, VectorU) 
Applies a function to the corresponding elements of two vectors
and returns the result in a new vector.

 MapIntoT, U(FuncT, U, VectorT, VectorU) 
Applies a function to the elements of a vector.

 MapIntoT, U, V(FuncT, U, V, VectorT, VectorU, VectorV) 
Applies a function to the corresponding elements of two vectors
and returns the result in a third vector.

 Max(Vector) 
Returns the value of the largest component of a vector.

 Max(Double, Vector) 
Returns a vector whose components are the maximum of the components of a vector
and a real number..

 Max(Vector, Vector) 
Returns a vector whose components are the maximums of the components of two vectors.

 Max(Vector, Double) 
Returns a vector whose components are the maximum of the components of a vector
and a real number..

 MaxT(VectorT) 
Returns the value of the largest component of a vector.

 MaxT(T, VectorT) 
Returns a vector whose elements are the maximum of the components of a vector
and a real number.

 MaxT(VectorT, VectorT) 
Returns a vector whose elements are the maximums of the components of two vectors.

 MaxT(VectorT, T) 
Returns a vector whose elements are the maximum of the components of a vector
and a real number.

 MaximumDistance(Vector, Vector) 
Returns the largest distance between two vectors.

 MaximumDistanceT(VectorT, VectorT) 
Returns the largest distance between two vectors.

 MaxIndex(Vector) 
Returns the index of the largest component of a vector.

 MaxIndexT(VectorT) 
Returns the index of the largest component of a vector.

 MaxIntoT(VectorT, VectorT, VectorT) 
Returns a vector whose elements are the maximums of the components of two vectors.

 MaxIntoT(VectorT, T, VectorT) 
Returns a vector whose elements are the maximum of the components of a vector
and a real number.

 Min(Vector) 
Returns the value of the smallest component of a vector.

 Min(Double, Vector) 
Returns a vector whose components are the minimums of the components of a vector
and a real number.

 Min(Vector, Vector) 
Returns a vector whose components are the minimums of the components of two vectors.

 Min(Vector, Double) 
Returns a vector whose components are the minimums of the components of a vector
and a real number.

 MinT(VectorT) 
Returns the value of the smallest component of a vector.

 MinT(T, VectorT) 
Returns a vector whose elements are the minimum of the components of a vector
and a real number.

 MinT(VectorT, VectorT) 
Returns a vector whose elements are the minimums of the components of two vectors.

 MinT(VectorT, T) 
Returns a vector whose elements are the minimum of the components of a vector
and a real number.

 MinIndex(Vector) 
Returns the index of the smallest component of a vector.

 MinIndexT(VectorT) 
Returns the index of the smallest component of a vector.

 MinIntoT(VectorT, VectorT, VectorT) 
Returns a vector whose elements are the minimums of the components of two vectors.

 MinIntoT(VectorT, T, VectorT) 
Returns a vector whose elements are the minimum of the components of a vector
and a real number.

 MinkowskiMeasure(Double, Vector, Vector) 
Returns the Minkowski distance between two vectors.

 MinkowskiMeasureT(T, VectorT, VectorT) 
Returns the Minkowski distance between two vectors.

 Multiply(Double, Vector) 
Multiplies a vector by a constant.

 MultiplyT(T, VectorT) 
Multiplies a vector by a constant.

 MultiplyT(MatrixT, VectorT) 
Multiplies a vector by a matrix.

 MultiplyT(VectorT, T) 
Multiplies a vector by a constant.

 MultiplyT(MatrixT, TransposeOperation, VectorT) 
Multiplies a vector by a matrix.

 MultiplyInto(Double, Vector, Vector) 
Multiplies a vector by a constant.

 MultiplyIntoT(T, VectorT, VectorT) 
Multiplies a vector by a constant.

 MultiplyIntoT(MatrixT, VectorT, VectorT) 
Multiplies a vector by a matrix.

 MultiplyIntoT(VectorT, T, VectorT) 
Multiplies a vector by a constant.

 MultiplyIntoT(MatrixT, TransposeOperation, VectorT, VectorT) 
Multiplies a vector by a matrix.

 Negate(Vector) 
Negates a vector.

 NegateT(VectorT) 
Negates a vector.

 NegateInto(Vector, Vector) 
Negates a vector.

 NegateIntoT(VectorT, VectorT) 
Negates a vector.

 Not 
Computes the logical negation of a boolean vector.

 NotEqualToT(T, VectorT) 
Checks if the elements of one vector are not equal to a constant.

 NotEqualToT(VectorT, VectorT) 
Checks if the elements of one vector are not equal to the corresponding elements
of another vector.

 NotEqualToT(VectorT, T) 
Checks if the elements of one vector are not equal to a constant.

 NotEqualToT(VectorT, VectorT, VectorBoolean) 
Checks if the elements of one vector are not equal to the corresponding elements
of another vector.

 NotEqualToIntoT(T, VectorT, VectorBoolean) 
Checks if the elements of one vector are not equal to a constant.

 NotEqualToIntoT(VectorT, T, VectorBoolean) 
Checks if the elements of one vector are not equal to a constant.

 Or 
Computes the logical disjunction of two boolean vectors.

 Permute(Vector, Permutation) 
Permutes a vector.

 PermuteT(VectorT, Permutation) 
Permutes a vector.

 Pow(Vector, Double) 
Returns a vector whose components are the components of another vector raised to the specified power.

 Pow(Vector, Int32) 
Returns a vector whose components are the components of another vector raised to the specified power.

 Product(Vector) 
Returns the product of the components of a vector.

 ProductT(VectorT) 
Returns the product of the components of a vector.

 Project(Vector, Vector) 
Returns the projection of one vector onto another.

 ProjectT(VectorT, VectorT) 
Returns the projection of one vector onto another.

 Reciprocal(Vector) 
Returns a vector whose components are the inverses (reciprocals) of the components of another vector.

 ReciprocalT(VectorT) 
Returns a vector whose elements are the inverses (reciprocals) of the components of another vector.

 ReciprocalIntoT 
Computes the inverses (reciprocals) of the elements of a vector.

 Round(Vector, MidpointRounding) 
Returns a vector whose components are the components of another vector
rounded to the nearest integer.

 RoundT(VectorT, MidpointRounding) 
Returns a vector whose elements are the components of another vector
rounded to the nearest integer.

 Sin(Vector) 
Returns a vector whose components are the sines of the components of another vector.

 SinT(VectorT) 
Computes the sine of the elements of a vector.

 Sinh(Vector) 
Returns a vector whose components are the hyperbolic sines of the components of another vector.

 SinhT(VectorT) 
Computes the hyperbolic sine of the elements of a vector.

 SinhIntoT 
Computes the hyperbolic sine of the elements of a vector.

 SinIntoT 
Computes the sine of the elements of a vector.

 SortT(VectorT) 
Sorts a vector in ascending order.

 SortT(VectorT, SortOrder) 
Sorts a vector in the specified order.

 SortT(VectorT, SortOrder, Permutation) 
Sorts a vector in the specified order and also returns the sorting permutation.

 SplitByT 
Splits a vector according to the specified grouping.

 Sqrt(Vector) 
Returns a vector whose components are the square roots of the components of another vector.

 SqrtT(VectorT) 
Computes the square root of the elements of a vector.

 SqrtIntoT 
Computes the square root of the elements of a vector.

 SquaredDifferenceT 
Returns the norm of the difference of two vectors.

 SquaredEuclideanDistanceT 
Returns the square of the Euclidean distance between two vectors.

 SquaredEuclidianDistance 
Returns the square of the Euclidian distance between two vectors.

 Subtract(Double, Vector) 
Subtracts a vector from a constant.

 Subtract(Vector, Vector) 
Subtracts two vector values.

 Subtract(Vector, Double) 
Subtracts a constant from a vector.

 SubtractT(T, VectorT) 
Subtracts a vector from a constant.

 SubtractT(VectorT, VectorT) 
Subtracts two vectors.

 SubtractT(VectorT, T) 
Subtracts a constant from a vector.

 SubtractInto(Double, Vector, Vector) 
Subtracts two vector values.

 SubtractInto(Vector, Vector, Vector) 
Subtracts two vector values.

 SubtractInto(Vector, Double, Vector) 
Subtracts two vector values.

 SubtractIntoT(T, VectorT, VectorT) 
Subtracts a vector from a constant.

 SubtractIntoT(VectorT, VectorT, VectorT) 
Subtracts one vector from another.

 SubtractIntoT(VectorT, T, VectorT) 
Subtracts two vectors.

 Sum(Vector) 
Returns the sum of the components of a vector.

 SumT(VectorT) 
Returns the sum of the components of a vector.

 Swap(Vector, Vector) 
Swaps the elements of two vectors.

 SwapT(VectorT, VectorT) 
Swaps the elements of two vectors.

 Tan(Vector) 
Returns a vector whose components are the tangents of the components of another vector.

 TanT(VectorT) 
Computes the tangent of the elements of a vector.

 Tanh(Vector) 
Returns a vector whose components are the hyperbolic tangents of the components of another vector.

 TanhT(VectorT) 
Computes the hyperbolic tangent of the elements of a vector.

 TanhIntoT 
Computes the hyperbolic tangent of the elements of a vector.

 TanIntoT 
Computes the tangent of the elements of a vector.

 Xor 
Computes the exclusive disjunction of two boolean vectors.
