nrutil.c

matlab 例程

#include<stdio.h>
#include<stddef.h>
#include<stdlib.h>

//报告错误
void nrerror(char *error_text)
{
	printf("Numerical Recipes run-time error...\n");
	printf("%s\n",error_text);
	printf("..now exiting to system..\n");
	exit(1);
}

/***************************************
函数：vector
功能：申请一个实数数组
参数：nl:数组的最低下标
      nh:数组的最高下标
返回:数组地址
***************/
float *vector(long nl,long nh)
{
	float *v;
	v=(float *)calloc((unsigned)(nh-nl+1),sizeof(float));
	if(!v) nrerror("allocation failure in vector()");
	return v-nl;
}
/***************************************
函数：ivector
功能：申请一个整数数组
参数：nl:数组的最低下标
      nh:数组的最高下标
返回:数组地址
***************/
int *ivector(long nl,long nh)
{
	int *v;
	v=(int *)calloc((unsigned)(nh-nl+1),sizeof(int));
	if(!v) nrerror("allocation failure in ivector()");
	return v-nl;
}
/***************************************
函数：cvector
功能：申请一个无符合字符数组
参数：nl:数组的最低下标
      nh:数组的最高下标
返回:数组地址
***************/
unsigned char *cvector(long nl,long nh)
{
	unsigned char *v;
	v=(unsigned char *)calloc((unsigned)(nh-nl+1),sizeof(unsigned char));
	if(!v) nrerror("allocation failure in cvector()");
	return v-nl;
}
/***************************************
函数：lvector
功能：申请一个长整数数组
参数：nl:数组的最低下标
      nh:数组的最高下标
返回:数组地址
***************/
unsigned long *lvector(long nl,long nh)
{
	unsigned long *v;
	v=(unsigned long *)calloc((unsigned)(nh-nl+1),sizeof(unsigned long));
	if(!v) nrerror("allocation failure in lvector()");
	return v-nl;
}
/***************************************
函数：dvector
功能：申请一个双精度实数数组
参数：nl:数组的最低下标
      nh:数组的最高下标
返回:数组地址
***************/
double *dvector(long nl,long nh)
{
	double *v;
	v=(double *)calloc((unsigned)(nh-nl+1),sizeof(double));
	if(!v) nrerror("allocation failure in dvector()");
	return v-nl;
}
/*************************************
函数名称：matrix
功能： 申请一个实数二维数组（矩阵）
参数：nrl:数组的行最低下标
      nrh:数组的行最高下标
      ncl:数组的列最低下标
      nch:数组的列最高下标
返回：数组地址
***************************/
float **matrix(long nrl,long nrh,long ncl,long nch)
{
	int i;
	float **m;
	m=(float **)calloc((unsigned)(nrh-nrl+1),sizeof(float *));
	if(!m)nrerror("allocation failure 1 in matrix()");
	m-=nrl;
	
	for(i=nrl;i<=nrh;i++){
		m[i]=(float *)calloc((unsigned)(nch-ncl+1),sizeof(float));
	if(!m[i])nrerror("allocation failure 2 in matrix()");
	m[i]-=ncl;
	}
	return m;
}
/*************************************
函数名称：dmatrix
功能： 申请一个双精度数二维数组（矩阵）
参数：nrl:数组的行最低下标
      nrh:数组的行最高下标
      ncl:数组的列最低下标
      nch:数组的列最高下标
返回：数组地址
***************************/
double **dmatrix(long nrl,long nrh,long ncl,long nch)
{
	int i;
	double **m;
	m=(double **)calloc((unsigned)(nrh-nrl+1),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),sizeof(double));
	if(!m[i])nrerror("allocation failure 2 in dmatrix()");
	m[i]-=ncl;
	}
	return m;
}
/*************************************
函数名称：imatrix
功能： 申请一个整数二维数组（矩阵）
参数：nrl:数组的行最低下标
      nrh:数组的行最高下标
      ncl:数组的列最低下标
      nch:数组的列最高下标
返回：数组地址
***************************/
int **imatrix(long nrl,long nrh,long ncl,long nch)
{
	int i;
	int **m;
	m=(int **)calloc((unsigned)(nrh-nrl+1),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),sizeof(int));
	if(!m[i])nrerror("allocation failure 2 in imatrix()");
	m[i]-=ncl;
	}
	return m;
}
/*************************************
函数名称：cmatrix
功能： 申请一个无符合字符型二维数组（矩阵）
参数：nrl:数组的行最低下标
      nrh:数组的行最高下标
      ncl:数组的列最低下标
      nch:数组的列最高下标
返回：数组地址
***************************/
unsigned char **cmatrix(long nrl,long nrh,long ncl,long nch)
{
	int i;
    unsigned char **m;
	m=(unsigned char **)calloc((unsigned)(nrh-nrl+1),sizeof(unsigned char *));
	if(!m)nrerror("allocation failure 1 in dmatrix()");
	m-=nrl;
	
	for(i=nrl;i<=nrh;i++){
		m[i]=(unsigned char *)calloc((unsigned)(nch-ncl+1),sizeof(unsigned char));
	if(!m[i])nrerror("allocation failure 2 in dmatrix()");
	m[i]-=ncl;
	}
	return m;
}
/************************************
函数：submatrix
功能：求一个二维矩阵的子矩阵
参数：a:二维矩阵的首地址
      oldrl:数组的行最低下标
	  oldrh:数组的行最高下标
	  oldcl:数组的列最低下标
	  oldch:数组的列最高下标
	  newrl:新数组的行最低下标
	  newcl:新数组的列最低下标
返回：数组地址
*****************************/
float **submatrix(float **a,long oldrl,long oldrh,long oldcl,long oldch,long newrl,long newcl)
{
	int i,j;
	float **m;
	m=(float **)calloc((unsigned)(oldrh-oldrl+1),sizeof(float *));
	if(!m)nrerror("allocation failure in submatrix()");
	m-=newrl;

	for(i=oldrl,j=newrl;i<=oldrh;i++,j++) m[j]=a[i]+oldcl-newcl;
	return m;
}
/******************************
函数名称：convert_matrix
功能： 将一个实数一维数组转化炜二维数组
参数：a:原一维数组
      nrl:数组的行最低下标
      nrh:数组的行最高下标
      ncl:数组的列最低下标
      nch:数组的列最高下标
返回：二维数组地址
***************************/
float **convert_matrix(float *a,long nrl,long nrh,long ncl,long nch)
{
	int i,j,nrow,ncol;
    float **m;
	nrow=nrh-nrl+1;
	ncol=nch-ncl+1;
	m=(float **)calloc((unsigned)(nrow),sizeof(float *));
	if(!m)nrerror("allocation failure  in convert_matrix()");
	m-=nrl;
	
	
	for(i=0,j=nrl;i<=nrow-1;i++,j++) m[j]=a+ncol*i-ncl;
    return m;
}

void free_vector(float *v,long nl,long nh)
{
	free((char*)(v+nl));
}
void free_ivector(int *v,long nl,long nh)
{
	free((char*)(v+nl));
}
void free_cvector(unsigned char *v,long nl,long nh)
{
	free((char*)(v+nl));
}
void free_lvector(unsigned long *v,long nl,long nh)
{
	free((char*)(v+nl));
}
void free_dvector(double *v,long nl,long nh)
{
	free((char*)(v+nl));
}

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

void free_submatrix(float **b,long nrl,long nrh,long ncl,long nch)
{

	free((char*)(b+nrl));
}

void free_convert_matrix(float **b,long nrl,long nrh,long ncl,long nch)
{

	free((char*)(b+nrl));
}