Hjorth-Jensen M. Computational Physics
Подождите немного. Документ загружается.
Extrapolat Error
0.0 1.00083361 1.00020835 1.00005208 1.00000000 0.00000000
1.0 2.72054782 2.71884818 2.71842341 2.71828183 0.00000001
2.0 7.39521570 7.39059561 7.38944095 7.38905610 0.00000003
3.0 20.10228045 20.08972176 20.08658307 20.08553692 0.00000009
4.0 54.64366366 54.60952560 54.60099375 54.59815003 0.00000024
5.0 148.53687797 148.44408109 148.42088912 148.41315910 0.00000064
Table 3.3: Result for numerically calculated second derivatives of using extrapolation.
The first three values are those calculated with three different step sizes, , and with
. The extrapolated result to should then be compared with the exact ones from
Table 3.1.
Chapter 4
Classes, templates and modules
in preparation (not finished as of 11/26/03)
4.1 Introduction
C++’ strength over C and F77 is the possibility to define new data types, tailored to some prob-
lem.
A user-defined data type contains data (variables) and functions operating on the data
Example: a point in 2D
– data: x and y coordinates of the point
– functions: print, distance to another point, ...
Classes into structures
Pass arguments to methods
Allocate storage for objects
Implement associations
Encapsulate internal details into classes
Implement inheritance in data structures
Classes contain a new data type and the procedures that can be performed by the class. The
elements (or components) of the data type are the class data members, and the procedures are the
class member functions.
61
62 CHAPTER 4. CLASSES, TEMPLATES AND MODULES
4.2 A first encounter, the vector class
Class MyVector: a vector
Data: plain C array
Functions: subscripting, change length, assignment to another vector, inner product with
another vector, ...
This examples demonstrates many aspects of C++ programming
Create vectors of a specified length: MyVector v(n);
Create a vector with zero length: MyVector v;
Redimension a vector to length n: v.redim(n);
Create a vector as a copy of another vector w: MyVector v(w);
Extract the length of the vector: const int n = v.size();
Extract an entry: double e = v(i);
Assign a number to an entry: v(j) = e;
Set two vectors equal to each other: w = v;
Take the inner product of two vectors: double a = w.inner(v);
or alternatively a = inner(w,v);
Write a vector to the screen: v.print(cout);
class MyVector
{
private :
double A; / / vector en trie s (C array )
int length ;
void all oc ate ( int n ) ; / / all oca te memory , length=n
void de al l oc a te ( ) ; / / free memory
public :
MyVector ( ) ; / / MyVector v ;
MyVector ( int n ) ; / / MyVector v ( n ) ;
MyVector ( const MyVector& w) ; / / MyVector v (w) ;
~MyVector ( ) ; / / clean up dynamic memory
bool redim ( int n ) ; / / v . redim (m) ;
MyVector& operator = ( const MyVector& w) ; / / v = w;
4.2. A FIRST ENCOUNTER, THE VECTOR CLASS 63
double operator ( ) ( int i ) const ; / / a = v ( i ) ;
double& operator () ( int i ) ; / / v ( i ) = a ;
void p r int ( std : : ostream & o ) const ; / / v . pri nt ( cout ) ;
double inner ( const MyVector& w) const ; / / a = v . inner (w) ;
int si ze ( ) const { return length ; } / / n = v . s ize ( ) ;
};
\ end{ l i s t i n g }
Constr uctors t e l l how we de clare a v ari abl e of type MyVector and how
th is v ar i ab l e is i n i t i a l i z e d
\ begin { l s t l i s t i n g }
MyVector v ; / / declare a vector of length 0
/ / t h i s a ct u al ly means cal lin g the fu nc ti on
MyVector : : MyVector ( )
{ A = NULL; length = 0 ; }
MyVector v ( n) ; / / declare a vector of length n
/ / means c al l ing the f unct ion
MyVector : : MyVector ( int n)
{ a l l o c ate ( n ) ; }
void MyVector : : a l l o c a t e ( int n )
{
length = n ;
A = new double [ n ] ; / / create n doubles in memory
}
A MyVector object is created (dynamically) at run time, but must also be destroyed when it
is no longer in use. The destructor specifies how to destroy the object:
MyVector : :~ MyVector ( )
{
de a llo cat e ( ) ;
}
/ / f re e dynamic memory :
void MyVector : : dea llo cat e ( )
{
delete [ ] A;
}
64 CHAPTER 4. CLASSES, TEMPLATES AND MODULES
/ / v and w are MyVector o bj ec ts
v = w;
/ / means c al l ing
MyVector& MyVector : : operator = ( const MyVector& w)
/ / for se t t i n g v = w;
{
redim (w. siz e () ) ; / / make v as long as w
int i ;
for ( i = 0 ; i < length ; i ++) { / / ( C arrays s t a r t at 0 )
A[ i ] = w.A[ i ] ;
}
return this ;
}
/ / return of this , i . e . a MyVector& , allows nested
u = v = u_vec = v_vec ;
v . redim ( n ) ; / / make a v of length n
bool MyVector : : redim ( int n )
{
i f ( length == n )
return fal se ; / / no need to a ll oca te anything
else {
i f (A ! = NULL) {
/ / " t h i s " object has already allocate d memory
de a ll o cat e ( ) ;
}
a ll ocate ( n) ;
return true ; / / the length was changed
}
}
MyVector v (w) ; / / take a copy of w
MyVector : : MyVector ( const MyVector& w)
{
a l l o c a te (w. si ze ( ) ) ; / / " t hi s " obje ct gets w’ s length
th is = w; / / c a ll operator=
}
/ / a and v are MyVector objects ; want to set
a ( j ) = v ( i +1) ;
4.2. A FIRST ENCOUNTER, THE VECTOR CLASS 65
/ / the meaning of a ( j ) i s defined by
in line double& MyVector : : operator ( ) ( int i )
{
return A[ i 1];
/ / base index i s 1 ( not 0 as in C/C++)
}
Inline functions: function body is copied to calling code, no overhead of function call!
Note: inline is just a hint to the compiler; there is no guarantee that the compiler really
inlines the function
Why return a double reference?
double& MyVector : : operator ( ) ( int i ) { return A[ i 1]; }
/ / returns a r eference ( ‘ ‘ poi nter ’ ’) d i r e c t l y to A[ i 1]
/ / such that the c all ing code can change A[ i 1]
/ / given MyVector a ( n ) , b(n) , c ( n) ;
for ( int i = 1 ; i <= n ; i ++)
c ( i ) = a ( i ) b ( i ) ;
/ / compiler i n l i n i n g t r a n s l a t e s t h i s to :
for ( int i = 1 ; i <= n ; i ++)
c .A[ i 1] = a .A[ i 1] b .A[ i 1];
/ / or perhaps
for ( int i = 0 ; i < n ; i ++)
c .A[ i ] = a .A[ i ] b .A[ i ] ;
/ / more op ti m iz ation s by a smart compiler :
double ap = & a .A[ 0 ] ; / / s t a r t of a
double bp = &b .A[ 0 ] ; / / s t a r t of b
double cp = & c .A[ 0 ] ; / / s t a r t of c
for ( int i = 0 ; i < n ; i ++)
cp [ i ] = ap [ i ] bp [ i ] ; / / pure C!
Inlining and the programmer’s complete control with the definition of subscripting allow
void MyVector : : p r i n t ( std : : ostream & o ) const
{
int i ;
for ( i = 1 ; i <= length ; i ++)
o < < < < i < < < < ( this ) ( i ) < < ;
}
66 CHAPTER 4. CLASSES, TEMPLATES AND MODULES
double a = v . inner (w) ;
double MyVector : : inner ( const MyVector& w) const
{
int i ; double sum = 0 ;
for ( i = 0 ; i < length ; i ++)
sum += A[ i ] w.A[ i ] ;
/ / a lter na ti ve :
/ / for ( i = 1; i <= length ; i ++) sum += ( t h i s ) ( i ) w( i ) ;
return sum ;
}
/ / MyVector v
cout < < v ;
ostream & operator < < ( ostream & o , const MyVector& v )
{ v . pri n t ( o ) ; return o ; }
/ / must return ostream & for nested output operators :
cout < < < < w;
/ / t hi s is rea li z ed by these cal l s :
operator < < ( cout , ) ;
operator < < ( cout , w) ;
We can redefine the multiplication operator to mean the inner product of two vectors:
double a = v w; / / example on a t t r a c t i v e syntax
class MyVector
{
. . .
/ / compute ( th i s ) w
double operator ( const MyVector& w) const ;
. . .
};
double MyVector : : operator ( const MyVector& w) const
{
return inner (w) ;
}
/ / have some MyVector u , v , w ; double a ;
u = v + a w;
/ / global f unct ion operator+
MyVector operator + ( const MyVector& a , const MyVector& b)
{
4.3. CLASSES AND TEMPLATES IN C++ 67
MyVector tmp( a . s iz e () ) ;
for ( int i =1; i <=a . s ize () ; i ++)
tmp ( i ) = a ( i ) + b( i ) ;
return tmp ;
}
/ / global f unct ion operator
MyVector operator ( const MyVector& a , double r )
{
MyVector tmp( a . s iz e () ) ;
for ( int i =1; i <=a . s ize () ; i ++)
tmp ( i ) = a ( i ) r ;
return tmp ;
}
/ / symmetric operator : r a
MyVector operator ( double r , const MyVector& a )
{ return operator ( a , r ) ; }
4.3 Classes and templates in C++
Class MyVector is a vector of doubles
What about a vector of floats or ints?
Copy and edit code...?
No, this can be done automatically by use of macros or templates!!
Templates are the native C++ constructs for parameterizing parts of classes
template <typename Type>
class MyVector
{
Type A;
int length ;
public :
. . .
Type& operator () ( int i ) { return A[ i 1]; }
. . .
};
Declarations in user code:
MyVector <double > a (10) ;
MyVector <int > counters ;
Much simpler to use than macros for parameterization.
68 CHAPTER 4. CLASSES, TEMPLATES AND MODULES
It is easy to use class MyVector
Lots of details visible in C and Fortran 77 codes are hidden inside the class
It is not easy to write class MyVector
Thus: rely on ready-made classes in C++ libraries unless you really want to write develop
your own code and you know what are doing
C++ programming is effective when you build your own high-level classes out of well-
tested lower-level classes
4.4 Using Blitz++ with vectors and matrices
4.5 Building new classes
4.6 MODULE and TYPE declarations in Fortran 90/95
4.7 Object orienting in Fortran 90/95
4.8 An example of use of classes in C++ and Modules in For-
tran 90/95