#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#		"End of shell archive."
# Contents:  macros.h macros.ps matalloc.c matalloc.h matio.c matio.h
#   mattrans.c mattrans.h matutil.c matutil.h
# Wrapped by karin@borodin on Wed Jul 24 21:33:22 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'macros.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'macros.h'\"
else
echo shar: Extracting \"'macros.h'\" \(825 characters\)
sed "s/^X//" >'macros.h' <<'END_OF_FILE'
X#define REAL	double
X
X#define nil NULL
X#define ZERO 	0.0
X#define ONE 	1.0
X#define HALF 	0.5
X
X#define BOOLEAN int
X#define TRUE 	1
X#define YES 	1
X#define OK 		1
X#define FALSE	0
X#define NO 		0
X
X#define FOREVER for(;;)
X
X#define SQR(x) ((x)*(x))
X
X#define SWAP(a,b,temp) {temp=a; a=b; b=temp;}
X#define DSWAP(a,b) {double temp=a; a=b; b=temp;}
X#define ISWAP(a,b) {int temp=a; a=b; b=temp;}
X
X#define MAX(a,b) (((a)>=(b)) ? a : b)
X#define MIN(a,b) (((a)<=(b)) ? a : b)
X
X#define DABS(a) (((a)>=0) ? a : -a)
X
X#define EPS_MACH 1e-22
X#define SQRT_EPS_MACH 1e-11
X
X#define PI			3.141592654
X#define PI_HALF 	1.570796327
X#define SQRT2		1.414213562
X#define SQRT3		1.732050808
X#define SQRT6		2.449489743
X#define SQRT37		6.082762530
X
X#define POWER(x,i) (pow(x,(double)(i)))
X#define COS(x) (cos(x))
X#define SIN(x) (sin(x))
X#define EXP(x) (exp(x))
END_OF_FILE
if test 825 -ne `wc -c <'macros.h'`; then
    echo shar: \"'macros.h'\" unpacked with wrong size!
fi
# end of 'macros.h'
fi
if test -f 'macros.ps' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'macros.ps'\"
else
echo shar: Extracting \"'macros.ps'\" \(1101 characters\)
sed "s/^X//" >'macros.ps' <<'END_OF_FILE'
X%!
X/scalefactor 1200.0 def
X/L {lineto} def
X/M {moveto} def          
X/S {stroke} def
X/NP {newpath} def
X/CP {closepath} def
X/SD {setdash} def         
X/SL {setlinewidth} def
X/SG {setgray} def
X/Palatino-Roman findfont
Xscalefactor scalefont setfont
X5.00 setlinewidth
X2 setlinejoin
X0.01 0.01 scale
X
X%----------------------------------------------------------------------
X% operator: alignedshow
X% usage:	<halign> <valign> <string> alignedshow
X%----------------------------------------------------------------------
X
X/left   1 def
X/center 2 def
X/right  3 def
X
X/top    1 def
X/bottom 3 def
X
X/alignedshow {
X	dup stringwidth
X	pop
X	4 -1 roll
X	dup left eq {pop pop 0} {center eq {2 div neg} {neg} ifelse } ifelse
X	scalefactor
X	4 -1 roll
X	dup bottom eq {pop pop 0} {center eq {0.24 mul neg} {neg} ifelse } ifelse
X	rmoveto
X	show
X} def
X
X
X%----------------------------------------------------------------------
X% operator: AT (mnemonics for 'aligned text')
X% usage:	<halign> <valign> <string> <x> <y> alignedshow
X%----------------------------------------------------------------------
X
X/AT {moveto alignedshow} def
X
END_OF_FILE
if test 1101 -ne `wc -c <'macros.ps'`; then
    echo shar: \"'macros.ps'\" unpacked with wrong size!
