Matrix-Vector Operations in IronPython QuickStart Sample

Illustrates how to perform operations that involve both matrices and vectors in IronPython.

This sample is also available in: C#, Visual Basic, F#.

Overview

This QuickStart sample demonstrates how to perform common operations involving both matrices and vectors using Numerics.NET.

The sample covers several key areas of matrix and vector operations:

Basic matrix arithmetic including addition, subtraction and matrix multiplication
Matrix-vector products, both left multiplication (Mv) and right multiplication (vM)
In-place operations combining matrices and vectors like adding or subtracting matrix-vector products
Computing matrix norms including one-norm, infinity norm and Frobenius norm
Matrix operations like computing the trace and transpose

The code shows how to create matrices and vectors, perform calculations efficiently, and access properties of the results. It demonstrates proper usage of operator overloading and specialized methods for combined operations. The sample includes detailed comments explaining each operation and its mathematical significance.

The code

import numerics

from Extreme.Mathematics import *

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

# Illustrates operations on DenseMatrix objects and combined
# operations on Vector and DenseMatrix objects from the
# Extreme.Mathematics.LinearAlgebra namespace of Extreme Numerics.NET.

# For details on the basic workings of Vector 
# objects, including constructing, copying and
# cloning vectors, see the BasicVectors QuickStart
# Sample.
#
# For details on the basic workings of DenseMatrix
# objects, including constructing, copying and
# cloning vectors, see the BasicVectors QuickStart
# Sample.
#
# Let's create some vectors to work with.
v1 = Vector([1, 2, 3, 4, 5])
v2 = Vector([1, -2, 3, -4, 5])
print "v1 = {0:.4f}".format(v1)
print "v2 = {0:.4f}".format(v2)

# Also, here are a couple of matrices.
# We start out with a 5x5 identity matrix:
m1 = DenseMatrix.GetIdentity(5)
# Now we use the GetDiagonal method and combine it
# with the SetValue method of the Vector class to
# set some of the off-diagonal elements:
m1.GetDiagonal(1).SetValue(2)
m1.GetDiagonal(2).SetValue(3)
m1.GetDiagonal(-1).SetValue(4)
print "m1 = {0:.4f}".format(m1)
# We define our second matrix by hand:
m2 = Matrix([[1,1,1,1,1], [2,3,4,8,-1], [3,5,9,27,1], [4,7,16,64,-1], [5,9,25,125,1]])
print "m2 = {0:.4f}".format(m2)
print 
			
#
# Matrix arithmetic
#

# The Matrix class defines operator overloads for
# addition, subtraction, and multiplication of
# matrices.

# Addition:
print "Matrix arithmetic:"
m = m1 + m2
print "m1 + m2 = {0:.4f}".format(m)
# Subtraction:
m = m1 - m2
print "m1 - m2 = {0:.4f}".format(m)
# Multiplication is the True matrix product:
m = m1 * m2
print "m1 * m2 = {0:.4f}".format(m)
print 

#
# Matrix-Vector products
#

# The DenseMatrix class defines overloaded addition, # subtraction, and multiplication operators 
# for vectors and matrices:
print "Matrix-vector products:"
v = m1 * v1
print "m1 v1 = {0:.4f}".format(v)
# You can also multiply a vector by a matrix on the right.
# This is equivalent to multiplying on the left by the 
# transpose of the matrix:
v = v1 * m1
print "v1 m1 = {0:.4f}".format(v)
			
# Now for some methods of the Vector class that
# involve matrices:
# Add a product of a matrix and a vector:
v.Add(m1, v1)
print "v + m1 v1 = {0:.4f}".format(v)
# Or add a scaled product:
v.Add(-2, m1, v2)
print "v - 2 m1 v2 = {0:.4f}".format(v)
# You can also use static Subtract methods:
v.Subtract(m1, v1)
print "v - m1 v1 = {0:.4f}".format(v)
print 

#
# Matrix norms
#
print "Matrix norms"
# Matrix norms are not as easily defined as
# vector norms. Three matrix norms are available.
# 1. The one-norm through the OneNorm property:
a = m2.OneNorm()
print "OneNorm of m2 = {0:.4f}".format(a)
# 2. The infinity norm through the 
#    InfinityNorm property:
a = m2.InfinityNorm()
print "InfinityNorm of m2 = {0:.4f}".format(a)
# 3. The Frobenius norm is often used because it
#    is easy to calculate.
a = m2.FrobeniusNorm()
print "FrobeniusNorm of m2 = {0:.4f}".format(a)
print 

# The trace of a matrix is the sum of its diagonal
# elements. It is returned by the Trace property:
a = m2.Trace()
print "Trace(m2) = {0:.4f}".format(a)

# The Transpose method returns the transpose of a 
# matrix. This transposed matrix shares element storage
# with the original matrix. Use the CloneData method
# to give the transpose its own data storage.
m = m2.Transpose()
print "Transpose(m2) = {0:.4f}".format(m)