def ludcmp_chol(matrix, test=False):
"""
Decomposes/factorizes square, positive definite input matrix into
one lower and one upper matrix. The upper matrix is the transpose of
the lower matrix.
NB. It only works on square, symmetric, positive definite matrices!!!
"""
if test:
errortext1 = "Input matrix not positive definite in ludcmp_chol!"
assert is_posdefinite(matrix), errortext1
errortext2 = "Input matrix not symmetric in ludcmp_chol!"
assert is_symmetrical(matrix), errortext2
ndim = squaredim(matrix, 'ludcmp_chol')
# Create new square matrix of the same size as the input matrix:
clower = Matrix()
clower.zero(ndim, ndim)
# Perform the necessary manipulations:
for k in range(0, ndim):
kp1 = k + 1
for j in range(0, kp1):
summ = 0.0
for i in range(0, j): summ += clower[k][i]*clower[j][i]
if j == k: clower[k][j] = sqrt(matrix[k][j] - summ)
else: clower[k][j] = (matrix[k][j]-summ) / float(clower[j][j])
clowert = transposed(clower)
return clower, clowert
def is_posdefinite(matrix):
"""
The test for positive definiteness using the determinants of the nested
principal minor matrices is taken from Varian; "Microeconomic Analysis".
Returns True if input matrix is positive definite, False otherwise.
"""
flag = True
ndim = squaredim(matrix, 'is_posdefinite')
for k in range(0, ndim):
'''# Test No. 1 - Necessary condition for positive SEMI-definiteness:
if matrix[k][k] <= 0.0:
flag = False
break'''
# (Test No. 2 -) Sufficient condition for positive definiteness:
minor = Matrix()
kp1 = k + 1
minor.zero(kp1, kp1)
for j in range(0, kp1):
for i in range(0, kp1): minor[j][i] = matrix[j][i]
x = determinant(minor)
del minor
if x <= 0.0:
flag = False
break
return flag
def ludcmp_crout(matrix):
"""
Decomposes/factorizes square input matrix into a lower and an
upper matrix using Crout's algorithm WITHOUT pivoting.
NB. It only works for square matrices!!!
"""
ndim = squaredim(matrix, 'ludcmp_crout')
# Copy object instance to new matrix in order for the original instance
# not to be destroyed.
# Create two new square matrices of the same sized as the input matrix:
# one unity matrix (to be the lower matrix), one zero matrix (to be
# the upper matrix)
copymx = deepcopy(matrix)
lower = Matrix()
lower.unity(ndim)
upper = Matrix()
upper.zero(ndim, ndim)
permlist = list(range(0, ndim))
# Perform the necessary manipulations:
for j in range(0, ndim):
iu = 0
while iu <= j:
k = 0
summ = 0.0
while k < iu:
summ += lower[iu][k]*upper[k][j]
k = k + 1
upper[iu][j] = copymx[iu][j] - summ
iu = iu + 1
il = j + 1
while il < ndim:
k = 0
summ = 0.0
while k < j:
summ += lower[il][k]*upper[k][j]
k = k + 1
divisor = float(upper[j][j])
if abs(divisor) < TINY: divisor = fsign(divisor)*TINY
lower[il][j] = (copymx[il][j]-summ) / divisor
il = il + 1
parity = 1.0
return lower, upper, permlist, parity
def ludcmp_crout(matrix):
"""
Decomposes/factorizes square input matrix into a lower and an
upper matrix using Crout's algorithm WITHOUT pivoting.
NB. It only works for square matrices!!!
"""
ndim = squaredim(matrix, 'ludcmp_crout')
# Copy object instance to new matrix in order for the original instance
# not to be destroyed.
# Create two new square matrices of the same sized as the input matrix:
# one unity matrix (to be the lower matrix), one zero matrix (to be
# the upper matrix)
copymx = deepcopy(matrix)
lower = Matrix()
lower.unity(ndim)
upper = Matrix()
upper.zero(ndim, ndim)
permlist = list(range(0, ndim))
# Perform the necessary manipulations:
for j in range(0, ndim):
iu = 0
while iu <= j:
k = 0
summ = 0.0
while k < iu:
summ += lower[iu][k] * upper[k][j]
k = k + 1
upper[iu][j] = copymx[iu][j] - summ
iu = iu + 1
il = j + 1
while il < ndim:
k = 0
summ = 0.0
while k < j:
summ += lower[il][k] * upper[k][j]
k = k + 1
divisor = float(upper[j][j])
if abs(divisor) < TINY: divisor = fsign(divisor) * TINY
lower[il][j] = (copymx[il][j] - summ) / divisor
il = il + 1
parity = 1.0
return lower, upper, permlist, parity
def inverted(matrix, pivoting=True):
"""
Only square matrices can be inverted!
"""
ndim = squaredim(matrix, 'inverted')
# First: LU-decompose matrix to be inverted
if pivoting:
lower, upper, permlist, parity = ludcmp_crout_piv(matrix)
else:
lower, upper, permlist, parity = ludcmp_crout(matrix)
# Create unity matrix
unitymatrix = Matrix()
unitymatrix.unity(ndim)
# Loop over the columns in unity matrix and substitute
# (uses the fact that rows and columns are the same in a unity matrix)
columns = Matrix()
columns.zero(ndim, ndim)
for k in range(0, ndim):
columns[k] = lusubs(lower, upper, unitymatrix[k], permlist)
# preparations below for changing lusubs to handling column vector
# instead of list
#row = Matrix([unitymatrix[k]])
#column = transpose(row)
#columns[k] = lusubs(lower, upper, column, permlist)
#del column
# Transpose matrix to get inverse
newmatrix = ndim * [float('nan')]
for k in range(0,
ndim): # List comprehension is used for the innermost loop
newmatrix[k] = array('d', [row[k] for row in columns])
imatrix = Matrix(newmatrix)
del newmatrix
return imatrix
def inverted(matrix, pivoting=True):
"""
Only square matrices can be inverted!
"""
ndim = squaredim(matrix, 'inverted')
# First: LU-decompose matrix to be inverted
if pivoting:
lower, upper, permlist, parity = ludcmp_crout_piv(matrix)
else:
lower, upper, permlist, parity = ludcmp_crout(matrix)
# Create unity matrix
unitymatrix = Matrix()
unitymatrix.unity(ndim)
# Loop over the columns in unity matrix and substitute
# (uses the fact that rows and columns are the same in a unity matrix)
columns = Matrix()
columns.zero(ndim, ndim)
for k in range(0, ndim):
columns[k] = lusubs(lower, upper, unitymatrix[k], permlist)
# preparations below for changing lusubs to handling column vector
# instead of list
#row = Matrix([unitymatrix[k]])
#column = transpose(row)
#columns[k] = lusubs(lower, upper, column, permlist)
#del column
# Transpose matrix to get inverse
newmatrix = ndim*[float('nan')]
for k in range(0, ndim): # List comprehension is used for the innermost loop
newmatrix[k] = array('d', [row[k] for row in columns])
imatrix = Matrix(newmatrix)
del newmatrix
return imatrix
def ludcmp_crout_piv(matrix):
"""
Decomposes/factorizes square input matrix into a lower
and an upper matrix using Crout's algorithm WITH pivoting.
NB. It only works on square matrices!!!
"""
ndim = squaredim(matrix, 'ludcmp_crout_piv')
ndm1 = ndim - 1
vv = array('d', ndim*[0.0])
permlist = list(range(0, ndim))
parity = 1.0
imax = 0
# Copy to matrix to be processed (maintains the original matrix intact)
compactlu = deepcopy(matrix)
for i in range(0, ndim): # Copy and do some other stuff
big = 0.0
for j in range(0, ndim):
temp = abs(compactlu[i][j])
if temp > big: big = temp
assert big > 0.0
vv[i] = 1.0/big
# Perform the necessary manipulations:
for j in range(0, ndim):
for i in range(0, j):
sum = compactlu[i][j]
for k in range(0, i): sum -= compactlu[i][k] * compactlu[k][j]
compactlu[i][j] = sum
big = 0.0
for i in range(j, ndim):
sum = compactlu[i][j]
for k in range(0, j): sum -= compactlu[i][k] * compactlu[k][j]
compactlu[i][j] = sum
dum = vv[i] * abs(sum)
if dum > big:
big = dum
imax = i
if j != imax:
# Substitute row imax and row j
imaxdum = permlist[imax] # NB in !!!!!!!!!!!!!!!!
jdum = permlist[j] # NB in !!!!!!!!!!!!!!!!
permlist[j] = imaxdum # NB in !!!!!!!!!!!!!!!!
permlist[imax] = jdum # NB in !!!!!!!!!!!!!!!!
for k in range(0, ndim):
dum = compactlu[imax][k]
compactlu[imax][k] = compactlu[j][k]
compactlu[j][k] = dum
parity = - parity
vv[imax] = vv[j]
#permlist[j] = imax # NB out !!!!!!!!!!!!!!!!!!!!!
divisor = float(compactlu[j][j])
if abs(divisor) < TINY: divisor = fsign(divisor)*TINY
dum = 1.0 / divisor
if j != ndm1:
jp1 = j + 1
for i in range(jp1, ndim): compactlu[i][j] *= dum
lower = Matrix()
lower.zero(ndim, ndim)
upper = Matrix()
upper.zero(ndim, ndim)
for i in range(0, ndim):
for j in range(i, ndim): lower[j][i] = compactlu[j][i]
for i in range(0, ndim):
lower[i][i] = 1.0
for i in range(0, ndim):
for j in range(i, ndim): upper[i][j] = compactlu[i][j]
del compactlu
return lower, upper, permlist, parity
def ludcmp_crout_piv(matrix):
"""
Decomposes/factorizes square input matrix into a lower
and an upper matrix using Crout's algorithm WITH pivoting.
NB. It only works on square matrices!!!
"""
ndim = squaredim(matrix, 'ludcmp_crout_piv')
ndm1 = ndim - 1
vv = array('d', ndim * [0.0])
permlist = list(range(0, ndim))
parity = 1.0
imax = 0
# Copy to matrix to be processed (maintains the original matrix intact)
compactlu = deepcopy(matrix)
for i in range(0, ndim): # Copy and do some other stuff
big = 0.0
for j in range(0, ndim):
temp = abs(compactlu[i][j])
if temp > big: big = temp
assert big > 0.0
vv[i] = 1.0 / big
# Perform the necessary manipulations:
for j in range(0, ndim):
for i in range(0, j):
sum = compactlu[i][j]
for k in range(0, i):
sum -= compactlu[i][k] * compactlu[k][j]
compactlu[i][j] = sum
big = 0.0
for i in range(j, ndim):
sum = compactlu[i][j]
for k in range(0, j):
sum -= compactlu[i][k] * compactlu[k][j]
compactlu[i][j] = sum
dum = vv[i] * abs(sum)
if dum > big:
big = dum
imax = i
if j != imax:
# Substitute row imax and row j
imaxdum = permlist[imax] # NB in !!!!!!!!!!!!!!!!
jdum = permlist[j] # NB in !!!!!!!!!!!!!!!!
permlist[j] = imaxdum # NB in !!!!!!!!!!!!!!!!
permlist[imax] = jdum # NB in !!!!!!!!!!!!!!!!
for k in range(0, ndim):
dum = compactlu[imax][k]
compactlu[imax][k] = compactlu[j][k]
compactlu[j][k] = dum
parity = -parity
vv[imax] = vv[j]
#permlist[j] = imax # NB out !!!!!!!!!!!!!!!!!!!!!
divisor = float(compactlu[j][j])
if abs(divisor) < TINY: divisor = fsign(divisor) * TINY
dum = 1.0 / divisor
if j != ndm1:
jp1 = j + 1
for i in range(jp1, ndim):
compactlu[i][j] *= dum
lower = Matrix()
lower.zero(ndim, ndim)
upper = Matrix()
upper.zero(ndim, ndim)
for i in range(0, ndim):
for j in range(i, ndim):
lower[j][i] = compactlu[j][i]
for i in range(0, ndim):
lower[i][i] = 1.0
for i in range(0, ndim):
for j in range(i, ndim):
upper[i][j] = compactlu[i][j]
del compactlu
return lower, upper, permlist, parity