fi
# end of 'macros.ps'
fi
if test -f 'matalloc.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'matalloc.c'\"
else
echo shar: Extracting \"'matalloc.c'\" \(7868 characters\)
sed "s/^X//" >'matalloc.c' <<'END_OF_FILE'
X/*--------------------------------------------------------------------------
X    matalloc.c
X
X      matrix and vector routines from 'Numerical Recipes in C',
X      Appendix D, p. 705 ff.
X
X   mnemonics
X        
X       n = number of, l = lower bound, h = higher bound,
X       r = row, c = column, v = vector, m = matrix
X
X    typical usage 
X
X        double **a = dmatrix(1,m,1,n);
X        int *v = ivector(1,n);
X
X        ...
X
X        free_dmatrix(a,1,m,1,n);
X        free_ivector(v,1,n);    
X--------------------------------------------------------------------------*/
X
X#include <malloc.h>
X#include <strings.h>
X#include <stdio.h>
X
X#include "macros.h"
X#include "matalloc.h"
X
X#define nil NULL
X
Xvoid  error(error_text)
X    char            error_text[];
X{
X    void            exit();
X    /*
X     * Termination of program. All buffers were flushed and all files
X     * were closed. The value in brackets is returned to the calling
X     * process.0 = correct end of program and any other value means that
X     * an error occured
X     */
X    fprintf(stderr, "\n\n%s\n", error_text);
X    exit(1);
X}
X
Xfloat *vector(nl, nh)
X    int             nl, nh;
X{
X    float          *v;
X    v = (float *) malloc((unsigned) (nh - nl + 1) * sizeof(float));
X    if (!v)
X        error("Allocation failure in vector()");
X    return v - nl;
X}
X
Xint *ivector(nl, nh)
X    int             nl, nh;
X{
X    int            *v;
X    if (nh < nl) return nil;
X    v = (int *) malloc((unsigned) (nh - nl + 1) * sizeof(int));
X    if (!v)
X        error("Allocation failure in ivector()");
X    return v - nl;
X}
X
Xdouble  *dvector(nl, nh)
X    int nl, nh;
X{
X    double *v;
X    if (nh < nl) return nil;
X    v = (double *) malloc((unsigned) (nh - nl + 1) * sizeof(double));
X    if (!v)
X        error("Allocation failure in dvector()");
X    return v - nl;
X}
X
Xfloat **matrix(nrl, nrh, ncl, nch)
X    int nrl, nrh, ncl, nch;
X{
X    int             i;
X    float         **m;
X    m = (float **) malloc((unsigned) (nrh - nrl + 1) * sizeof(float *));
X    if (!m)
X        error("Allocation failure 1 in matrix()");
X    m -= nrl;
X    for (i = nrl; i <= nrh; i++) {
X        m[i] = (float *) malloc((unsigned) (nch - ncl + 1) * sizeof(float));
X        if (!m[i])
X            error("Allocation failure 2 in matrix()");
X        m[i] -= ncl;
X    } return m;
X}
X
X
Xdouble **dmatrix(nrl, nrh, ncl, nch)
X    int nrl, nrh, ncl, nch;
X{
X    int             i;
X    double        **m;
X    m = (double **) malloc((unsigned) (nrh - nrl + 1) * sizeof(double *));
X    if (!m)
X        error("Allocation failure 1 in dmatrix()");
X    m -= nrl;
X    for (i = nrl; i <= nrh; i++) {
X        m[i] = (double *) malloc((unsigned) (nch - ncl + 1) * sizeof(double));
X        if (!m[i])
X            error("Allocation failure 2 in dmatrix()");
X        m[i] -= ncl;
X    } return m;
X}
X
Xint **imatrix(nrl, nrh, ncl, nch)
X    int nrl, nrh, ncl, nch;
X{
X    int  i, **m;
X    
X    m = (int **) malloc((unsigned) (nrh - nrl + 1) * sizeof(int *));
X    if (!m)
X        error("Allocation failure 1 in imatrix()");
X    m -= nrl;
X    for (i = nrl; i <= nrh; i++) {
X        m[i] = (int *) malloc((unsigned) (nch - ncl + 1) * sizeof(int));
X        if (!m[i])
X            error("Allocation failure 2 in imatrix()");
X        m[i] -= ncl;
X    } return m;
X}
X
Xdouble  **upper_dmatrix(nrl, nrh, ncl, nch)
X    int             nrl, nrh, ncl, nch;
X{
X    int             i, j, new_nrh;
X    double        **m;
X    
X    new_nrh = MIN(nrh-nrl, nch-ncl) + nrl;
X    
X    m = (double **) malloc((unsigned) (new_nrh - nrl + 1) * sizeof(double *));
X    if (!m)
X        error("Allocation failure 1 in dmatrix()");
X    m -= nrl;
X    for (i = nrl, j = ncl; i <= new_nrh; i++, j++) {
X        m[i] = (double *) malloc((unsigned) (nch - j + 1) * sizeof(double));
X        if (!m[i])
X            error("Allocation failure 2 in dmatrix()");
X        m[i] -= j;
X    }
X    return m;
X}
X
X
Xdouble **lower_dmatrix(nrl, nrh, ncl, nch)
X    int nrl, nrh, ncl, nch;
X{
X    double **m;
X    int i, new_nch = ncl;
X    
X    m = (double **) malloc((unsigned) (nrh - nrl + 1) * sizeof(double *));
X    if (!m) error("Allocation failure 1 in lower_dmatrix()");
X    m -= nrl;
X    
X    for (i=nrl; i<=nrh && new_nch<=nch; i++, new_nch++) {
X        m[i] = (double *) malloc((unsigned) (new_nch - ncl + 1) * sizeof(double));
X        if (!m[i]) error("Allocation failure 2 in lower_dmatrix()");
X        m[i] -= ncl;
X    }
X    for (; i<=nrh; i++) {
X        m[i] = (double *) malloc((unsigned) (nch - ncl + 1) * sizeof(double));
X        if (!m[i]) error("Allocation failure 2 in lower_dmatrix()");
X        m[i] -= ncl;
X    }
X    return m;
X}
X
X
Xdouble **dsubmatrix(a, nrl, nrh, ncl, nch, new_nrl, new_ncl)
X    double **a;
X    int nrl, nrh, ncl, nch, new_nrl, new_ncl;
X{
X    double **m;
X    int i, j;
X    
X    m = (double **) malloc((unsigned) (nrh - nrl + 1) * sizeof(double *));
X    if (!m) error("Allocation failure in dsubmatrix()");
X    m -= new_nrl;
X    
X    for (i=nrl, j=new_nrl; i<=nrh; i++, j++)  m[j] = a[i] + ncl - new_ncl;
X    return m;
X}
X
X
Xvoid 
Xfree_vector(v, nl, nh)
X    float          *v;
X    int             nl, nh;
X{
X    if (v!=nil) free((char *) (v + nl));
X}
X
X
Xvoid 
Xfree_ivector(v, nl, nh)
X    int            *v;
X    int             nl, nh;
X{
X    if (v!=nil) free((char *) (v + nl));
X}
X
Xvoid 
Xfree_dvector(v, nl, nh)
X    double         *v;
X    int             nl, nh;
X{
X    if (v!=nil) free((char *) (v + nl));
X}
X
Xvoid 
Xfree_matrix(m, nrl, nrh, ncl, nch)
X    float         **m;
X    int             nrl, nrh, ncl, nch;
X{
X    int             i;
X    for (i = nrh; i >= nrl; i--)
X        free((char *) (m[i] + ncl));
X    free((char *) (m + nrl));
X}
X
Xvoid 
Xfree_dmatrix(m, nrl, nrh, ncl, nch)
X    double        **m;
X    int             nrl, nrh, ncl, nch;
X{
X    int             i;
X    for (i = nrh; i >= nrl; i--)
X        free((char *) (m[i] + ncl));
X    free((char *) (m + nrl));
X}
X
Xvoid 
Xfree_imatrix(m, nrl, nrh, ncl, nch)
X    int           **m;
X    int             nrl, nrh, ncl, nch;
X{
X    int             i;
X    for (i = nrh; i >= nrl; i--)
X        free((char *) (m[i] + ncl));
X    free((char *) (m + nrl));
X}
X
X
Xvoid free_upper_dmatrix(m, nrl, nrh, ncl, nch)
X    double        **m;
X    int             nrl, nrh, ncl, nch;
X{
X    int             i, j, new_nrh;
X    
X    new_nrh = MIN(nrh-nrl, nch-ncl) + nrl;
X    
X    for (i = nrl, j = ncl; i <= new_nrh; i++, j++) {
X        free((char *) (m[i] + j));
X    }
X    free((char *) (m + nrl));
X}
X
X
Xvoid free_lower_dmatrix(m, nrl, nrh, ncl, nch)
X    double        **m;
X    int             nrl, nrh, ncl, nch;
X{
X    int             i;
X    for (i = nrh; i >= nrl; i--)
X        free((char *) (m[i] + ncl));
X        
X    free((char *) (m + nrl));
X}
X
X
Xvoid free_dsubmatrix(m, nrl, nrh, ncl, nch)
X    double **m;
X    int nrl, nrh, ncl, nch;
X{
X    free((char *) (m + nrl));
X}
X
Xdouble ***dtensor(nrl, nrh, ncl, nch, ntl, nth)
X    int nrl, nrh, ncl, nch, ntl, nth;
X{
X    int             i,j;
X    double        ***m;
X    m = (double ***) malloc((unsigned) (nrh - nrl + 1) * sizeof(double **));
X    if (!m)
X        error("Allocation failure 1 in dtensor()");
X    m -= nrl;
X    for (i = nrl; i <= nrh; i++) {
X        m[i] = (double **) malloc((unsigned) (nch - ncl + 1) * sizeof(double *));
X        if (!m[i])
X            error("Allocation failure 2 in dtensor()");
X        m[i] -= ncl;
X    for (j = ncl; j <= nch; j++) {
X        m[i][j] = (double *) malloc((unsigned) (nth - ntl + 1) * sizeof(double));
X        if (!m[i][j])
X            error("Allocation failure 3 in dtensor()");
X        m[i][j] -= ntl;
X               }
X    } return m;
X}
X
Xvoid free_dtensor(m, nrl, nrh, ncl, nch, ntl, nth)
X    double         ***m;
X    int             nrl, nrh, ncl, nch, ntl, nth;
X{
X    int             i,j;
X    for (i = nrh; i >= nrl; i--){
X       for (j = nch; j >= ncl; j--)
X        free((char *) (m[i][j] + ntl));
X       free((char *) (m[i] + ncl));
X
X        }
X    free((char *) (m + nrl));
X}
END_OF_FILE
if test 7868 -ne `wc -c <'matalloc.c'`; then
    echo shar: \"'matalloc.c'\" unpacked with wrong size!
