#include <malloc.h>
#include <stdio.h>

void nrerror(error_text)
char error_text[];
/* Numerical Recipes standard error handler */
{
	void _exit();

	fprintf(stderr,"Numerical Recipes run-time error...\n");
	fprintf(stderr,"%s\n",error_text);
	fprintf(stderr,"...now exiting to system...\n");
	_exit(1);
}

float *vector(n)
int n;
/* allocate a float vector with subscript range v[0..n] */
{
	float *v;

	v=(float *)malloc((unsigned) (n)*sizeof(float));
	if (!v) nrerror("allocation failure in vector()");
	return v;
}

int *ivector(n)
int n;
/* allocate an int vector with subscript range v[0..n] */
{
	int *v;

	v=(int *)malloc((unsigned) (n)*sizeof(int));
	if (!v) nrerror("allocation failure in ivector()");
	return v;
}

short int *isvector(n)
int n;
/* allocate a short int vector with subscript range v[0..n] */
{
	short int *v;

	v=(short int *)malloc((unsigned) (n)*sizeof(short int));
	if (!v) nrerror("allocation failure in isvector()");
	return v;
}

char *cvector(n)
int n;
/* allocate a char vector with subscript range v[0..n] */
{
	char *v;

	v=(char *)malloc((unsigned) (n)*sizeof(char));
	if (!v) nrerror("allocation failure in cvector()");
	return v;
}

double *dvector(n)
int n;
/* allocate a double vector with subscript range v[0..n] */
{
	double *v;

	v=(double *)malloc((unsigned) (n)*sizeof(double));
	if (!v) nrerror("allocation failure in dvector()");
	return v;
}

float **matrix(nr,nc)
int nr,nc;
/* allocate a float matrix with size m[nr][nc] */
{
	int i;
	float **m;

	/* allocate pointers to rows */
	m=(float **) malloc((unsigned) (nr)*sizeof(float*));
	if (!m) nrerror("allocation failure 1 in matrix()");

	/* allocate rows and set pointers to them */
	for(i=0;i<nr;i++) {
		m[i]=(float *) malloc((unsigned) (nc)*sizeof(float));
		if (!m[i]) nrerror("allocation failure 2 in matrix()");
	}
	/* return pointer to array of pointers to rows */
	return m;
}

double **dmatrix(nr,nc)
int nr,nc;
/* allocate a double matrix with size m[nr][nc] */
{
	int i;
	double **m;

	/* allocate pointers to rows */
	m=(double **) malloc((unsigned) (nr)*sizeof(double*));
	if (!m) nrerror("allocation failure 1 in dmatrix()");

	/* allocate rows and set pointers to them */
	for(i=0;i<nr;i++) {
		m[i]=(double *) malloc((unsigned) (nc)*sizeof(double));
		if (!m[i]) nrerror("allocation failure 2 in dmatrix()");
	}
	/* return pointer to array of pointers to rows */
	return m;
}

int **imatrix(nr,nc)
int nr,nc;
/* allocate an int matrix with size m[nr][nc] */
{
	int i,**m;

	/* allocate pointers to rows */
	m=(int **)malloc((unsigned) (nr)*sizeof(int*));
	if (!m) nrerror("allocation failure 1 in imatrix()");

	/* allocate rows and set pointers to them */
	for(i=0;i<nr;i++) {
		m[i]=(int *)malloc((unsigned) (nc)*sizeof(int));
		if (!m[i]) nrerror("allocation failure 2 in imatrix()");
	}
	/* return pointer to array of pointers to rows */
	return m;
}

short **ismatrix(nr,nc)
int nr,nc;
/* allocate a short int matrix with size m[nr][nc] */
{
	int i;
        short int **m;

	/* allocate pointers to rows */
	m=(short int **)malloc((unsigned) (nr)*sizeof(short int*));
	if (!m) nrerror("allocation failure 1 in ismatrix()");

	/* allocate rows and set pointers to them */
	for(i=0;i<nr;i++) {
		m[i]=(short int *)malloc((unsigned) (nc)*sizeof(short int));
		if (!m[i]) nrerror("allocation failure 2 in ismatrix()");
	}
	/* return pointer to array of pointers to rows */
	return m;
}
char **cmatrix(nr,nc)
int nr,nc;
/* allocate a char matrix with size m[nr][nc] */
{
	int i;
        char **m;

	/* allocate pointers to rows */
	m=(char **)malloc((unsigned) (nr)*sizeof(char));
	if (!m) nrerror("allocation failure 1 in cmatrix()");

	/* allocate rows and set pointers to them */
	for(i=0;i<nr;i++) {
		m[i]=(char *)malloc((unsigned) (nc)*sizeof(char));
		if (!m[i]) nrerror("allocation failure 2 in cmatrix()");
	}
	/* return pointer to array of pointers to rows */
	return m;
}

float **submatrix(a,oldrl,oldrh,oldcl,oldch,newrl,newcl)
/* point a submatrix [newrl..][newcl..] to a[oldrl..oldrh][oldcl..oldch] */
float **a;
int oldrl,oldrh,oldcl,oldch,newrl,newcl;
{
	int i,j;
	float **m;

	/* allocate array of pointers to rows */
	m=(float **) malloc((unsigned) (oldrh-oldrl+1)*sizeof(float*))-newrl;
	if (!m) nrerror("allocation failure in submatrix()");

	/* set pointers to rows */
	for(i=oldrl,j=newrl;i<=oldrh;i++,j++) m[j]=a[i];

	/* return pointer to array of pointers to rows */
	return m;
}

void free_vector(v,n)
float *v;
int n;
/* free a float vector allocated with vector() */
{
	free((char*) (v));
}

void free_ivector(v,n)
int *v,n;
/* free an int vector allocated with ivector() */
{
	free((char*) (v));
}

void free_isvector(v,n)
short int *v;
int n;
/* free a short int vector allocated with isvector() */
{
	free((char*) (v));
}

void free_cvector(v,n)
char *v;
int n;
/* free a char vector allocated with cvector() */
{
	free((char*) (v));
}

void free_dvector(v,n)
double *v;
int n;
/* free a double vector allocated with dvector() */
{
	free((char*) (v));
}

void free_matrix(m,nr,nc)
float **m;
int nr,nc;
/* free a float matrix allocated by matrix() */
{
	int i;

	for(i=nr-1;i>=0;i--) free((char*) (m[i]));
	free((char*) (m));
}

void free_dmatrix(m,nr,nc)
double **m;
int nr,nc;
/* free a double matrix allocated by dmatrix() */
{
	int i;

	for(i=nr-1;i>=0;i--) free((char*) (m[i]));
	free((char*) (m));
}

void free_imatrix(m,nr,nc)
int **m;
int nr,nc;
/* free an int matrix allocated by imatrix() */
{
	int i;

	for(i=nr-1;i>=0;i--) free((char*) (m[i]));
	free((char*) (m));
}

void free_ismatrix(m,nr,nc)
short int **m;
int nr,nc;
/* free a short int matrix allocated by ismatrix() */
{
	int i;

	for(i=nr-1;i>=0;i--) free((char*) (m[i]));
	free((char*) (m));
}

void free_cmatrix(m,nr,nc)
char **m;
int nr,nc;
/* free a char matrix allocated by cmatrix() */
{
	int i;

	for(i=nr-1;i>=0;i--) free((char*) (m[i]));
	free((char*) (m));
}

void free_submatrix(b,nrl,nrh,ncl,nch)
/* free a submatrix allocated by submatrix() */
float **b;
int nrl,nrh,ncl,nch;
{
	free((char*) (b+nrl));
}