# Linear Equations in IronPython QuickStart Sample

Illustrates how to solve systems of simultaneous linear equations in IronPython.

View this sample in: C# Visual Basic F#

```Python import numerics # The DenseMatrix and LUDecomposition classes reside in the # Extreme.Mathematics.LinearAlgebra namespace. from Extreme.Mathematics import * from Extreme.Mathematics.LinearAlgebra import * # Illustrates solving systems of simultaneous linear # equations using the DenseMatrix and LUDecomposition classes # in the Extreme.Mathematics.LinearAlgebra namespace of the Extreme # Optimization Mathematics Library for .NET. # A system of simultaneous linear equations is # defined by a square matrix A and a right-hand # side B, which can be a vector or a matrix. # # You can use any matrix type for the matrix A. # The optimal algorithm is automatically selected. # Let's start with a general matrix: m = Matrix([[1, 1, 1, 1], [1, 2, 4, 2], [1, 3, 9, 1], [1, 4, 16, 2]]) b1 = Vector([ 1, 3, 6, 3 ]) b2 = Matrix([[1, 6], [2, 5], [3, 3], [3, 8]]) print "m = {0:.4f}".format(m) # # The Solve method # # The following solves m x = b1. The second # parameter specifies whether to overwrite the # right-hand side with the result. x1 = m.Solve(b1, False) print "x1 = {0:.4f}".format(x1) # If the overwrite parameter is omitted, the # right-hand-side is overwritten with the solution: m.Solve(b1) print "b1 = {0:.4f}".format(b1) # You can solve for multiple right hand side # vectors by passing them in a DenseMatrix: x2 = m.Solve(b2, False) print "x2 = {0:.4f}".format(x2) # # Related Methods # # You can verify whether a matrix is singular # using the IsSingular method: print "IsSingular(m) =", m.IsSingular() # The inverse matrix is returned by the Inverse # method: print "Inverse(m) = {0:.4f}".format(m.GetInverse()) # The determinant is also available: print "Det(m) = {0:.4f}".format(m.GetDeterminant()) # The condition number is an estimate for the # loss of precision in solving the equations print "Cond(m) = {0:.4f}".format(m.EstimateConditionNumber()) print # # The LUDecomposition class # # If multiple operations need to be performed # on the same matrix, it is more efficient to use # the LUDecomposition class. This class does the # bulk of the calculations only once. print "Using LU Decomposition:" # The constructor takes an optional second argument # indicating whether to overwrite the original # matrix with its decomposition: lu = m.GetLUDecomposition(False) # All methods mentioned earlier are still available: x2 = lu.Solve(b2, False) print "x2 = {0:.4f}".format(x2) print "IsSingular(m) =", lu.IsSingular() print "Inverse(m) = {0:.4f}".format(lu.GetInverse()) print "Det(m) = {0:.4f}".format(lu.GetDeterminant()) print "Cond(m) = {0:.4f}".format(lu.EstimateConditionNumber()) # In addition, you have access to the # components, L and U of the decomposition. # L is lower unit-triangular: print " L = {0:.4f}".format(lu.LowerTriangularFactor) # U is upper triangular: print " U = {0:.4f}".format(lu.UpperTriangularFactor) ```