Nuget packages

Configuration

Using Parallelism

Mathematics Library User's Guide

Vector and Matrix Library User's Guide

Data Analysis Library User's Guide

Statistics Library User's Guide

Data Access Library User's Guide

Reference

Home»Documentation»Vector and Matrix Library User's Guide»Matrices»Accessing Rows and Columns

Accessing Rows and Columns

Extreme Optimization Numerical Libraries for .NET Professional

Matrices are two-dimensional tables. The Extreme Optimization Numerical Libraries for .NET includes classes that allow you to work with the rows and columns of a matrix as vectors. In addition, these classes allow you to easily navigate through a matrix.

Accessing individual elements

The MatrixT class has an ItemInt32, Int32 property. The first index is the zero-based row index. The second index is the zero-based column index. In languages that don't support indexers, you can use the indexed Item property. If the index is greater than or equal to the number of rows or columns, an exception of type ArgumentOutOfRangeException is thrown.

C++

Copy

var m = Matrix.Create(2, 2, (i, j) => 11 + 10 * i + j);
// m -> [[ 11 12 ]
//       [ 21 22 ]]
m[1, 1] = 99;
// m -> [[ 11 12 ]
//       [ 21 99 ]]

Dim m = Matrix.Create(2, 2, Function(i, j) 11 + 10 * i + j)
' m -> (( 11 12 )
'       ( 21 22 ))
m(1, 1) = 99
' m -> (( 11 12 )
'       ( 21 99 ))

let m = Matrix.Create(2, 2, fun i j -> 11 + 10 * i + j)
// m -> [[ 11 12 ]
//       [ 21 22 ]]
m.[1, 1] <- 99
// m -> [[ 11 12 ]
//       [ 21 99 ]]

Accessing rows and columns

There are three ways to access the rows or columns of a matrix: through indexers, through row and column getter methods, and through enumerators.

Indexer access

The indexer property is overloaded to allow for direct indexed access to complete or partial rows or columns. The indexers are similar to the indexers for vectors. For row access, the first index is the row index. The second index can be any value that is valid for a vector indexer. The special range All lets you access an entire row or column without having to specify any details about the range.

C++

Copy

var m = Matrix.Create(3, 3, (i, j) => 11 + 10 * i + j);
// m -> [[ 11 12 13 ]
//       [ 21 22 23 ]
//       [ 31 32 33 ]]
var row1 = m[0, Range.All];
// row1 -> [ 11 12 13 ]
var column1 = m[Range.All, 1];
// column1 -> [ 12 22 32 ]
var row2 = m[1, new Range(1, 2)];
// row2 -> [ 22 23 ]
var row3 = m[1, new Range(0, 2, 2)];
// row3 -> [ 21 23 ]

Dim m = Matrix.Create(3, 3, Function(i, j) 11 + 10 * i + j)
' m -> (( 11 12 13 )
'       ( 21 22 23 )
'       ( 31 32 33 ))
Dim row1 = m(0, Range.All)
' row1 -> ( 11 12 13 )
Dim column1 = m(Range.All, 1)
' column1 -> ( 12 22 32 )
Dim row2 = m(1, New Range(1, 2))
' row2 -> ( 22 23 )
Dim row3 = m(1, New Range(0, 2, 2))
' row3 -> ( 21 23 )

let m = Matrix.Create(3, 3, fun i j -> 11 + 10 * i + j)
// m -> [[ 11 12 13 ]
//       [ 21 22 23 ]
//       [ 31 32 33 ]]
let row1 = m.[0, *]
// row1 -> [ 11 12 13 ]
let column1 = m.[*, 1]
// column1 -> [ 12 22 32 ]
let row2 = m.[1, 1..2]
// row2 -> [ 22 23 ]
let row3 = m.[1, Range(0, 2, 2)]
// row3 -> [ 21 23 ]

The first example retrieves the entire first row of the matrix m. The second example retrieves the entire second column. The third example retrieves only the last two elements of the second row. The final example retrieves the first and last element of the second row.

The indexers can be assigned to as well. In this case, he elements in the range specified by the index are set to the corresponding elements of the right-hand side. This is illustrated in the next example:

C++

Copy

m[1, new Range(1, 2)] = Vector.Create(88, 99);
// m -> [[ 11 12 13 ]
//       [ 21 88 99 ]
//       [ 31 32 33 ]]
m[1, new Range(0, 2, 2)] = Vector.Create(77, 66);
// m -> [[ 11 12 13 ]
//       [ 77 88 66 ]
//       [ 31 32 33 ]]
m[Range.All, 1] = Vector.Create(1, 2, 3);
// m -> [[ 11 1 13 ]
//       [ 77 2 66 ]
//       [ 31 3 33 ]]

