TVector.cpp

Go to the documentation of this file.
00001 
00002 
00011 template <class TRing>
00012 TVector<TRing>::TVector(size_t _size,  const TRing* _ring, string _name)  :     ring(_ring), 
00013                                                                                 size(_size),   
00014                                                                                 name(_name)
00015 {
00016         assert (size>=0);
00017         
00018 
00019         data = NULL;
00020         data = new TNum[size];
00021 
00022         assert(data!=NULL);
00023         fillZero();
00024 }
00025 
00026 
00035 template <class TRing>
00036 template <class _istream>
00037 void TVector<TRing>::createFromStream(_istream & _dataStream)
00038 {
00039         #ifdef DEBUG
00040                 std::cerr << " TVector::createFromStream(): " << std::endl << std::endl; 
00041         #endif
00042 
00043         try{
00044                 string vectorStr = extractNextBracedData(_dataStream);
00045                 //      cerr << "vectorStr" << vectorStr << endl;
00046         
00047                 stringstream    vectorStream(vectorStr);
00048         
00049                 //      vectorStream << vectorStr;
00050         
00051                 int GroupCount = countGroups(vectorStream);
00052         
00053                 assert(GroupCount==1);
00054                 data = NULL;
00055                 //cerr << "vectorStream.str()" << vectorStream.str() << endl;
00056                 extractChar(vectorStream, '{');
00057         
00058                 size = countElements(vectorStream);
00059                 
00060                 data = new TNum[size];
00061         
00062                 for ( size_t elemNr=0;  elemNr<size ;  elemNr++)
00063                 {
00064                         int currEntry=0;
00065                         vectorStream >> currEntry;
00066                         
00067                         data[elemNr] = ring->ConvertScalar(currEntry);
00068         
00069                         if ( elemNr !=size-1 ) 
00070                                 extractChar( vectorStream, ',' );
00071                         else
00072                                 extractChar( vectorStream, '}' );
00073                 }
00074         }
00075         catch(...)
00076         {
00077                 cerr << "TVector: failed to parse " << _dataStream.str() << endl;
00078         }
00079 }
00080 
00081 
00082 
00086 template <class TRing> 
00087 template <class _istream>
00088 TVector<TRing>::TVector(  const TRing* _ring, _istream& sstream , string _name) : ring(_ring), name(_name)
00089 {
00090         createFromStream<_istream>(sstream);
00091 }
00092 
00093 
00094 
00095 
00099 template <class TRing>
00100 TVector<TRing>::TVector(string vecString,  const TRing* _ring, string _name) : ring(_ring), name(_name)
00101 {
00102         std::stringstream vs;
00103         vs << vecString;
00104         createFromStream<std::stringstream>(vs);
00105 }
00106 
00107 
00108 
00109 template <class TRing>
00110 TVector<TRing>:: ~TVector()
00111 {
00112         if (data!=NULL)
00113                 delete[] data;
00114 };
00115 
00116 
00117 
00118 
00119 template <class TRing>
00120 void TVector<TRing>::checkBounds(size_t pos) const
00121 {
00122         assert( pos<size);
00123 }
00124 
00125 
00126 
00127 
00128 template <class TRing>
00129 size_t TVector<TRing>::getSize() const
00130 {               
00131         return size;
00132 }
00133 
00135 template <class TRing>
00136 void TVector<TRing>::fillZero()
00137 {       
00138 
00139         //std::fill(data, data+rows*cols, TNum::Zero);
00140 
00141         for (size_t pos=0; pos<size; pos++)
00142         {
00143                 data[pos] = TNum::Zero;
00144         }
00145         //memset(data ,0x00,size*sizeof(TNum));
00146 }
00147 
00148 template <class TRing>
00149 inline typename TRing::ElementType &    TVector<TRing>::operator[]	(const size_t pos)
00150 {
00151         #ifdef SAFE
00152                 checkBounds(pos);
00153         #endif
00154         return data[pos] ;
00155 }
00156 
00157 template <class TRing>
00158 inline void TVector<TRing>::setVal(const size_t pos, const typename TRing::ElementType val)
00159 {
00160         #ifdef SAFE
00161                 checkBounds(pos);
00162         #endif
00163         data[pos] = val;
00164 }
00165 
00166 
00167 template <class TRing>
00168 inline void TVector<TRing>::setValByRef(const size_t pos,const typename TRing::ElementType& val)
00169 {
00170         #ifdef SAFE
00171                 checkBounds(pos);
00172         #endif
00173         data[pos] = val;
00174 }
00175 
00176 
00177 template <class TRing>
00178 inline typename TRing::ElementType TVector<TRing>::getVal(const size_t pos) const
00179 {
00180         #ifdef SAFE
00181                 checkBounds(pos);
00182         #endif
00183         return ( data[pos] );
00184 }
00185 
00186 
00187 template <class TRing>
00188 inline typename TRing::ElementType& TVector<TRing>::getValRef(const size_t pos)
00189 {
00190         #ifdef SAFE
00191                 checkBounds(pos);
00192         #endif
00193         return data[pos];
00194 }
00195 
00196 
00197 template <class TRing>
00198 inline const typename TRing::ElementType& TVector<TRing>::getConstValRef(const size_t pos) const
00199 {
00200         #ifdef SAFE
00201                 checkBounds(pos);
00202         #endif
00203         return data[pos];
00204 }
00205 
00210 
00214 
00215 template <class TRing>
00216 void TVector<TRing>::randomInit(long * _pRandomInit )
00217 {
00218         // only implemented for EpsPrecision==0
00219         assert(ring->getEpsPrecision()==0) ;
00220         for (size_t pos=0; pos<size; pos++)
00221         {
00222                 data[pos] = ring->ConvertScalar( random( _pRandomInit, ring->getCharacteristic()-1 )     );
00223         }
00224 }
00225 
00226 
00227 template <class TRing>
00228 bool   TVector<TRing>::isZero() const
00229 {
00230         for (size_t i=0; i<size; i++)
00231         {
00232                 if ( data[i].isNotZero() )
00233                         return false;
00234         }
00235         return true;
00236 }
00237 
00238 template <class TRing>
00239 bool   TVector<TRing>::isNotZero() const
00240 {
00241         for (size_t i=0; i<size; i++)
00242         {
00243                 if ( data[i].isNotZero() )
00244                         return true;
00245         }
00246         return false;
00247 }
00248 
00249 template <class TRing>
00250 bool  TVector<TRing>::operator==( TVector<TRing> & vec) const
00251 {
00252         if (this->getSize() != vec.getSize() )
00253                 return false;
00254 
00255         for (size_t i=0; i<size; i++)
00256         {
00257                 if ( this->getVal(i) != vec .getVal(i) )
00258                         return false;
00259         }
00260         return true;
00261 }
00262 
00263 template <class TRing>
00264 bool  TVector<TRing>::operator!=( TVector<TRing> & vec) const
00265 {
00266         if (this->getSize() != vec.getSize() )
00267                 return true;
00268 
00269         for (size_t i=0; i<size; i++)
00270         {
00271                 if ( this->getVal(i) != vec .getVal(i) )
00272                         return true;
00273         }
00274         return false;
00275 }
00276 
00278 template <class TRing>
00279 void TVector<TRing>::outputAsMatrix(ostream & os)
00280 {
00281         os << std::endl << name << " = " ;
00282         os  << "{" ;
00283 
00284         for (size_t i=0; i<size; i++)
00285         {
00286                 if (i>0)
00287                 {
00288                         os << ", " << std::endl;
00289                 }
00290                 os << "{";
00291                 os << data[i];
00292                 os << "}" ;
00293         }
00294         os << std::endl << "};" << std::endl;
00295 }
00296 
00297 
00298 template <class TRing> 
00299 std::ostream &  operator<<(std::ostream & out, const TVector<TRing>& z)
00300 {  
00301         out << "" << z.getName() << "={ " ;
00302 
00303         for ( size_t i=0; i<z.getSize(); i++)
00304         {
00305                 if (i>0)
00306                         out << ", " ;
00307                 out << z.getVal(i) ;
00308         }
00309         out << "}; " ;
00310         return out;
00311 } ;
00312 
Generated on Tue Nov 23 13:10:52 2010 for centerfocus by  doxygen 1.6.3