| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |

In This Package:

MagVec Class Reference

#include <MagVec.h>

List of all members.


Public Member Functions

 MagVec (int N)
 MagVec ()
 MagVec (const MagVec &v)
 ~MagVec ()
double & operator[] (int i)
const double & operator[] (int i) const
MagVec & operator= (const MagVec &v)
MagVec operator+ (const MagVec &v)
MagVec operator+ (const MagVec &v) const
MagVec & operator+= (const MagVec &v)
MagVec operator- (const MagVec &v)
MagVec operator- (const MagVec &v) const
MagVec & operator-= (const MagVec &v)
double operator * (const MagVec &v)
double operator * (const MagVec &v) const
MagVec operator * (const double &d)
MagVec & operator *= (const double &d)
void reSize (int Nnew)
int n_elem () const

Private Attributes

int Nele
double * ptr_data

Detailed Description

Definition at line 8 of file MagVec.h.

Constructor & Destructor Documentation

MagVec::MagVec ( int  N  ) 

Definition at line 14 of file MagVec.cpp.

00014                     {
00015 
00016   Nele = N;
00017   ptr_data = new double[Nele];
00018   for(int i=0;i<Nele;i++) *(ptr_data+i)=0.;
00019 }

MagVec::MagVec (  ) 

Definition at line 6 of file MagVec.cpp.

00006                {
00007 
00008   Nele = 0;
00009   ptr_data = 0;  // set pointer to null
00010 
00011 }

MagVec::MagVec ( const MagVec &  v  ) 

Definition at line 21 of file MagVec.cpp.

00021                               {
00022 
00023   Nele = v.Nele;
00024   ptr_data = new double[Nele]; 
00025   for(int i=0;i<Nele;i++) *(ptr_data+i)=v[i];
00026 
00027 }

MagVec::~MagVec (  ) 

Definition at line 29 of file MagVec.cpp.

00030 {delete [] ptr_data;}

Member Function Documentation

double & MagVec::operator[] ( int  i  ) 

Definition at line 33 of file MagVec.cpp.

00033                                 {
00034 
00035   if( i < 0 ) { std::cerr << "MagVec: Index < zero! " << std::endl; return ptr_data[0]; }; 
00036   if( i >= Nele ) { std::cerr << "MagVec: Index too large! " << std::endl; return ptr_data[0]; }; 
00037 
00038   return  *(ptr_data+i);
00039 
00040 }

const double & MagVec::operator[] ( int  i  )  const

Definition at line 42 of file MagVec.cpp.

00042                                             {
00043 
00044   if( i < 0 ) { std::cerr << "MagVec: Index < zero! " << std::endl; return ptr_data[0]; }; 
00045   if( i >= Nele ) { std::cerr << "MagVec: Index too large! " << std::endl; return ptr_data[0]; }; 
00046 
00047   return  *(ptr_data+i);
00048 
00049 }

MagVec & MagVec::operator= ( const MagVec &  v  ) 

Definition at line 51 of file MagVec.cpp.

00051                                          {
00052 
00053   if(Nele!=0 && Nele!=v.Nele) {
00054 std::cerr << "MagVec Assignment: size does not match!" << std::endl; return *this;
00055   }
00056  
00057   if ( ptr_data != v.ptr_data ) {
00058     reSize(v.Nele);
00059     for(int i=0;i<Nele;i++) *(ptr_data+i) = v[i];
00060   }
00061 
00062   return *this;
00063 
00064 }

MagVec MagVec::operator+ ( const MagVec &  v  ) 

Definition at line 66 of file MagVec.cpp.

00066                                         {
00067 
00068   if( Nele != v.Nele ) { std::cerr << "operator+: vectors size does not match!" << std::endl; return *this; }; 
00069   MagVec b(Nele);
00070 
00071   for (int i=0;i<Nele;i++) b[i] = *(ptr_data+i) + v[i];
00072   return b;
00073 
00074 }

MagVec MagVec::operator+ ( const MagVec &  v  )  const

Definition at line 76 of file MagVec.cpp.

00076                                               {
00077 
00078   if( Nele != v.Nele ) { std::cerr << "operator+: vectors size does not match!" << std::endl; return *this; }; 
00079   MagVec b(Nele);
00080  
00081   for (int i=0;i<Nele;i++) b[i] = *(ptr_data+i) + v[i];
00082   return b;
00083 
00084 }