fi
# end of 'matalloc.c'
fi
if test -f 'matalloc.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'matalloc.h'\"
else
echo shar: Extracting \"'matalloc.h'\" \(829 characters\)
sed "s/^X//" >'matalloc.h' <<'END_OF_FILE'
X/*-----------------------------------------------------------------------------
X
X   'matalloc.h'   headerfile for matrix/vector-utilities 'matalloc.c'
X
X------------------------------------------------------------------------------*/
X
Xextern void error();
X
Xextern float *vector();
Xextern int *ivector();
Xextern double *dvector();
X
Xextern float **matrix();
Xextern int **imatrix();
Xextern double **dmatrix();
X
Xextern double **upper_dmatrix();
Xextern double **lower_dmatrix();
X
Xextern double **dsubmatrix();
X
Xextern void free_vector();
Xextern void free_ivector();
Xextern void free_dvector();
X
Xextern void free_matrix();
Xextern void free_imatrix();
Xextern void free_dmatrix();
X
Xextern void free_upper_dmatrix();
Xextern void free_lower_dmatrix();
X
Xextern void free_dsubmatrix();
Xextern double ***dtensor();
Xextern void free_dtensor();
END_OF_FILE
if test 829 -ne `wc -c <'matalloc.h'`; then
    echo shar: \"'matalloc.h'\" unpacked with wrong size!
fi
# end of 'matalloc.h'
fi
if test -f 'matio.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'matio.c'\"
else
echo shar: Extracting \"'matio.c'\" \(2306 characters\)
sed "s/^X//" >'matio.c' <<'END_OF_FILE'
X/*-----------------------------------------------------------------------
X	matio.c
X		
X		contains some input/output-routines for vectors and matrices
X		as defined in matalloc.c (from Numerical Recipes)		
X-----------------------------------------------------------------------*/
X
X#include <strings.h>
X#include <stdio.h>
X
X#include "macros.h"
X#include "matio.h"
X
X
Xvoid fprintf_dvector(f, format, v, nl, nh)
X    FILE *f;
X	char *format;
X	double *v;
X    int nl, nh;
X{
X	int i;
X	if (v!=nil) for (i=nl; i<=nh; i++) fprintf(f, format, v[i]);
X	else fprintf(f, "nil");
X}
X
X
Xvoid sprintf_dvector(str, format, v, nl, nh)
X	char *str, *format;
X	double *v;
X    int nl, nh;
X{
X	int i;
X	static char s[20];
X	str = "";
X	if (v!=nil) {
X		for (i=nl; i<=nh; i++) {
X			sprintf(s, format, v[i]);
X			strcat(str, s);
X		} 
X	}
X	else strcat(str, "nil");
X}
X
X
Xvoid fprintf_ivector(f, format, v, nl, nh)
X    FILE *f;
X	char *format;
X    int *v, nl, nh;
X{
X	int i;
X	if (v!=nil) for (i=nl; i<=nh; i++) fprintf(f, format, v[i]);
X	else fprintf(f, "nil");
X}
X
X
Xvoid fprintf_dmatrix(f, format, a, ml, mh, nl, nh)
X    FILE *f;
X	char *format;
X	double **a;
X    int ml, mh, nl, nh;
X{
X	int i,j;
X	for (i=ml; i<=mh; i++) {
X		for (j=nl; j<=nh; j++) {
X			fprintf(f, format, a[i][j]);
X		}
X		fprintf(f, "\n");
X	} 
X	fprintf(f, "\n");
X}
X
X
Xvoid fprintf_imatrix(f, format, a, ml, mh, nl, nh)
X    FILE *f;
X	char *format;
X    int **a, ml, mh, nl, nh;
X{
X	int i,j;
X	for (i=ml; i<=mh; i++) {
X		for (j=nl; j<=nh; j++) {
X			fprintf(f, format, a[i][j]);
X		}
X		fprintf(f, "\n");
X	} 
X	fprintf(f, "\n");
X}
X
X
Xvoid fscanf_dvector(f, format, v, nl, nh)
X    FILE *f;
X	char *format;
X	double *v;
X    int nl, nh;
X{
X	int i;
X	for (i=nl; i<=nh; i++) {
X		fscanf(f, format, &v[i]);
X	} 
X}
X
X
Xvoid fscanf_ivector(f, format, v, nl, nh)
X    FILE *f;
X	char *format;
X    int *v, nl, nh;
X{
X	int i;
X	for (i=nl; i<=nh; i++) {
X		fscanf(f, format, &v[i]);
X	} 
X}
X
X
Xvoid fscanf_dmatrix(f, format, a, ml, mh, nl, nh)
X    FILE *f;
X	char *format;
X	double **a;
X    int ml, mh, nl, nh;
X{
X	int i,j;
X	for (i=ml; i<=mh; i++) {
X		for (j=nl; j<=nh; j++) {
X			fscanf(f, format, &a[i][j]);
X		}
X	}
X}
X
X
Xvoid fscanf_imatrix(f, format, a, ml, mh, nl, nh)
X    FILE *f;
X	char *format;
X    int **a, ml, mh, nl, nh;
X{
X	int i,j;
X	for (i=ml; i<=mh; i++) {
X		for (j=nl; j<=nh; j++) {
X			fscanf(f, format, &a[i][j]);
X		}
X	}
X}
X
X
X
END_OF_FILE
if test 2306 -ne `wc -c <'matio.c'`; then
    echo shar: \"'matio.c'\" unpacked with wrong size!