m(1, New Range(1, 2)) = Vector.Create(88, 99)
' m -> (( 11 12 13 )
'       ( 21 88 99 )
'       ( 31 32 33 ))
m(1, New Range(0, 2, 2)) = Vector.Create(77, 66)
' m -> (( 11 12 13 )
'       ( 77 88 66 )
'       ( 31 32 33 ))
m(Range.All, 1) = Vector.Create(1, 2, 3)
' m -> (( 11 1 13 )
'       ( 77 2 66 )
'       ( 31 3 33 ))

m.[1, 1..2] <- Vector.Create(88, 99)
// m -> [[ 11 12 13 ]
//       [ 21 88 99 ]
//       [ 31 32 33 ]]
m.[1, Range(0, 2, 2)] <- Vector.Create(77, 66)
// m -> [[ 11 12 13 ]
//       [ 77 88 66 ]
//       [ 31 32 33 ]]
m.[*, 1] <- Vector.Create(1, 2, 3)
// m -> [[ 11 1 13 ]
//       [ 77 2 66 ]
//       [ 31 3 33 ]]

Boolean masks and predicates may also be used to select a subset of the elements of the row or column. Once again, you can both get and set the elements:

C++

Copy

var m = Matrix.Create(3, 3, (i, j) => Elementary.Pow(i, j));
// m -> [[ 1 1 1 ]
//       [ 1 2 4 ]
//       [ 1 3 9 ]]
var mask1 = Vector.Create(false, true, true);
var row1 = m[1, mask1];
// row1 -> [ 4 9 ]
var column1 = m[x => x > 1.0, 1];
// column1 -> [ 2 3 ]
m[1, mask1] = Vector.Create(4.0, 7.0);
// m -> [[ 1 1 1 ]
//       [ 1 4 7 ]
//       [ 1 3 9 ]]

Dim m = Matrix.Create(Of Double)(3, 3, Function(i, j) Elementary.Pow(i, j))
' m -> (( 1 1 1 )
'       ( 1 2 4 )
'       ( 1 3 9 ))
Dim mask1 = Vector.Create(False, True, True)
Dim row1 = m(1, mask1)
' row1 -> ( 4 9 )
Dim column1 = m(Function(x) x > 1.0, 1)
' column1 -> ( 2 3 )
m(1, mask1) = Vector.Create(4.0, 7.0)
' m -> (( 1 1 1 )
'       ( 1 4 7 )
'       ( 1 3 9 ))

let m = Matrix.Create(3, 3, fun i j -> Elementary.Pow(float i, j))
// m -> [[ 1 1 1 ]
//       [ 1 2 4 ]
//       [ 1 3 9 ]]
let mask1 = Vector.Create(false, true, true)
let row1 = m.[1, mask1]
// row1 -> [ 4 9 ]
let column1 = m.[Func<_,_>(fun x -> x > 1.0), 1]
// column1 -> [ 2 3 ]
m.[1, mask1] <- Vector.Create(4.0, 7.0)
// m -> [[ 1 1 1 ]
//       [ 1 4 7 ]
//       [ 1 3 9 ]]

Row and Column slices

The GetRow and GetColumn methods provide the same functionality as indexed range access, but add the option to specify the intent.

GetRow always takes the row index as its first argument. If no further arguments are supplied, the entire row is returned. A partial row can be returned by providing the column index of the first and last index in the new vector, and optionally a stride. You can also pass a Range structure as the only second argument. GetColumn has similar overloads. The first argument is always the column index. The remaining arguments, if present, specify the range of row indexes. The following code sample performs the same operations as the indexed range sample above, but uses GetRow and GetColumn:

C++

Copy

var m = Matrix.Create(3, 3, (i, j) => 11 + 10 * i + j, ArrayMutability.Immutable);
// m -> [[ 11 12 13 ]
//       [ 21 22 23 ]
//       [ 31 32 33 ]]
var row1 = m.GetRow(1, 1, 2, Intent.WritableCopy);
// row1 -> [ 22, 23 ] and writable
// Note that this would fail since m is immutable:
// m[1, 2] = 99;
// But we can change the row vector:
row1[0] = 99;
// row1 -> [ 99, 23 ]
// m is unchanged.
var row2 = m.GetRow(1, new Range(0, 2, 2));
// row2 -> [ 21 23 ]
var column1 = m.GetColumn(1);
// column1 -> [ 12 22 32 ]

Dim m = Matrix.Create(3, 3, Function(i, j) 11 + 10 * i + j,
    ArrayMutability.Immutable)
