Diploma Thesis Percolation Simulation
C++ Sourcecode Documentation

www.AndreasKrueger.de/thesis/code
Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members  

measure< T > Class Template Reference

#include <measure.h>

Inheritance diagram for measure:

Inheritance graph
[legend]
Collaboration diagram for measure< T >:

Collaboration graph
[legend]
List of all members.

Public Methods

 measure (const T &av=(T) 0, const T &sdev=(T) 0)
T av (void)
T sdev (void)
void set_av (const T &av)
void set_sdev (const T &sdev)
measure & operator+= (const measure &rhs)
measure & operator+= (const T &rhs)
measure & operator-= (const measure &rhs)
measure & operator-= (const T &rhs)
measure & operator *= (const measure &rhs)
measure & operator *= (const T &rhs)
measure & operator/= (const measure &rhs)
measure & operator/= (const T &rhs)
measure & operator++ (int dummy)
measure & operator-- (int dummy)

Private Attributes

T value
T stddev

Friends

measure operator- (const measure &rhs)
measure operator+ (const measure &rhs)
measure operator+ (const measure &lhs, const measure &rhs)
measure operator+ (const measure &lhs, const T &rhs)
measure operator+ (const T &lhs, const measure &rhs)
measure operator- (const measure &lhs, const measure &rhs)
measure operator- (const measure &lhs, const T &rhs)
measure operator- (const T &lhs, const measure &rhs)
measure operator * (const measure &lhs, const measure &rhs)
measure operator * (const measure &lhs, const T &rhs)
measure operator * (const T &lhs, const measure &rhs)
measure operator/ (const measure &lhs, const measure &rhs)
measure operator/ (const measure &lhs, const T &rhs)
measure operator/ (const T &lhs, const measure &rhs)
bool overlap (const measure &lhs, const measure &rhs)
bool overlap (const measure &lhs, const T &rhs)
bool overlap (const T &lhs, const measure &rhs)
ostream & operator<< (ostream &os, const measure &i)
istream & operator>> (istream &is, measure &i)
measure pow (const measure &lhs, const measure &rhs)
measure pow (const measure &lhs, const T &rhs)
measure pow (const measure &lhs, const int &rhs)
measure pow (const T &lhs, const measure &rhs)
measure pow (const int &lhs, const measure &rhs)
measure log (const measure &arg)
measure log10 (const measure &arg)
measure fabs (const measure &arg)
measure exp (const measure &arg)
measure sqrt (const measure &arg)
measure sin (const measure &arg)
measure cos (const measure &arg)
measure tan (const measure &arg)
measure asin (const measure &arg)
measure acos (const measure &arg)
measure atan (const measure &arg)

template<class T>
class measure< T >

Constructor & Destructor Documentation

template<class T>
measure< T >::measure (  const T &    av = (T)0,
const T &    sdev = (T)0
)  [inline]
 

Definition at line 162 of file measure.h. 

00163                          : value(av), stddev(::fabs(sdev))
00164                         {};

Member Function Documentation

template<class T>
T measure< T >::av (  void    )  [inline]
 

Definition at line 165 of file measure.h.

Referenced by statistics::calculate_all_moments(), statistics::statistical< RES, ELEM >::general_moment(), measure< RES >::measure(), measure< RES >::set_av(), and datafiles::write_ff_line(). 

00165 {return value;};

template<class T>
measure< T > & measure< T >::operator *= (  const T &    rhs ) 
 

Definition at line 433 of file measure.h. 

00433                                               {
00434         this *= measure<T>(rhs,0);
00435         return *this;
00436 }

template<class T>
measure< T > & measure< T >::operator *= (  const measure< T > &    rhs ) 
 

Definition at line 305 of file measure.h.

References measure< T >::stddev, and measure< T >::value. 

00305                                                        {
00306         stddev =sum2<T>(stddev*rhs.value, rhs.stddev*value);
00307         value *=rhs.value;
00308         return *this;
00309 }

template<class T>
measure& measure< T >::operator++ (  int    dummy )  [inline]
 

Definition at line 177 of file measure.h. 

00177 {value++;return *this;};

template<class T>
measure< T > & measure< T >::operator+= (  const T &    rhs ) 
 

Definition at line 393 of file measure.h. 

00393                                               {
00394         this += measure<T>(rhs,0);
00395         return *this;
00396 }

template<class T>
measure< T > & measure< T >::operator+= (  const measure< T > &    rhs ) 
 

