 Name  Description 

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

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

 AbsoluteMaxT(VectorComplexT) 
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.

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

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

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

 AbsoluteMinT(VectorComplexT) 
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.

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

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

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

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

 AddT(VectorT, VectorT) 
Adds two vectors.

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

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

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

 AddIntoT(T, VectorT, 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.

 AlignT, U(VectorT, VectorU) 
Aligns two vectors along their indexes using the default join type.

 AlignT, U(VectorT, VectorU, JoinType) 
Aligns two vectors along their indexes.

 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.

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

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

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

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

 BrayCurtisDistanceT 
Returns the BrayCurtis distance between two vectors.

 CanberraDistanceT 
Returns the Canberra distance between two vectors.

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

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

 ConjugateT 
Returns the conjugate of a vector.

 ConjugateIntoT 
Conjugates the elements of a vector.

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

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

 CorrelationDistanceT 
Returns a distance that is a function of the correlation between two vectors.

 CosT 
Computes the cosine of the elements of a vector.

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

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

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

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

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

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

 CreateT(T, Boolean, ArrayMutability) 
Constructs a new dense 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(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.

 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.

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

 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.

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

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

 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.

 CreateSparseUnitVectorT 
Constructs a new sparse vector of the specified length.

 CrossProductT 
Returns the cross product of two 3D vectors.

 DifferenceT 
Computes the forward or backward difference of a vector.

 DifferenceIntoT 
Computes the forward or backward difference of a vector.

 DivideT 
Divides a vector by a constant.

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

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

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

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

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

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

 ElementwiseMultiplyIntoT 
Multiplies a vector elementwise by another vector.

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

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

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

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

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

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

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

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

 EqualToT(VectorT, T) 
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(T, VectorT) 
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, T, 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.

 EuclideanDistanceT 
Returns the classic Euclidean distance between two vectors.

 ExpT 
Computes the exponential of the elements of a vector.

 ExpIntoT 
Computes the exponential of the elements of a vector.

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

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

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

 GreaterThanT(VectorT, T) 
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(T, VectorT) 
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, T, 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.

 GreaterThanOrEqualToT(VectorT, T) 
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(T, VectorT) 
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, T, 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.

 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.

 InverseFourierTransformT 
Returns the inverse Fourier transform of a vector.

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

 JoinT(VectorT, VectorT) 
Joins two vectors.

 LessThanT(VectorT, T) 
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(T, VectorT) 
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, T, 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.

 LessThanOrEqualToT(VectorT, T) 
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(T, VectorT) 
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, T, 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.

 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.

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

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

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

 MaxT(VectorT, T) 
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(T, VectorT) 
Returns a vector whose elements are the maximum of the components of a vector
and a real number.

 MaximumDistanceT 
Returns the largest distance between two vectors.

 MaxIndexT 
Returns the index of the largest component of a vector.

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

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

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

 MinT(VectorT, T) 
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(T, VectorT) 
Returns a vector whose elements are the minimum of the components of a vector
and a real number.

 MinIndexT 
Returns the index of the smallest component of a vector.

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

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

 MinkowskiMeasureT 
Returns the Minkowski distance between two vectors.

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

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

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

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

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

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

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

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

 NegateT 
Negates a vector.

 NegateIntoT 
Negates a vector.

 Not 
Computes the logical negation of a boolean vector.

 NotEqualToT(VectorT, T) 
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(T, VectorT) 
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.

 PermuteT 
Permutes a vector.

 ProductT 
Returns the product of the components of a vector.

 ProjectT 
Returns the projection of one vector onto another.

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

 RoundT 
Returns a vector whose elements are the components of another vector
rounded to the nearest integer.

 SinT 
Computes the sine of the elements of a vector.

 SinhT 
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(VectorT, IGrouping) 
Splits a vector according to the specified grouping.

 SplitByT(VectorT, ICategoricalVector) 
Splits a vector according to the specified grouping.

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

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

 SubtractT(VectorT, VectorT) 
Subtracts two vectors.

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

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

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

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

 SumT 
Returns the sum of the components of a vector.

 SwapT 
Swaps the elements of two vectors.

 TanT 
Computes the tangent of the elements of a vector.

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