Vector<T> Class

Represents a vector, a one-dimensional array of real numbers.

Definition

Namespace: Numerics.NET
Assembly: Numerics.NET (in Numerics.NET.dll) Version: 9.0.3

public abstract class Vector<T> : IEnumerable, 
	IFormattable, IList<T>, ICollection<T>, IEnumerable<T>, IEquatable<Vector<T>>, 
	ISummarizable, IVector, IDataFrame, ICloneable, ISerializable, 
	IStructuralEquatable, IStructuralComparable

Visual Basic

Public MustInherit Class Vector(Of T)
	Implements IEnumerable, IFormattable, IList(Of T), 
	ICollection(Of T), IEnumerable(Of T), IEquatable(Of Vector(Of T)), 
	ISummarizable, IVector, IDataFrame, ICloneable, ISerializable, 
	IStructuralEquatable, IStructuralComparable

C++/CLI

generic<typename T>
public ref class Vector abstract : IEnumerable, 
	IFormattable, IList<T>, ICollection<T>, IEnumerable<T>, IEquatable<Vector<T>^>, 
	ISummarizable, IVector, IDataFrame, ICloneable, ISerializable, 
	IStructuralEquatable, IStructuralComparable

[<AbstractClassAttribute>]
type Vector<'T> = 
    class
        interface IEnumerable
        interface IFormattable
        interface IList<'T>
        interface ICollection<'T>
        interface IEnumerable<'T>
        interface IEquatable<Vector<'T>>
        interface ISummarizable
        interface IVector
        interface IDataFrame
        interface ICloneable
        interface ISerializable
        interface IStructuralEquatable
        interface IStructuralComparable
    end

Inheritance: Object → Vector<T>

Derived: Numerics.NET.CategoricalVector<T>
Numerics.NET.Distributed.DistributedVector<T>
Numerics.NET.LinearAlgebra.BlockVector<T>
Numerics.NET.LinearAlgebra.ComposedComplexVector<T>
Numerics.NET.LinearAlgebra.ConstantVector<T>
Numerics.NET.LinearAlgebra.DenseVector<T>
Numerics.NET.LinearAlgebra.IndexedVector<T>
Numerics.NET.LinearAlgebra.SparseVector<T>
Numerics.NET.SignalProcessing.ComplexConjugateSignalVector<T>
More Less

Implements: IDataFrame, ISummarizable, IVector, ICollection<T>, IEnumerable<T>, IList<T>, IEnumerable, IStructuralComparable, IStructuralEquatable, ICloneable, IEquatable<Vector<T>>, IFormattable, ISerializable

Type Parameters

T

Remarks

A vector class represents a one-dimensional array of T precision floating-point numbers.

A vector class provides methods and properties for all the common operations on vectors, including norms, dot products, as well as retrieving extreme values from a vector.

Overloaded versions of the major arithmetic operators are provided for languages that support them. For languages that don't support operator overloading, equivalent static methods are supplied.

To allow for greater efficiency, overloaded instance methods are available for many compound operations on vectors.

Constructors

Vector<T>(Int32, ArrayAttributes)	Constructs a new vector with the specified number of elements.
Vector<T>(SerializationInfo, StreamingContext)	Constructs a new vector from serialization values.

Properties

Attributes	Gets attributes associated with the vector.
CanReshape	Gets whether the vector can be reshaped into a matrix.
Count	Gets the number of items that are not missing. Preliminary
ElementType	Gets the element type of the vector.
FormatString	Gets or sets the format to use for each element when creating a string representation of the vector.
Index	Gets or sets the index of labels for the vector. Preliminary
IsImmutable	Gets whether the vector's elements are immutable.
IsReadOnly	Gets whether the vector can be written to.
IsSparse	Gets a value that indicates whether the vector is sparse.
Item[Func<T, Boolean>]	Gets or sets the elements of a vector that match the specified condition.
Item[IEnumerable<Int32>]	Gets or sets the elements of the vector with the specified indexes.
Item[Index]	Gets or sets a specific element of this vector.
Item[Int32]	Gets or sets a specific element of this vector.
Item[Range]	Gets or sets a range of elements of the vector.
Item[Range]	Gets or sets a range of elements of the vector.
Item[Vector<Boolean>]	Gets or sets the elements of a vector that match the specified condition.
Length	Gets the number of elements in the vector.
MayHaveMissingValues	Gets or sets whether the vector may contain missing values that require special handling in calculations.
MissingValue	Gets or sets the value that is used to represent missing values.
MissingValueRepresentation	Gets how missing values are represented in the vector.
Name	Gets or sets the name of the vector.
NonzeroCount	Gets the number of nonzero elements in the vector.
NonzeroElements	Gets a collection of IndexValuePair<T> objects representing the nonzero elements of this instance.
Precedence	Infrastructure. This property supports the Numerics.NET infrastructure and is not intended to be used directly from your code.

Methods