Definition at line 293 of file measure.h.

References measure< T >::stddev, and measure< T >::value. 

00293                                                        {
00294         stddev =sum2<T>(stddev, rhs.stddev);
00295         value +=rhs.value;
00296         return *this;
00297 }

template<class T>
measure& measure< T >::operator-- (  int    dummy )  [inline]
 

Definition at line 178 of file measure.h. 

00178 {value--;return *this;};

template<class T>
measure< T > & measure< T >::operator-= (  const T &    rhs ) 
 

Definition at line 413 of file measure.h. 

00413                                               {
00414         this -= measure<T>(rhs,0);
00415         return *this;
00416 }

template<class T>
measure< T > & measure< T >::operator-= (  const measure< T > &    rhs ) 
 

Definition at line 299 of file measure.h.

References measure< T >::stddev, and measure< T >::value. 

00299                                                        {
00300         stddev =sum2<T>(stddev, rhs.stddev);
00301         value -=rhs.value;
00302         return *this;
00303 }

template<class T>
measure< T > & measure< T >::operator/= (  const T &    rhs ) 
 

Definition at line 453 of file measure.h. 

00453                                               {
00454         this /= measure<T>(rhs,0);
00455         return *this;
00456 }

template<class T>
measure< T > & measure< T >::operator/= (  const measure< T > &    rhs ) 
 

Definition at line 311 of file measure.h.

References measure< T >::stddev, and measure< T >::value. 

00311                                                        {
00312         stddev =sum2<T>(stddev/rhs.value, rhs.stddev*value/(rhs.value*rhs.value));
00313         value /=rhs.value;
00314         return *this;
00315 }

template<class T>
T measure< T >::sdev (  void    )  [inline]
 

Definition at line 166 of file measure.h.

Referenced by measure< RES >::measure(), statistics::muvarskewkurt< RES >::sdev_of_mean(), measure< RES >::set_sdev(), and datafiles::write_ff_line(). 

00166 {return stddev;};

template<class T>
void measure< T >::set_av (  const T &    av )  [inline]
 

Definition at line 167 of file measure.h.

Referenced by statistics::statistical< RES, ELEM >::general_moment(). 

00167 {value=av;};

template<class T>
void measure< T >::set_sdev (  const T &    sdev )  [inline]
 

Definition at line 168 of file measure.h.

Referenced by statistics::statistical< RES, ELEM >::general_moment(), and statistics::muvarskewkurt< RES >::sdev_of_mean(). 

00168 {stddev=::fabs(sdev);};

Friends And Related Function Documentation

template<class T>
measure acos (  const measure< T > &    arg )  [friend]
 

Definition at line 370 of file measure.h. 

00370                                                         {
00371         measure<T> temp;
00372         temp.stddev=arg.stddev/sqrt(1- arg.value*arg.value);
00373         temp.value=acos(arg.value);
00374         return temp;
00375 }

template<class T>
measure asin (  const measure< T > &    arg )  [friend]
 

Definition at line 364 of file measure.h. 

00364                                                         {
00365         measure<T> temp;
00366         temp.stddev=arg.stddev/sqrt(1- arg.value*arg.value);
00367         temp.value=asin(arg.value);
00368         return temp;
00369 }

template<class T>
measure atan (  const measure< T > &    arg )  [friend]
 

Definition at line 376 of file measure.h. 

00376                                                         {
00377         measure<T> temp;
00378         temp.stddev=arg.stddev/(1+ arg.value*arg.value);
00379         temp.value=atan(arg.value);
00380         return temp;
00381 }

template<class T>
measure cos (  const measure< T > &    arg )  [friend]
 

Definition at line 352 of file measure.h. 

00352                                                        {
00353         measure<T> temp;
00354         temp.stddev=arg.stddev*fabs(sin(arg.value));
00355         temp.value=cos(arg.value);
00356         return temp;
00357 }

template<class T>
measure exp (  const measure< T > &    arg )  [friend]
 

Definition at line 499 of file measure.h. 

00499 { return pow(exp(1),arg);}

template<class T>
measure fabs (  const measure< T > &    arg )  [friend]
 

Definition at line 339 of file measure.h. 

00339                                       {
00340         measure<T> temp;
00341         temp.stddev=arg.stddev;
00342         temp.value=fabs(arg.value);
00343         return temp;
00344 }

template<class T>
measure log (  const measure< T > &    arg )  [friend]
 

Definition at line 325 of file measure.h. 