MagVec & MagVec::operator+= ( const MagVec &  v  ) 

Definition at line 86 of file MagVec.cpp.

00086                                           {
00087 
00088  if( Nele != v.Nele ) { std::cerr << "operator+=: vectors size does not match!" << std::endl; return *this; }; 
00089 
00090  for (int i=0;i<Nele;i++) *(ptr_data+i)+=v[i];
00091   return *this;
00092 
00093 }

MagVec MagVec::operator- ( const MagVec &  v  ) 

Definition at line 95 of file MagVec.cpp.

00095                                          {
00096 
00097   if( Nele != v.Nele ) { std::cerr << "operator+: vectors size does not match!" << std::endl; return *this; }
00098   MagVec b(Nele);
00099 
00100   for (int i=0;i<Nele;i++) b[i] = *(ptr_data+i) - v[i];
00101   return b;
00102 
00103 }

MagVec MagVec::operator- ( const MagVec &  v  )  const

Definition at line 105 of file MagVec.cpp.

00105                                               {
00106 
00107   if( Nele != v.Nele ) { std::cerr << "operator+: vectors size does not match!" << std::endl; return *this; }
00108   MagVec b(Nele);
00109  
00110   for (int i=0;i<Nele;i++) b[i] = *(ptr_data+i) - v[i];
00111   return b;
00112 
00113 }

MagVec & MagVec::operator-= ( const MagVec &  v  ) 

Definition at line 115 of file MagVec.cpp.

00115                                           {
00116 
00117  if( Nele != v.Nele ) { std::cerr << "operator+=: vectors size does not match!" << std::endl; return *this; }
00118 
00119 
00120 
00121  for (int i=0;i<Nele;i++) *(ptr_data+i)-=v[i];
00122   return *this;
00123 
00124 }

double MagVec::operator * ( const MagVec &  v  ) 

Definition at line 126 of file MagVec.cpp.

00126                                         {
00127   double  b=0.;
00128   if( Nele != v.Nele ) { std::cerr << "scalar product: vectors size does not match!" << std::endl; return b; }
00129 
00130  for (int i=0;i<Nele;i++) b += *(ptr_data+i)*v[i];
00131   return b;
00132 }

double MagVec::operator * ( const MagVec &  v  )  const

Definition at line 134 of file MagVec.cpp.

00134                                               {
00135   double  b=0.;
00136   if( Nele != v.Nele ) { std::cerr << "scalar product: vectors size does not match!" << std::endl; return b; }
00137 
00138  for (int i=0;i<Nele;i++) b += *(ptr_data+i)*v[i];
00139   return b;
00140 }

MagVec MagVec::operator * ( const double &  d  ) 

MagVec & MagVec::operator *= ( const double &  d  ) 

Definition at line 144 of file MagVec.cpp.

00144                                           {
00145 
00146   for (int i=0;i<Nele;i++) *(ptr_data+i)*= d;
00147 
00148   return *this;
00149 
00150 }

void MagVec::reSize ( int  Nnew  ) 

Definition at line 153 of file MagVec.cpp.

00153                             {
00154 
00155  
00156   if ( Nnew>=0 && Nnew != Nele ) {
00157     double*  p = ptr_data;
00158     int Nele_old = Nele;
00159     ptr_data = new double[Nnew];
00160     Nele = Nnew;
00161     int k = Nele <= Nele_old ? Nele : Nele_old;
00162 
00163     p += k;
00164     double*  q = ptr_data + k;
00165     while (q > ptr_data) *(--q) = *(--p);
00166 
00167     delete [] p;
00168   }
00169 
00170 
00171 
00172 }

int MagVec::n_elem (  )  const

Definition at line 174 of file MagVec.cpp.

00174                          {
00175 
00176   return Nele;
00177 
00178 }

Member Data Documentation

int MagVec::Nele [private]

Definition at line 44 of file MagVec.h.

double* MagVec::ptr_data [private]

Definition at line 46 of file MagVec.h.

The documentation for this class was generated from the following files:
| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |
Generated on Mon Apr 11 20:04:56 2011 for Magnet by doxygen 1.4.7