AbsCore	Computes the absolute values of the elements of a vector.
AbsInPlace	Computes the absolute values of the elements of a vector in-place.
AbsoluteMaxIndex	Returns the index of the element in this vector that has the largest absolute value.
AbsoluteMinIndex	Returns the index of the element in this vector that has the smallest absolute value.
Accumulate<TAccumulator>(TAccumulator)	Adds the elements of the vector to the specified accumulator.
Accumulate<TAccumulator>(TAccumulator, Int32, Int32)	Adds the elements of the vector to the specified accumulator.
AccumulateWhere<TAccumulator, TPredicate>(TAccumulator, TPredicate)	Adds the elements of the vector that match a predicate to the specified accumulator.
AccumulateWhere<TAccumulator, TPredicate>(TAccumulator, TPredicate, Int32, Int32)	Adds the elements of the vector that match a predicate to the specified accumulator.
AcosCore	Computes the inverse cosine of the elements of a vector.
AcoshCore	Computes the inverse hyperbolic cosine of the elements of a vector.
AcoshInPlace	Computes the inverse hyperbolic cosine of the elements of a vector in-place.
AcosInPlace	Computes the inverse cosine of the elements of a vector in-place.
Add(T, Vector<T>)	Adds a vector and a constant.
Add(Vector<T>, T)	Adds a vector and a constant.
AddCore(T, Vector<T>)	Adds a constant to a vector in-place.
AddCore(Vector<T>, Vector<T>)	Adds two vectors.
AddInPlace(T)	Adds a constant to a vector.
AddInPlace(Vector<T>)	Adds another vector to this vector in-place.
AddInto	Adds a vector and a constant.
AddProductInPlace(LinearOperator<T>, Vector<T>)	Adds the product of a matrix and a Vector<T> to this Vector<T>.
AddProductInPlace(LinearOperator<T>, TransposeOperation, Vector<T>)	Adds the product of a matrix and a Vector<T> to this Vector<T>.
AddScaledAsLeftCore	Adds two vectors.
AddScaledAsRightCore	Adds two vectors.
AddScaledInPlace	Adds a scaled vector to this vector.
AddScaledProductInPlace(T, LinearOperator<T>, Vector<T>)	Adds the scaled product of a matrix and a Vector<T> to this Vector<T>.
AddScaledProductInPlace(T, LinearOperator<T>, TransposeOperation, Vector<T>)	Adds the scaled product of a matrix and a vector in-place to a vector.
Aggregate(TypePreservingAggregatorGroup)	Applies the specified aggregator to the vector.
Aggregate(TypePreservingAggregatorGroup, Boolean)	Applies the specified aggregator to the vector.
Aggregate<TResult>(AggregatorGroup<TResult>)	Applies the specified aggregator to the vector.
Aggregate<TResult>(Aggregator<T, TResult>, Nullable<Boolean>)	Applies the specified aggregator to the vector.
Aggregate<TResult>(AggregatorGroup<TResult>, Boolean)	Applies the specified aggregator to the vector.
AggregateBy(IGrouping, TypePreservingAggregatorGroup)	Returns a new vector that aggregates the columns according to the specified grouping.
AggregateBy<U>(IGrouping, Aggregator<T, U>)	Aggregates the vector according to the specified grouping.
AggregateBy<U>(IGrouping, AggregatorGroup<U>)	Returns a new vector that aggregates the columns according to the specified grouping.
AggregateBy<U>(IPivot, Aggregator<T, U>)	Returns a new matrix that aggregates the elements according to the specified pivot grouping.
AggregateBy<U>(IPivot, AggregatorGroup<U>)	Returns a new matrix that aggregates the elements according to the specified pivot grouping.
All	Returns whether all the elements of the vector satisfy a condition.
Angle	Returns the angle between two vectors.
Any	Returns whether any of the elements of the vector satisfy a condition.
AsCategorical(Index<T>)	Returns a categorical vector containing the same data as this vector.
AsCategorical(SortOrder)	Returns a categorical vector containing the same data as this vector.
AsDenseVector()	Returns this vector as a dense vector.
AsDenseVector<TStorage>()	Returns this vector as a dense vector.
AsinCore	Computes the inverse sine of the elements of a vector.
AsIndex	Converts a vector to an index. Preliminary
AsinhCore	Computes the inverse hyperbolic sine of the elements of a vector.
AsinhInPlace	Computes the inverse hyperbolic sine of the elements of a vector in-place.
AsinInPlace	Computes the inverse sine of the elements of a vector in-place.
Atan2AsXCore	Computes the four-quadrant inverse tangent of the corresponding elements of two matrices.
Atan2AsYCore	Computes the four-quadrant inverse tangent of the elements of a vector.
AtanCore	Computes the inverse tangent of the elements of a vector.
AtanhCore	Computes the inverse hyperbolic tangent of the elements of a vector.
AtanhInPlace	Computes the inverse hyperbolic tangent of the elements of a vector in-place.
AtanInPlace	Computes the inverse tangent of the elements of a vector in-place.
Broadcast	Broadcasts the elements of the vector along the specified dimension.
BroadcastInto	Broadcasts the elements of the vector along the specified dimension.
By<K>	Enables accessing elements of an indexed vector using strongly typed indexes.
Cast<U>	Casts the elements of the vector to the specified type.
CastInto<U>	Casts the elements of the vector to the specified type.
CeilingCore	Computes the smallest integers greater than the elements of a vector.
CeilingInPlace	Computes the smallest integers greater than the elements of a vector in-place.
Clip	Returns a vector whose elements are the components of a vector constrained to be within the specified interval.
Clone()	Makes a copy of this vector.
Clone(CloningMethod)	Makes a copy of this vector using the specified method.
CloneData	If possible, gives this instance its own copy of its elements.
Conjugate()	Conjugates the elements of a vector and returns the result.
Conjugate(Vector<T>)	Returns the conjugate of a vector.
ConjugateCore	Conjugates the elements of a vector.
ConjugateDotProduct	Returns the dot product of this vector with another vector.
ConjugateInPlace	Conjugates all elements of a vector in-place.
CopyTo(ArraySlice<T>)	Copies the elements of this vector to an array.
CopyTo(IVector)	Copies the elements of this vector to an untyped vector.
CopyTo(Span<T>)	Copies the elements of this vector to a span.
CopyTo(SpanSlice<T>)	Copies the elements of this vector to a span slice.
CopyTo(T[])	Copies the elements of this vector to an array.
CopyTo(Vector<T>)	Copies the elements of this vector to another vector.
CopyTo(T[], Int32)	Copies the elements of this vector to an array.
CopyTo(Vector<T>, Int32)	Copies the elements of this vector to another vector starting at the specified position.
CopyToOrClone	Copies the elements of this vector to another vector, if it exists; otherwise clones the vector using the specified method.
CosCore	Computes the cosine of the elements of a vector.
CoshCore	Computes the hyperbolic cosine of the elements of a vector.
CoshInPlace	Computes the hyperbolic cosine of the elements of a vector in-place.
CosInPlace	Computes the cosine of the elements of a vector in-place.
CrossProduct	Returns the cross product of two 3D vectors.
CumulativeProduct	Gets the product of the elements of the vector.
CumulativeProductInPlace	Gets the product of the elements of the vector.
CumulativeProductInto	Gets the product of the elements of the vector.
CumulativeSum	Gets the sum of the elements of the vector.
CumulativeSumInPlace	Gets the sum of the elements of the vector.
CumulativeSumInto	Gets the cumulative sum of the elements of the vector.
DifferenceCore	Computes the forward or backward difference of a vector.
Dispose()	Releases unmanaged resources.
Dispose(Boolean)	Releases unmanaged resources.
Divide	Divides a vector by a constant.
DivideInPlace	Divides a vector in-place by a constant.
DotProduct	Returns the dot product of this vector with another vector.
ElementwiseConjugateMultiplyAsLeftCore	Multiplies two vectors element-wise.
ElementwiseConjugateMultiplyAsRightCore	Multiplies two vectors element-wise.
ElementwiseDivideAsLeftCore	Divides two vectors element-wise.
ElementwiseDivideAsRightCore	Divides two vectors element-wise.
ElementwiseDivideInPlace	Divides this vector in-place element-wise by another vector.
ElementwiseMultiplyCore	Multiplies two vectors element-wise.
ElementwiseMultiplyInPlace	Multiplies this vector in-place element-wise by another vector.
ElementwisePowAsLeftCore(Vector<T>, Vector<T>)	Raises the elements of a vector to a power from the corresponding elements in another vector.
ElementwisePowAsLeftCore(Vector<Int32>, Vector<T>)	Raises the elements of a vector to a power from the corresponding elements in another vector.
ElementwisePowAsRightCore	Raises two vectors element-wise.
ElementwisePowCore(Int32, Vector<T>)	Raises the element of a vector to a constant power.
ElementwisePowCore(T, Vector<T>)	Raises the element of a vector to a constant power.
ElementwisePowInPlace(Int32)	Raises the elements of a vector in-place to a constant power.
ElementwisePowInPlace(T)	Raises the elements of a vector in-place to a constant power.
ElementwisePowInPlace(Vector<T>)	Raises this vector in-place element-wise by another vector.
ElementwisePowInPlace(Vector<Int32>)	Raises this vector in-place element-wise by another vector.
EnsureWritable()	Ensures that every element in the vector can be written to.
EnsureWritable(Int32)	Ensures that the element at the specified index in the vector can be written to.
EnsureWritable(Range)	Ensures that the element at the specified index in the vector can be written to.
EnsureWritable(Int32, Int32)	Ensures that the element at the specified index in the vector can be written to.
Equals(Object)	Determines whether the specified Object is equal to the current Vector<T>. (Overrides Object.Equals(Object))
Equals(Vector<T>)	Determines whether the specified Vector<T> is equal to the current Vector<T>.
Equals(Object, IEqualityComparer)	Returns whether an object is structurally equal to this instance.
EqualToCore(T, Vector<Boolean>)	Checks if the elements of one vector are equal to a constant.
EqualToCore(Vector<T>, Vector<Boolean>)	Checks if the elements of one vector are equal to the corresponding elements of another vector.
ExpCore	Computes the exponential of the elements of a vector.
ExpInPlace	Computes the exponential of the elements of a vector in-place.
Finalize	Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object)
Find	Enumerates the indexes that match a condition.
FloorCore	Computes the largest integers smaller than the elements of a vector.
FloorInPlace	Computes the largest integers smaller than the elements of a vector in-place.
Get<K>(K)	Gets the value with the specified key.
Get<K1, K2>(K1, K2)	Gets the value at the specified key.
GetEnumerator	Returns an enumerator over the elements of the vector.
GetHashCode()	Returns the hash code for this instance. (Overrides Object.GetHashCode())
GetHashCode(IEqualityComparer)	Returns a hash code for this instance.
GetMissingValueIndexMask	Gets an integer array that specifies the locations of missing values.
GetMissingValueMask	Gets a boolean array that specifies the locations of missing values.
GetNearest<K>	Gets the value in the vector whose key in the index is nearest to the specified key.
GetNearestValues<K>	Returns a vector containing the items nearest to the specified key values.
GetObjectData	Populates a SerializationInfo with the values needed to serialize the target object. Obsolete.
GetSlice(Int32)	Returns a vector whose elements are a subset of the elements of this instance
GetSlice(Range)	Returns a vector whose elements are a subset of the elements of this instance
GetSlice(Int32, Int32)	Returns a vector whose elements are a subset of the elements of this instance
GetSlice(Range, Intent)	Returns a vector whose elements are a subset of the elements of this instance
GetSlice(Slice, Intent)	Returns a vector whose elements are a subset of the elements of this instance.
GetSlice(Int32, Int32, Intent)	Returns a vector whose elements are a subset of the elements of this instance
GetSlice(Int32, Int32, Int32)	Returns a vector whose elements are a subset of the elements of this instance
GetSlice(Int32, Int32, Int32, Intent)	Returns a vector whose elements are a subset of the elements of this instance.
GetSliceCore	Returns a vector whose elements are a subset of the elements of this instance.
GetType	Gets the Type of the current instance. (Inherited from Object)
GetValue(Int32)	Gets the vector element at the specified position.
GetValue<K>(K)	Gets the value at the specified key. Preliminary
GetValues(Vector<Boolean>)	Returns the elements of a vector that match the specified condition.
GetValues(Subset, Intent)	Returns a vector that contains the specified subset of elements of the vector.
GetValues(Int32[], Boolean, Intent)	Returns a new vector that contains the elements of the vector with the specified indexes.
GetValues(ReadOnlySpan<Int32>, Boolean, Intent)	Returns a new vector that contains the elements of the vector with the specified indexes.
GetValues<K>(IEnumerable<K>)	Returns a vector containing the items at the specified key values. Preliminary
GreaterThanCore(T, Vector<Boolean>)	Checks if the elements of one vector are greater than a constant.
GreaterThanCore(Vector<T>, Vector<Boolean>)	Checks if the elements of one vector are greater than the corresponding elements of another vector.
GreaterThanOrEqualToCore(T, Vector<Boolean>)	Checks if the elements of one vector are greater than or equal to a constant.
GreaterThanOrEqualToCore(Vector<T>, Vector<Boolean>)	Checks if the elements of one vector are greater than or equal to the corresponding elements of another vector.
HypotCore	Computes the square root of the sum of the squared corresponding elements of this vector and another vector.
IsElementWritable	Gets whether the value of the element at the specified index can be changed.
IsMissing	Returns whether the value at the specified index is missing.
KeysAndValues<K>	Enumerates all keys and associated values.
LessThanCore(T, Vector<Boolean>)	Checks if the elements of one vector are less than a constant.
LessThanCore(Vector<T>, Vector<Boolean>)	Checks if the elements of one vector are greater than the corresponding elements of another vector.
LessThanOrEqualToCore(T, Vector<Boolean>)	Checks if the elements of one vector are less than or equal to a constant.
LessThanOrEqualToCore(Vector<T>, Vector<Boolean>)	Checks if the elements of one vector are greater than or equal to the corresponding elements of another vector.
LessThanOrEqualToInto	Checks if the elements of one vector are greater than or equal to the corresponding elements of another vector.
Log10Core	Computes the base 10 logarithm of the elements of a vector.
Log10InPlace	Computes the logarithm of the elements of a vector in-place.
LogCore(Vector<T>)	Computes the logarithm of the elements of a vector.
LogCore(T, Vector<T>)	Computes the logarithm of the elements of a vector.
LogInPlace()	Computes the logarithm of the elements of a vector in-place.
LogInPlace(T)	Computes the logarithm of the elements of a vector in-place.
MakeImmutable	Protects the vector from changes in values or structure.
Map<U>(Func<T, U>)	Applies a function to the elements of a vector and returns the result.
Map<U>(Func<T, U>, Vector<T>)	Applies a function to the elements of a vector and returns the result in a new vector.
Map<U, V>(Func<T, U, V>, Vector<T>, Vector<U>)	Applies a function to the corresponding elements of two vectors and returns the result in a new vector.
MapAsFirstCore<U, V>	Applies a function to the corresponding elements of two vectors.
MapAsSecondCore<U, V>	Applies a function to the corresponding elements of two vectors.
MapCore<U>(Func<T, U>, Vector<U>)	Applies a function to the elements of a vector.
MapCore<U>(Func<Int32, T, U>, Vector<U>)	Applies a function to the elements of a vector.
MapInPlace(Func<T, T>)	Applies a function in-place to the elements of a vector.
MapInPlace(Func<Int32, T, T>)	Applies a function in-place to the elements of a vector.
MapInPlace<U>(Func<U, T, T>, Vector<U>)	Applies a function in-place to the elements of a vector as the second argument.
MapInPlace<U>(Func<T, U, T>, Vector<U>)	Applies a function to the elements of a vector.
MapInto<U>(Func<T, U>, Vector<U>)	Applies a function to the elements of a vector.
MapInto<U>(Func<Int32, T, U>, Vector<U>)	Applies a function to the elements of a vector.
MapWhere<U>(Func<T, Boolean>, Func<T, U>)	Applies a function to the elements of a vector that meet a condition and returns the result.
MapWhere<U>(Func<Int32, T, Boolean>, Func<T, U>)	Applies a function to the elements of a vector that meet a condition and returns the result.
MapWhereCore<U>(Func<T, Boolean>, Func<T, U>, Vector<U>)	Applies a function to the elements of a vector.
MapWhereCore<U>(Func<Int32, T, Boolean>, Func<T, U>, Vector<U>)	Applies a function to the elements of a vector.
Max()	Returns the value of the largest element in this vector.
Max(Int32)	Returns the value of the largest element in this vector.
MaxCore(T, Vector<T>)	Returns a vector whose elements are the maximum of the components of a vector and a real number.
MaxCore(Vector<T>, Vector<T>)	Returns a vector whose elements are the maximums of the components of two vectors.
MaxIndex	Returns the index of the largest element in this vector.
MaxInPlace	Returns a vector whose elements are the maximum of the components of a vector and a real number.
MemberwiseClone	Creates a shallow copy of the current Object. (Inherited from Object)
Min()	Returns the value of the smallest element in this vector.
Min(Int32)	Returns the value of the smallest element in this vector.
MinCore(T, Vector<T>)	Returns a vector whose elements are the minimum of the components of a vector and a real number.
MinCore(Vector<T>, Vector<T>)	Returns a vector whose elements are the minimums of the components of two vectors.
MinIndex	Returns the index of the smallest element in this vector.
MinInPlace	Returns a vector whose elements are the minimum of the components of a vector and a real number.
MultiplyCore	Multiplies a vector by a constant.
MultiplyInPlace(T)	Multiplies a vector in-place by the specified factor.
MultiplyInPlace(Matrix<T>, MatrixOperationSide)	Multiplies a Vector<T> by a Matrix<T>.
NegateInPlace	Negates a vector in-place.
Norm()	Returns the two-norm of the vector.
Norm(Int32)	Returns the norm of the specified order of this vector.
Norm(T)	Returns the norm of the specified order of this vector.
Normalize	Scales the vector to make its two-norm equal to one.
NormInternal(Int32)	Returns the norm of the specified order of this vector.
NormInternal(T)	Returns the norm of the specified order of this vector.
NormSquared	Returns the square of the two-norm of this vector.
NotEqualToCore(T, Vector<Boolean>)	Checks if the elements of one vector are not equal to a constant.
NotEqualToCore(Vector<T>, Vector<Boolean>)	Checks if the elements of one vector are not equal to the corresponding elements of another vector.
OneNorm	Returns the one-norm of this vector.
PermuteInPlace(Permutation)	Permutes a vector.
PermuteInPlace(Permutation, Boolean)	Permutes a vector.
PermuteInPlace(Vector<T>, Permutation)	Permutes a vector.
Product	Gets the product of the elements of the vector.
Project	Returns the projection of one vector onto another.
Protect	Returns a read-only copy of the vector.
ProtectInPlace	Protects the vector from changes in values or structure.
ReciprocalCore	Computes the inverses (reciprocals) of the elements of a vector.
ReciprocalInPlace	Computes the inverses (reciprocals) of the elements of a vector in-place.
RemoveMissingValues	Removes all the missing values from a vector and returns the result.
ReplaceMissingValues(T)	Replaces all missing values in the vector with the specified value.
ReplaceMissingValues(Vector<T>)	Replaces all missing values in the vector with the corresponding element in another vector.
ReplaceMissingValues(Direction, Int32)	Replaces all missing values in a vector with the specified value.
ReplaceMissingValuesInPlace(T)	Replaces all missing values in the vector with the specified value in-place.
ReplaceMissingValuesInPlace(Vector<T>)	Replaces all missing values in the vector with the corresponding element in another vector in-place.
ReplaceMissingValuesInPlace(Direction, Int32)	Replaces all missing values in a vector with the specified value in-place.
ReplaceMissingValuesInto(T, Vector<T>)	Replaces all missing values in a vector with the specified value.
ReplaceMissingValuesInto(Vector<T>, Vector<T>)	Replaces all missing values in the vector with the corresponding element in another vector.
ReplaceMissingValuesInto(Direction, Vector<T>, Int32)	Replaces all missing values in a vector with the previous or next non-missing value.
ReplaceValue	Replaces every occurrence of a value with a new value.
ReplaceValueInPlace	Replaces every occurrence of a value with a new value.
ReplaceValueInto	Replaces every occurrence of a value with a new value.
Resample(Recurrence, Direction, TypePreservingAggregatorGroup)	Returns a new vector that resamples the values in the vector using the specified recurrence pattern and aggregator.
Resample<R>(Index<R>, Direction, TypePreservingAggregatorGroup)	Returns a new vector that resamples the values in the vector using the specified index and aggregator.
Resample<U>(Recurrence, Direction, AggregatorGroup<U>)	Returns a new vector that resamples the values in the vector using the specified recurrence pattern and aggregator.
Resample<R, U>(Index<R>, Direction, AggregatorGroup<U>)	Returns a new vector that resamples the values in the vector using the specified index and aggregator.
Reshape	Returns a matrix that contains the vector elements columnwise.
SetMissing	Declares that the value at the specified index is missing.
SetToZero	Sets all the elements of the vector to 0.
SetValue(T)	Sets all the elements of the vector to the specified value.
SetValue(T, Int32)	Sets the vector element at the specified position to the specified value.
SetValue<K>(T, K)	Sets the value at the specified key value. Preliminary
SetValues(T, Range)	Sets a range of elements of the vector to the specified value.
SetValues(T, Vector<Boolean>)	Sets the elements of a vector that match the specified condition to the specified value.
SetValues(T, Func<T, Boolean>)	Sets all the elements that meet a condition to the specified value.
SetValues(Vector<T>, Vector<Boolean>)	Sets the elements of a vector that match the specified condition.
ShallowCopy	Makes a shallow copy of this vector.
SinCore	Computes the sine of the elements of a vector.
SinhCore	Computes the hyperbolic sine of the elements of a vector.
SinhInPlace	Computes the hyperbolic sine of the elements of a vector in-place.
SinInPlace	Computes the sine of the elements of a vector in-place.
SortInPlace()	Sorts the vector in ascending order.
SortInPlace(SortOrder)	Sorts the vector in the specified order.
SortInPlace(SortOrder, Permutation)	Sorts the vector in the specified order.
SqrtCore	Computes the square root of the elements of a vector.
SqrtInPlace	Computes the square root of the elements of a vector in-place.
SubtractAsLeftCore(T, Vector<T>)	Subtracts a constant from a vector.
SubtractAsLeftCore(Vector<T>, Vector<T>)	Subtracts one vector from another.
SubtractAsRightCore(T, Vector<T>)	Subtracts a vector from a constant.
SubtractAsRightCore(Vector<T>, Vector<T>)	Subtracts one vector from another.
SubtractInPlace(T)	Subtracts a constant value from the elements of this vector in-place.
SubtractInPlace(Vector<T>)	Subtracts another vector from this vector in-place.
SubtractProductInPlace	Subtracts the product of a matrix and a Vector<T> from this Vector<T>.
Sum	Gets the sum of the elements of the vector.
Summarize()	Returns a summary of the contents of the matrix using the default summary options.
Summarize(SummaryOptions)	Returns a summary of the contents of the matrix using the specified options.
SwapElements	Exchanges two elements of the vector.
TanCore	Computes the tangent of the elements of a vector.
TanhCore	Computes the hyperbolic tangent of the elements of a vector.
TanhInPlace	Computes the hyperbolic tangent of the elements of a vector in-place.
TanInPlace	Computes the tangent of the elements of a vector in-place.
ToArray	Gets the elements of the vector.
ToColumnMatrix	Creates a matrix with the vector as its only column..
ToDataFrame<C>(C)	Returns a data frame with the current vector as its only column.
ToDataFrame<R, C>(Index<R>, C)	Returns a data frame with the current vector as its only column.
ToDenseVector()	Makes a copy of this instance and returns it as a dense vector.
ToDenseVector<TStorage>()	Makes a copy of this instance and returns it as a dense vector.
Top	Returns a vector containing the specified number of elements from the top of the sorted vector.
ToRowMatrix	Creates a matrix with the vector as its only column..
ToSparseVector	Creates a copy of the vector as a SparseVector<T>.
ToString()	Returns a string that represents the current object. (Overrides Object.ToString())
ToString(String)	Converts the numeric value of this vector instance to its equivalent string representation, using the specified format.
ToString(String, IFormatProvider)	Returns a String representation of this vector.
ToStringInternal	Writes a string representation of this Vector<T> to an instance of StringBuilder using the specified number format.
TryAggregate<TResult>(Aggregator<T, TResult>, TResult)	Applies the specified aggregator to the vector.
TryAggregate<TResult>(Aggregator<T, TResult>, Nullable<Boolean>, TResult)	Applies the specified aggregator to the vector.
TryAggregate<TResult, TPredicate>(Aggregator<T, TResult>, TPredicate, Nullable<Boolean>, TResult)	Applies the specified aggregator to the vector.
TryCast<U>	Attempts to convert the elements of the vector to the specified type.
TryEnsureWritable()	Ensures that every element in the vector can be written to.
TryEnsureWritable(Int32)	Ensures that the element at the specified index in the vector can be written to.
TryEnsureWritable(Int32, Int32)	Ensures that the element at the specified index in the vector can be written to.
TryGet<K>	Attempts to get the value with the specified key.
Unstack<R, C>	Returns a data frame that contains the values in the vector arranged according to the levels in a hierarchical index.
WeightedNorm	Returns the weighted two-norm of the vector.
WeightedNormSquared	Returns the square of the weighted two-norm of the vector.
Window<U>(Int32, AggregatorGroup<U>)	Returns a new vector that aggregates the values in a sliding window of the specified size.
Window<U>(Int32, Int32, Boolean, AggregatorGroup<U>)	Returns a new vector that aggregates the values in a sliding window of the specified size.
WithName<C>	Sets the name of a vector to the specified value.