00325                                      {
00326         measure<T> temp;
00327         temp.stddev=arg.stddev/fabs(arg.value);
00328         temp.value=log(arg.value);
00329         return temp;
00330 }

template<class T>
measure log10 (  const measure< T > &    arg )  [friend]
 

Definition at line 332 of file measure.h. 

00332                                        {
00333         measure<T> temp;
00334         temp.stddev=arg.stddev/(fabs(arg.value)*log(10));
00335         temp.value=log10(arg.value);
00336         return temp;
00337 }

template<class T>
measure operator * (  const T &    lhs,
const measure< T > &    rhs
)  [friend]
 

Definition at line 448 of file measure.h. 

00448                                                          {
00449         return measure<T>(lhs,0) * rhs ;
00450 }

template<class T>
measure operator * (  const measure< T > &    lhs,
const T &    rhs
)  [friend]
 

Definition at line 444 of file measure.h. 

00444                                                          {
00445         return lhs * measure<T>(rhs,0);
00446 }

template<class T>
measure operator * (  const measure< T > &    lhs,
const measure< T > &    rhs
)  [friend]
 

Definition at line 438 of file measure.h. 

00438                                                                   {
00439         measure<T> temp=lhs;
00440         temp*=rhs;
00441         return temp;
00442 }

template<class T>
measure operator+ (  const T &    lhs,
const measure< T > &    rhs
)  [friend]
 

Definition at line 408 of file measure.h. 

00408                                                          {
00409         return measure<T>(lhs,0) + rhs ;
00410 }

template<class T>
measure operator+ (  const measure< T > &    lhs,
const T &    rhs
)  [friend]
 

Definition at line 404 of file measure.h. 

00404                                                          {
00405         return lhs + measure<T>(rhs,0);
00406 }

template<class T>
measure operator+ (  const measure< T > &    lhs,
const measure< T > &    rhs
)  [friend]
 

Definition at line 398 of file measure.h. 

00398                                                                   {
00399         measure<T> temp=lhs;
00400         temp+=rhs;
00401         return temp;
00402 }

template<class T>
measure operator+ (  const measure< T > &    rhs )  [friend]
 

Definition at line 476 of file measure.h. 

00476                                                              {
00477         return rhs;
00478 }

template<class T>
measure operator- (  const T &    lhs,
const measure< T > &    rhs
)  [friend]
 

Definition at line 428 of file measure.h. 

00428                                                          {
00429         return measure<T>(lhs,0) - rhs ;
00430 }

template<class T>
measure operator- (  const measure< T > &    lhs,
const T &    rhs
)  [friend]
 

Definition at line 424 of file measure.h. 

00424                                                          {
00425         return lhs - measure<T>(rhs,0);
00426 }

template<class T>
measure operator- (  const measure< T > &    lhs,
const measure< T > &    rhs
)  [friend]
 

Definition at line 418 of file measure.h. 

00418                                                                   {
00419         measure<T> temp=lhs;
00420         temp-=rhs;
00421         return temp;
00422 }

template<class T>
measure operator- (  const measure< T > &    rhs )  [friend]
 

Definition at line 472 of file measure.h. 

00472                                                              {
00473         return ((T)0-rhs);
00474 }

template<class T>
measure operator/ (  const T &    lhs,
const measure< T > &    rhs
)  [friend]
 

Definition at line 468 of file measure.h. 

00468                                                          {
00469         return measure<T>(lhs,0) / rhs ;
00470 }

template<class T>
measure operator/ (  const measure< T > &    lhs,
const T &    rhs
)  [friend]
 

Definition at line 464 of file measure.h. 

00464                                                          {
00465         return lhs / measure<T>(rhs,0);
00466 }

template<class T>
measure operator/ (  const measure< T > &    lhs,
const measure< T > &    rhs
)  [friend]
 

Definition at line 458 of file measure.h. 

00458                                                                   {
00459         measure<T> temp=lhs;
00460         temp/=rhs;
00461         return temp;
00462 }

template<class T>
ostream& operator<< (  ostream &    os,
const measure< T > &    i
)  [friend]
 

Definition at line 279 of file measure.h. 

00279                                                         {
00280         return os<<rhs.value<<ASCII_PLUSMINUS<<rhs.stddev;
00281 }

template<class T>
istream& operator>> (  istream &    is,
measure< T > &    i
)  [friend]
 

Definition at line 283 of file measure.h. 