fi
# end of 'matio.c'
fi
if test -f 'matio.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'matio.h'\"
else
echo shar: Extracting \"'matio.h'\" \(505 characters\)
sed "s/^X//" >'matio.h' <<'END_OF_FILE'
X/*----------------------------------------------------------------------
X
X	matio.h
X	
X		header-file for matio.c (the collection of input/output-
X		routines for vectors and matrices)
X		
X----------------------------------------------------------------------*/
X
X
Xextern void fprintf_dvector();
Xextern void fprintf_ivector();
Xextern void fprintf_dmatrix();
Xextern void fprintf_imatrix();
X
Xextern void fscanf_dvector();
Xextern void fscanf_ivector();
Xextern void fscanf_dmatrix();
Xextern void fscanf_imatrix();
X
END_OF_FILE
if test 505 -ne `wc -c <'matio.h'`; then
    echo shar: \"'matio.h'\" unpacked with wrong size!
fi
# end of 'matio.h'
fi
if test -f 'mattrans.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'mattrans.c'\"
else
echo shar: Extracting \"'mattrans.c'\" \(10763 characters\)
sed "s/^X//" >'mattrans.c' <<'END_OF_FILE'
X/*-----------------------------------------------------------------------
X	mattrans.c
X		
X		contains all programs needed for solution of a linear
X		least square problem norm(Ax-b) = min. The job is
X		done by a Householder-triangulation, followed by a
X		Cholesky-decomposition (only in case of an underdetermined 
X		least square) and some back-substitutions. For details
X		of the algorithm see [Dd, Sautter]
X		
X	data structures
X	
X		matrices are stored as pointers to arrays of pointers to rows
X	    as in 'Numerical Recipes', i. e. the matrix element a(i,j) is
X	    stored in a[i][j].		
X-------------------------------------------------------------------------*/
X	
X#include <strings.h>
X#include <stdio.h>
X#include <math.h>
X
X#include "macros.h"
X#include "matalloc.h"		/* matrix and vector allocation 	*/
X#include "matutil.h"		/* matrix and vector utilities 		*/ 
X
X#include "mattrans.h"
X	
X/*------------------------------------------------------------------------
X	'householder'
X
X 	   triangulation by Householder transformations, QAP = R
X
X	input 
X
X		a[1..m][1..n]   = matrix to be transformed
X		cond			= upper bound for subcondition (rankreduction)
X		rank			= pseudorank
X
X	output
X
X		a[1..m][1..n]   = upper triangular matrix in a[i][j] for i<j,
X						  Householder vectors in a[j..m][j], j = 1, ..., p
X		pivot[1..n] 	= permutation matrix in compact form
X		d[1..p]  		= diagonal elements of the upper triangular matrix
X		cond			= subcondition of the matrix
X		p				= new pseudorank (old one if no rankreduction
X						  occured)
X		signum			= sign of the permutation (+1 = even number,
X						  -1 = odd number of transpositions)	
X-------------------------------------------------------------------------*/
X
Xvoid householder(a, d, cond, pivot, m, n, p, signum)
X	int m, n, *p, *signum, *pivot;
X	double **a, *d, *cond;
X{
X	int i, j, k, jmax, q;
X	double h, temp, t, dd;
X
X	for (i=1; i<=n; i++) {    		/* pivot = identity */
X	   pivot[i] = i;
X	}
X	*signum = 1;
X
X	if (m<=1 && n<=1) {
X		d[1] = a[1][1];
X		*cond = 1.0;
X	}
X	else {
X		for (j=1; j<=n; j++) {
X			d[j] = column_product(a, j, j, 1, m);
X		}	
X
X		for (k=1; k<= (*p); k++) {
X			if (k!=n) {
X				h = d[k];
X				jmax = k;
X				for (j=k+1; j<=n; j++) {
X					if (d[j] > h) {
X						h = d[j];
X						jmax = j;
X					}
X				}
X				if (jmax != k) {
X					ISWAP(pivot[k], pivot[jmax]);
X					swap_columns(a, jmax, k, 1, m);
X					d[jmax] = d[k];
X					*signum = - *signum;
X				}						
X			}
X			h = column_product(a, k, k, k, m);
X			t = sqrt(h);
X			if (k==1) {
X				dd = t/(*cond);
X			}
X			if (t<=dd) {
X				*p = k-1;				/* rank-reduction */
X			}
X			else {
X				if (k<m) {
X					temp = a[k][k];
X					d[k] = t = (temp>0) ? -t : t;
X					a[k][k] = temp - t;
X					if (k!=n) {	
X						t = 1/(h-temp*t);
X						for (j=k+1; j<=n; j++) {
X							temp = t * column_product(a, k, j, k, m);
X							for (i=k; i<=m; i++) {
X								a[i][j] -= temp * a[i][k];
X							}	
X							d[j] = d[j] - SQR(a[k][j]);
X						}	
X					}	
X				}
X				else d[k] = a[k][k];	
X			}	        					
X		} /* end for */
X		if (*p == m) *cond = fabs(d[1] / d[m]);
X	} /* end else */
X} /* end householder */
X
X
X/*------------------------------------------------------------------------
X	'prepare_solution'
X
X 	   computes the matrices V and L used in solution
X
X	input 
X
X		a[1..m][1..n]   = upper triangular matrix in a[i][j] for i<j,
X						  Householder vectors in a[j..m][j], j = 1, ..., p
X		d[1..p]   		= diagonal elements of upper triangular matrix
X		p				= pseudorank
X
X
X	output
X	
X		v[1..p][1..q]	= matrix V = R^(-1) * S used for the least square
X						  solution
X		l[1..q][1..q]	= lower triangular matrix from the Cholesky-
X						  decomposition of I - V^T * V = L * L^T
X	
X		(where q is defined as q = n-p)		
X-------------------------------------------------------------------------*/
X
Xvoid prepare_solution(a, v, l, d, m, n, p)
X	int m, n, p;
X	double **a, **v, **l, *d;
X{
X	int i, j, k, q;
X	double temp;
X
X	if (p<n) {
X		q = n-p;
X		for (j=1; j<=q; j++) {
X			for (i=p; i>=1; i--){
X				temp = a[i][p+j];
X				for (k=i+1; k<=p; k++) {
X					temp -= a[i][k] * v[k][j];
X				}
X				v[i][j] = temp / d[i];
X			}
X			for (i=1; i<=j; i++) {
X				temp = column_product(v, i, j, 1, p)
X						 - row_product(l, i, j, 1, i-1);
X				l[j][i] = (i!=j) ? temp/d[i] : sqrt(1+temp);
X			}
X		}		
X	}
X} /* prepare_solution */
X
X/*----------------------------------------------------------------------
X    solution
X   
X   	is to be called after householder and prepare_solution to get the
X   	best least sqare solution x = A^+ * b, where x is the pseudoinverse 
X   	of a, i. e. the vector satisfying
X   	
X   		a)  norm(A*x - b) = min
X   	   	b)  norm(x) = min    	   	
X----------------------------------------------------------------------*/
X
Xvoid solution(a, v, l, d, b_in, x_out, pivot, m, n, p)
X	double **a, **l, **v, *d, *b_in, *x_out;
X	int m, n, p, *pivot;
X{
X	double 	temp,
X			*u = dvector(1, p),
X			*x = dvector(1, n),
X			*b = dvector(1, m),
X		    *c = b, 
X		    *y = x,
X		    *z = x+p;
X		    
X	int i, j, k, q = n-p;
X	
X	copy_dvector(b, b_in, 1, m);
X	
X/* apply HH-transformation to the right side, b := Q * b   */
X
X	for (j=1; j<=p && j<m; j++) {
X		temp = 0;
X		for (i=j; i<=m; i++) {		
X			temp += a[i][j] * b[i];
X		}
X		temp = temp / (d[j] * a[j][j]);
X		for (i=j; i<=m; i++) {
X			b[i] += temp * a[i][j];
X		}
X	}
X	
X/* u := R^(-1) * c, where c = b[1..p]  */
X	
X	for (i=p; i>=1; i--) {
X		temp = b[i];
X		for (j=i+1; j<=p; j++) {
X			temp -= a[i][j] * u[j];
X		}
X		u[i] = temp/d[i];
X	}
X	
X	mat_trans_vec_mult(v, u, z, p, q);	
X	transposed_lower_back_substitution(l, z, z, q);
X	lower_back_substitution(l, z, z, q);
X		
X/* y := u - V * z     */
X
X	for (i=1; i<=p; i++) {
X		y[i] = u[i];
X		for (j=1; j<=q; j++) {
X			y[i] -= v[i][j] * z[j];
X		}
X	}	
X	
X/* x_out := pivot^T * x  */
X
X	for (i=1; i<=n; i++) {
X		x_out[pivot[i]] = x[i];
X	}
X	
X	free_dvector(u,1,p);
X	free_dvector(x,1,n);
X	free_dvector(b, 1, m);
X	
X} /* solution */		 
X
X/*--------------------------------------------------------------------
X	determinant		computes the determinant of the (n,n)-matrix a using
X					householder()	
X----------------------------------------------------------------------*/
X
Xdouble determinant(a, d, pivot, n)
X	double **a, *d;
X	int *pivot, n;
X{
X	double temp=1, cond = 1 / EPS_MACH;
X	int i, p=n, signum;
X
X	householder(a, d, &cond, pivot, n, n, &p, &signum);
X	if (p<n) temp = 0.0;
X	else {
X		for (i=1; i<=n; i++) temp *= d[i];
X		temp *= signum;
X		if (n % 2 == 0) 	temp = -temp;
X	}
X	return temp;
X}
X	
XBOOLEAN upper_cholesky(a, n)
X	double **a;
X	int n;
X{
X	int i, j, k;
X	double temp;
X	for (i=1; i<=n; i++) {
X		temp = a[i][i];
X		for (k=1; k<i; k++) {
X			temp -= SQR(a[k][i]);
X		}
X		if (temp < 0) {
X			printf("Error in upper_cholesky, sqrt not defined in row %d\n", i);
X			break;
X					}
X		a[i][i] = sqrt(temp);
X		for (j=i+1; j<=n; j++) {
X			temp = a[i][j];
X			for (k=1; k<i; k++) {
X				temp -= a[k][i] * a[k][j];
X			}
X			a[i][j] = temp / a[i][i];
X		}
X	}
X	if (i<=n) return FALSE;
X	else return TRUE;
X}
X
X
XBOOLEAN lower_cholesky(a, n)
X	double **a;
X	int n;
X{
X	int i, j, k;
X	double temp;
X	for (j=1; j<=n; j++) {
X		temp = a[j][j];
X		for (k=1; k<j; k++) {
X			temp -= SQR(a[j][k]);
X		}
X		if (temp < 0) {
X			printf("Error in lower_cholesky, sqrt not defined in row %d\n", j);
X			break;
X		}
X		a[j][j] = sqrt(temp);
X		for (i=j+1; i<=n; i++) {
X			temp = a[i][j];
X			for (k=1; k<j; k++) {
X				temp -= a[i][k] * a[j][k];
X			}
X			a[i][j] = temp / a[j][j];
X		}
X	}
X	if (i<=n) return FALSE;
X	else return TRUE;
X}
X
X/*-------------------------------------------------------------------------
X	m-vector b = product of the (m,m)-matrix q with the m-vector x	
X-------------------------------------------------------------------------*/
X
Xvoid q_vec_mult(a, d, x, b, m, n, p)
X	double **a, *d, *x, *b;
X	int m, n, p;
X{
X	int i, k;
X	double temp;
X	
X	copy_dvector(b, x, 1, m);
X	for (k=1; k<=p && k<m; k++) {
X		temp = 0;
X		for (i=k; i<=m; i++) temp += a[i][k] * b[i];
X		temp /= d[k] * a[k][k];
X		for (i=k; i<=m; i++) b[i] += temp * a[i][k];
X	}
X}
X
X/*-------------------------------------------------------------------------
X	m-vector b = product of the (m,m)-matrix q^T with the m-vector x	
X-------------------------------------------------------------------------*/
X
Xvoid q_trans_vec_mult(a, d, x, b, m, n, p)
X	double **a, *d, *x, *b;
X	int m, n, p;
X{
X	int i, k;
X	double temp;
X	
X	copy_dvector(b, x, 1, m);
X	for (k=MIN(p, m-1); k>=1; k--) {
X		temp = 0;
X		for (i=k; i<=m; i++) temp += a[i][k] * b[i];
X		temp /= d[k] * a[k][k];
X		for (i=k; i<=m; i++) b[i] += temp * a[i][k];
X	}
X}
X
X/*-------------------------------------------------------------------------
X	m-vector b = product of the (m,n)-matrix Q * A_old * PI with
X				 the n-vector x
X	
X							|    R    |   S   |
X	Q * A_old * PI	 	=	|---------|-------|
X							|    0    |  eps  |	
X-------------------------------------------------------------------------*/
X
Xvoid rs_vec_mult(a, d, x, b, m, n, p)
X	double **a, *d, *x, *b;
X	int m, n, p;
X{
X	int i, j;
X	double temp;
X	
X	for (i=1; i<=p; i++) {
X		temp = d[i] * x[i];
X		for (j=i+1; j<=n; j++) {
X			temp += a[i][j] * x[j];
X		}
X		b[i] = temp;
X	}
X	for (; i<=m; i++) {
X		temp = 0;
X		for (j=p+1; j<=n; j++) {
X			temp += a[i][j] * x[j];
X		}
X		b[i] = temp;
X	}
X}
X
X/*-------------------------------------------------------------------------
X	n-vector b = product of the (n,m)-matrix (Q * A_old * PI)^T with
X				 the m-vector x
X	
X							|   R^T   |   0   |
X	(Q * A_old * PI)^T 	=	|---------|-------|
X							|   S^T   | eps^T |	
X-------------------------------------------------------------------------*/
X
Xvoid rs_trans_vec_mult(a, d, x, b, m, n, p)
X	double **a, *d, *x, *b;
X	int m, n, p;
X{
X	int i, j;
X	double temp;
X	
X	for (i=1; i<=p; i++) {
X		temp = d[i] * x[i];
X		for (j=i-1; j>=1; j--) {
X			temp += a[j][i] * x[j];
X		}
X		b[i] = temp;
X	}
X	for (; i<=n; i++) {
X		temp = 0;
X		for (j=1; j<=m; j++) {
X			temp += a[j][i] * x[j];
X		}
X		b[i] = temp;
X	}
X}
X
X/*-------------------------------------------------------------------------
X	p-vector x = product of the triangular (p,p)-matrix r^(-1) with the
X				 p-vector b by backsubstitution	
X-------------------------------------------------------------------------*/
X
Xvoid r_inv_vec_mult(a, d, b, x, p)
X	double **a, *d, *x, *b;
X	int p;
X{
X	int i, j;
X	double temp;
X	
X	for (i=p; i>=1; i--) {
X		temp = b[i];
X		for (j=i+1; j<=p; j++) {
X			temp -= a[i][j] * x[j];
X		}
X		x[i] = temp / d[i];
X	}
X}
X	
X/*-------------------------------------------------------------------------
X	p-vector x = product of the triangular (p,p)-matrix r^(-T) with the
X				 p-vector b by backsubstitution	
X-------------------------------------------------------------------------*/
X
Xvoid r_trans_inv_vec_mult(a, d, b, x, p)
X	double **a, *d, *x, *b;
X	int p;
X{
X	int i, j;
X	double temp;
X	
X	for (i=1; i<=p; i++) {
X		temp = b[i];
X		for (j=1; j<=i-1; j++) {
X			temp -= a[j][i] * x[j];
X		}
X		x[i] = temp / d[i];
X	} 
X}
X
X	
X	
X					
END_OF_FILE
if test 10763 -ne `wc -c <'mattrans.c'`; then
    echo shar: \"'mattrans.c'\" unpacked with wrong size!
