Ptv.cpp

Go to the documentation of this file.
00001 // Copyright (C) 2006-2009 Kent-Andre Mardal and Simula Research Laboratory.
00002 // Licensed under the GNU GPL Version 2, or (at your option) any later version.
00003 
00004 #include "Ptv.h"
00005 #include <iostream>
00006 #include <math.h>
00007 
00008 using std::ostream;
00009 using std::endl;
00010 
00011 double Ptv::tol = 1.0e-9;
00012 double Ptv_match::tol = 1.0e-9;
00013 //double Ptv::tol = .0;
00014 //double Ptv_match::tol = .0;
00015 
00016 Ptv::Ptv() : dim(0)
00017 {
00018         v = new double[0];
00019 }
00020 
00021 
00022 Ptv::Ptv(double x, double y)
00023 {
00024         dim = 2;
00025         v = new double[2];
00026         v[0] = x;
00027         v[1] = y;
00028 }
00029 
00030 
00031 Ptv::Ptv(double x, double y, double z)
00032 {
00033         dim = 3;
00034         v = new double[3];
00035         v[0] = x;
00036         v[1] = y;
00037         v[2] = z;
00038 }
00039 
00040 
00041 Ptv::Ptv(unsigned int size_)
00042 {
00043         dim = size_;
00044         v = new double[dim];
00045         for (unsigned int i=0; i< dim; i++)
00046         {
00047                 v[i] = 0.0;
00048         }
00049 }
00050 
00051 
00052 // FIXME:
00053 // The constructor which takes int, double* could/should work
00054 // on the double* provided instead of creating a copy.
00055 // This however affects the destructor. Since Ptv should
00056 // not delete memory.
00057 // We could introduce a bool external_storage in Ptv which
00058 // is used as a test in the destructor.
00059 
00060 Ptv::Ptv(unsigned int size_, double* v_)
00061 {
00062         dim = size_;
00063         v = new double[dim];
00064         for (unsigned int i=0; i< dim; i++)
00065         {
00066                 v[i] = v_[i];
00067         }
00068 }
00069 
00070 
00071 Ptv::Ptv(const Ptv& p)
00072 {
00073         dim = p.size();
00074         v = new double[dim];
00075         for (unsigned int i=0; i< dim; i++)
00076         {
00077                 v[i] = p[i];
00078         }
00079 
00080 }
00081 
00082 
00083 Ptv::~Ptv()
00084 {
00085         delete [] v;
00086 }
00087 
00088 
00089 void Ptv::redim(unsigned int size_, double* v_)
00090 {
00091         if (dim != size_ )
00092         {
00093                 delete [] v;
00094                 dim = size_;
00095                 v = new double[dim];
00096         }
00097 
00098         for (unsigned int i=0; i< dim; i++)
00099         {
00100                 v[i] = v_[i];
00101         }
00102 }
00103 
00104 
00105 void Ptv::redim(unsigned int size_)
00106 {
00107         if (dim != size_ )
00108         {
00109                 delete [] v;
00110                 dim = size_;
00111                 v = new double[dim];
00112         }
00113         for (unsigned int i=0; i< dim; i++)
00114         {
00115                 v[i] = 0.0;
00116         }
00117 }
00118 
00119 
00120 void Ptv::fill(double* v_)
00121 {
00122         for (unsigned int i=0; i< dim; i++)
00123         {
00124                 v[i] = v_[i];
00125         }
00126 }
00127 
00128 
00129 const unsigned int Ptv::size() const { return dim;}
00130 
00131 const double& Ptv::operator [] (unsigned int i) const
00132 {
00133         return v[i];
00134 }
00135 
00136 
00137 double& Ptv::operator [] (unsigned int i)
00138 {
00139         return v[i];
00140 }
00141 
00142 
00143 Ptv& Ptv::operator = (const Ptv& p)
00144 {
00145         if ( this != &p)
00146         {
00147                 if ( dim != p.size())
00148                 {
00149                         delete [] v;
00150                         dim = p.size();
00151                         v = new double[dim];
00152                 }
00153                 for (unsigned int i=0; i< dim; i++)
00154                 {
00155                         v[i] = p[i];
00156                 }
00157         }
00158         return *this;
00159 }
00160 
00161 
00162 bool Ptv::less(const Ptv& p) const
00163 {
00164 
00165         if ( dim <  p.size() ) return true ;
00166         if ( dim >  p.size() ) return false;
00167 
00168         /* 
00169         for (int i=dim-1; i>= 0; i--) {
00170           if ( fabs(v[i] - p[i]) > tol ) {
00171                 if (v[i] < p[i])
00172                   return true;
00173                 else
00174         return false;
00175         }
00176         }
00177         */
00178 
00179         for (int i=dim-1; i>= 0; i--)
00180         {
00181                 if ( v[i] + tol >= p[i] - tol &&  v[i] - tol <= p[i] + tol )
00182                 {
00183                 }
00184                 else if (v[i] + tol  < p[i] - tol  )
00185                 {
00186                         return true;
00187                 }
00188                 else if ( v[i] - tol > p[i] + tol  )
00189                 {
00190                         return false;
00191                 }
00192         }
00193 
00194         return false;
00195 }
00196 
00197 
00198 ostream & operator<< ( ostream& os, const Ptv& p)
00199 {
00200         if (p.size() >= 1)
00201         {
00202                 os <<"[";
00203                 for (unsigned int i=0; i< p.size()-1; i++)
00204                 {
00205                         os <<p[i]<<",";
00206                 }
00207                 os <<p[p.size()-1]<<"]";
00208         }
00209         else
00210         {
00211                 os <<"Ptv not created properly"<<endl;
00212         }
00213         return os;
00214 }
00215 
00216 
00217 Ptv_match::Ptv_match()
00218 {
00219         d = 0 ; v = 0.0;
00220 }
00221 
00222 
00223 Ptv_match::Ptv_match(unsigned int d_, double v_)
00224 {
00225         d = d_ ; v = v_;
00226 }
00227 
00228 
00229 bool Ptv_match:: operator () (const Ptv &p)
00230 {
00231         if ( v + tol >= p[d] && v - tol <= p[d] ) return true;
00232         else return false;
00233 }

Generated on Mon Aug 31 16:16:45 2009 for SyFi by  doxygen 1.5.9