CLHEP VERSION Reference Documentation
   
CLHEP Home Page     CLHEP Documentation     CLHEP Bug Reports

testEngineCopy.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 // $Id: testEngineCopy.cc,v 1.2 2010/06/16 17:24:53 garren Exp $
3 // ----------------------------------------------------------------------
4 #include "CLHEP/Units/GlobalPhysicalConstants.h" // used to provoke shadowing warnings
5 #include "CLHEP/Random/Randomize.h"
6 #include "CLHEP/Random/NonRandomEngine.h"
7 #include "CLHEP/Random/defs.h"
8 #include <iostream>
9 #include <iomanip>
10 #include <vector>
11 
12 #define CLEAN_OUTPUT
13 #ifdef CLEAN_OUTPUT
14  std::ofstream output("testEngineCopy.cout");
15 #else
16  std::ostream & output = std::cout;
17 #endif
18 
19 // Normally on for routine validation:
20 
21 #ifdef TURNOFF
22 #endif
23 
24 #define TEST_ENGINE_COPY
25 
26 #define VERBOSER
27 #define VERBOSER2
28 
29 using namespace CLHEP;
30 
31 // Absolutely Safe Equals Without Registers Screwing Us Up
32 bool equals01(const std::vector<double> &ab) {
33  return ab[1]==ab[0];
34 }
35 bool equals(double a, double b) {
36  std::vector<double> ab(2);
37  ab[0]=a; ab[1]=b;
38  return (equals01(ab));
39 }
40 
41 std::vector<double> aSequence(int n) {
42  std::vector<double> v;
43  DualRand e(13542);
44  RandFlat f(e);
45  for (int i=0; i<n; i++) {
46  v.push_back(f());
47  }
48  return v;
49 }
50 
51 
52 // ----------- Copy of engines -----------
53 
54 template <class E>
55 int vectorTest64(int n) {
56  output << "Copy 64bit test for " << E::engineName() << "\n";
57 
58  E e;
59  double x = 0;
60  for (int i=0; i<n; i++) x += e.flat();
61  E f( e );
62  x = e.flat();
63  output << "x = " << x << std::endl;
64 
65  double y = f.flat();
66  output << "y = " << y << std::endl;
67  if( x != y ) return n;
68 
69  for( int i=0; i<1000; ++i ) {
70  x = e.flat();
71  y = f.flat();
72  if( !equals(x,y) ) {
73  output << "i = " << i << " x, y " << x << " " << y
74  << " vectorTest64 problem: e != f \n";
75  return n+i;
76  }
77  }
78 
79  return 0;
80 }
81 // special case for NonRandomEngine
82 template <>
84  output << "Copy 64bit test for " << NonRandomEngine::engineName() << "\n";
85 
86  std::vector<double> nonRand = aSequence(500);
87  NonRandomEngine e;
88  e.setRandomSequence(&nonRand[0], nonRand.size());
89 
90  double x = 0;
91  for (int i=0; i<n; i++) x += e.flat();
92  std::vector<unsigned long> v = e.put();
93  NonRandomEngine f(e);
94  x = e.flat();
95  output << "x = " << x << std::endl;
96 
97  double y = f.flat();
98  output << "y = " << y << std::endl;
99  if( x != y ) return n;
100 
101  for( int i=0; i<300; ++i ) {
102  if( e.flat() != f.flat() ) {
103  output << "i = " << i << " vectorTest64 for NonRandomEngine problem: e != f \n";
104  return n+i;
105  }
106  }
107 
108  return 0;
109 }
110 
111 template <class E>
112 E vectorRestore1(int n, std::vector<double> & v) {
113  output << "Copy for " << E::engineName() << "\n";
114  E e(97538466);
115  double r=0;
116  for (int i=0; i<n; i++) r += e.flat();
117  E f(e);
118  for (int j=0; j<25; j++) v.push_back(e.flat());
119 #ifdef VERBOSER2
120  output << "First four of v are: "
121  << v[0] << ", " << v[1] << ", " << v[2] << ", " << v[3] << "\n";
122 #endif
123  return f;
124 }
125 
126 template <>
128 vectorRestore1<NonRandomEngine> (int n, std::vector<double> & v) {
129 #ifdef VERBOSER2
130  output << "Copy for " << NonRandomEngine::engineName() << "\n";
131 #endif
132  std::vector<double> nonRand = aSequence(500);
133  NonRandomEngine e;
134  e.setRandomSequence(&nonRand[0], nonRand.size());
135  double r=0;
136  for (int i=0; i<n; i++) r += e.flat();
137  NonRandomEngine f(e);
138  for (int j=0; j<25; j++) v.push_back(e.flat());
139 #ifdef VERBOSER2
140  output << "First four of v are: "
141  << v[0] << ", " << v[1] << ", " << v[2] << ", " << v[3] << "\n";
142 #endif
143  return f;
144 }
145 
146 template <class E>
147 int vectorRestore2(E & f, const std::vector<double> & v) {
148  int stat = 0;
149  std::vector<double> k;
150  for (int j=0; j<25; j++) k.push_back(f.flat());
151 #ifdef VERBOSER2
152  output << "First four of k are: "
153  << k[0] << ", " << k[1] << ", " << k[2] << ", " << k[3] << "\n";
154 #endif
155  for (int m1=0; m1<25; m1++) {
156  if ( v[m1] != k[m1] ) {
157  std::cout << "???? Incorrect copy restored value for engine: "
158  << E::engineName() << "\n";
159  #ifdef CLEAN_OUTPUT
160  output << "???? Incorrect copy restored value for engine: "
161  << E::engineName() << "\n";
162  #endif
163  stat |= 1048576;
164  return stat;
165  }
166  }
167  return stat;
168 }
169 
170 
171 template <class E>
172 int vectorRestore(int n) {
173  std::vector<double> v;
174  int status1 = vectorTest64<E>(n);
175  E f = vectorRestore1<E>(n,v);
176  int status2 = vectorRestore2<E>(f, v);
177  return (status1 | status2);
178 }
179 
180 
181 
182 // ---------------------------------------------
183 // ---------------------------------------------
184 // ---------------------------------------------
185 
186 
187 int main() {
188  int stat = 0;
189 
190 #ifdef TEST_ENGINE_COPY
191  output << "\n=================================\n";
192  output << " Part IX \n";
193  output << " Copy test of engines\n";
194  output << "=================================\n\n";
195 
196  stat |= vectorRestore<DualRand>(113);
197  // copies of DRand48Engine are not allowed
198  //stat |= vectorRestore<DRand48Engine>(114);
199  stat |= vectorRestore<Hurd160Engine>(115);
200  stat |= vectorRestore<Hurd288Engine>(116);
201  stat |= vectorRestore<HepJamesRandom>(117);
202  stat |= vectorRestore<MTwistEngine>(118);
203  stat |= vectorRestore<RanecuEngine>(139);
204  stat |= vectorRestore<Ranlux64Engine>(119);
205  stat |= vectorRestore<RanluxEngine>(120);
206  stat |= vectorRestore<RanshiEngine>(121);
207  stat |= vectorRestore<TripleRand>(122);
208  stat |= vectorRestore<NonRandomEngine>(123);
209  // anonymous engines are not copyable
210  //stat |= vectorRestore<RandEngine>(129);
211 #endif
212 
213  output << "\n=============================================\n\n";
214 
215  if (stat != 0) {
216  std::cout << "One or more problems detected: stat = " << stat << "\n";
217  output << "One or more problems detected: stat = " << stat << "\n";
218  } else {
219  output << "ranRestoreTest passed with no problems detected.\n";
220  }
221 
222  if (stat == 0) return 0;
223  if (stat > 0) return -(stat|1);
224  return stat|1;
225 }
226 
CLHEP::NonRandomEngine
Definition: Matrix/CLHEP/Random/NonRandomEngine.h:40
a
@ a
Definition: testCategories.cc:125
output
std::ofstream output("testEngineCopy.cout")
vectorRestore
int vectorRestore(int n)
Definition: testEngineCopy.cc:172
b
@ b
Definition: testCategories.cc:125
equals
bool equals(double a, double b)
Definition: testEngineCopy.cc:35
vectorTest64< NonRandomEngine >
int vectorTest64< NonRandomEngine >(int n)
Definition: testEngineCopy.cc:83
CLHEP::NonRandomEngine::put
virtual std::ostream & put(std::ostream &os) const
Definition: NonRandomEngine.cc:101
CLHEP::detail::n
n
Definition: Ranlux64Engine.cc:85
vectorRestore2
int vectorRestore2(E &f, const std::vector< double > &v)
Definition: testEngineCopy.cc:147
f
void f(void g())
Definition: excDblThrow.cc:38
CLHEP
Definition: ClhepVersion.h:13
v
they are gone ZOOM Features Discontinued The following features of the ZOOM package were felt to be extreme overkill These have been after checking that no existing user code was utilizing as in SpaceVector v
Definition: keyMergeIssues.doc:324
CLHEP::NonRandomEngine::engineName
static std::string engineName()
Definition: Matrix/CLHEP/Random/NonRandomEngine.h:72
vectorRestore1< NonRandomEngine >
NonRandomEngine vectorRestore1< NonRandomEngine >(int n, std::vector< double > &v)
Definition: testEngineCopy.cc:128
aSequence
std::vector< double > aSequence(int n)
Definition: testEngineCopy.cc:41
CLHEP::NonRandomEngine::flat
double flat()
Definition: NonRandomEngine.cc:68
j
long j
Definition: JamesRandomSeeding.txt:28
CLHEP::DualRand
Definition: Matrix/CLHEP/Random/DualRand.h:51
main
int main()
Definition: testEngineCopy.cc:187
vectorTest64
int vectorTest64(int n)
Definition: testEngineCopy.cc:55
i
long i
Definition: JamesRandomSeeding.txt:27
CLHEP::RandFlat
Definition: Matrix/CLHEP/Random/RandFlat.h:42
x
any side effects of that construction would occur twice The semantics of throw x
Definition: whyZMthrowRethrows.txt:37
vectorRestore1
E vectorRestore1(int n, std::vector< double > &v)
Definition: testEngineCopy.cc:112
k
long k
Definition: JamesRandomSeeding.txt:29
CLHEP::NonRandomEngine::setRandomSequence
void setRandomSequence(double *s, int n)
Definition: NonRandomEngine.cc:52
equals01
bool equals01(const std::vector< double > &ab)
Definition: testEngineCopy.cc:32