fi
# end of 'mattrans.c'
fi
if test -f 'mattrans.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'mattrans.h'\"
else
echo shar: Extracting \"'mattrans.h'\" \(624 characters\)
sed "s/^X//" >'mattrans.h' <<'END_OF_FILE'
X/*----------------------------------------------------------------------
X
X	mattrans.h
X	
X		header-file for mattrans.c (programs for the solution of linear 
X		least square problems)
X		
X----------------------------------------------------------------------*/
X
X
Xextern void householder();
Xextern void prepare_solution();
Xextern void solution();
X
Xextern double determinant();
X
Xextern void q_vec_mult();
Xextern void q_trans_vec_mult();
Xextern void rs_vec_mult();
Xextern void rs_trans_vec_mult();
Xextern void r_inv_vec_mult();
Xextern void r_trans_inv_vec_mult();
X
Xextern BOOLEAN upper_cholesky();
Xextern BOOLEAN lower_cholesky();
X
END_OF_FILE
if test 624 -ne `wc -c <'mattrans.h'`; then
    echo shar: \"'mattrans.h'\" unpacked with wrong size!
fi
# end of 'mattrans.h'
fi
if test -f 'matutil.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'matutil.c'\"
else
echo shar: Extracting \"'matutil.c'\" \(6649 characters\)
sed "s/^X//" >'matutil.c' <<'END_OF_FILE'
X/*-----------------------------------------------------------------------
X	matutil.c
X		
X		contains some often used routines for vectors and matrices
X		as defined in matalloc.c (from Numerical Recipes)		
X-----------------------------------------------------------------------*/
X
X#include <strings.h>
X#include <stdio.h>
X#include <math.h>
X
X#include "matutil.h"
X#include "macros.h"
X#include "matalloc.h"
X
Xvoid const_dvector(v, a, nl, nh)
X	double *v, a;
X	int nl, nh;
X{
X	int i;
X	for (i=nl; i<=nh; i++) v[i] = a;
X}
X
Xvoid swap_dvectors(v,w,nl,nh)
X	double *v, *w;
X	int nl, nh;
X{
X	int i;
X	for (i=nl; i<=nh; i++) {
X		DSWAP(v[i], w[i]);
X	}
X}
X
Xvoid copy_dvector(v,w,nl,nh)
X	double *v, *w;
X	int nl, nh;
X{
X	int i;
X	for (i=nl; i<=nh; i++) {
X		v[i] = w[i];
X	}
X}
X
Xvoid turn_dvector(v, nl, nh)
X	double *v;
X	int nl, nh;
X{
X	int i;
X	for (i=nl; i<=nh; i++) {
X		v[i] = - v[i];
X	}
X}
X
Xvoid copy_ivector(v,w,nl,nh)
X	int *v, *w, nl, nh;
X{
X	int i;
X	for (i=nl; i<=nh; i++) {
X		v[i] = w[i];
X	}
X}
X
Xvoid copy_dmatrix(a, b, nrl, nrh, ncl, nch)
X	double **a, **b;
X	int nrl, nrh, ncl, nch;
X{
X	int i, j;
X	for (i=nrl; i<=nrh; i++) {
X		for (j=ncl; j<=nch; j++) 	a[i][j] = b[i][j];
X	}
X}
X
Xvoid copy_upper_dmatrix(a, b, nrl, nrh, ncl, nch)
X	double **a, **b;
X	int nrl, nrh, ncl, nch;
X{
X	int i, j;
X	for (i=nrl; i<=nrh; i++) {
X		for (j=ncl+i-nrl; j<=nch; j++) 	a[i][j] = b[i][j];
X	}
X}
X
Xvoid copy_lower_dmatrix(a, b, nrl, nrh, ncl, nch)
X	double **a, **b;
X	int nrl, nrh, ncl, nch;
X{
X	int i, j;
X	for (j=nrl; j<=nch; j++) {
X		for (i=nrl+j-nrl; i<=nrh; i++) 	a[i][j] = b[i][j];
X	}
X}
X
Xvoid swap_columns(a, j, k, ml, mh)
X	double **a;
X	int j, k, ml, mh;
X{
X	int i;
X
X	for (i=ml; i<=mh; i++) {
X		DSWAP(a[i][j], a[i][k]);
X	}
X}
X
X/*-------------------------------------------------------------------------
X	product, distance and norm
X--------------------------------------------------------------------------*/
X
Xdouble product(v,w,nl,nh)
X	double *v, *w;
X	int nl,nh;
X{
X	int i;
X	double temp;
X	
X	temp = 0;
X	for (i=nl; i<=nh; i++) {
X		temp += v[i] * w[i];
X	}
X	return (temp);
X}
X
Xdouble column_product(a, j, k, ml, mh)
X	double **a;
X	int j, k, ml, mh;
X{
X	int i;
X	double temp;
X	
X	temp = 0;
X	for (i=ml; i<=mh; i++) {
X		temp += a[i][j] * a[i][k];
X	}
X	return (temp);
X}
X
Xdouble row_product(a, i, k, nl, nh)
X	double **a;
X	int i, k, nl, nh;
X{
X	int j;
X	double temp;
X	
X	temp = 0;
X	for (j=nl; j<=nh; j++) {
X		temp += a[i][j] * a[k][j];
X	}
X	return (temp);
X}
X
Xdouble squared_distance(v, w, nl, nh)
X	double *v, *w;
X	int nl, nh;
X{
X	double temp = 0;
X	int i;
X	for (i=nl; i<=nh; i++) {
X		temp += SQR(v[i] - w[i]);
X	}
X	return temp;
X}	
X	
Xdouble distance(v, w, nl, nh)
X	double *v, *w;
X	int nl, nh;
X{
X	return sqrt(squared_distance(v, w, nl, nh));
X}
X
Xdouble squared_norm(v, nl, nh)
X	double *v;
X	int nl, nh;
X{
X	int i;
X	double temp = 0;
X	for (i=nl; i<=nh; i++) {
X		temp += SQR(v[i]);
X	}
X	return temp;
X}
X
Xdouble norm(v, nl, nh)
X	double *v;
X	int nl, nh;
X{
X	return sqrt(squared_norm(v, nl, nh));
X}
X
Xdouble max_norm(v, nl, nh)
X	double *v;
X	int nl, nh;
X{
X	double temp, max;
X	int i;
X	
X	max = DABS(v[nl]);
X	for (i=nl+1; i<=nh; i++) {
X		temp = DABS(v[i]);
X		if (max < temp) max = temp;
X	}	
X	return max;
X}
X
X/*-------------------------------------------------------------------------
X	scaled product, distance, norm
X--------------------------------------------------------------------------*/
X
Xdouble sproduct(v, w, scale, nl, nh)
X	double *v, *w, *scale;
X	int nl,nh;
X{
X	int i;
X	double temp;
X	
X	if (scale == nil) 	return product(v, w, nl, nh);
X	temp = 0;
X	for (i=nl; i<=nh; i++) {
X		temp += v[i] * w[i] / SQR(scale[i]);
X	}
X	return (temp);
X}
X
Xdouble squared_snorm(v, scale, nl, nh)
X	double *v, *scale;
X	int nl, nh;
X{
X	int i;
X	double temp = 0;
X	
X	if (scale == nil) 	return squared_norm(v, nl, nh);
X	for (i=nl; i<=nh; i++) {
X		temp += SQR(v[i] / scale[i]);
X	}
X	return temp;
X}
X
Xdouble snorm(v, scale, nl, nh)
X	double *v, *scale;
X	int nl, nh;
X{
X	return sqrt(squared_snorm(v, scale, nl, nh));
X}
X
Xdouble squared_sdistance(v, w, scale, nl, nh)
X	double *v, *w, *scale;
X	int nl, nh;
X{
X	double temp = 0;
X	int i;
X	if (scale == nil) 	return squared_distance(v, w, nl, nh);
X	for (i=nl; i<=nh; i++) {
X		temp += SQR((v[i] - w[i]) / scale[i]);
X	}
X	return temp;
X}
X	
Xdouble sdistance(v, w, scale, nl, nh)
X	double *v, *w, *scale;
X	int nl, nh;
X{
X	return sqrt(squared_sdistance(v, w, scale, nl, nh));
X}
X		
Xdouble max_snorm(v, scale, nl, nh)
X	double *v, *scale;
X	int nl, nh;
X{
X	double temp, max;
X	int i;
X	
X	if (scale == nil) 	return max_norm(v, nl, nh);
X	max = DABS(v[nl] / scale[nl]);
X	for (i=nl+1; i<=nh; i++) {
X		temp = DABS(v[i] / scale[i]);
X		if (max < temp) max = temp;
X	}	
X	return max;
X}
X
X/*-------------------------------------------------------------------------
X	matrix-vector operations
X--------------------------------------------------------------------------*/
X
Xvoid mat_vec_mult(a, x, b, m, n)
X	double *b, **a, *x;	
X	int m, n;
X{
X	double temp;
X	int i, j;
X
X	for (i=1; i<=m; i++) {
X		temp = 0;
X		for (j=1; j<=n; j++) {
X			temp += a[i][j] * x[j];
X		}
X		b[i] = temp;
X	}
X}
X
X/*-----------------------------------------------------------------------
X
X	Multiplikation einer als obere Dreiecksmatrix abgespeicherten
X	symmetrischen (n,n)-Matrix a mit einem Vektor x
X	
X-----------------------------------------------------------------------*/
X	
Xvoid sym_mat_vec_mult(a, x, b, n)
X	double *b, **a, *x;	
X	int n;
X{
X	double temp;
X	int i, j;
X
X	for (i=1; i<=n; i++) {
X		temp = a[i][i] * x[i];
X		for (j=1; j<i; j++) {
X			temp += a[j][i] * x[j];
X		}
X		for (j=i+1; j<=n; j++) {
X			temp += a[i][j] * x[j];
X		}
X		b[i] = temp;
X	}
X}
X	
Xvoid mat_trans_vec_mult(a, x, b, m, n)
X	double *b, **a, *x;	
X	int m, n;
X{
X	double temp;
X	int i, j;
X
X	for (j=1; j<=n; j++) {
X		temp = 0;
X		for (i=1; i<=m; i++) {
X			temp += a[i][j] * x[i];
X		}
X		b[j] = temp;
X	}
X}
X		
Xvoid lower_back_substitution(l, x, b, n)
X	double **l, *x, *b;
X	int n;
X{
X	double temp;
X	int i, j;
X	
X	for (i=1; i<=n; i++) {
X		temp = b[i];
X		for (j=1; j<=i-1; j++) {
X			temp -= l[i][j] * x[j];
X		}
X		x[i] = temp / l[i][i];
X	} 
X}	
X
Xvoid transposed_lower_back_substitution(l, x, b, n)
X	double **l, *x, *b;
X	int n;
X{
X	double temp;
X	int i, j;
X	
X	for (i=n; i>=1; i--) {
X		temp = b[i];
X		for (j=i+1; j<=n; j++) {
X			temp -= l[j][i] * x[j];
X		}
X		x[i] = temp / l[i][i];
X	}
X}
X
Xvoid transposed_upper_back_substitution(r, x, b, n)
X	double **r, *x, *b;
X	int n;
X{
X	double temp;
X	int i, j;
X	
X	for (i=1; i<=n; i++) {
X		temp = b[i];
X		for (j=1; j<=i-1; j++) {
X			temp -= r[j][i] * x[j];
X		}
X		x[i] = temp / r[i][i];
X	} 
X}	
X
Xvoid upper_back_substitution(r, x, b, n)
X	double **r, *x, *b;
X	int n;
X{
X	double temp;
X	int i, j;
X	
X	for (i=n; i>=1; i--) {
X		temp = b[i];
X		for (j=i+1; j<=n; j++) {
X			temp -= r[i][j] * x[j];
X		}
X		x[i] = temp / r[i][i];
X	}
X}
X	
END_OF_FILE
if test 6649 -ne `wc -c <'matutil.c'`; then
    echo shar: \"'matutil.c'\" unpacked with wrong size!
