Aggregator<T, TResult>.AggregateInto Method

Definition

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

Overload List

AggregateInto(Matrix<T>, Vector<TResult>)	Aggregates the columns of a matrix. Obsolete.
AggregateInto(Vector<T>, IGrouping, Vector<TResult>)	Groups the elements of a vector according to the specified grouping. Obsolete.
AggregateInto(Vector<T>, ReadOnlySpan<Int32>, Nullable<Boolean>, Vector<TResult>)	Aggregates the elements of a vector according to the specified level indexes. Obsolete.
AggregateInto<TPredicate>(Vector<T>, ReadOnlySpan<Int32>, TPredicate, Nullable<Boolean>, Vector<TResult>)	Groups the elements of a vector according to the specified level indexes. Obsolete.
AggregateInto<TPredicate>(Int32, ReadOnlySpan<T>, Int32, ReadOnlySpan<Int32>, Int32, Int32, TPredicate, Boolean, SpanSlice<TResult>)	Groups the elements of a vector according to the specified level indexes.

AggregateInto(Matrix<T>, Vector<TResult>)

Note: This API is now obsolete.

Aggregates the columns of a matrix.

[ObsoleteAttribute("Use the AggregateColumns method instead.")]
public Vector<TResult> AggregateInto(
	Matrix<T> values,
	Vector<TResult>? result
)

Visual Basic

<ObsoleteAttribute("Use the AggregateColumns method instead.")>
Public Function AggregateInto ( 
	values As Matrix(Of T),
	result As Vector(Of TResult)
) As Vector(Of TResult)

C++/CLI

public:
[ObsoleteAttribute(L"Use the AggregateColumns method instead.")]
Vector<TResult>^ AggregateInto(
	Matrix<T>^ values, 
	Vector<TResult>^ result
)

[<ObsoleteAttribute("Use the AggregateColumns method instead.")>]
member AggregateInto : 
        values : Matrix<'T> * 
        result : Vector<'TResult> -> Vector<'TResult>

Parameters

values Matrix<T>: The matrix whose columns to aggregate.
result Vector<TResult>: The vector that is to hold the result. May be null.

Return Value

Vector<TResult>

AggregateInto(Vector<T>, IGrouping, Vector<TResult>)

Note: This API is now obsolete.

Groups the elements of a vector according to the specified grouping.

[ObsoleteAttribute("Use the AggregateBy method instead.")]
public Vector<TResult> AggregateInto(
	Vector<T> values,
	IGrouping grouping,
	Vector<TResult>? result
)

Visual Basic

<ObsoleteAttribute("Use the AggregateBy method instead.")>
Public Function AggregateInto ( 
	values As Vector(Of T),
	grouping As IGrouping,
	result As Vector(Of TResult)
) As Vector(Of TResult)

C++/CLI

public:
[ObsoleteAttribute(L"Use the AggregateBy method instead.")]
Vector<TResult>^ AggregateInto(
	Vector<T>^ values, 
	IGrouping^ grouping, 
	Vector<TResult>^ result
)

[<ObsoleteAttribute("Use the AggregateBy method instead.")>]
member AggregateInto : 
        values : Vector<'T> * 
        grouping : IGrouping * 
        result : Vector<'TResult> -> Vector<'TResult>

Parameters

values Vector<T>: The vector to aggregate.
grouping IGrouping: A grouping.
result Vector<TResult>: The vector that is to hold the result. May be null.

Return Value

Vector<TResult>

AggregateInto(Vector<T>, ReadOnlySpan<Int32>, Nullable<Boolean>, Vector<TResult>)

Note: This API is now obsolete.

Aggregates the elements of a vector according to the specified level indexes.

[ObsoleteAttribute("Use the AggregateBy method instead.")]
public Vector<TResult> AggregateInto(
	Vector<T> values,
	ReadOnlySpan<int> levels,
	bool? skipMissingValues,
	Vector<TResult> result
)

Visual Basic

<ObsoleteAttribute("Use the AggregateBy method instead.")>
Public Function AggregateInto ( 
	values As Vector(Of T),
	levels As ReadOnlySpan(Of Integer),
	skipMissingValues As Boolean?,
	result As Vector(Of TResult)
) As Vector(Of TResult)

C++/CLI

public:
[ObsoleteAttribute(L"Use the AggregateBy method instead.")]
Vector<TResult>^ AggregateInto(
	Vector<T>^ values, 
	ReadOnlySpan<int> levels, 
	Nullable<bool> skipMissingValues, 
	Vector<TResult>^ result
)

[<ObsoleteAttribute("Use the AggregateBy method instead.")>]
member AggregateInto : 
        values : Vector<'T> * 
        levels : ReadOnlySpan<int> * 
        skipMissingValues : Nullable<bool> * 
        result : Vector<'TResult> -> Vector<'TResult>

Parameters

values Vector<T>: The vector to aggregate.
levels ReadOnlySpan<Int32>: An array of level indexes.
skipMissingValues Nullable<Boolean>: Specifies whether missing values should be excluded from the aggregation. If null, then the value is inferred from values.
result Vector<TResult>: The vector that is to hold the result. May be null.

Return Value

Vector<TResult>

AggregateInto<TPredicate>(Vector<T>, ReadOnlySpan<Int32>, TPredicate, Nullable<Boolean>, Vector<TResult>)

Note: This API is now obsolete.

Groups the elements of a vector according to the specified level indexes.

[ObsoleteAttribute("Use the AggregateBy method instead.")]
public Vector<TResult> AggregateInto<TPredicate>(
	Vector<T> values,
	ReadOnlySpan<int> levels,
	TPredicate predicate,
	bool? skipMissingValues,
	Vector<TResult> result
)
where TPredicate : struct, new(), IFastFunc<T, bool>