00283                                                   {
00284         T value, stddev;
00285         is >> value;    rhs.value=value;
00286         is >> stddev;   rhs.stddev=fabs(stddev);
00287         return is;
00288 }

template<class T>
bool overlap (  const T &    lhs,
const measure< T > &    rhs
)  [friend]
 

Definition at line 506 of file measure.h. 

00506                                                                    {
00507         return overlap(measure<T>(lhs,0), rhs);
00508 }

template<class T>
bool overlap (  const measure< T > &    lhs,
const T &    rhs
)  [friend]
 

Definition at line 503 of file measure.h. 

00503                                                                    {
00504         return overlap(lhs, measure<T>(rhs,0));
00505 }

template<class T>
bool overlap (  const measure< T > &    lhs,
const measure< T > &    rhs
)  [friend]
 

Definition at line 384 of file measure.h. 

00384                                                                             {
00385         return (fabs(lhs.value-rhs.value)) < (lhs.stddev + rhs.stddev);
00386 }

template<class T>
measure pow (  const int &    lhs,
const measure< T > &    rhs
)  [friend]
 

Definition at line 494 of file measure.h. 

00494                                                      {
00495         return pow(measure<T>((T)lhs,0), rhs);
00496 }

template<class T>
measure pow (  const T &    lhs,
const measure< T > &    rhs
)  [friend]
 

Definition at line 481 of file measure.h. 

00481                                                     {
00482         return pow(measure<T>(lhs,0), rhs);
00483 }

template<class T>
measure pow (  const measure< T > &    lhs,
const int &    rhs
)  [friend]
 

Definition at line 490 of file measure.h. 

00490                                                      {
00491         return pow(lhs, measure<T>((T)rhs,0));
00492 }

template<class T>
measure pow (  const measure< T > &    lhs,
const T &    rhs
)  [friend]
 

Definition at line 485 of file measure.h. 

00485                                                    {
00486         return pow(lhs, measure<T>(rhs,0));
00487 }

template<class T>
measure pow (  const measure< T > &    lhs,
const measure< T > &    rhs
)  [friend]
 

Definition at line 317 of file measure.h. 

00317                                                             {
00318         measure<T> temp;
00319         temp.stddev=sum2<T>(lhs.stddev*rhs.value*pow(lhs.value,rhs.value-1), 
00320                                         rhs.stddev*log(lhs.value)*pow(lhs.value,rhs.value));
00321         temp.value=pow(lhs.value, rhs.value);
00322         return temp;
00323 }

template<class T>
measure sin (  const measure< T > &    arg )  [friend]
 

Definition at line 346 of file measure.h. 

00346                                                        {
00347         measure<T> temp;
00348         temp.stddev=arg.stddev*fabs(cos(arg.value));
00349         temp.value=sin(arg.value);
00350         return temp;
00351 }

template<class T>
measure sqrt (  const measure< T > &    arg )  [friend]
 

Definition at line 501 of file measure.h. 

00501 { return pow(arg, 0.5);}

template<class T>
measure tan (  const measure< T > &    arg )  [friend]
 

Definition at line 358 of file measure.h. 

00358                                                        {
00359         measure<T> temp;
00360         temp.stddev=arg.stddev/(cos(arg.value)*cos(arg.value));
00361         temp.value=tan(arg.value);
00362         return temp;
00363 }

Member Data Documentation

template<class T>
T measure< T >::stddev [private]
 

Definition at line 160 of file measure.h.

Referenced by acos(), asin(), atan(), cos(), fabs(), log(), log10(), measure< RES >::measure(), measure< T >::operator *=(), measure< T >::operator+=(), measure< T >::operator-=(), measure< T >::operator/=(), operator>>(), overlap(), pow(), measure< RES >::sdev(), measure< RES >::set_sdev(), sin(), and tan().

template<class T>
T measure< T >::value [private]
 

Definition at line 160 of file measure.h.

Referenced by acos(), asin(), atan(), measure< RES >::av(), cos(), fabs(), log(), log10(), measure< RES >::measure(), measure< T >::operator *=(), measure< RES >::operator++(), measure< T >::operator+=(), measure< RES >::operator--(), measure< T >::operator-=(), measure< T >::operator/=(), operator>>(), overlap(), pow(), measure< RES >::set_av(), sin(), and tan().

The documentation for this class was generated from the following file:




Diploma Thesis Sourcecode Documentation
check out the text and the executable binaries

www.AndreasKrueger.de/thesis/code