Operators

Addition(T, Vector<T>)	Adds a vector and a constant.
Addition(Vector<T>, T)	Adds a vector and a constant.
Addition(Vector<T>, Vector<T>)	Adds two vectors.
AdditionAssignment(Vector<T>, T)	Defines the compound addition assignment operator for a vector and a scalar in F#.
AdditionAssignment(Vector<T>, Vector<T>)	Defines the compound addition assignment operator for vectors in F#.
Division(Vector<T>, T)	Divides a vector by a constant.
DivisionAssignment(Vector<T>, T)	Defines the compound division assignment operator for a vector and a scalar in F#.
DotDivide(Vector<T>, Vector<T>)	Defines the element-wise division operator for vectors in F#.
DotDivideAssignment(Vector<T>, Vector<T>)	Defines the element-wise division compound assignment operator for vectors in F#.
DotEquals(T, Vector<T>)	Checks if the elements of one vector are equal to a constant.
DotEquals(Vector<T>, T)	Checks if the elements of one vector are equal to a constant.
DotEquals(Vector<T>, Vector<T>)	Checks if the elements of one vector are equal to the corresponding elements of another vector.
DotGreater(T, Vector<T>)	Checks if the elements of one vector are greater than a constant.
DotGreater(Vector<T>, T)	Checks if the elements of one vector are greater than a constant.
DotGreater(Vector<T>, Vector<T>)	Checks if the elements of one vector are greater than the corresponding elements of another vector.
DotGreaterEquals(T, Vector<T>)	Checks if the elements of one vector are greater than or equal to a constant.
DotGreaterEquals(Vector<T>, T)	Checks if the elements of one vector are greater than or equal to a constant.
DotGreaterEquals(Vector<T>, Vector<T>)	Checks if the elements of one vector are greater than or equal to the corresponding elements of another vector.
DotLess(T, Vector<T>)	Checks if the elements of one vector are less than a constant.
DotLess(Vector<T>, T)	Checks if the elements of one vector are less than a constant.
DotLess(Vector<T>, Vector<T>)	Checks if the elements of one vector are less than the corresponding elements of another vector.
DotLessEquals(T, Vector<T>)	Checks if the elements of one vector are less than or equal to a constant.
DotLessEquals(Vector<T>, T)	Checks if the elements of one vector are less than or equal to a constant.
DotLessEquals(Vector<T>, Vector<T>)	Checks if the elements of one vector are less than or equal to the corresponding elements of another vector.
DotLessGreater(T, Vector<T>)	Checks if the elements of one vector are not equal to a constant.
DotLessGreater(Vector<T>, T)	Checks if the elements of one vector are not equal to a constant.
DotLessGreater(Vector<T>, Vector<T>)	Checks if the elements of one vector are not equal to the corresponding elements of another vector.
DotMultiply(Vector<T>, Vector<T>)	Defines the element-wise multiplication operator for vectors in F#.
DotMultiplyAssignment(Vector<T>, Vector<T>)	Defines the element-wise multiplication compound assignment operator for vectors in F#.
DotMultiplyMultiply(Vector<T>, T)	Defines the element-wise exponentiation operator for matrices in F#.
DotMultiplyMultiply(Vector<T>, Vector<T>)	Defines the componentwise exponentiation operator for matrices in F#.
DotMultiplyMultiply(Vector<T>, Vector<Int32>)	Defines the componentwise exponentiation operator for matrices in F#.
DotMultiplyMultiply(Vector<T>, Int32)	Defines the componentwise exponentiation operator for matrices in F#.
Equality(Vector<T>, Vector<T>)	Returns whether two instances of vector are equal.
Implicit(T[] to Vector<T>)	Implicitly converts an array of T to a Vector<T>.
Inequality(Vector<T>, Vector<T>)	Returns whether two instances of vector are not equal.
Multiply(T, Vector<T>)	Multiplies a vector by a constant.
Multiply(Vector<T>, T)	Multiplies a vector by a constant.
MultiplyAssignment(Vector<T>, T)	Defines the compound multiplication assignment operator for a vector and a scalar in F#.
Subtraction(T, Vector<T>)	Subtracts a vector from a constant.
Subtraction(Vector<T>, T)	Subtracts a constant from a vector.
Subtraction(Vector<T>, Vector<T>)	Subtracts two vectors.
SubtractionAssignment(Vector<T>, T)	Defines the compound subtraction assignment operator for a vector and a scalar in F#.
SubtractionAssignment(Vector<T>, Vector<T>)	Defines the compound subtraction assignment operator for vectors in F#.
UnaryNegation(Vector<T>)	Negates a vector.

