myarrays.h

格子Boltzmann方法 格子Boltzmann方法是为了保留格子气自动机方法的优点

// MyArrays.h 动态分配多维(2,3,4维)数组(C/C++)  Written by Li Qing.

#ifndef MYARRAYS_H
#define MYARRAYS_H

//#define USE_CPP_COMPILER	// 如果仅用C编译器，请将此行全改成注释行

// for C
void *Calloc1DArray(int n, int size_t);
void Free1DArray(void *array);

void **Calloc2DArray(int n2, int n1, int size_t);	// 仍然按照“最右边的下标变化最快”的原则
void Free2DArray(void **array);

void ***Calloc3DArray(int n3, int n2, int n1, int size_t);
void Free3DArray(void ***array);

void ****Calloc4DArray(int n4, int n3, int n2, int n1, int size_t);
void Free4DArray(void ****array);


// for C++
#ifdef USE_CPP_COMPILER

#ifndef NULL
	#define NULL 0
#endif

template <class T> T *New1DArray(int n, T *&array);
template <class T> void Delete1DArray(T *&array);

template <class T> T **New2DArray(int n2, int n1, T **&array);
template <class T> void Delete2DArray(T **&array);

template <class T> T ***New3DArray(int n3, int n2, int n1, T ***&array);
template <class T> void Delete3DArray(T ***&array);

template <class T> T ****New4DArray(int n4, int n3, int n2, int n1, T ****&array);
template <class T> void Delete4DArray(T ****&array);

//=================== for 1D ===================
template <class T> T *New1DArray(int n, T *&array)
{
	array = new T[n];
	return array;
}

template <class T> void Delete1DArray(T *&array)
{
	if(array) delete [] array;
	array = NULL;
}

//=================== for 2D ===================
template <class T> T **New2DArray(int n2, int n1, T **&array)
{
	int i;

	array = (T**)new unsigned long[n2];
	if(array==NULL) return array;

	array[0] = new T[n2*n1];
	if(array[0]==NULL)
	{
		delete array;
		return array=NULL;
	}

	for(i=1; i<n2; i++)
		array[i] = array[0] + i*n1;
	return array;
}

template <class T> void Delete2DArray(T **&array)
{
	if(array[0]) delete [] array[0];
	if(array) delete [] array;
	array = NULL;
}

//=================== for 3D ===================
template <class T> T ***New3DArray(int n3, int n2, int n1, T ***&array)
{
	int i, j;

	array = (T***)new unsigned long[n3];
	if(array==NULL) return array;

	array[0] = (T**)new unsigned long[n3*n2];
	if(array[0]==NULL)
	{
		delete array;
		return array=NULL;
	}
	for(j=1; j<n3; j++)
		array[j] = array[0] + j*n2;

	array[0][0] = new T[n3*n2*n1];
	if(array[0][0]==NULL)
	{
		delete array[0];
		delete array;
		return array=NULL;
	}
	for(j=0; j<n3; j++)
		for(i=0; i<n2; i++)
			array[j][i] = array[0][0] + (j*n2 + i)*n1;
	return array;
}

template <class T> void Delete3DArray(T ***&array)
{
	if(array[0][0]) delete [] array[0][0];
	if(array[0]) delete [] array[0];
	if(array) delete [] array;
	array = NULL;
}

//=================== for 4D ===================
template <class T> T ****New4DArray(int n4, int n3, int n2, int n1, T ****&array)
{
	int i, j, k;

	array = (T****)new unsigned long[n4];
	if(array==NULL) return array;

	array[0] = (T***)new unsigned long[n4*n3];
	if(array[0]==NULL)
	{
		delete array;
		return array=NULL;
	}
	for(k=1; k<n4; k++)
		array[k] = array[0] + k*n3;

	array[0][0] = (T**)new unsigned long[n4*n3*n2];
	if(array[0][0]==NULL)
	{
		delete array[0];
		delete array;
		return array=NULL;
	}
	for(k=0; k<n4; k++)
		for(j=0; j<n3; j++)
			array[k][j] = array[0][0] + (k*n3 + j)*n2;

	array[0][0][0] = new T[n4*n3*n2*n1];
	if(array[0][0][0]==NULL)
	{
		delete array[0][0];
		delete array[0];
		delete array;
		return array=NULL;
	}
	for(k=0; k<n4; k++)
		for(j=0; j<n3; j++)
			for(i=0; i<n2; i++)
				array[k][j][i] = array[0][0][0] + ((k*n3+j)*n2+i)*n1;
	return array;
}

template <class T> void Delete4DArray(T ****&array)
{
	if(array[0][0][0]) delete [] array[0][0][0];
	if(array[0][0]) delete [] array[0][0];
	if(array[0]) delete [] array[0];
	if(array) delete [] array;
	array = NULL;
}
#endif	// USE_CPP_COMPILER

#endif	// MYARRAY_H