ref: a411870ee4640241e3c494367d922847da84f972
dir: /appl/math/linalg.b/
implement LinAlg;
include "sys.m";
sys: Sys;
print: import sys;
include "math.m";
math: Math;
ceil, fabs, floor, Infinity, log10, pow10, sqrt: import math;
dot, gemm, iamax: import math;
include "linalg.m";
# print a matrix in MATLAB-compatible format
printmat(label:string, a:array of real, lda, m, n:int)
{
if(m>30 || n>10)
return;
if(sys==nil){
sys = load Sys Sys->PATH;
math = load Math Math->PATH;
}
print("%% %d by %d matrix\n",m,n);
print("%s = [",label);
for(i:=0; i<m; i++){
print("%.4g",a[i]);
for(j:=1; j<n; j++)
print(", %.4g",a[i+lda*j]);
if(i==m-1)
print("]\n");
else
print(";\n");
}
}
# Constant times a vector plus a vector.
daxpy(da:real, dx:array of real, dy:array of real)
{
n := len dx;
gemm('N','N',n,1,n,da,nil,0,dx,n,1.,dy,n);
}
# Scales a vector by a constant.
dscal(da:real, dx:array of real)
{
n := len dx;
gemm('N','N',n,1,n,0.,nil,0,nil,0,da,dx,n);
}
# gaussian elimination with partial pivoting
# dgefa factors a double precision matrix by gaussian elimination.
# dgefa is usually called by dgeco, but it can be called
# directly with a saving in time if rcond is not needed.
# (time for dgeco) = (1 + 9/n)*(time for dgefa) .
# on entry
# a REAL precision[n][lda]
# the matrix to be factored.
# lda integer
# the leading dimension of the array a .
# n integer
# the order of the matrix a .
# on return
# a an upper triangular matrix and the multipliers
# which were used to obtain it.
# the factorization can be written a = l*u where
# l is a product of permutation and unit lower
# triangular matrices and u is upper triangular.
# ipvt integer[n]
# an integer vector of pivot indices.
# info integer
# = 0 normal value.
# = k if u[k][k] .eq. 0.0 . this is not an error
# condition for this subroutine, but it does
# indicate that dgesl or dgedi will divide by zero
# if called. use rcond in dgeco for a reliable
# indication of singularity.
dgefa(a:array of real, lda, n:int, ipvt:array of int): int
{
if(sys==nil){
sys = load Sys Sys->PATH;
math = load Math Math->PATH;
}
info := 0;
nm1 := n - 1;
if(nm1 >= 0)
for(k := 0; k < nm1; k++){
kp1 := k + 1;
ldak := lda*k;
# find l = pivot index
l := iamax(a[ldak+k:ldak+n]) + k;
ipvt[k] = l;
# zero pivot implies this column already triangularized
if(a[ldak+l]!=0.){
# interchange if necessary
if(l!=k){
t := a[ldak+l];
a[ldak+l] = a[ldak+k];
a[ldak+k] = t;
}
# compute multipliers
t := -1./a[ldak+k];
dscal(t,a[ldak+k+1:ldak+n]);
# row elimination with column indexing
for(j := kp1; j < n; j++){
ldaj := lda*j;
t = a[ldaj+l];
if(l!=k){
a[ldaj+l] = a[ldaj+k];
a[ldaj+k] = t;
}
daxpy(t,a[ldak+k+1:ldak+n],a[ldaj+k+1:ldaj+n]);
}
}else
info = k;
}
ipvt[n-1] = n-1;
if(a[lda*(n-1)+(n-1)] == 0.)
info = n-1;
return info;
}
# dgesl solves the double precision system
# a * x = b or trans(a) * x = b
# using the factors computed by dgeco or dgefa.
# on entry
# a double precision[n][lda]
# the output from dgeco or dgefa.
# lda integer
# the leading dimension of the array a .
# n integer
# the order of the matrix a .
# ipvt integer[n]
# the pivot vector from dgeco or dgefa.
# b double precision[n]
# the right hand side vector.
# job integer
# = 0 to solve a*x = b ,
# = nonzero to solve trans(a)*x = b where
# trans(a) is the transpose.
# on return
# b the solution vector x .
# error condition
# a division by zero will occur if the input factor contains a
# zero on the diagonal. technically this indicates singularity
# but it is often caused by improper arguments or improper
# setting of lda.
dgesl(a:array of real, lda, n:int, ipvt:array of int, b:array of real, job:int)
{
nm1 := n - 1;
if(job == 0){ # job = 0 , solve a * x = b
# first solve l*y = b
if(nm1 >= 1)
for(k := 0; k < nm1; k++){
l := ipvt[k];
t := b[l];
if(l!=k){
b[l] = b[k];
b[k] = t;
}
daxpy(t,a[lda*k+k+1:lda*k+n],b[k+1:n]);
}
# now solve u*x = y
for(kb := 0; kb < n; kb++){
k = n - (kb + 1);
b[k] = b[k]/a[lda*k+k];
t := -b[k];
daxpy(t,a[lda*k:lda*k+k],b[0:k]);
}
}else{ # job = nonzero, solve trans(a) * x = b
# first solve trans(u)*y = b
for(k := 0; k < n; k++){
t := dot(a[lda*k:lda*k+k],b[0:k]);
b[k] = (b[k] - t)/a[lda*k+k];
}
# now solve trans(l)*x = y
if(nm1 >= 1)
for(kb := 1; kb < nm1; kb++){
k = n - (kb+1);
b[k] += dot(a[lda*k+k+1:lda*k+n],b[k+1:n]);
l := ipvt[k];
if(l!=k){
t := b[l];
b[l] = b[k];
b[k] = t;
}
}
}
}