Extension Methods

Abs<T>	Returns a vector whose elements are the absolute values of the components of another vector. (Defined by Vector)
AbsInto<T>	Computes the absolute values of the elements of a vector. (Defined by Vector)
AbsoluteMax<T>	Returns the value of the element in this vector that has the largest absolute value. (Defined by Vector)
AbsoluteMax<T>	Returns the value of the element in this vector that has the largest absolute value. (Defined by Vector)
AbsoluteMin<T>	Returns the value of the element in this vector that has the smallest absolute value. (Defined by Vector)
AbsoluteMin<T>	Returns the value of the element in this vector that has the smallest absolute value. (Defined by Vector)
Acos<T>	Computes the inverse cosine of the elements of a vector. (Defined by Vector)
Acosh<T>	Computes the inverse hyperbolic cosine of the elements of a vector. (Defined by Vector)
AcoshInto<T>	Computes the inverse hyperbolic cosine of the elements of a vector. (Defined by Vector)
AcosInto<T>	Computes the inverse cosine of the elements of a vector. (Defined by Vector)
AddInto<T>	Adds two vectors. (Defined by Vector)
AddProduct<T>	Adds the product of a matrix and a vector to a vector. (Defined by Vector)
AddProduct<T>	Adds the product of a matrix and a vector to a vector. (Defined by Vector)
AddProductInto<T>	Adds the scaled product of a matrix and a vector to a vector. (Defined by Vector)
AddScaledInto<T>	Adds two vectors. (Defined by Vector)
AddScaledProduct<T>	Adds the scaled product of a matrix and a vector to a vector. (Defined by Vector)
AddScaledProduct<T>	Adds the scaled product of a matrix and a vector to a vector. (Defined by Vector)
AddScaledProductInto<T>	Adds the scaled product of a matrix and a vector to a vector. (Defined by Vector)
Aggregate<T>	Applies an accumulator function over the elements of a vector. (Defined by LinqExtensions)
Aggregate<T, TAccumulate>	Applies an accumulator function over the elements of a vector. (Defined by LinqExtensions)
Aggregate<T, TAccumulate, TResult>	Aggregates the elements of a vector using the specified accumulator and seed value. (Defined by LinqExtensions)
All<T>	Returns whether all values in a vector satisfy the specified predicate. (Defined by Vector)
Angle<T>	Returns the angle between two vectors. (Defined by Vector)
Any<T>	Returns whether at least one value in a vector satisfies a predicate. (Defined by Vector)
Asin<T>	Computes the inverse sine of the elements of a vector. (Defined by Vector)
Asinh<T>	Computes the inverse hyperbolic sine of the elements of a vector. (Defined by Vector)
AsinhInto<T>	Computes the inverse hyperbolic sine of the elements of a vector. (Defined by Vector)
AsinInto<T>	Computes the inverse sine of the elements of a vector. (Defined by Vector)
Atan<T>	Computes the inverse tangent of the elements of a vector. (Defined by Vector)
Atan2<T>	Computes the four-quadrant inverse tangent of the corresponding elements of two matrices. (Defined by Vector)
Atan2Into<T>	Computes the four-quadrant inverse tangent of the corresponding elements of two matrices. (Defined by Vector)
Atanh<T>	Computes the inverse hyperbolic tangent of the elements of a vector. (Defined by Vector)
AtanhInto<T>	Computes the inverse hyperbolic tangent of the elements of a vector. (Defined by Vector)
AtanInto<T>	Computes the inverse tangent of the elements of a vector. (Defined by Vector)
Bin<T>	Sorts values into bins and returns the result as a categorical vector. (Defined by Vector)
Bin<T>	Sorts values into bins and returns the result as a categorical vector. (Defined by Vector)
Bin<T>	Sorts values into bins and returns the result as a categorical vector. (Defined by Vector)
Bin<T>	Sorts values into bins and returns the result as a categorical vector. (Defined by Vector)
Bin<T>	Sorts values into bins and returns the result as a categorical vector. (Defined by Vector)
Ceiling<T>	Returns a vector whose elements are the components of another vector rounded up to the nearest integer. (Defined by Vector)
CeilingInto<T>	Computes the smallest integers greater than the elements of a vector. (Defined by Vector)
CentralMoment<T>	Returns the specified central moment of the elements of a vector. (Defined by Stats)
Clip<T>	Returns a vector whose elements are the components of a vector constrained to be within the specified interval. (Defined by Vector)
ClipInto<T>	Returns a vector whose elements are the components of a vector constrained to be within the specified interval. (Defined by Vector)
Concat<T>	Concatenates two vectors. (Defined by LinqExtensions)
Conjugate<T>	Returns the conjugate of a vector. (Defined by Vector)
ConjugateInto<T>	Conjugates the elements of a vector. (Defined by Vector)
Correlation<T>	Gets the Pearson correlation coefficient between two sets of values. (Defined by Stats)
CorrelationAs<T, TResult>	Gets the Pearson correlation coefficient between two sets of values. (Defined by Stats)
Cos<T>	Computes the cosine of the elements of a vector. (Defined by Vector)
Cosh<T>	Computes the hyperbolic cosine of the elements of a vector. (Defined by Vector)
CoshInto<T>	Computes the hyperbolic cosine of the elements of a vector. (Defined by Vector)
CosInto<T>	Computes the cosine of the elements of a vector. (Defined by Vector)
Covariance<T>	Gets the covariance between two sets of values. (Defined by Stats)
CovarianceAs<T, TResult>	Gets the covariance between two sets of values. (Defined by Stats)
CreateHistogram<T>	Returns a histogram of a vector using the specified bin arrangement. (Defined by Histogram)
CrossProduct<T>	Returns the cross product of two 3D vectors. (Defined by Vector)
Difference<T>	Computes the forward or backward difference of a vector. (Defined by Vector)
DifferenceInto<T>	Computes the forward or backward difference of a vector. (Defined by Vector)
DotProduct<T>	Returns the dot product of two vectors. (Defined by Vector)
ElementwisePow<T>	Raises the element of a vector to a constant power. (Defined by Vector)
ElementwisePow<T>	Raises the elements of a vector to a power from the corresponding elements in another vector. (Defined by Vector)
ElementwisePow<T>	Raises the elements of a vector to an integer power from the corresponding elements in another vector. (Defined by Vector)
ElementwisePow<T>	Raises the element of a vector to a constant power. (Defined by Vector)
ElementwisePowInto<T>	Raises the element of a vector to a constant power. (Defined by Vector)
ElementwisePowInto<T>	Raises the elements of a vector to a power from the corresponding elements in another vector. (Defined by Vector)
ElementwisePowInto<T>	Raises the elements of a vector to an integer power from the corresponding elements in another vector. (Defined by Vector)
ElementwisePowInto<T>	Raises the element of a vector to a constant power. (Defined by Vector)
Exp<T>	Computes the exponential of the elements of a vector. (Defined by Vector)
ExpInto<T>	Computes the exponential of the elements of a vector. (Defined by Vector)
Floor<T>	Returns a vector whose elements are the components of another vector rounded down to the nearest integer. (Defined by Vector)
FloorInto<T>	Computes the largest integers smaller than the elements of a vector. (Defined by Vector)
Group<T>	Returns a grouping by the unique elements in a list. (Defined by Grouping)
Group<T>	Returns a grouping by the unique elements in a sequence. (Defined by Grouping)
Group<T>	Returns a grouping by the unique elements in a list using the specified comparer to determine equality. (Defined by Grouping)
Group<T>	Returns a grouping by the unique elements in a sequence using the specified comparer to determine equality. (Defined by Grouping)
GroupBy<T, TKey>	Groups the elements of a vector according to the specified key selector function. (Defined by LinqExtensions)
GroupBy<T, TKey>	Groups the elements of a vector according to the specified key selector function and key comparer. (Defined by LinqExtensions)
GroupBy<T, TKey, TElement>	Groups the elements of a vector according to the specified key selector and element selector functions. (Defined by LinqExtensions)
GroupBy<T, TKey, TResult>	Groups the elements of a vector according to the specified key selector function and creates a result value from each group and its key. (Defined by LinqExtensions)
GroupBy<T, TKey, TElement>	Groups the elements of a vector according to the specified key selector and element selector functions, and key comparer. (Defined by LinqExtensions)
GroupBy<T, TKey, TResult>	Groups the elements of a vector according to the specified key selector function and creates a result value from each group and its key. Key values are compared using the specified comparer. (Defined by LinqExtensions)
GroupBy<T, TKey, TElement, TResult>	Groups the elements of a vector according to the specified key selector function and creates a result value from each group and its key. The elements of each group are projected using the specified function. (Defined by LinqExtensions)
GroupBy<T, TKey, TElement, TResult>	Groups the elements of a vector according to the specified key selector function and creates a result value from each group and its key. Key values are compared using the specified comparer, and the elements of each group are projected using the specified function. (Defined by LinqExtensions)
HarmonicMean<T>	Returns the harmonic mean of the elements of a vector. (Defined by Stats)
HarmonicMeanAs<T, TResult>	Returns the harmonic mean of the elements of a vector. (Defined by Stats)
Hypot<T>	Computes the square root of the sum of the squared corresponding elements of two matrices. (Defined by Vector)
HypotInto<T>	Computes the square root of the sum of the squared corresponding elements of two matrices. (Defined by Vector)
InfinityNorm<T>	Returns the infinity norm of a vector. (Defined by VectorExtensions)
InterQuartileRange<T>	Returns the inter-quartile range of the elements of a numerical variable. (Defined by Stats)
Join<T>	Joins two vectors. (Defined by Vector)
Kurtosis<T>	Returns the kurtosis supplement of the elements of a vector. (Defined by Stats)
KurtosisAs<T, TResult>	Returns the kurtosis supplement of the elements of an array. (Defined by Stats)
Lag<T>	Returns a vector whose observations are moved ahead by one observation. (Defined by VectorExtensions)
Lag<T>	Returns a vector whose observations are moved ahead by the specified number of observations. (Defined by VectorExtensions)
Lag<T>	Returns a vector whose observations are moved ahead by the specified number of observations. (Defined by VectorExtensions)
Log<T>	Returns a vector whose elements are the logarithms of the components of another vector. (Defined by Vector)
Log<T>	Returns a vector whose elements are the logarithms of the components of another vector. (Defined by Vector)
Log10<T>	Returns a vector whose elements are the base 10 logarithms of the components of another vector. (Defined by Vector)
Log10Into<T>	Computes the base 10 logarithm of the elements of a vector. (Defined by Vector)
LogInto<T>	Computes the logarithm of the elements of a vector. (Defined by Vector)
LogInto<T>	Computes the logarithm of the elements of a vector. (Defined by Vector)
MakeDistributed<T>	Returns a distributed version of a vector. (Defined by DistributedExtensions)
Max<T>	Returns the value of the largest component of a vector. (Defined by Vector)
Max<T>	Returns a vector whose elements are the maximums of the components of two vectors. (Defined by Vector)
Max<T>	Returns a vector whose elements are the maximum of the components of a vector and a real number. (Defined by Vector)
MaxInto<T>	Returns a vector whose elements are the maximums of the components of two vectors. (Defined by Vector)
MaxInto<T>	Returns a vector whose elements are the maximum of the components of a vector and a real number. (Defined by Vector)
Mean<T>	Returns the mean of the elements of a vector. (Defined by Stats)
MeanAs<T, TResult>	Returns the mean of the elements of a vector. (Defined by Stats)
Median<T>	Returns the median of the elements of a vector. (Defined by Stats)
Min<T>	Returns the value of the smallest component of a vector. (Defined by Vector)
Min<T>	Returns a vector whose elements are the minimums of the components of two vectors. (Defined by Vector)
Min<T>	Returns a vector whose elements are the minimum of the components of a vector and a real number. (Defined by Vector)
MinInto<T>	Returns a vector whose elements are the minimums of the components of two vectors. (Defined by Vector)
MinInto<T>	Returns a vector whose elements are the minimum of the components of a vector and a real number. (Defined by Vector)
Moment<T>	Returns the specified raw moment of the elements of an array. (Defined by Stats)
MultiplyInto<T>	Multiplies a vector by a constant. (Defined by Vector)
NegateInto<T>	Negates a vector. (Defined by Vector)
OneNorm<T>	Returns the one-norm of a vector. (Defined by VectorExtensions)
Percentile<T>	Gets the specified percentile. (Defined by Stats)
Permute<T>	Permutes a vector. (Defined by Vector)
PopulationKurtosis<T>	Returns the kurtosis supplement of the elements of an array. (Defined by Stats)
PopulationKurtosisAs<T, TResult>	Returns the kurtosis supplement of the elements of an array. (Defined by Stats)
PopulationSkewness<T>	Returns the population skewness of the elements of an array. (Defined by Stats)
PopulationSkewnessAs<T, TResult>	Returns the population skewness of the elements of an array. (Defined by Stats)
PopulationStandardDeviation<T>	Returns the population standard deviation of the elements of a vector. (Defined by Stats)
PopulationStandardDeviationAs<T, TResult>	Returns the population standard deviation of the elements of a vector. (Defined by Stats)
PopulationVariance<T>	Returns the variance of the elements of a vector. (Defined by Stats)
PopulationVarianceAs<T, TResult>	Returns the variance of the elements of a vector. (Defined by Stats)
Product<T>	Returns the product of the components of a vector. (Defined by Vector)
Project<T>	Returns the projection of one vector onto another. (Defined by Vector)
Quantile<T>	Gets the specified quantile. (Defined by VectorExtensions)
Quantiles<T>	Gets the specified quantile. (Defined by VectorExtensions)
Range<T>	Returns the range of the elements of a numerical variable. (Defined by Stats)
Ranks<T>	Returns the ranks of the observations. (Defined by Stats)
Reciprocal<T>	Returns a vector whose elements are the inverses (reciprocals) of the components of another vector. (Defined by Vector)
ReciprocalInto<T>	Computes the inverses (reciprocals) of the elements of a vector. (Defined by Vector)
Round<T>	Returns a vector whose elements are the components of another vector rounded to the nearest integer. (Defined by Vector)
Round<T>	Returns a vector whose elements are the components of another vector rounded to the nearest integer. (Defined by Matrix)
Select<T, TResult>	Projects each element of a vector into a new form. (Defined by LinqExtensions)
Select<T, TResult>	Projects each element of a vector into a new form by incorporating the elements index. (Defined by LinqExtensions)
SelectMany<T, TResult>	Projects each element of a vector to a vector and flattens the resulting vectors into one vector. (Defined by LinqExtensions)
SelectMany<T, TResult>	Projects each element of a vector to a vector incorporating the element's index and flattens the resulting vectors into one vector. (Defined by LinqExtensions)
SelectMany<T, TCollection, TResult>	Projects each element of a vector to a vector and flattens the resulting vectors into one vector, and applies a selector function to each element of the flattened vector. (Defined by LinqExtensions)
SelectMany<T, TCollection, TResult>	Projects each element of a vector to a vector incorporating the element's index and flattens the resulting vectors into one vector, and applies a selector function to each element of the flattened vector. (Defined by LinqExtensions)
Sin<T>	Computes the sine of the elements of a vector. (Defined by Vector)
Sinh<T>	Computes the hyperbolic sine of the elements of a vector. (Defined by Vector)
SinhInto<T>	Computes the hyperbolic sine of the elements of a vector. (Defined by Vector)
SinInto<T>	Computes the sine of the elements of a vector. (Defined by Vector)
Skewness<T>	Returns the skewness of the elements of an array. (Defined by Stats)
SkewnessAs<T, TResult>	Returns the skewness of the elements of an array. (Defined by Stats)
Sort<T>	Sorts a vector in ascending order. (Defined by Vector)
Sort<T>	Sorts a vector in the specified order. (Defined by Vector)
Sort<T>	Sorts a vector in the specified order and also returns the sorting permutation. (Defined by Vector)
SplitBy<T>	Splits a vector according to the specified grouping. (Defined by Vector)
SplitBy<T>	Splits a vector according to the specified grouping. (Defined by Vector)
Sqrt<T>	Computes the square root of the elements of a vector. (Defined by Vector)
SqrtInto<T>	Computes the square root of the elements of a vector. (Defined by Vector)
SquaredDifference<T>	Returns the norm of the difference of two vectors. (Defined by Vector)
StandardDeviation<T>	Returns the standard deviation of the elements of a vector. (Defined by Stats)
StandardDeviation<T>	Returns the standard deviation of the elements of a sequence. (Defined by Stats)
StandardDeviationAs<T, TResult>	Returns the standard deviation of the elements of a vector. (Defined by Stats)
SubtractInto<T>	Subtracts one vector from another. (Defined by Vector)
SubtractInto<T>	Subtracts two vectors. (Defined by Vector)
Sum<T>	Computes the sum of the sequence of values. (Defined by ArrayMath)
Sum<T>	Returns the sum of the components of a vector. (Defined by Vector)
Sum<T, U>	Computes the sum of the sequence of values that are obtained by invoking a transform function on each element of the input sequence. (Defined by ArrayMath)
Sum<T, T2, U>	Computes the sum of the sequence of values that are obtained by invoking a transform function on each pair of elements of the input sequences. (Defined by ArrayMath)
SumAs<T, TResult>	Returns the sum of the elements of a vector. (Defined by Stats)
Tan<T>	Computes the tangent of the elements of a vector. (Defined by Vector)
Tanh<T>	Computes the hyperbolic tangent of the elements of a vector. (Defined by Vector)
TanhInto<T>	Computes the hyperbolic tangent of the elements of a vector. (Defined by Vector)
TanInto<T>	Computes the tangent of the elements of a vector. (Defined by Vector)
ToJson<T>	Returns a string containing a vector in JSON format. (Defined by JsonFile)
ToLookup<T, TKey>	Creates a lookup from a vector according to the specified key selector function. (Defined by LinqExtensions)
ToLookup<T, TKey>	Creates a lookup from a vector according to the specified key selector function and key comparer. (Defined by LinqExtensions)
ToLookup<T, TKey, TElement>	Creates a lookup from a vector according to the specified key selector and element selector functions. (Defined by LinqExtensions)
ToLookup<T, TKey, TElement>	Creates a lookup from a vector according to the specified key selector and element selector functions, and key comparer. (Defined by LinqExtensions)
TrimmedMean<T>	Returns the trimmed mean of the elements of a numerical variable. (Defined by Stats)
Truncate<T>	Returns a vector whose elements are the components of another vector rounded to the nearest integer towards zero. (Defined by Matrix)
TwoNorm<T>	Returns the two-norm of a vector. (Defined by VectorExtensions)
Unstack<R, C>	Transforms a vector with a two-level index into a data frame whose columns correspond to the second level in the index. (Defined by DataFrame)
Variance<T>	Returns the variance of the elements of a vector. (Defined by Stats)
VarianceAs<T, TResult>	Returns the variance of the elements of a span. (Defined by Stats)
WeightedMean<T>	Returns the mean of the variable with observations weighted by the specified vector. (Defined by Stats)
WeightedStandardDeviation<T>	Returns the standard deviation of the variable with observations weighted by the specified vector. (Defined by Stats)
Where<T>	Filters the elements of a vector based on a predicate. (Defined by LinqExtensions)
Where<T>	Filters the elements of a vector based on a predicate. Each element's index is used in the logic of the predicate function. (Defined by LinqExtensions)