395 lines
7.9 KiB
C++
395 lines
7.9 KiB
C++
#ifndef ARRAY_H_INC
|
|
#define ARRAY_H_INC
|
|
|
|
#include <iostream>
|
|
#include <string.h>
|
|
|
|
// ********** ARRAY CLASS INFO **************************************
|
|
/*
|
|
//..............................................................
|
|
// Overview of array classes in Array.h
|
|
//......... Declaration of array objects........................
|
|
// supports integer data (IntArray) or double data (DoubleArray)
|
|
// supports one, two or three dimensional arrays
|
|
IntArray A(m); // array of integers, Length n
|
|
IntArray A(m,n); // array of integers, dimensions: m x n
|
|
DoubleArray A(m,n,o); // array of doubles, dimensions m x n x o
|
|
//............ Access the size of the array.....................
|
|
A.m; // size of first dimension
|
|
A.n; // size of second dimension
|
|
A.o; // size of third dimension
|
|
A.Length; // total number of values stored
|
|
//........... Access the array entries .........................
|
|
A(i); // return data[i]
|
|
A(i,j); // return data[j*m+i]
|
|
A(i,j,k); // return data[k*m*n+j*m+i]
|
|
//..............................................................
|
|
*/
|
|
|
|
using namespace std;
|
|
|
|
class IntArray{
|
|
public:
|
|
IntArray Copy();
|
|
|
|
int Length;
|
|
int m,n,o;
|
|
int *data;
|
|
IntArray();
|
|
IntArray(int size);
|
|
IntArray(int nx,int ny);
|
|
IntArray(int nx,int ny,int nz);
|
|
~IntArray();
|
|
|
|
void New(int size);
|
|
void New(int nx, int ny);
|
|
void New(int nx, int ny, int nz);
|
|
|
|
int & operator()(int index)
|
|
{return data[index];}
|
|
int & operator()(int i, int j)
|
|
{ return data[j*m+i];}
|
|
int & operator()(int i, int j, int k)
|
|
{ return data[k*m*n+j*m+i];}
|
|
|
|
int e(int i);
|
|
int e(int i, int j);
|
|
int e(int i, int j, int k);
|
|
|
|
int *Pointer() {return data;}
|
|
};
|
|
|
|
class DoubleArray{
|
|
public:
|
|
DoubleArray Copy();
|
|
|
|
int Length;
|
|
int m;
|
|
int n;
|
|
int o;
|
|
double *data;
|
|
DoubleArray();
|
|
DoubleArray(int size);
|
|
DoubleArray(int nx, int ny);
|
|
DoubleArray(int nx, int ny, int nz);
|
|
~DoubleArray();
|
|
|
|
void New(int size);
|
|
void New(int nx, int ny);
|
|
void New(int nx, int ny, int nz);
|
|
|
|
double & operator()(int index)
|
|
{return data[index];}
|
|
double & operator()(int i, int j)
|
|
{return data[j*m+i];}
|
|
double & operator()(int i, int j, int k)
|
|
{return data[k*m*n+j*m+i];}
|
|
double e(int i);
|
|
double e(int i, int j);
|
|
double e(int i, int j, int k);
|
|
|
|
double *Pointer() {return data;}
|
|
};
|
|
|
|
/*
|
|
* Array.cpp
|
|
*
|
|
* Created by James Mcclure on 3/31/09.
|
|
* Copyright 2009 __MyCompanyName__. All rights reserved.
|
|
*
|
|
*/
|
|
|
|
// *****************************************
|
|
// ******** class IntArray ****************
|
|
// *****************************************
|
|
/*IntArray::IntArray();
|
|
IntArray::IntArray(int size);
|
|
IntArray::IntArray(int nx, int ny);
|
|
IntArray::IntArray(int nx, int ny, int nz);
|
|
IntArray::~IntArray();
|
|
void IntArray::New(int size);
|
|
void IntArray::New(int nx, int ny);
|
|
void IntArray::New(int nx, int ny,int nz);
|
|
int IntArray::e(int i);
|
|
int IntArray::e(int i, int j);
|
|
int IntArray::e(int i, int j, int k);
|
|
|
|
// *****************************************
|
|
// ******** class DoubleArray **************
|
|
// *****************************************
|
|
DoubleArray::DoubleArray();
|
|
DoubleArray::DoubleArray(int size);
|
|
DoubleArray::DoubleArray(int nx, int ny);
|
|
DoubleArray::DoubleArray(int nx, int ny,int nz);
|
|
DoubleArray::~DoubleArray();
|
|
void DoubleArray::New(int size);
|
|
void DoubleArray::New(int nx, int ny);
|
|
void DoubleArray::New(int nx, int ny,int nz);
|
|
double DoubleArray::e(int i);
|
|
double DoubleArray::e(int i, int j);
|
|
double DoubleArray::e(int i, int j, int k);
|
|
extern DoubleArray IncreaseSize(DoubleArray &A, int addLength);
|
|
extern IntArray IncreaseSize(IntArray &A, int addLength);
|
|
*/
|
|
|
|
/*
|
|
* Array.cpp
|
|
*
|
|
* Created by James Mcclure on 3/31/09.
|
|
* Copyright 2009 __MyCompanyName__. All rights reserved.
|
|
*
|
|
*/
|
|
/*
|
|
* Array.cpp
|
|
*
|
|
* Created by James Mcclure on 3/31/09.
|
|
* Copyright 2009 __MyCompanyName__. All rights reserved.
|
|
*
|
|
*/
|
|
|
|
IntArray::IntArray()
|
|
{
|
|
m=n=o=Length=0;
|
|
}
|
|
|
|
IntArray::IntArray(int size)
|
|
{
|
|
data = new int [size];
|
|
Length = size;
|
|
m = size;
|
|
n = 1;
|
|
o = 1;
|
|
}
|
|
|
|
IntArray::IntArray(int nx, int ny)
|
|
{
|
|
m = nx;
|
|
n = ny;
|
|
o = 1;
|
|
Length = m*n;
|
|
data = new int [Length];
|
|
}
|
|
|
|
IntArray::IntArray(int nx, int ny, int nz)
|
|
{
|
|
m = nx;
|
|
n = ny;
|
|
o = nz;
|
|
Length = m*n*o;
|
|
data = new int [Length];
|
|
}
|
|
|
|
IntArray::~IntArray()
|
|
{
|
|
delete data;
|
|
}
|
|
|
|
|
|
void IntArray::New(int size)
|
|
{
|
|
m=size;
|
|
n = 1;
|
|
o = 1;
|
|
data = new int [size];
|
|
Length = size;
|
|
}
|
|
|
|
void IntArray::New(int nx, int ny)
|
|
{
|
|
m = nx;
|
|
n = ny;
|
|
o = 1;
|
|
Length = m*n;
|
|
data = new int [Length];
|
|
}
|
|
|
|
void IntArray::New(int nx, int ny,int nz)
|
|
{
|
|
m = nx;
|
|
n = ny;
|
|
o = nz;
|
|
Length = m*n*o;
|
|
data = new int [Length];
|
|
}
|
|
|
|
int IntArray::e(int i)
|
|
{
|
|
return data[i];
|
|
}
|
|
|
|
int IntArray::e(int i, int j)
|
|
{
|
|
return data[m*j+i];
|
|
}
|
|
|
|
int IntArray::e(int i, int j, int k)
|
|
{
|
|
return data[m*n*k+m*j+i];
|
|
}
|
|
|
|
// *****************************************
|
|
// ******** class DoubleArray **************
|
|
// *****************************************
|
|
DoubleArray::DoubleArray()
|
|
{
|
|
m=n=o=Length=0;
|
|
}
|
|
|
|
DoubleArray::DoubleArray(int size)
|
|
{
|
|
m=size;
|
|
n = 1;
|
|
o = 1;
|
|
data = new double [size];
|
|
Length = size;
|
|
}
|
|
|
|
DoubleArray::DoubleArray(int nx, int ny)
|
|
{
|
|
m = nx;
|
|
n = ny;
|
|
o = 1;
|
|
Length = m*n;
|
|
data = new double [Length];
|
|
}
|
|
|
|
DoubleArray::DoubleArray(int nx, int ny,int nz)
|
|
{
|
|
m = nx;
|
|
n = ny;
|
|
o = nz;
|
|
Length = m*n*o;
|
|
data = new double [Length];
|
|
}
|
|
|
|
void DoubleArray::New(int size)
|
|
{
|
|
m=size;
|
|
n = 1;
|
|
o = 1;
|
|
data = new double [size];
|
|
Length = size;
|
|
}
|
|
|
|
void DoubleArray::New(int nx, int ny)
|
|
{
|
|
m = nx;
|
|
n = ny;
|
|
o = 1;
|
|
Length = m*n;
|
|
data = new double [Length];
|
|
}
|
|
|
|
void DoubleArray::New(int nx, int ny,int nz)
|
|
{
|
|
m = nx;
|
|
n = ny;
|
|
o = nz;
|
|
Length = m*n*o;
|
|
data = new double [Length];
|
|
}
|
|
|
|
DoubleArray::~DoubleArray()
|
|
{
|
|
delete data;
|
|
}
|
|
|
|
double DoubleArray::e(int i)
|
|
{
|
|
return data[i];
|
|
}
|
|
|
|
double DoubleArray::e(int i, int j)
|
|
{
|
|
return data[j*m+i];
|
|
}
|
|
|
|
double DoubleArray::e(int i, int j, int k)
|
|
{
|
|
return data[k*m*n+j*m+i];
|
|
}
|
|
|
|
extern DoubleArray IncreaseSize(DoubleArray &A, int addLength)
|
|
{
|
|
if (addLength<0) {
|
|
printf("IncreaseSize(Array,Length) Length needs to be >0.");
|
|
return DoubleArray();
|
|
}
|
|
|
|
int newM,newN,newO;
|
|
if (A.o>1) {
|
|
if (addLength%(A.m*A.n)!=0) {
|
|
printf("IncreaseSize(Array,Length) Length needs to be a multiple of m*n");
|
|
return DoubleArray();
|
|
}
|
|
newM = A.m;
|
|
newN = A.n;
|
|
newO = A.o + addLength/(A.m*A.n);
|
|
}
|
|
else if (A.n>1) {
|
|
if (addLength%(A.m)!=0) {
|
|
printf("IncreaseSize(Array,Length) Length needs to be a multiple of m");
|
|
return DoubleArray();
|
|
}
|
|
newM = A.m;
|
|
newN = A.n + addLength/A.m;
|
|
newO = 1;
|
|
}
|
|
else {
|
|
newM = A.m + addLength;
|
|
newN = 1;
|
|
newO = 1;
|
|
}
|
|
|
|
DoubleArray toReturn(newM,newN,newO);
|
|
memcpy(toReturn.Pointer(),A.Pointer(),A.Length*sizeof(double));
|
|
return toReturn;
|
|
}
|
|
extern IntArray IncreaseSize(IntArray &A, int addLength)
|
|
{
|
|
if (addLength<0) {
|
|
printf("IncreaseSize(Array,Length) Length needs to be >0.");
|
|
return IntArray();
|
|
}
|
|
|
|
int newM,newN,newO;
|
|
if (A.o>1) {
|
|
if (addLength%(A.m*A.n)!=0) {
|
|
printf("IncreaseSize(Array,Length) Length needs to be a multiple of m*n");
|
|
return IntArray();
|
|
}
|
|
newM = A.m;
|
|
newN = A.n;
|
|
newO = A.o + addLength/(A.m*A.n);
|
|
}
|
|
else if (A.n>1) {
|
|
if (addLength%(A.m)!=0) {
|
|
printf("IncreaseSize(Array,Length) Length needs to be a multiple of m");
|
|
return IntArray();
|
|
}
|
|
newM = A.m;
|
|
newN = A.n + addLength/A.m;
|
|
newO = 1;
|
|
}
|
|
else {
|
|
newM = A.m + addLength;
|
|
newN = 1;
|
|
newO = 1;
|
|
}
|
|
|
|
IntArray toReturn(newM,newN,newO);
|
|
memcpy(toReturn.Pointer(),A.Pointer(),A.Length*sizeof(int));
|
|
return toReturn;
|
|
}
|
|
|
|
DoubleArray DoubleArray::Copy()
|
|
{
|
|
DoubleArray CopyInto(m,n,o);
|
|
// Check that the allocation worked.
|
|
if (CopyInto.Length!=Length) return CopyInto; // Failed. Already printed an error message.
|
|
memcpy(CopyInto.Pointer(),Pointer(),Length*sizeof(double));
|
|
return CopyInto;
|
|
}
|
|
|
|
#endif
|