ref: a5cb451b299b03f44154fac5780b6a57ca130ce0
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; } } } }