#include <stdio.h>
#include <stdlib.h>
#include "numcip.h"

void nrerror(char error_text[])
{	
	fprintf(stderr,"Numerical Recipes run-time error...\n");
	fprintf(stderr,"%s\n",error_text);
	fprintf(stderr,"...now exiting to system...\n");
	exit(1);
}

int *ivector(int nl,int nh)
{
	int *v;
	v=(int *)calloc((unsigned) (nh-nl+1), (unsigned) sizeof(int));
	if (!v) 
		nrerror("allocation failure in ivector()");
	return v-nl;
}

void free_ivector(int *v, int nl, int nh)
{
	free ((char*) (v+nl));
}

int **imatrix(int nrl,int nrh,int ncl,int nch)
{
	int i;
	int **m;
	
	m=(int **) calloc((unsigned) (nrh-nrl+1), (unsigned) sizeof(int*));
	if (!m) 
		nrerror("allocation failure 1 in imatrix()");
	m -= nrl;
	for (i=nrl; i<=nrh;i++)
		{
		m[i]=(int *) calloc((unsigned) (nch-ncl+1), (unsigned) sizeof(int));
		if (!m[i])
			nrerror ("allocation failure 2 in imatrix()");
		m[i] -= ncl;
		}
	return m;
}

void free_imatrix(int **m, int nrl,int nrh,int ncl,int nch)
{
	int i;
	
	for (i=nrh;i>=nrl;i--)
		free((char*) (m[i]+ncl));
	free((char*) (m+nrl));
}

double **dmatrix(int nrl,int nrh,int ncl,int nch)
{
	int i;
	double **m;
	
	m=(double **) calloc((unsigned) (nrh-nrl+1), (unsigned) sizeof(double*));
	if (!m) 
		nrerror("allocation failure 1 in dmatrix()");
	m -= nrl;
	for (i=nrl; i<=nrh;i++)
		{
		m[i]=(double *) calloc((unsigned) (nch-ncl+1), (unsigned) sizeof(double));
		if (!m[i])
			nrerror ("allocation failure 2 in dmatrix()");
		m[i] -= ncl;
		}
	return m;
}

void free_dmatrix(double **m, int nrl,int nrh,int ncl,int nch)
{
	int i;
	
	for (i=nrh;i>=nrl;i--)
		free((char*) (m[i]+ncl));
	free((char*) (m+nrl));
}

double *dvector(int nl,int nh)
{
	double *v;
	
	v=(double *) calloc((unsigned) (nh-nl+1), (unsigned) sizeof(double));
	if (!v) nrerror("allocation failure in dvector()");
	return v-nl;
}

void free_dvector(double *v, int nl, int nh)
{
	free((char*) (v+nl));
}

unsigned char **ucmatrix(int nrl,int nrh,int ncl,int nch)
{
	int i;
	unsigned char **m;
	
	m=(unsigned char **) calloc((unsigned) (nrh-nrl+1),(unsigned) sizeof(unsigned char*));
	if (!m) 
		nrerror("allocation failure 1 in ucmatrix()");
	m -= nrl;
	for (i=nrl; i<=nrh;i++)
		{
		m[i]=(unsigned char *) calloc((unsigned) (nch-ncl+1),(unsigned) sizeof(unsigned char));
		if (!m[i])
			nrerror ("allocation failure 2 in ucmatrix()");
		m[i] -= ncl;
		}
	return m;
}

void free_ucmatrix(unsigned char **m, int nrl,int nrh,int ncl,int nch)
{
	int i;
	
	for (i=nrh;i>=nrl;i--)
		free((char*) (m[i]+ncl));
	free((char*) (m+nrl));
}

float *vector(int nl, int nh)
{
	float *v;
	
	v=(float *) calloc((unsigned) (nh-nl+1), (unsigned) sizeof(float));
	if (!v) nrerror("allocation failure in vector()");
	return v-nl;
}

void free_vector(float *v, int nl, int nh)
{
	free((char*) (v+nl));
}

/*n3matrix allocates space for a three dimensional matrix*/
float ***n3matrix(int nl,int nr,int ml,int mr,int kl,int kr)
{
	int i,j;
	float ***m;
	
	m=(float ***) calloc((unsigned) (nr-nl+1),(unsigned) sizeof(float**));
	if (!m)
		nrerror("allocation failure 1 in n3matrix");
	m -= nl;
	for (i=nl; i<=nr; i++)
		{
		m[i]=(float **) calloc((unsigned) (mr-ml+1),(unsigned) sizeof(float*));
		if (!m[i])
			nrerror("allocation failure 2 in n3matrix");
		m[i] -= ml;
		for (j=ml; j<=mr;j++)
			{
			m[i][j]=(float *) calloc((unsigned) (kr-kl+1),(unsigned) sizeof(float));
			if (!m[i][j])
				nrerror("allocation failure 3 in n3matrix");
			m[i][j] -= kl;
			}
		}
	return m;
}

/*free_n3matrix free allocated space for n3matrix*/
void free_n3matrix(float ***m, int nl,int nr,int ml,int mr,int kl,int kr)
{
	int i,j;
	
	for (i=nl;i>=nr;i--)
		{
		for (j=ml;j>=mr;j--)
			free((char *) (m[i][j]+kl));
		free((char*) (m[i]+ml));
		 }
	free((char *) (m+nl));
}