Visual Basic

<ObsoleteAttribute("Use the AggregateBy method instead.")>
Public Function AggregateInto(Of TPredicate As {Structure, New, IFastFunc(Of T, Boolean)}) ( 
	values As Vector(Of T),
	levels As ReadOnlySpan(Of Integer),
	predicate As TPredicate,
	skipMissingValues As Boolean?,
	result As Vector(Of TResult)
) As Vector(Of TResult)

C++/CLI

public:
[ObsoleteAttribute(L"Use the AggregateBy method instead.")]
generic<typename TPredicate>
where TPredicate : value class, gcnew(), IFastFunc<T, bool>
Vector<TResult>^ AggregateInto(
	Vector<T>^ values, 
	ReadOnlySpan<int> levels, 
	TPredicate predicate, 
	Nullable<bool> skipMissingValues, 
	Vector<TResult>^ result
)

[<ObsoleteAttribute("Use the AggregateBy method instead.")>]
member AggregateInto : 
        values : Vector<'T> * 
        levels : ReadOnlySpan<int> * 
        predicate : 'TPredicate * 
        skipMissingValues : Nullable<bool> * 
        result : Vector<'TResult> -> Vector<'TResult>  when 'TPredicate : struct, new() and IFastFunc<'T, bool>

Parameters

values Vector<T>: The vector to aggregate.
levels ReadOnlySpan<Int32>: An array of level indexes.
predicate TPredicate: A predicate that filters the values that are to be included in the aggregation.
skipMissingValues Nullable<Boolean>: Specifies whether missing values should be excluded from the aggregation. If null, then the value is inferred from values.
result Vector<TResult>: The vector that is to hold the result. May be null.

Type Parameters

TPredicate: The type of predicate.

Return Value

Vector<TResult>

AggregateInto<TPredicate>(Int32, ReadOnlySpan<T>, Int32, ReadOnlySpan<Int32>, Int32, Int32, TPredicate, Boolean, SpanSlice<TResult>)

Groups the elements of a vector according to the specified level indexes.

public virtual void AggregateInto<TPredicate>(
	int length,
	ReadOnlySpan<T> values,
	int stride,
	ReadOnlySpan<int> levels,
	int levelsStride,
	int maxLevel,
	TPredicate predicate,
	bool skipMissingValues,
	SpanSlice<TResult> result
)
where TPredicate : struct, new(), IFastFunc<T, bool>

Visual Basic

Public Overridable Sub AggregateInto(Of TPredicate As {Structure, New, IFastFunc(Of T, Boolean)}) ( 
	length As Integer,
	values As ReadOnlySpan(Of T),
	stride As Integer,
	levels As ReadOnlySpan(Of Integer),
	levelsStride As Integer,
	maxLevel As Integer,
	predicate As TPredicate,
	skipMissingValues As Boolean,
	result As SpanSlice(Of TResult)
)

C++/CLI

public:
generic<typename TPredicate>
where TPredicate : value class, gcnew(), IFastFunc<T, bool>
virtual void AggregateInto(
	int length, 
	ReadOnlySpan<T> values, 
	int stride, 
	ReadOnlySpan<int> levels, 
	int levelsStride, 
	int maxLevel, 
	TPredicate predicate, 
	bool skipMissingValues, 
	SpanSlice<TResult> result
)

abstract AggregateInto : 
        length : int * 
        values : ReadOnlySpan<'T> * 
        stride : int * 
        levels : ReadOnlySpan<int> * 
        levelsStride : int * 
        maxLevel : int * 
        predicate : 'TPredicate * 
        skipMissingValues : bool * 
        result : SpanSlice<'TResult> -> unit  when 'TPredicate : struct, new() and IFastFunc<'T, bool>
override AggregateInto : 
        length : int * 
        values : ReadOnlySpan<'T> * 
        stride : int * 
        levels : ReadOnlySpan<int> * 
        levelsStride : int * 
        maxLevel : int * 
        predicate : 'TPredicate * 
        skipMissingValues : bool * 
        result : SpanSlice<'TResult> -> unit  when 'TPredicate : struct, new() and IFastFunc<'T, bool>

Parameters

length Int32: The number of elements in the input.
values ReadOnlySpan<T>: A read-only span of values.
stride Int32: The distance between successive elements in values.
levels ReadOnlySpan<Int32>: An array of level indexes.
levelsStride Int32: The distance between successive elements in levels.
maxLevel Int32: The number of levels in levels.
predicate TPredicate: A predicate that filters the values that are to be included in the aggregation.
skipMissingValues Boolean: Optional. Specifies whether missing values should be excluded from the aggregation. The default is false.
result SpanSlice<TResult>: The span that is to hold the result. May be null.

Type Parameters

TPredicate: The type of predicate.

Remarks

The elements of levels must be less than maxLevel. Negative values are considered missing and are not included in the aggregation.

Aggregator<T, TResult>.AggregateInto Method

Definition

Overload List

AggregateInto(Matrix<T>, Vector<TResult>)

Parameters

Return Value

AggregateInto(Vector<T>, IGrouping, Vector<TResult>)

Parameters

Return Value

AggregateInto(Vector<T>, ReadOnlySpan<Int32>, Nullable<Boolean>, Vector<TResult>)

Parameters

Return Value

AggregateInto<TPredicate>(Vector<T>, ReadOnlySpan<Int32>, TPredicate, Nullable<Boolean>, Vector<TResult>)

Parameters

Type Parameters

Return Value

AggregateInto<TPredicate>(Int32, ReadOnlySpan<T>, Int32, ReadOnlySpan<Int32>, Int32, Int32, TPredicate, Boolean, SpanSlice<TResult>)

Parameters

Type Parameters

Remarks

See Also

Reference