{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\froman\fcharset0 Times New Roman;}{\f1\fswiss\fcharset0 Arial;}}
{\*\generator Msftedit 5.41.15.1507;}\viewkind4\uc1\pard\sb100\sa100\f0\fs24 #include "arrays.h" /* ******************************************************************* * * Convenient classes for vectors and matrices--unit offset * with bounds-checkings and dynamical allocation. The advantage * of using these objects is that the allocation and deallocation * of memory is automatically performed by the constructor and * destructor of the class. These arrays also look very * Fortran-like: elements are accessed using parentheses * instead of square brackets. Also, the ordering of elements * in the matrix conforms to the Fortran standard of the * left-most indices advancing more quickly. Note that these * objects can be treated like ordinary variables in many ways. * * Example: * dvector r(4); // creates 4-dimensional vector * r(3)=5.0; // assigns value to r(3) * dvector a, b(r); // creates a and b, with b identical to r * a=r; // r is copied into a (previous a lost) * a(); // this deletes memory of a * b.dim(); // returns dimension of b * dmatrix a(5,8); * a(2,1)=0.0; * a.rowdim(); // row dimension of a * a.coldim(); // column dimension of a * * a.reset(3,4); // resets memory for a * b.reset(12); // resets memory for b * ********************************************************************* */ dvector::dvector() \{n=0;\} dvector::dvector(int dim) \{n=dim; if (dim<1)\{ cerr << "negative or zero dimension in dvector"<<endl; exit(1);\} m=new double[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} --m; \} dvector::dvector(const dvector& rvec) \{int i; n=rvec.n; if (n>0)\{ m=new double[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; for (i=1;i<=n;i++) m[i]=rvec.m[i]; \} \} dvector& dvector::operator=(const dvector& rvec) \{int i; if (n!=rvec.n)\{ if (n>0) delete [] ++m; n=rvec.n; if (n>0)\{ m=new double[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} for (i=1;i<=n;i++) m[i]=rvec.m[i]; return *this; \} int dvector::dim() const \{return n;\} dvector::~dvector() \{if (n>0) delete [] ++m;\} void dvector::operator()() \{if (n>0)\{ delete [] ++m; n=0;\} \} void dvector::reset(int dim) \{ if (n!=dim)\{ if (dim<1)\{ cerr << "negative or zero dimension in dvector"<<endl; exit(1);\} if (n>0) delete [] ++m; n=dim; if (n>0)\{ m=new double[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} \} double &dvector::operator()(int i) const \{return ((i>=1)&&(i<=n)) ? m[i] : (cerr << "dvector out of bounds"<<endl,exit(-1),m[1]);\} // ************************************************************* ivector::ivector() \{n=0;\} ivector::ivector(int dim) \{n=dim; if (dim<1)\{ cerr << "negative or zero dimension in ivector"<<endl; exit(1);\} m=new int[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} --m; \} ivector::ivector(const ivector& rvec) \{int i; n=rvec.n; if (n>0)\{ m=new int[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; for (i=1;i<=n;i++) m[i]=rvec.m[i]; \} \} ivector& ivector::operator=(const ivector& rvec) \{int i; if (n!=rvec.n)\{ if (n>0) delete [] ++m; n=rvec.n; if (n>0)\{ m=new int[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} for (i=1;i<=n;i++) m[i]=rvec.m[i]; return *this; \} int ivector::dim() const \{return n;\} ivector::~ivector() \{if (n>0) delete [] ++m;\} void ivector::operator()() \{if (n>0)\{ delete [] ++m; n=0;\} \} void ivector::reset(int dim) \{ if (n!=dim)\{ if (dim<1)\{ cerr << "negative or zero dimension in ivector"<<endl; exit(1);\} if (n>0) delete [] ++m; n=dim; if (n>0)\{ m=new int[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} \} int &ivector::operator()(int i) const \{return ((i>=1)&&(i<=n)) ? m[i] : (cerr << "ivector out of bounds"<<endl,exit(-1),m[1]);\} // ************************************************************* Svector::Svector() \{n=0;\} Svector::Svector(int dim) \{n=dim; if (dim<1)\{ cerr << "negative or zero dimension in Svector"<<endl; exit(1);\} m=new charString[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} --m; \} Svector::Svector(const Svector& rvec) \{int i; n=rvec.n; if (n>0)\{ m=new charString[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; for (i=1;i<=n;i++) m[i]=rvec.m[i]; \} \} Svector& Svector::operator=(const Svector& rvec) \{int i; if (n!=rvec.n)\{ if (n>0) delete [] ++m; n=rvec.n; if (n>0)\{ m=new charString[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} for (i=1;i<=n;i++) m[i]=rvec.m[i]; return *this; \} int Svector::dim() const \{return n;\} Svector::~Svector() \{if (n>0) delete [] ++m;\} void Svector::operator()() \{if (n>0)\{ delete [] ++m; n=0;\} \} void Svector::reset(int dim) \{ if (n!=dim)\{ if (dim<1)\{ cerr << "negative or zero dimension in Svector"<<endl; exit(1);\} if (n>0) delete [] ++m; n=dim; if (n>0)\{ m=new charString[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} \} charString &Svector::operator()(int i) const \{return ((i>=1)&&(i<=n)) ? m[i] : (cerr << "Svector out of bounds"<<endl,exit(-1),m[1]);\} // ************************************************************* Bvector::Bvector() \{n=0;\} Bvector::Bvector(int dim) \{n=dim; if (dim<1)\{ cerr << "negative or zero dimension in Bvector"<<endl; exit(1);\} m=new Boot[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} --m; \} Bvector::Bvector(const Bvector& rvec) \{int i; n=rvec.n; if (n>0)\{ m=new Boot[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; for (i=1;i<=n;i++) m[i]=rvec.m[i]; \} \} Bvector& Bvector::operator=(const Bvector& rvec) \{int i; if (n!=rvec.n)\{ if (n>0) delete [] ++m; n=rvec.n; if (n>0)\{ m=new Boot[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} for (i=1;i<=n;i++) m[i]=rvec.m[i]; return *this; \} int Bvector::dim() const \{return n;\} Bvector::~Bvector() \{if (n>0) delete [] ++m;\} void Bvector::operator()() \{if (n>0)\{ delete [] ++m; n=0;\} \} void Bvector::reset(int dim) \{ if (n!=dim)\{ if (dim<1)\{ cerr << "negative or zero dimension in Bvector"<<endl; exit(1);\} if (n>0) delete [] ++m; n=dim; if (n>0)\{ m=new Boot[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} \} Boot &Bvector::operator()(int i) const \{return ((i>=1)&&(i<=n)) ? m[i] : (cerr << "Bvector out of bounds"<<endl,exit(-1),m[1]);\} // ************************************************************* dmatrix::dmatrix() \{n=0;\} dmatrix::dmatrix(int rowdim, int coldim) \{if ((rowdim<1)||(coldim<1))\{ cerr << " negative or zero dimension in dmatrix"<<endl; exit(-1);\} nr=rowdim; nc=coldim; n=nr*nc; m=new double[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} --m; \} dmatrix::dmatrix(const dmatrix& rmat) \{int i; nr=rmat.nr; nc=rmat.nc; n=rmat.n; if (n>0)\{ m=new double[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; for (i=1;i<=n;i++) m[i]=rmat.m[i]; \} \} dmatrix& dmatrix::operator=(const dmatrix& rmat) \{int i; if (n!=rmat.n)\{ if (n>0) delete [] ++m; n=rmat.n; if (n>0)\{ m=new double[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} for (i=1;i<=n;i++) m[i]=rmat.m[i]; nr=rmat.nr; nc=rmat.nc; return *this; \} int dmatrix::rowdim() const \{return nr;\} int dmatrix::coldim() const \{return nc;\} dmatrix::~dmatrix() \{if (n>0) delete [] ++m;\} void dmatrix::operator()() \{if (n>0)\{ delete [] ++m; n=0; nr=0; nc=0;\} \} void dmatrix::reset(int rowdim, int coldim) \{int dim; dim=rowdim*coldim; if (n!=dim)\{ if ((rowdim<1)||(coldim<1))\{ cerr << " negative or zero dimension in dmatrix"<<endl; exit(-1);\} if (n>0) delete [] ++m; n=dim; if (n>0)\{ m=new double[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} nr=rowdim; nc=coldim; \} double &dmatrix::operator()(int i, int j) const \{return ((i>=1)&&(i<=nr)&&(j>=1)&&(j<=nc)) ? m[i+(j-1)*nr] : (cerr << "dmatrix out of bounds"<<endl,exit(-1),m[1]);\} // ************************************************************* imatrix::imatrix() \{n=0;\} imatrix::imatrix(int rowdim, int coldim) \{if ((rowdim<1)||(coldim<1))\{ cerr << " negative or zero dimension in imatrix"<<endl; exit(-1);\} nr=rowdim; nc=coldim; n=nr*nc; m=new int[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} --m; \} imatrix::imatrix(const imatrix& rmat) \{int i; nr=rmat.nr; nc=rmat.nc; n=rmat.n; if (n>0)\{ m=new int[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; for (i=1;i<=n;i++) m[i]=rmat.m[i]; \} \} imatrix& imatrix::operator=(const imatrix& rmat) \{int i; if (n!=rmat.n)\{ if (n>0) delete [] ++m; n=rmat.n; if (n>0)\{ m=new int[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} for (i=1;i<=n;i++) m[i]=rmat.m[i]; nr=rmat.nr; nc=rmat.nc; return *this; \} int imatrix::rowdim() const \{return nr;\} int imatrix::coldim() const \{return nc;\} imatrix::~imatrix() \{if (n>0) delete [] ++m;\} void imatrix::operator()() \{if (n>0)\{ delete [] ++m; n=0; nr=0; nc=0;\} \} void imatrix::reset(int rowdim, int coldim) \{int dim; dim=rowdim*coldim; if (n!=dim)\{ if ((rowdim<1)||(coldim<1))\{ cerr << " negative or zero dimension in imatrix"<<endl; exit(-1);\} if (n>0) delete [] ++m; n=dim; if (n>0)\{ m=new int[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} nr=rowdim; nc=coldim; \} int &imatrix::operator()(int i, int j) const \{return ((i>=1)&&(i<=nr)&&(j>=1)&&(j<=nc)) ? m[i+(j-1)*nr] : (cerr << "imatrix out of bounds"<<endl,exit(-1),m[1]);\} // ************************************************************* gaussian::gaussian()\{\} gaussian::gaussian(const double& mean_val, const double& sdev_val) \{ mean_value=mean_val; if (sdev_val>=0.0) standard_deviation=sdev_val; else\{ cerr << " Error: standard deviation in gaussian cannot be negative"<<endl; exit(1);\} \} gaussian::gaussian(const gaussian& g_in) \{ mean_value=g_in.mean_value; standard_deviation=g_in.standard_deviation; \} gaussian::~gaussian()\{\} gaussian& gaussian::operator=(const gaussian &g_copy) \{ mean_value=g_copy.mean_value; standard_deviation=g_copy.standard_deviation; return *this; \} void gaussian::assign(const double& mean_val, const double& sdev_val) \{ mean_value=mean_val; if (sdev_val>=0.0) standard_deviation=sdev_val; else\{ cerr << " Error: standard deviation in gaussian cannot be negative"<<endl; exit(1);\} \} double gaussian::mean() const \{ return mean_value; \} double gaussian::stdev() const \{ return standard_deviation; \} // ************************************************************* gvector::gvector() \{n=0;\} gvector::gvector(int dim) \{n=dim; if (dim<1)\{ cerr << "negative or zero dimension in gvector"<<endl; exit(1);\} m=new gaussian[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} --m; \} gvector::gvector(const gvector& rvec) \{int i; n=rvec.n; if (n>0)\{ m=new gaussian[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; for (i=1;i<=n;i++) m[i]=rvec.m[i]; \} \} gvector& gvector::operator=(const gvector& rvec) \{int i; if (n!=rvec.n)\{ if (n>0) delete [] ++m; n=rvec.n; if (n>0)\{ m=new gaussian[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} for (i=1;i<=n;i++) m[i]=rvec.m[i]; return *this; \} int gvector::dim() const \{return n;\} gvector::~gvector() \{if (n>0) delete [] ++m;\} void gvector::operator()() \{if (n>0)\{ delete [] ++m; n=0;\} \} void gvector::reset(int dim) \{ if (n!=dim)\{ if (dim<1)\{ cerr << "negative or zero dimension in gvector"<<endl; exit(1);\} if (n>0) delete [] ++m; n=dim; if (n>0)\{ m=new gaussian[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} \} gaussian &gvector::operator()(int i) const \{return ((i>=1)&&(i<=n)) ? m[i] : (cerr << "gvector out of bounds"<<endl,exit(-1),m[1]);\} // ************************************************************* Bmatrix::Bmatrix() \{n=0;\} Bmatrix::Bmatrix(int rowdim, int coldim) \{if ((rowdim<1)||(coldim<1))\{ cerr << " negative or zero dimension in Bmatrix"<<endl; exit(-1);\} nr=rowdim; nc=coldim; n=nr*nc; m=new Boot[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} --m; \} Bmatrix::Bmatrix(const Bmatrix& rmat) \{int i; nr=rmat.nr; nc=rmat.nc; n=rmat.n; if (n>0)\{ m=new Boot[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; for (i=1;i<=n;i++) m[i]=rmat.m[i]; \} \} Bmatrix& Bmatrix::operator=(const Bmatrix& rmat) \{int i; if (n!=rmat.n)\{ if (n>0) delete [] ++m; n=rmat.n; if (n>0)\{ m=new Boot[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} for (i=1;i<=n;i++) m[i]=rmat.m[i]; nr=rmat.nr; nc=rmat.nc; return *this; \} int Bmatrix::rowdim() const \{return nr;\} int Bmatrix::coldim() const \{return nc;\} Bmatrix::~Bmatrix() \{if (n>0) delete [] ++m;\} void Bmatrix::operator()() \{if (n>0)\{ delete [] ++m; n=0; nr=0; nc=0;\} \} void Bmatrix::reset(int rowdim, int coldim) \{int dim; dim=rowdim*coldim; if (n!=dim)\{ if ((rowdim<1)||(coldim<1))\{ cerr << " negative or zero dimension in Bmatrix"<<endl; exit(-1);\} if (n>0) delete [] ++m; n=dim; if (n>0)\{ m=new Boot[n]; if (!m)\{ cerr << " problem allocating memory"<<endl; exit(1);\} m--; \}\} nr=rowdim; nc=coldim; \} \par
\pard\f1\fs20\par
}