/*n4matrix allocates space for a four dimensional matrix*/
float ****n4matrix(int nl,int nr,int ml,int mr, int kl,int kr,int jl,int jr)
{
	int i,j,k;
	float ****m;
	
	m=(float ****) calloc((unsigned) (nr-nl+1),(unsigned) sizeof(float***));
	if (!m)
		nrerror("allocation failure 1 in n4matrix");
	m -= nl;
	for (i=nl; i<=nr; i++)
		{
		m[i]=(float ***) calloc((unsigned) (mr-ml+1),(unsigned) sizeof(float**));
		if (!m[i])
			nrerror("allocation failure 2 in n4matrix");
		m[i] -= ml;
		for (j=ml; j<=mr;j++)
			{
			m[i][j]=(float **) calloc((unsigned) (kr-kl+1),(unsigned) sizeof(float*));
			if (!m[i][j])
				nrerror("allocation failure 3 in n4matrix");
			m[i][j] -= kl;
			for(k=jl;k<=jr;k++)
				{
				m[i][j][k]=(float *) calloc((unsigned) (jr-jl+1),(unsigned) sizeof(float));
				if (!m[i][j])
					nrerror("allocation failure 4 in n4matrix");
				m[i][j][k] -= jl;
				}
			}
		}
	return m;
}

/*free_n4matrix free allocated space for n4matrix*/
void free_n4matrix(float ****m, int nl,int nr,int ml,int mr,int kl,int kr,int jl,int jr)
{
	int i,j,k;
	
	for (i=nl;i>=nr;i--)
		{
		for (j=ml;j>=mr;j--)
			{
			for (k=jl;k>=jr;k--)
				free((char *) (m[i][j][k]+jl));
			free((char *) (m[i][j]+kl));
			}
		free((char*) (m[i]+ml));
		 }
	free((char *) (m+nl));
}

/*d3matrix allocates space for a three dimensional matrix*/
double ***d3matrix(int nl,int nr,int ml,int mr,int kl,int kr)
{
	int i,j;
	double ***m;
	
	m=(double ***) calloc((unsigned) (nr-nl+1),(unsigned) sizeof(double**));
	if (!m)
		nrerror("allocation failure 1 in d3matrix");
	m -= nl;
	for (i=nl; i<=nr; i++)
		{
		m[i]=(double **) calloc((unsigned) (mr-ml+1),(unsigned) sizeof(double*));
		if (!m[i])
			nrerror("allocation failure 2 in d3matrix");
		m[i] -= ml;
		for (j=ml; j<=mr;j++)
			{
			m[i][j]=(double *) calloc((unsigned) (kr-kl+1),(unsigned) sizeof(double));
			if (!m[i][j])
				nrerror("allocation failure 3 in d3matrix");
			m[i][j] -= kl;
			}
		}
	return m;
}

/*free_d3matrix free allocated space for d3matrix*/
void free_d3matrix(double ***m, int nl,int nr,int ml,int mr,int kl,int kr)
{
	int i,j;
	
	for (i=nl;i>=nr;i--)
		{
		for (j=ml;j>=mr;j--)
			free((char *) (m[i][j]+kl));
		free((char*) (m[i]+ml));
		 }
	free((char *) (m+nl));
}

float **n2matrix(int nrl,int nrh,int ncl,int nch)
{
	int i;
	float **m;
	
	m=(float **) calloc((unsigned) (nrh-nrl+1), (unsigned) sizeof(float*));
	if (!m) 
		nrerror("allocation failure 1 in n2matrix()");
	m -= nrl;
	for (i=nrl; i<=nrh;i++)
		{
		m[i]=(float *) calloc((unsigned) (nch-ncl+1), (unsigned) sizeof(float));
		if (!m[i])
			nrerror ("allocation failure 2 in n2matrix()");
		m[i] -= ncl;
		}
	return m;
}

void free_n2matrix(float **m, int nrl,int nrh,int ncl,int nch)
{
	int i;
	
	for (i=nrh;i>=nrl;i--)
		free((char*) (m[i]+ncl));
	free((char*) (m+nrl));
}

double *bigvector(long nl,long nh)
{
	double *v;
	
	v=(double *) calloc((unsigned) (nh-nl+1), (unsigned) sizeof(double));
	if (!v) nrerror("allocation failure in bigvector()");
	return v-nl;
}

void free_bigvector(double *v, long nl, long nh)
{
	free((char*) (v+nl));
}

double **bmatrix(long nrl,long nrh,long ncl,long nch)
{
	long i;
	double **m;
	
	m=(double **) calloc((unsigned) (nrh-nrl+1), (unsigned) sizeof(double*));
	if (!m) 
		nrerror("allocation failure 1 in dmatrix()");
	m -= nrl;
	for (i=nrl; i<=nrh;i++)
		{
		m[i]=(double *) calloc((unsigned) (nch-ncl+1), (unsigned) sizeof(double));
		if (!m[i])
			nrerror ("allocation failure 2 in dmatrix()");
		m[i] -= ncl;
		}
	return m;
}

void free_bmatrix(double **m, long nrl,long nrh,long ncl,long nch)
{
	long i;
	
	for (i=nrh;i>=nrl;i--)
		free((char*) (m[i]+ncl));
	free((char*) (m+nrl));
}