' m -> (( 11 12 13 )
'       ( 21 22 23 )
'       ( 31 32 33 ))
Dim row1 = m.GetRow(1, 1, 2, Intent.WritableCopy)
' row1 -> ( 22, 23 ) and writable
' Note that this would fail since m is immutable:
' m(1, 2) = 99
' But we can change the row vector:
row1(0) = 99
' row1 -> ( 99, 23 )
' m is unchanged.
Dim row2 = m.GetRow(1, New Range(0, 2, 2))
' row2 -> ( 21 23 )
Dim column1 = m.GetColumn(1)
' column1 -> ( 12 22 32 )

let m = Matrix.Create(3, 3, (fun i j -> 11 + 10 * i + j), ArrayMutability.Immutable)
// m -> [[ 11 12 13 ]
//       [ 21 22 23 ]
//       [ 31 32 33 ]]
let row1 = m.GetRow(1, 1, 2, Intent.WritableCopy)
// row1 -> [ 22, 23 ] and writable
// Note that this would fail since m is immutable:
// m.[1, 2] = 99
// But we can change the row vector:
row1.[0] <- 99
// row1 -> [ 99, 23 ]
// m is unchanged.
let row2 = m.GetRow(1, Range(0, 2, 2))
// row2 -> [ 21 23 ]
let column1 = m.GetColumn(1)
// column1 -> [ 12 22 32 ]

Note that the matrix m is immutable, so its rows and columns are always immutable as well. In the example, we make a writable copy of a row, and the elements of this vector can be changed without changing the elements of m.

Enumeration

Matrix operations often involve performing some action on each of the rows or columns of a matrix. The Rows and Columns properties return the rows and columns as collections that can be iterated over.

Enumerating rows and columns is often more efficient than getting each row or column in a loop because only one vector may be allocated

The following example shows a method that calculates the sum of the absolute values of a matrix.

C++

Copy

double SumOfAbsoluteValues(Matrix<double> a)
{
    double sum = 0;
    foreach (var column in a.Columns)
        sum += column.OneNorm();
    return sum;
}

Function SumOfAbsoluteValues(a As Matrix(Of Double)) As Double
    Dim sum = 0.0
    For Each column In a.Columns
        sum += column.OneNorm()
    Next
    Return sum
End Function

let SumOfAbsoluteValues(a : Matrix<double>) =
    let mutable sum = 0.0
    for column in a.Columns do
        sum <- sum + column.OneNorm()
    sum

The one-norm of a vector equals the sum of the absolute values of its elements. All we have to do to obtain the sum of the absolute values of a matrix, then, is to sum the one-norms of all the rows or columns. Since most algorithms are optimized for matrices stored in column major order, it is recommended to iterate over the columns rather than the rows whenever possible.

Accessing diagonals

The GetDiagonal method returns a vector whose elements are the diagonal of a matrix. The method has an optional argument that specifies the index of the diagonal. A value of zero indicates the main diagonal. A value greater than zero indicates a super-diagonal. A value less than zero indicates a sub-diagonal. The default is to return the main diagonal.

As with the GetRow and GetRow methods, an Intent value can be passed as the last argument.

Accessing sub-matrices

Sometimes it may be useful to treat part of a matrix as if it were a matrix in its own right. There are two ways of achieving this.

Indexed range access

The indexer for the MatrixT class has several overloads that lets you extract a part of a matrix. Both arguments of the indexer are Range structures. The first specifies the range of rows to include. The second argument specifies the range of columns. Both arguments may have the special value All, which indicates that the entire column or row should be included. Some examples:

C++

Copy

var m = Matrix.CreateRandom(10, 10);
// Extract the 2nd to the 5th row of m:
var m1 = m[new Range(1, 4), Range.All];
// Extract the odd columns:
var m2 = m[Range.All, new Range(1, 10, 2)];
// Extract the 4x4 leading sub-matrix of m:
var m3 = m[new Range(0, 3), new Range(0, 3)];

Dim m = Matrix.CreateRandom(10, 10)
' Extract the 2nd to the 5th row of m:
Dim m1 = m(New Range(1, 4), Range.All)
' Extract the odd columns:
Dim m2 = m(Range.All, New Range(1, 10, 2))
' Extract the 4x4 leading sub-matrix of m:
Dim m3 = m(New Range(0, 3), New Range(0, 3))

let m = Matrix.CreateRandom(10, 10)
// Extract the 2nd to the 5th row of m:
let m1 = m.[1..4, *]
// Extract the odd columns:
let m2 = m.[Range.All, Range(1, 10, 2)]
// Extract the 4x4 leading sub-matrix of m:
let m3 = m.[0..3, 0..3]

You can also assign to ranges. The following example sets the upper right and lower left blocks of a 10x10 matrix to the identity matrix:

C++

Copy

var m = Matrix.Create<double>(10, 10);
var ones = Vector.CreateConstant(5, 1.0);
var identity5 = Matrix.CreateDiagonal(ones);
m[new Range(0, 4), new Range(5, 9)] = identity5;
m[new Range(5, 9), new Range(0, 4)] = identity5;

