ComplexMatrixDense(Int32, Int32, Complex, StorageOrder) Method

Creates a dense ComplexMatrix instance having the specified size, and assigns data to entries applying the given storage order.

Definition

Namespace: Novacta.Analytics
Assembly: Novacta.Analytics (in Novacta.Analytics.dll) Version: 2.1.0+428f3840cfab98dda567bb0ed350b302533e273a

C#

public static ComplexMatrix Dense(
	int numberOfRows,
	int numberOfColumns,
	Complex[] data,
	StorageOrder storageOrder
)

VB

Public Shared Function Dense ( 
	numberOfRows As Integer,
	numberOfColumns As Integer,
	data As Complex(),
	storageOrder As StorageOrder
) As ComplexMatrix

C++

public:
static ComplexMatrix^ Dense(
	int numberOfRows, 
	int numberOfColumns, 
	array<Complex>^ data, 
	StorageOrder storageOrder
)

F#

static member Dense : 
        numberOfRows : int * 
        numberOfColumns : int * 
        data : Complex[] * 
        storageOrder : StorageOrder -> ComplexMatrix

Parameters

numberOfRows Int32: The number of matrix rows.
numberOfColumns Int32: The number of matrix columns.
data Complex: The data assigned to matrix entries.
storageOrder StorageOrder: The linear ordering of matrix entries assumed when assigning data.

Return Value

ComplexMatrix
The matrix having the specified size and data.

Remarks

ComplexMatrix dense instances allocate storage for each matrix entry. Sparse ComplexMatrix instances can be created by calling method Sparse(Int32, Int32, Int32).

Parameter data is unidimensional, while matrix entries are bi-dimensional, since are defined by their row and column indexes. As a consequence, entries must be linearly ordered to define a correspondence between data and matrix entries. Supported linear orderings can be specified through parameter storageOrder. If constant ColumnMajor is passed, then the order is assumed by columns: matrix entries are ordered by their column index first, and entries laying on a given column are in turn ordered by their row index. This implies that the first numberOfRows entries in data will be assumed to contain the first column of the returned matrix, and so on. If constant RowMajor is passed, then the order is assumed by rows: matrix entries are ordered by their row index first, and entries laying on a given row are in turn ordered by their column index. This implies that the first numberOfColumns entries in data will be assumed to contain the first row of the returned matrix, and so on.

Example

In the following example, a dense matrix is created by passing both RowMajor and ColMajor ordered data.

Creation of a dense matrix with RowMajor or ColMajor ordered data

using System;
using System.Numerics;

namespace Novacta.Analytics.CodeExamples
{
    public class ComplexDenseExample0  
    {
        public void Main()
        {
            // Set matrix dimensions.
            int numberOfRows = 3;
            int numberOfColumns = 2;

            // Create the data.
            var data = new Complex[6] {
                new(1, -1), new(5, -5),
                new(2, -2), new(6, -6),
                new(3, -3), new(7, -7)
            };

            // Assume the data as RowMajor ordered.
            StorageOrder storageOrder = StorageOrder.RowMajor;

            // Create the matrix.
            var matrix = ComplexMatrix.Dense(
                numberOfRows, numberOfColumns, data, storageOrder);
            Console.WriteLine("Assuming RowMajor ordered data.");
            Console.WriteLine("The data matrix:");
            Console.WriteLine(matrix);

            // Assume the data as ColMajor ordered.
            storageOrder = StorageOrder.ColumnMajor;

            // Create the matrix.
            matrix = ComplexMatrix.Dense(
                numberOfRows, numberOfColumns, data, storageOrder);
            Console.WriteLine("Assuming ColMajor ordered data.");
            Console.WriteLine("The data matrix:");
            Console.WriteLine(matrix);
        }
    }
}

// Executing method Main() produces the following output:
// 
// Assuming RowMajor ordered data.
// The data matrix:
// (                1,               -1) (                5,               -5) 
// (                2,               -2) (                6,               -6) 
// (                3,               -3) (                7,               -7) 
// 
// 
// Assuming ColMajor ordered data.
// The data matrix:
// (                1,               -1) (                6,               -6) 
// (                5,               -5) (                3,               -3) 
// (                2,               -2) (                7,               -7) 
// 
//

Exceptions

ArgumentException	storageOrder is not a field of StorageOrder. -or- data has Length not equal to the multiplication of numberOfRows by numberOfColumns.
ArgumentOutOfRangeException	numberOfRows is not positive. -or- numberOfColumns is not positive.
ArgumentNullException	data is null.