Diploma Thesis Percolation Simulation C++ Sourcecode Documentation

www.AndreasKrueger.de/thesis/code

                 

---

my_vector.h

Go to the documentation of this file.

// ndim_vector.h
// class definition for a variable-dim vector 
// up to MAXDIM dimensions (faster than variable-dim!) 
// with subtraction, length, unit-, null- and randomvector
// first implemented idea 1.2.2000  
//
// VERSION 2.3
// last update: 27.9.2001
// Andreas Krueger

// #define COORDFLOAT float             // for cordinates
// #define REAL double          // for radius, filligfactor, etc. 
// #define NUMBER long          // for the number of clusters, etc.

// TODO: 
//
// COORDFLOAT coord(int dir);
// set the OUTSIDE access to coordinate from [0;...;MAXDIM-1] to [1;...;MAXDIM]
// so that x=1, y=2, z=3, etc.
//
// it is already that way in the counting algos 
// using bool lower {   return (u.x[dir-1] < border); }
// but it is NOT in the visualization 
// and all other places that use COORDFLOAT coord(int dir); !!!
// e.g. coordinate2boxes
// e.g. ...

#ifndef LOADED_LITTLE_HELPERS
#include "little_helpers.h"
#endif

class myVector {
  int dim;                                                      // protected variable for dimensionality
  COORDFLOAT x[MAXDIM];                                 // protected vector components 

public:       
  myVector();                                                           // Default-Constructor (dim=0)
  myVector(int setdim);                                 // Constructor-function for definition, calls set_dim
  myVector(const myVector& u);                          // CopyConstructor

  void set_dim(int setdim);                             // sets dimensionality and sets coordinates=0;
  friend int getdim(const myVector &u); // gives dimension

  void randomvect (COORDFLOAT L);                       // (0...L)^dimension
  void nullvect();                                              // 0,0,0,...,0 (x0, x1, x2, , ... , dim-1)
  void unitvect();                                              // 0,0,0,...,0 (x0, x1, x2, , ... , dim-1)
  friend REAL length(const myVector &u);        // vector length
  friend REAL squarelength(const myVector &u);  // square of vector length (no SQRT!)

  myVector& operator=(const myVector& u);                               // sets same dimension and copies
  myVector& operator-=(const myVector&);                                                // subtraction for connection vectors
  friend myVector operator- (const myVector&,const myVector&);  // subtraction for connection vectors
  friend myVector operator- (const myVector&);                                          // (x1, x2)  -->  (-x1, -x2)
  
  friend ostream& operator<<(ostream&, myVector&);                      // output operator
  friend istream& operator>>(istream&, myVector&);                      // input operator
  friend bool operator<(const myVector&,const myVector&);               // compare operator (length order)
  bool operator!=(const myVector& u);                                                   // different vectors?
  friend bool lower(const myVector&, COORDFLOAT border,int dir);        // is vector in lower (than 'border') part of this dimensional direction?

  COORDFLOAT coord(int dir);                            // returns x[...];
};

myVector::myVector(){
        dim=0;
}

myVector::myVector(int setdim){
        if ((setdim<1)||(setdim>MAXDIM)) {
                errorout("'myVector' dimension < 1 or > MAXDIM");
                exit(1);
        }
        else{
                set_dim(setdim);
        }
}

myVector::myVector(const myVector &u) {                         // copy constructor
        dim=u.dim;                                                                      // create the new vector with same dimensionality
        for (int i=0;i<dim;i++) {                                       // copy components
                x[i] = u.x[i];
        }
}

inline void myVector::set_dim(int setdim){
        dim=setdim;
        nullvect();
}

int getdim(const myVector &u) {
        return u.dim;
}


inline REAL length(const myVector &u) {
   COORDFLOAT temp=0;
        for (int i=0;i<u.dim;i++) 
                {temp+=u.x[i]*u.x[i];}
        return sqrt(temp);
}

REAL squarelength(const myVector &u) {
   COORDFLOAT temp=0;
        for (int i=0;i<u.dim;i++) 
                {temp+=u.x[i]*u.x[i];}
        return temp;
}

ostream& operator<<(ostream& os, myVector& z) {
        cout <<'(';
        for (int i=0;i<z.dim-1;i++) {
                cout<<z.x[i]<<',';
        }
        return os<<z.x[z.dim-1]<<')';
}

istream& operator>>(istream& is, myVector& z) {
        for (int i=0;i<z.dim;i++) {
                cin>>z.x[i];
        }
        return is;
}

inline myVector& myVector::operator=(const myVector& u) {                       // give only reference for faster code
        if (dim!=u.dim) errorout("'=' different dimensionality");
        else{
                for (int i=0;i<dim;i++) {
                        x[i] = u.x[i];
                }
        }
        return *this;
}

inline myVector& myVector::operator-=(const myVector& u) {      // give only reference for faster code
        if (dim!=u.dim) errorout("'-=' different dimensionality");
        else {
                for (int i=0;i<dim;i++) {
                        x[i] -= u.x[i];
                }
        }
        return *this;
}


myVector operator- (const myVector& u, const myVector& v) {             
        if (u.dim!=v.dim) {
                errorout("'-' different dimensionality");
                return u;
        }
        else{
                myVector temp = u;
                return (temp -= v);                                                             // calls myVector::operator-=(myVector)
        }
}

myVector operator- (const myVector& u){
        myVector temp(u.dim);
        temp.nullvect();
        return (temp-=u);
}

inline void myVector::nullvect () {
        for (int i=0;i<dim;i++) {
                x[i] = 0;
        }
}
void myVector::unitvect() {
        for (int i=0;i<dim;i++) {
                x[i] = 1;
        }
}



REAL short_random (REAL L) {
        REAL temp=rand()*L/(double)RAND_MAX;
        return temp;
}

REAL long_random(REAL L){
        REAL temp=rand()+rand()/(REAL)RAND_MAX;
        temp*=L/(REAL)RAND_MAX;
        return temp;
}


void myVector::randomvect (COORDFLOAT L) {
        for (int i=0;i<dim;i++) {
                x[i] = long_random(L);
        }
}



bool operator<(const myVector &u, const myVector &v) {                  // length order
  return (length(u) < length(v) );
}

bool myVector::operator!=(const myVector& u) {  // give only reference for faster code
        bool temp=0;
        if (u.dim!=dim) temp=1;
        else {
                for (int i=0;i<u.dim;i++) {
                        if (x[i] != u.x[i]) temp=1;
                }
        }
        return temp;
}


bool lower(const myVector& u, COORDFLOAT border, int dir) {
        // is myVector u in lower (than 'border') part of this dimensional direction?
        if ((dir<1)||(dir>u.dim)) {
                errorout("space direction < 1 or > dim");
                exit(1);
                return false;
        }
        else return (u.x[dir-1] < border);
}


COORDFLOAT myVector::coord(int dir) {
        return x[dir];
}

//  end of class definition: myVector

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

www.AndreasKrueger.de/thesis/code