Dim m = Matrix.Create(Of Double)(10, 10)
Dim ones = Vector.CreateConstant(5, 1.0)
Dim identity5 = Matrix.CreateDiagonal(ones)
m(New Range(0, 4), New Range(5, 9)) = identity5
m(New Range(5, 9), New Range(0, 4)) = identity5

let m = Matrix.Create<double>(10, 10)
let ones = Vector.CreateConstant(5, 1.0)
let identity5 = Matrix.CreateDiagonal(ones)
m.[Range(0, 4), Range(5, 9)] <- identity5
m.[Range(5, 9), Range(0, 4)] <- identity5

We first create a 5x5 identity matrix by calling the CreateDiagonal method. We then assign this matrix to the selected blocks of m.

Matrix slices

The same results can be achieved with the GetSubmatrix method, which is somewhat more flexible. Like the GetRow and GetColumn methods mentioned earlier, you can specify the intended use of the sub-matrix. You can also apply a transposition operation to the matrix.

The ranges can be specified using either Range structures or explicit start and end indices. An optional argument lets you specify the transpose operation to apply, if any. The earlier examples can be expressed using the GetSubmatrix method as follows:

C++

Copy

var m = Matrix.CreateRandom(10, 10);
// Extract the 2nd to the 5th row of m. 
// Start and end columns are supplied manually.
var m1 = m.GetSubmatrix(1, 4, 0, 9);
// Extract the odd columns:
// Here we need to supply the transpose parameter.
var m2 = m.GetSubmatrix(0, 9, 1, 1, 10, 2, TransposeOperation.None);
// Extract the 4x4 leading sub-matrix of m.
// And let's get its transpose, just because we can:
var m3 = m.GetSubmatrix(0, 3, 1, 0, 3, 1,
    TransposeOperation.Transpose);

Dim m = Matrix.CreateRandom(10, 10)
' Extract the 2nd to the 5th row of m. 
' Start and end columns are supplied manually.
Dim m1 = m.GetSubmatrix(1, 4, 0, 9)
' Extract the odd columns:
' Here we need to supply the transpose parameter.
Dim m2 = m.GetSubmatrix(0, 9, 1, 1, 10, 2, TransposeOperation.None)
' Extract the 4x4 leading sub-matrix of m.
' And let's get its transpose, just because we can:
Dim m3 = m.GetSubmatrix(0, 3, 1, 0, 3, 1,
    TransposeOperation.Transpose)

let m = Matrix.CreateRandom(10, 10)
// Extract the 2nd to the 5th row of m. 
// Start and end columns are supplied manually.
let m1 = m.GetSubmatrix(1, 4, 0, 9)
// Extract the odd columns:
// Here we need to supply the transpose parameter.
let m2 = m.GetSubmatrix(0, 9, 1, 1, 10, 2, TransposeOperation.None)
// Extract the 4x4 leading sub-matrix of m.
// And let's get its transpose, just because we can:
let m3 = m.GetSubmatrix(0, 3, 1, 0, 3, 1,
            TransposeOperation.Transpose)

Notice how in the last sample, the transpose of the sub-matrix was returned. You can still assign to sub-matrices using the CopyTo method:

C++

Copy

var m = Matrix.Create<double>(10, 10);
var ones = Vector.CreateConstant(5, 1.0);
var identity5 = Matrix.CreateDiagonal(ones);
identity5.CopyTo(m.GetSubmatrix(0, 4, 5, 9));
identity5.CopyTo(m.GetSubmatrix(5, 9, 0, 4));

Dim m = Matrix.Create(Of Double)(10, 10)
Dim ones = Vector.CreateConstant(5, 1.0)
Dim identity5 = Matrix.CreateDiagonal(ones)
identity5.CopyTo(m.GetSubmatrix(0, 4, 5, 9))
identity5.CopyTo(m.GetSubmatrix(5, 9, 0, 4))

let m = Matrix.Create<double>(10, 10)
let ones = Vector.CreateConstant(5, 1.0)
let identity5 = Matrix.CreateDiagonal(ones)
identity5.CopyTo(m.GetSubmatrix(0, 4, 5, 9)) |> ignore
identity5.CopyTo(m.GetSubmatrix(5, 9, 0, 4)) |> ignore

Send comments on this topic to support@extremeoptimization.com

Copyright © 2004-2023, Extreme Optimization. All rights reserved.
Extreme Optimization, Complexity made simple, M#, and M Sharp are trademarks of ExoAnalytics Inc.
Microsoft, Visual C#, Visual Basic, Visual Studio, Visual Studio.NET, and the Optimized for Visual Studio logo
are registered trademarks of Microsoft Corporation.