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
00046
00047 stringstream vectorStream(vectorStr);
00048
00049
00050
00051 int GroupCount = countGroups(vectorStream);
00052
00053 assert(GroupCount==1);
00054 data = NULL;
00055
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
00140
00141 for (size_t pos=0; pos<size; pos++)
00142 {
00143 data[pos] = TNum::Zero;
00144 }
00145
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
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