fi
# end of 'matutil.c'
fi
if test -f 'matutil.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'matutil.h'\"
else
echo shar: Extracting \"'matutil.h'\" \(1210 characters\)
sed "s/^X//" >'matutil.h' <<'END_OF_FILE'
X/*----------------------------------------------------------------------
X
X	matutil.h
X	
X		header-file for matutil.c (matrix and vector utilities)
X		
X----------------------------------------------------------------------*/
X
Xextern void const_dvector();
Xextern void swap_dvectors();
Xextern void copy_dvector();
Xextern void turn_dvector();
Xextern void copy_ivector();
Xextern void copy_dmatrix();
Xextern void copy_upper_dmatrix();
Xextern void copy_lower_dmatrix();
Xextern void swap_columns();
Xextern void swap_rows();
X
Xextern double product();
Xextern double column_product();
Xextern double row_product();
X
Xextern double squared_norm();
Xextern double squared_distance();
Xextern double norm();
Xextern double distance();
Xextern double max_norm();
X
X
Xextern void mat_vec_mult();
Xextern void sym_mat_vec_mult();
Xextern void mat_trans_vect_mult();
X
Xextern void lower_back_substitution();
Xextern void transposed_lower_back_substitution();
Xextern void upper_back_substitution();
Xextern void transposed_upper_back_substitution();
X
X/* scaled functions */
X
Xextern double squared_snorm();
Xextern double snorm();
Xextern double sproduct();
Xextern double squared_sdistance();
Xextern double sdistance();
Xextern double max_snorm();
X
END_OF_FILE
if test 1210 -ne `wc -c <'matutil.h'`; then
    echo shar: \"'matutil.h'\" unpacked with wrong size!
fi
# end of 'matutil.h'
fi
echo shar: End of shell archive.
exit 0

