Accessing Matrix Components QuickStart Sample (IronPython)

```Python
import numerics

# The Vector and Vector classes resides in the 
# Extreme.Mathematics.LinearAlgebra namespace.
from Extreme.Mathematics import *
from Extreme.Mathematics.LinearAlgebra import *

from System import Array

#/ Illustrates accessing matrix components and iterating 
#/ through the rows and columns of a matrix. Matrix classes
#/ reside in the Extreme.Mathematics.LinearAlgebra namespace 
#/ of the Extreme Optimization Mathematics Library for .NET.

# We'll work with this matrix:
m = Matrix.Create(2, 3, \
    Array[float]([ 1, 2, 3, 4, 5, 6 ]), \
    MatrixElementOrder.ColumnMajor)

#
# Individual components
#
# The Matrix class has an indexer property that takes two arguments:
# the row and column index. Both are zero based.
print "m[1,1] =", m[1, 1]

#
# Rows and columns
#

# Indexed range access

# The indexer property is overloaded to allow for direct indexed access 
# to complete or partial rows or columns.

row1 = m[0, 1:3]
# This prints "[3, 5]":
print "row1 =", row1

# The special range : lets you access an entire row
# or column without having to specify any details about the range.
row2 = m[1, :]
# This prints "[2, 4, 6]":
print "2nd row =", row2
column1 = m[:, 0]
# This prints "[1, 2]":
print "column1 =", column1

# We can assign to rows and columns, too:
m[:, 0] = row1
# This prints "[[3, 3, 5] [5, 4, 6]]"
print "m =", m

# GetRow and GetColumn provide an alternate mechanism 
# for achieving the same result.

# Passing just one parameter retrieves the specified row or column:
row1 = m.GetRow(1)
# This prints "[2, 4, 6]":
print "row1 =", row1
column1 = m.GetColumn(0)
# This prints "[1, 2]":
print "column1 =", column1

# You can also pass a start and end index:
row2 = m.GetRow(0, 1, 2)
# This prints "[3, 5]":
print "row2 =", row2

# We can assign to rows and columns, too, using CopyTo:
row2.CopyTo(m.GetColumn(0))
# This prints "[[3, 3, 5] [5, 4, 6]]"
print "m =", m

# Enumeration

# The Rows and Columns methods allow you to enumerate over 
# the rows and columns of a matrix.

# For example: this calculates the sum of the absolute values
# of the components of the matrix m:
sum = 0
for column in m.Columns:
	sum += column.OneNorm()
	
#
# Accessing diagonals
#

# Diagonals are retrieved using the GetDiagonal method:
mainDiagonal = m.GetDiagonal()
# An optional parameter specifies which diagonal:
#   n < 0 means subdiagonal
#   n > 0 means nth superdiagonal:
superDiagonal = m.GetDiagonal(1)

#
# Accessing submatrices
#

# Indexed range access
			
# A fourth overload of the indexer property lets you 
# extract a part of a matrix. Both parameters are Range 
# structures:
a = Matrix.Create(10, 10)
# Extract the 2nd to the 5th row of m:
a1 = a[1:5, :]
# Extract the odd columns:
a2 = a[:, 1:10:2]
# Extract the 4x4 leading submatrix of m:
a3 = a[0:4, 0:4]

# You can also assign to submatrices:
identity5 = DenseMatrix.GetIdentity(5)
a[0:5, 5:10] = identity5
a[5:10, 0:5] = identity5

# The same results can be achieved with the GetSubmatrix method.

# Extract the 2nd to the 5th row of m. 
# Start and end columns are supplied manually.
a4 = a.GetSubmatrix(1, 4, 0, 9)
# Extract the odd columns:
# Here we need to supply the transpose parameter.
a5 = a.GetSubmatrix(0, 9, 1, 1, 9, 2, TransposeOperation.None)
# Extract the 4x4 leading submatrix of m.
# And let's get its transpose, just because we can.
# We need to specify the row and column stride:
a6 = a.GetSubmatrix(0, 3, 1, 0, 3, 1, TransposeOperation.Transpose)

# You can still assign to submatrices, using the
# CopyTo method:
identity5.CopyTo(a.GetSubmatrix(0, 4, 5, 9))
identity5.CopyTo(a.GetSubmatrix(5, 9, 0, 4))
```