ILMathcounterT Method (T, T, InArrayInt64, StorageOrders)

public static RetArray<T> counter<T>(
	T start,
	T step,
	InArray<long> size,
	StorageOrders order = StorageOrders.ColumnMajor
)
where T : struct, new(), IEquatable<T>, IConvertible

Public Shared Function counter(Of T As {Structure, New, IEquatable(Of T), IConvertible}) ( 
	start As T,
	step As T,
	size As InArray(Of Long),
	Optional order As StorageOrders = StorageOrders.ColumnMajor
) As RetArray(Of T)

Dim start As T
Dim step As T
Dim size As InArray(Of Long)
Dim order As StorageOrders
Dim returnValue As RetArray(Of T)

returnValue = ILMath.counter(start, 
	step, size, order)

Parameters

start

Type: T
The start value for the new elements.

step

Type: T
The step size value for the new elements.

size

Type: ILNumericsInArrayInt64
Dimension lengths as vector.

order (Optional)

Type: ILNumericsStorageOrders
[Optional] The storage order for the new array. Default: ColumnMajor.

Type Parameters

T

Element type.

Return Value

The counter``1(UMP, UMP, InArrayInt64, StorageOrders) function and the corresponding overloads for providing individual dimension length parameters counter``1(UMP, UMP, Int64, StorageOrders),... create n-dimensional numeric arrays with automatically generated values based on a given start value and a step value. The size of the new array is determined by the size parameter(s). The firsts element value is assigned the start value. Subsequent values are computed by adding the value of step to each elements predecessor.

The term 'predecessor' here means: the predecessor E0 of element E1 is the element having an index I(E0) of I(E1) - 1, where the index I() corresponds to the storage location of the element in memory, relative to the first element.

The storage order is determined by order. By default, elements are lined up in memory in column major storage order. order must be one out of ColumnMajor or RowMajor. Note, how the storage order affects the order of values in the new array.

[ILNumerics Computing Engine]

Creating a new array of size [4,3], filled with upwards counting values, starting at 1.

Array<double> A = counter<double>(1, 1, 4, 3);
            //<Double> [4,3] 1...12 |
            //    [0]:           1          5          9
            //    [1]:           2          6         10
            //    [2]:           3          7         11
            //    [3]:           4          8         12

Creating a new array of size [4,3,2] of ushort values:

counter<sbyte>(10, -10, 4,3,2)
            //<SByte> [4,3] 1...12 |
            //    [0]: (:,:,0)
            //    [1]:    10  -30  -70
            //    [2]:     0  -40  -80
            //    [3]:   -10  -50  -90
            //    [4]:   -20  -60 -100
            //    [5]: (:,:,1)
            //    [6]:  -110  106   66
            //    [7]:  -120   96   56
            //    [8]:   126   86   46
            //    [9]:   116   76   36

Note, how the computed values of data type 'sbyte' wrap around at the limits of 'sbyte' without notice!

Creating a new array of size [4,3] with upwards counting values in row major order:

counter<float>(1, 1, 4,3, StorageOrders.RowMajor)
            //<Single> [4,3] 1...12 -
            //    [0]:           1          2          3
            //    [1]:           4          5          6
            //    [2]:           7          8          9
            //    [3]:          10         11         12
            

Reference