./scope1.0.2000.11.14/004075500007730000024000000000000720425475000132275ustar00patarg00001250000004./scope1.0.2000.11.14/rnd/004075500007730000024000000000000720425475300140155ustar00patarg00001250000004./scope1.0.2000.11.14/rnd/Makefile010064400007730000024000000003050720407060600154410ustar00patarg00001250000004 CXXFLAGS := -O OBJS := newran.o myexcept.o extreal.o .PHONY: clean %.o: %.cpp g++ $(CXXFLAGS) -c -o $@ $< libnewran.a: $(OBJS) ar cr $@ $(OBJS) ranlib $@ clean: rm -f $(OBJS) libnewran.a ./scope1.0.2000.11.14/rnd/boolean.h010064400007730000024000000011450720365250700156010ustar00patarg00001250000004//$$ boolean.h bool class // This is for compilers that don't have bool automatically defined #define bool_LIB 1 #ifndef bool_LIB #define bool_LIB 0 #ifdef use_namespace namespace RBD_COMMON { #endif class bool { int value; public: bool(const int b) { value = b ? 1 : 0; } bool(const void* b) { value = b ? 1 : 0; } bool() {} operator int() const { return value; } int operator!() const { return !value; } }; const bool true = 1; const bool false = 0; // version for some older versions of gnu g++ //#define false 0 //#define true 1 #ifdef use_namespace } #endif #endif ./scope1.0.2000.11.14/rnd/extreal.cpp010064400007730000024000000047520720365251000161620ustar00patarg00001250000004 // extreal.cpp ---------------------------------------------------------- #define WANT_STREAM #include "include.h" #include "boolean.h" #include "extreal.h" #ifdef use_namespace namespace NEWRAN { #endif ExtReal ExtReal::operator+(const ExtReal& er) const { if (c==Finite && er.c==Finite) return ExtReal(value+er.value); if (c==Missing || er.c==Missing) return ExtReal(Missing); if (c==Indefinite || er.c==Indefinite) return ExtReal(Indefinite); if (c==PlusInfinity) { if (er.c==MinusInfinity) return ExtReal(Indefinite); return *this; } if (c==MinusInfinity) { if (er.c==PlusInfinity) return ExtReal(Indefinite); return *this; } return er; } ExtReal ExtReal::operator-(const ExtReal& er) const { if (c==Finite && er.c==Finite) return ExtReal(value-er.value); if (c==Missing || er.c==Missing) return ExtReal(Missing); if (c==Indefinite || er.c==Indefinite) return ExtReal(Indefinite); if (c==PlusInfinity) { if (er.c==PlusInfinity) return ExtReal(Indefinite); return *this; } if (c==MinusInfinity) { if (er.c==MinusInfinity) return ExtReal(Indefinite); return *this; } return er; } ExtReal ExtReal::operator*(const ExtReal& er) const { if (c==Finite && er.c==Finite) return ExtReal(value*er.value); if (c==Missing || er.c==Missing) return ExtReal(Missing); if (c==Indefinite || er.c==Indefinite) return ExtReal(Indefinite); if (c==Finite) { if (value==0.0) return ExtReal(Indefinite); if (value>0.0) return er; return (-er); } if (er.c==Finite) { if (er.value==0.0) return ExtReal(Indefinite); if (er.value>0.0) return *this; return -(*this); } if (c==PlusInfinity) return er; return (-er); } ExtReal ExtReal::operator-() const { switch (c) { case Finite: return ExtReal(-value); case PlusInfinity: return ExtReal(MinusInfinity); case MinusInfinity: return ExtReal(PlusInfinity); case Indefinite: return ExtReal(Indefinite); case Missing: return ExtReal(Missing); } return 0.0; } ostream& operator<<(ostream& os, const ExtReal& er) { switch (er.c) { case Finite: os << er.value; break; case PlusInfinity: os << "plus-infinity"; break; case MinusInfinity: os << "minus-infinity"; break; case Indefinite: os << "indefinite"; break; case Missing: os << "missing"; break; } return os; } #ifdef use_namespace } #endif ./scope1.0.2000.11.14/rnd/extreal.h010064400007730000024000000017500720365251000156220ustar00patarg00001250000004 // extreal.h ---------------------------------------------------------- #ifndef EXTREAL_LIB #define EXTREAL_LIB 0 #ifdef use_namespace namespace NEWRAN { using namespace RBD_COMMON; } namespace RBD_LIBRARIES { using namespace NEWRAN; } namespace NEWRAN { #endif /************************ extended real class ***************************/ enum EXT_REAL_CODE { Finite, PlusInfinity, MinusInfinity, Indefinite, Missing }; class ExtReal { Real value; EXT_REAL_CODE c; public: ExtReal operator+(const ExtReal&) const; ExtReal operator-(const ExtReal&) const; ExtReal operator*(const ExtReal&) const; ExtReal operator-() const; friend ostream& operator<<( ostream&, const ExtReal& ); ExtReal(Real v) { c=Finite; value=v; } ExtReal(const EXT_REAL_CODE& cx) { c = cx; } ExtReal() { c = Missing; } Real Value() const { return value; } bool IsReal() const { return c==Finite; } EXT_REAL_CODE Code() const { return c; } }; #ifdef use_namespace } #endif #endif ./scope1.0.2000.11.14/rnd/hist.cpp010064400007730000024000000031640720365251100154620ustar00patarg00001250000004#define WANT_STREAM #define WANT_MATH #include "include.h" #include "boolean.h" #include "extreal.h" #include "newran.h" #ifdef use_namespace using namespace NEWRAN; #endif void Histogram(Random* rx, int n) // draw histogram with n obsv { int i,j; int count[20]; Real* a = new Real[n]; if (!a) { cout << "\nNo memory for Histogram\n"; return; } for (i = 0; i < n; i++) a[i] = rx->Next(); Real amax = a[0]; Real amin = a[0]; Real mean = a[0]; Real sd = 0; for (i = 1; i < n; i++) { if (amin > a[i]) amin = a[i]; else if (amax < a[i]) amax = a[i]; mean += a[i]; } mean /= n; for (i = 0; i < 20; i++) count[i]=0; for (i = 0; i < n; i++) { Real rat= (amax != amin) ? (a[i] - amin)/(amax - amin) : 1.0; j = (int)( 19.999 * rat ); count[j]++; Real diff = a[i] - mean; sd += diff*diff; } sd = sqrt(sd/(n-1)); j = 0; for (i = 0; i < 20; i++) { if (j < count[i]) j = count[i]; } if (j > 70) { for (i = 0; i < 20; i++) count[i] = (int)((70L*count[i])/j); } cout << "\n"; for (i = 0; i < 20; i++) { cout << "\n|"; for (j = 1; j < count[i]; j = j+1) cout << "*"; } cout << "\n" << rx->Name() << "\n"; cout << "p. mean = " << setw(9) << setprecision(5) << rx->Mean() << ", p. var = " << setw(9) << setprecision(5) << rx->Variance() << "\n"; cout << "s. mean = " << setw(9) << setprecision(5) << mean << ", s. var = " << setw(9) << setprecision(5) << sd*sd << ", max = " << setw(9) << setprecision(5) << amax << ", min = " << setw(9) << setprecision(5) << amin << "\n"; cout << flush; delete a; } an.h" #ifdef use_namespace using namespace NEWRAN; #endif void Histogram(Random* rx, int n) // draw histogram with n obsv { int i,j; int count[20]; Real* a = new Real[n]; if (!a) { cout << "\nNo memory for Histogram\n"; return; } for (i = 0; i < n; i++) a[i] = rx->Next(); Real amax = a[0]; Real amin = a[0]; Real mean = a[0]; Real sd = 0; for (i = 1; i < n; i++) ./scope1.0.2000.11.14/rnd/include.h010064400007730000024000000107500720365251200156030ustar00patarg00001250000004//$$ include.h include files required by various versions of C++ #ifndef INCLUDE_LIB #define INCLUDE_LIB //#define use_namespace // define name spaces //#define SETUP_C_SUBSCRIPTS // allow element access via A[i][j] // Activate just one of the following 3 statements #define SimulateExceptions // use simulated exceptions //#define UseExceptions // use C++ exceptions //#define DisableExceptions // don't use exceptions #define TEMPS_DESTROYED_QUICKLY // for compilers that delete // temporaries too quickly //#define TEMPS_DESTROYED_QUICKLY_R // the same thing but applied // to return from functions only //#define DO_FREE_CHECK // check news and deletes balance #define USING_DOUBLE // elements of type double //#define USING_FLOAT // elements of type float // activate the following statement if your compiler defines bool //#define bool_LIB 0 //*********************** end of options set by user ******************** #define DEFAULT_HEADER // use AT&T style header // if no other compiler is recognised #ifdef _MSC_VER // Microsoft #include // reactivate these statements to run under MSC version 7.0 // typedef int jmp_buf[9]; // extern "C" // { // int __cdecl setjmp(jmp_buf); // void __cdecl longjmp(jmp_buf, int); // } #ifdef WANT_STREAM #include #include #endif #ifdef WANT_MATH #include #include #endif #undef DEFAULT_HEADER #endif #ifdef __ZTC__ // Zortech #include #ifdef WANT_STREAM #include #include #define flush "" // not defined in iomanip? #endif #ifdef WANT_MATH #include #include #endif #undef DEFAULT_HEADER #endif #if defined __BCPLUSPLUS__ || defined __TURBOC__ // Borland or Turbo #include #ifdef WANT_STREAM #include #include #endif #ifdef WANT_MATH #include #define SystemV // optional in Borland #include // Borland has both float and values // but values.h returns +INF for // MAXDOUBLE in BC5 #endif #undef DEFAULT_HEADER #endif #ifdef __GNUG__ // Gnu C++ #include #ifdef WANT_STREAM #include #include #endif #ifdef WANT_MATH #include #include #endif #undef DEFAULT_HEADER #endif #ifdef Glock // Glockenspiel extern "C" { #include } #ifdef WANT_STREAM #include #include #endif #ifdef WANT_MATH extern "C" { #include } extern "C" { #include } #endif #define NO_LONG_NAMES // very long names don't work #undef DEFAULT_HEADER #endif #ifdef __WATCOMC__ // Watcom C/C++ #include #ifdef WANT_STREAM #include #include #endif #ifdef WANT_MATH #include #include #endif #undef DEFAULT_HEADER #endif #ifdef macintosh // MPW C++ on the Mac #include #ifdef WANT_STREAM #include #include #endif #ifdef WANT_MATH #include #include #endif #undef DEFAULT_HEADER #endif #ifdef DEFAULT_HEADER // for example AT&T #define ATandT #include #ifdef WANT_STREAM #include #include #endif #ifdef WANT_MATH #include #define SystemV // use System V #include #endif #endif #ifdef use_namespace namespace RBD_COMMON { #endif #ifdef USING_FLOAT // set precision type to float typedef float Real; typedef double long_Real; #endif #ifdef USING_DOUBLE // set precision type to double typedef double Real; typedef long double long_Real; #endif #ifdef use_namespace } #endif #ifdef use_namespace namespace RBD_COMMON {} namespace RBD_LIBRARIES // access all my libraries { using namespace RBD_COMMON; } #endif #endif ./scope1.0.2000.11.14/rnd/myexcept.cpp010064400007730000024000000314770720365251200163620ustar00patarg00001250000004//$$myexcept.cpp Exception handler // Copyright (C) 1993,4,6: R B Davies #define WANT_STREAM // include.h will get stream fns #include // C string library #include "include.h" // include standard files #include "boolean.h" #include "myexcept.h" // for exception handling #ifdef use_namespace namespace RBD_COMMON { #endif //#define REG_DEREG // for print out uses of new/delete //#define CLEAN_LIST // to print entries being added to // or deleted from cleanup list #ifdef SimulateExceptions void Throw() { for (Janitor* jan = JumpBase::jl->janitor; jan; jan = jan->NextJanitor) jan->CleanUp(); JumpItem* jx = JumpBase::jl->ji; // previous jumpbase; if ( !jx ) { Terminate(); } // jl was initial JumpItem JumpBase::jl = jx; // drop down a level; cannot be in front // of previous line Tracer::last = JumpBase::jl->trace; longjmp(JumpBase::jl->env, 1); } #endif // end of simulate exceptions unsigned long Exception::Select; char* Exception::what_error; int Exception::SoFar; int Exception::LastOne; Exception::Exception(const char* a_what) { Select++; SoFar = 0; if (!what_error) // make space for exception message { LastOne = 511; what_error = new char[512]; if (!what_error) // fail to make space { LastOne = 0; what_error = "No heap space for exception message\n"; } } AddMessage("\n\nAn exception has been thrown\n"); AddMessage(a_what); if (a_what) Tracer::AddTrace(); } void Exception::AddMessage(const char* a_what) { if (a_what) { int l = strlen(a_what); int r = LastOne - SoFar; if (l < r) { strcpy(what_error+SoFar, a_what); SoFar += l; } else if (r > 0) { strncpy(what_error+SoFar, a_what, r); what_error[LastOne] = 0; SoFar = LastOne; } } } void Exception::AddInt(int value) { bool negative; if (value == 0) { AddMessage("0"); return; } else if (value < 0) { value = -value; negative = true; } else negative = false; int n = 0; int v = value; // how many digits will we need? while (v > 0) { v /= 10; n++; } if (negative) n++; if (LastOne-SoFar < n) { AddMessage("***"); return; } SoFar += n; n = SoFar; what_error[n] = 0; while (value > 0) { int nv = value / 10; int rm = value - nv * 10; value = nv; what_error[--n] = (char)(rm + '0'); } if (negative) what_error[--n] = '-'; return; } void Tracer::PrintTrace() { cout << "\n"; for (Tracer* et = last; et; et=et->previous) cout << " * " << et->entry << "\n"; } void Tracer::AddTrace() { if (last) { Exception::AddMessage("Trace: "); Exception::AddMessage(last->entry); for (Tracer* et = last->previous; et; et=et->previous) { Exception::AddMessage("; "); Exception::AddMessage(et->entry); } Exception::AddMessage(".\n"); } } #ifdef SimulateExceptions Janitor::Janitor() { if (do_not_link) { do_not_link = false; NextJanitor = 0; OnStack = false; #ifdef CLEAN_LIST cout << "Not added to clean-list " << (unsigned long)this << "\n"; #endif } else { OnStack = true; #ifdef CLEAN_LIST cout << "Add to clean-list " << (unsigned long)this << "\n"; #endif NextJanitor = JumpBase::jl->janitor; JumpBase::jl->janitor=this; } } Janitor::~Janitor() { // expect the item to be deleted to be first on list // but must be prepared to search list if (OnStack) { #ifdef CLEAN_LIST cout << "Delete from clean-list " << (unsigned long)this << "\n"; #endif Janitor* lastjan = JumpBase::jl->janitor; if (this == lastjan) JumpBase::jl->janitor = NextJanitor; else { for (Janitor* jan = lastjan->NextJanitor; jan; jan = lastjan->NextJanitor) { if (jan==this) { lastjan->NextJanitor = jan->NextJanitor; return; } lastjan=jan; } Throw(Exception( "Cannot resolve memory linked list\nSee notes in myexcept.cpp for details\n" )); // This message occurs when a call to ~Janitor() occurs, apparently // without a corresponding call to Janitor(). This could happen if my // way of deciding whether a constructor is being called by new // fails. // It may happen if you are using my simulated exceptions and also have // your compiler s exceptions turned on. // It can also happen if you have a class derived from Janitor // which does not include a copy constructor [ eg X(const &X) ]. // Possibly also if delete is applied an object on the stack (ie not // called by new). Otherwise, it is a bug in myexcept or your compiler. // If you do not #define TEMPS_DESTROYED_QUICKLY you will get this // error with Microsoft C 7.0. There are probably situations where // you will get this when you do define TEMPS_DESTROYED_QUICKLY. This // is a bug in MSC. Beware of "operator" statements for defining // conversions; particularly for converting from a Base class to a // Derived class. // You may get away with simply deleting this error message and Throw // statement if you can not find a better way of overcoming the // problem. In any case please tell me if you get this error message, // particularly for compilers apart from Microsoft C 7.0. } } } JumpItem* JumpBase::jl; // will be set to zero jmp_buf JumpBase::env; bool Janitor::do_not_link; // will be set to false int JanitorInitializer::ref_count; JanitorInitializer::JanitorInitializer() { if (ref_count++ == 0) new JumpItem; // need JumpItem at head of list } #endif // end of SimulateExceptions Tracer* Tracer::last; // will be set to zero void Terminate() { cout << "\n\nThere has been an exception with no handler - exiting"; const char* what = Exception::what(); if (what) cout << what << "\n"; exit(1); } #ifdef DO_FREE_CHECK // Routines for tracing whether new and delete calls are balanced FreeCheckLink::FreeCheckLink() : next(FreeCheck::next) { FreeCheck::next = this; } FCLClass::FCLClass(void* t, char* name) : ClassName(name) { ClassStore=t; } FCLRealArray::FCLRealArray(void* t, char* o, int s) : Operation(o), size(s) { ClassStore=t; } FCLIntArray::FCLIntArray(void* t, char* o, int s) : Operation(o), size(s) { ClassStore=t; } FreeCheckLink* FreeCheck::next; int FreeCheck::BadDelete; void FCLClass::Report() { cout << " " << ClassName << " " << (unsigned long)ClassStore << "\n"; } void FCLRealArray::Report() { cout << " " << Operation << " " << (unsigned long)ClassStore << " " << size << "\n"; } void FCLIntArray::Report() { cout << " " << Operation << " " << (unsigned long)ClassStore << " " << size << "\n"; } void FreeCheck::Register(void* t, char* name) { FCLClass* f = new FCLClass(t,name); if (!f) { cout << "Out of memory in FreeCheck\n"; exit(1); } #ifdef REG_DEREG cout << "Registering " << name << " " << (unsigned long)t << "\n"; #endif } void FreeCheck::RegisterR(void* t, char* o, int s) { FCLRealArray* f = new FCLRealArray(t,o,s); if (!f) { cout << "Out of memory in FreeCheck\n"; exit(1); } #ifdef REG_DEREG cout << o << " " << s << " " << (unsigned long)t << "\n"; #endif } void FreeCheck::RegisterI(void* t, char* o, int s) { FCLIntArray* f = new FCLIntArray(t,o,s); if (!f) { cout << "Out of memory in FreeCheck\n"; exit(1); } #ifdef REG_DEREG cout << o << " " << s << " " << (unsigned long)t << "\n"; #endif } void FreeCheck::DeRegister(void* t, char* name) { FreeCheckLink* last = 0; #ifdef REG_DEREG cout << "Deregistering " << name << " " << (unsigned long)t << "\n"; #endif for (FreeCheckLink* fcl = next; fcl; fcl = fcl->next) { if (fcl->ClassStore==t) { if (last) last->next = fcl->next; else next = fcl->next; delete fcl; return; } last = fcl; } cout << "\nRequest to delete non-existent object of class and location:\n"; cout << " " << name << " " << (unsigned long)t << "\n"; BadDelete++; Tracer::PrintTrace(); cout << "\n"; } void FreeCheck::DeRegisterR(void* t, char* o, int s) { FreeCheckLink* last = 0; #ifdef REG_DEREG cout << o << " " << s << " " << (unsigned long)t << "\n"; #endif for (FreeCheckLink* fcl = next; fcl; fcl = fcl->next) { if (fcl->ClassStore==t) { if (last) last->next = fcl->next; else next = fcl->next; if (s >= 0 && ((FCLRealArray*)fcl)->size != s) { cout << "\nArray sizes do not agree:\n"; cout << " " << o << " " << (unsigned long)t << " " << ((FCLRealArray*)fcl)->size << " " << s << "\n"; Tracer::PrintTrace(); cout << "\n"; } delete fcl; return; } last = fcl; } cout << "\nRequest to delete non-existent real array:\n"; cout << " " << o << " " << (unsigned long)t << " " << s << "\n"; BadDelete++; Tracer::PrintTrace(); cout << "\n"; } void FreeCheck::DeRegisterI(void* t, char* o, int s) { FreeCheckLink* last = 0; #ifdef REG_DEREG cout << o << " " << s << " " << (unsigned long)t << "\n"; #endif for (FreeCheckLink* fcl = next; fcl; fcl = fcl->next) { if (fcl->ClassStore==t) { if (last) last->next = fcl->next; else next = fcl->next; if (s >= 0 && ((FCLIntArray*)fcl)->size != s) { cout << "\nArray sizes do not agree:\n"; cout << " " << o << " " << (unsigned long)t << " " << ((FCLIntArray*)fcl)->size << " " << s << "\n"; Tracer::PrintTrace(); cout << "\n"; } delete fcl; return; } last = fcl; } cout << "\nRequest to delete non-existent int array:\n"; cout << " " << o << " " << (unsigned long)t << " " << s << "\n"; BadDelete++; Tracer::PrintTrace(); cout << "\n"; } void FreeCheck::Status() { if (next) { cout << "\nObjects of the following classes remain undeleted:\n"; for (FreeCheckLink* fcl = next; fcl; fcl = fcl->next) fcl->Report(); cout << "\n"; } else cout << "\nNo objects remain undeleted\n\n"; if (BadDelete) { cout << "\nThere were " << BadDelete << " requests to delete non-existent items\n\n"; } } #endif // end of DO_FREE_CHECK // derived exception bodies Logic_error::Logic_error(const char* a_what) : Exception() { Select = Exception::Select; AddMessage("Logic error:- "); AddMessage(a_what); if (a_what) Tracer::AddTrace(); } Runtime_error::Runtime_error(const char* a_what) : Exception() { Select = Exception::Select; AddMessage("Runtime error:- "); AddMessage(a_what); if (a_what) Tracer::AddTrace(); } Domain_error::Domain_error(const char* a_what) : Logic_error() { Select = Exception::Select; AddMessage("domain error\n"); AddMessage(a_what); if (a_what) Tracer::AddTrace(); } Invalid_argument::Invalid_argument(const char* a_what) : Logic_error() { Select = Exception::Select; AddMessage("invalid argument\n"); AddMessage(a_what); if (a_what) Tracer::AddTrace(); } Length_error::Length_error(const char* a_what) : Logic_error() { Select = Exception::Select; AddMessage("length error\n"); AddMessage(a_what); if (a_what) Tracer::AddTrace(); } Out_of_range::Out_of_range(const char* a_what) : Logic_error() { Select = Exception::Select; AddMessage("out of range\n"); AddMessage(a_what); if (a_what) Tracer::AddTrace(); } Bad_cast::Bad_cast(const char* a_what) : Logic_error() { Select = Exception::Select; AddMessage("bad cast\n"); AddMessage(a_what); if (a_what) Tracer::AddTrace(); } Bad_typeid::Bad_typeid(const char* a_what) : Logic_error() { Select = Exception::Select; AddMessage("bad type id.\n"); AddMessage(a_what); if (a_what) Tracer::AddTrace(); } Range_error::Range_error(const char* a_what) : Runtime_error() { Select = Exception::Select; AddMessage("range error\n"); AddMessage(a_what); if (a_what) Tracer::AddTrace(); } Overflow_error::Overflow_error(const char* a_what) : Runtime_error() { Select = Exception::Select; AddMessage("overflow error\n"); AddMessage(a_what); if (a_what) Tracer::AddTrace(); } Bad_alloc::Bad_alloc(const char* a_what) : Exception() { Select = Exception::Select; AddMessage("bad allocation\n"); AddMessage(a_what); if (a_what) Tracer::AddTrace(); } unsigned long Logic_error::Select; unsigned long Runtime_error::Select; unsigned long Domain_error::Select; unsigned long Invalid_argument::Select; unsigned long Length_error::Select; unsigned long Out_of_range::Select; unsigned long Bad_cast::Select; unsigned long Bad_typeid::Select; unsigned long Range_error::Select; unsigned long Overflow_error::Select; unsigned long Bad_alloc::Select; #ifdef use_namespace } #endif ./scope1.0.2000.11.14/rnd/myexcept.h010064400007730000024000000263700720365251300160240ustar00patarg00001250000004//$$ myexcept.h Exception handling classes // A set of classes to simulate exceptions in C++ // // Partially copied from Carlos Vidal s article in the C users journal // September 1992, pp 19-28 // // Operations defined // Try { } // Throw ( exception object ) // ReThrow // Catch ( exception class ) { } // CatchAll { } // CatchAndThrow // // All catch lists must end with a CatchAll or CatchAndThrow statement // but not both. // // When exceptions are finally implemented replace Try, Throw(E), Rethrow, // Catch, CatchAll, CatchAndThrow by try, throw E, throw, catch, // catch(...), and {}. // // All exception classes must be derived from Exception, have no non-static // variables and must include the statement // // static unsigned long Select; // // Any constructor in one of these exception classes must include // // Select = Exception::Select; // // For each exceptions class, EX_1, some .cpp file must include // // unsigned long EX_1::Select; // #ifndef EXCEPTION_LIB #define EXCEPTION_LIB #ifdef use_namespace namespace RBD_COMMON { #endif void Terminate(); //********** classes for setting up exceptions and reporting ************// class Exception; class Tracer // linked list showing how { // we got here char* entry; Tracer* previous; public: Tracer(char*); ~Tracer(); void ReName(char*); static void PrintTrace(); // for printing trace static void AddTrace(); // insert trace in exception record static Tracer* last; // points to Tracer list friend class Exception; }; class Exception // The base exception class { protected: static char* what_error; // error message static int SoFar; // no. characters already entered static int LastOne; // last location in error buffer public: static void AddMessage(const char* a_what); // messages about exception static void AddInt(int value); // integer to error message static unsigned long Select; // for identifying exception Exception(const char* a_what = 0); static const char* what() { return what_error; } // for getting error message }; inline Tracer::Tracer(char* e) : entry(e), previous(last) { last = this; } inline Tracer::~Tracer() { last = previous; } inline void Tracer::ReName(char* e) { entry=e; } #ifdef SimulateExceptions // SimulateExceptions #include //************* the definitions of Try, Throw and Catch *****************// class JumpItem; class Janitor; class JumpBase // pointer to a linked list of jmp_buf s { public: static JumpItem *jl; static jmp_buf env; }; class JumpItem // an item in a linked list of jmp_buf s { public: JumpItem *ji; jmp_buf env; Tracer* trace; // to keep check on Tracer items Janitor* janitor; // list of items for cleanup JumpItem() : ji(JumpBase::jl), trace(0), janitor(0) { JumpBase::jl = this; } ~JumpItem() { JumpBase::jl = ji; } }; void Throw(); inline void Throw(const Exception&) { Throw(); } #define Try \ if (!setjmp( JumpBase::jl->env )) { \ JumpBase::jl->trace = Tracer::last; \ JumpItem JI387256156; #define ReThrow Throw() #define Catch(EXCEPTION) \ } else if (Exception::Select == EXCEPTION::Select) { #define CatchAll } else #define CatchAndThrow } else Throw(); //****************** cleanup heap following Throw ***********************// class Janitor { protected: static bool do_not_link; // set when new is called bool OnStack; // false if created by new public: Janitor* NextJanitor; virtual void CleanUp() {} Janitor(); virtual ~Janitor(); }; // The tiresome old trick for initializing the Janitor class // this is needed for classes derived from Janitor which have objects // declared globally class JanitorInitializer { public: JanitorInitializer(); private: static int ref_count; }; static JanitorInitializer JanInit; #endif // end of SimulateExceptions #ifdef UseExceptions #define Try try #define Throw(E) throw E #define ReThrow throw #define Catch catch #define CatchAll catch(...) #define CatchAndThrow {} #endif // end of UseExceptions #ifdef DisableExceptions // Disable exceptions #define Try { #define ReThrow Throw() #define Catch(EXCEPTION) } if (false) { #define CatchAll } if (false) #define CatchAndThrow } inline void Throw() { Terminate(); } inline void Throw(const Exception&) { Terminate(); } #endif // end of DisableExceptions #ifndef SimulateExceptions // ! SimulateExceptions class Janitor // a dummy version { public: virtual void CleanUp() {} Janitor() {} virtual ~Janitor() {} }; #endif // end of ! SimulateExceptions //******************** FREE_CHECK and NEW_DELETE ***********************// #ifdef DO_FREE_CHECK // DO_FREE_CHECK // Routines for tracing whether new and delete calls are balanced class FreeCheck; class FreeCheckLink { protected: FreeCheckLink* next; void* ClassStore; FreeCheckLink(); virtual void Report()=0; // print details of link friend class FreeCheck; }; class FCLClass : public FreeCheckLink // for registering objects { char* ClassName; FCLClass(void* t, char* name); void Report(); friend class FreeCheck; }; class FCLRealArray : public FreeCheckLink // for registering real arrays { char* Operation; int size; FCLRealArray(void* t, char* o, int s); void Report(); friend class FreeCheck; }; class FCLIntArray : public FreeCheckLink // for registering int arrays { char* Operation; int size; FCLIntArray(void* t, char* o, int s); void Report(); friend class FreeCheck; }; class FreeCheck { static FreeCheckLink* next; static int BadDelete; public: static void Register(void*, char*); static void DeRegister(void*, char*); static void RegisterR(void*, char*, int); static void DeRegisterR(void*, char*, int); static void RegisterI(void*, char*, int); static void DeRegisterI(void*, char*, int); static void Status(); friend class FreeCheckLink; friend class FCLClass; friend class FCLRealArray; friend class FCLIntArray; }; #define FREE_CHECK(Class) \ public: \ void* operator new(size_t size) \ { \ void* t = ::operator new(size); FreeCheck::Register(t,#Class); \ return t; \ } \ void operator delete(void* t) \ { FreeCheck::DeRegister(t,#Class); ::operator delete(t); } #ifdef SimulateExceptions // SimulateExceptions #define NEW_DELETE(Class) \ public: \ void* operator new(size_t size) \ { \ do_not_link=true; \ void* t = ::operator new(size); FreeCheck::Register(t,#Class); \ return t; \ } \ void operator delete(void* t) \ { FreeCheck::DeRegister(t,#Class); ::operator delete(t); } #endif // end of SimulateExceptions #define MONITOR_REAL_NEW(Operation, Size, Pointer) \ FreeCheck::RegisterR(Pointer, Operation, Size); #define MONITOR_INT_NEW(Operation, Size, Pointer) \ FreeCheck::RegisterI(Pointer, Operation, Size); #define MONITOR_REAL_DELETE(Operation, Size, Pointer) \ FreeCheck::DeRegisterR(Pointer, Operation, Size); #define MONITOR_INT_DELETE(Operation, Size, Pointer) \ FreeCheck::DeRegisterI(Pointer, Operation, Size); #else // DO_FREE_CHECK not defined #define FREE_CHECK(Class) public: #define MONITOR_REAL_NEW(Operation, Size, Pointer) {} #define MONITOR_INT_NEW(Operation, Size, Pointer) {} #define MONITOR_REAL_DELETE(Operation, Size, Pointer) {} #define MONITOR_INT_DELETE(Operation, Size, Pointer) {} #ifdef SimulateExceptions // SimulateExceptions #define NEW_DELETE(Class) \ public: \ void* operator new(size_t size) \ { do_not_link=true; void* t = ::operator new(size); return t; } \ void operator delete(void* t) { ::operator delete(t); } #endif // end of SimulateExceptions #endif // end of ! DO_FREE_CHECK #ifndef SimulateExceptions // ! SimulateExceptions #define NEW_DELETE(Class) FREE_CHECK(Class) #endif // end of ! SimulateExceptions //********************* derived exceptions ******************************// class Logic_error : public Exception { public: static unsigned long Select; Logic_error(const char* a_what = 0); }; class Runtime_error : public Exception { public: static unsigned long Select; Runtime_error(const char* a_what = 0); }; class Domain_error : public Logic_error { public: static unsigned long Select; Domain_error(const char* a_what = 0); }; class Invalid_argument : public Logic_error { public: static unsigned long Select; Invalid_argument(const char* a_what = 0); }; class Length_error : public Logic_error { public: static unsigned long Select; Length_error(const char* a_what = 0); }; class Out_of_range : public Logic_error { public: static unsigned long Select; Out_of_range(const char* a_what = 0); }; class Bad_cast : public Logic_error { public: static unsigned long Select; Bad_cast(const char* a_what = 0); }; class Bad_typeid : public Logic_error { public: static unsigned long Select; Bad_typeid(const char* a_what = 0); }; class Range_error : public Runtime_error { public: static unsigned long Select; Range_error(const char* a_what = 0); }; class Overflow_error : public Runtime_error { public: static unsigned long Select; Overflow_error(const char* a_what = 0); }; class Bad_alloc : public Exception { public: static unsigned long Select; Bad_alloc(const char* a_what = 0); }; #ifdef use_namespace } #endif #endif // end of EXCEPTION_LIB // class Exception; class Tracer // linked list showing how { // we got here char* entry; Tracer* previous; public: Tracer(char*); ~Tracer(); void ReName(char*); static void Pri./scope1.0.2000.11.14/rnd/newran.cpp010064400007730000024000000630520720365251300160110ustar00patarg00001250000004// newran.cpp ----------------------------------------------------------- // NEWRAN02 #define WANT_STREAM #define WANT_MATH #include "include.h" #include "newran.h" //#include "mother.h" #ifdef use_namespace namespace NEWRAN { #endif //********* classes which are used internally only ********************** //*********** chi-square-1 random number generator ********************** class ChiSq1 : public Normal // generate non-central chi-square // rv with 1 degree of freedom { Real deltasq; // non-centrality parameter Real delta; public: ChiSq1(Real); // non-centrality parameter ExtReal Mean() const { return 1.0+deltasq; } ExtReal Variance() const { return 2.0+4.0*deltasq; } Real Next(); }; //*********** Poisson random number generator, larger mu **************** class Poisson1 : public AsymGen // generate poisson rv, large mu { Real mu, ln_mu; public: Poisson1(Real); // constructor (Real=mean) Real Density(Real) const; // Poisson density function Real Next() { return floor(AsymGen::Next()); } ExtReal Mean() const { return mu; } ExtReal Variance() const { return mu; } }; //*********** Poisson random number generator, mu <= 10 **************** class Poisson2 : public Random // generate poisson rv, large mu { DiscreteGen* dg; public: Poisson2(Real); // constructor (Real=mean) ~Poisson2(); Real Next() { return dg->Next(); } ExtReal Mean() const { return dg->Mean(); } ExtReal Variance() const { return dg->Variance(); } }; //********** Gamma random number generator, alpha <= 1 ***************** class Gamma1 : public PosGen // generate gamma rv // shape parameter <= 1 { Real ln_gam, ralpha, alpha; public: Gamma1(Real); // constructor (Real=shape) Real Density(Real) const; // gamma density function Real Next(); // carries out power transform ExtReal Mean() const { return alpha; } ExtReal Variance() const { return alpha; } }; //********** Gamma random number generator, alpha > 1 ****************** class Gamma2 : public AsymGen // generate gamma rv // shape parameter > 1 { Real alpha, ln_gam; public: Gamma2(Real); // constructor (Real=shape) Real Density(Real) const; // gamma density function ExtReal Mean() const { return alpha; } ExtReal Variance() const { return alpha; } }; //*********** Binomial random number generator, n > 40 ***************** class Binomial1 : public AsymGen // generate binomial rv, larger n { Real p, q, ln_p, ln_q, ln_n_fac; int n; public: Binomial1(int nx, Real px); Real Density(Real) const; Real Next() { return floor(AsymGen::Next()); } ExtReal Mean() const { return p * n; } ExtReal Variance() const { return p * q * n; } }; //******* Binomial random number generator, n < 40 or n*p <= 8 ************* class Binomial2 : public Random // generate binomial rv, smaller n { DiscreteGen* dg; public: Binomial2(int nx, Real px); ~Binomial2(); Real Next() { return dg->Next(); } ExtReal Mean() const { return dg->Mean(); } ExtReal Variance() const { return dg->Variance(); } }; //************************ static variables *************************** double Random::seed; //unsigned long Random::iseed; // for Mother Real Random::Buffer[128]; Real Normal::Nxi; Real* Normal::Nsx; Real* Normal::Nsfx; long Normal::count=0; //**************************** utilities ****************************** inline Real square(Real x) { return x*x; } inline ExtReal square(const ExtReal& x) { return x*x; } static void ErrorNoSpace() { Throw(Bad_alloc("Newran: out of space")); } //************************* end of definitions ************************ Real Random::Raw() // get new uniform random number { // m = 2147483647 = 2^31 - 1; a = 16807; // 127773 = m div a; 2836 = m mod a long iseed = (long)seed; long hi = iseed / 127773L; // integer division long lo = iseed - hi * 127773L; // modulo iseed = 16807 * lo - 2836 * hi; if (iseed <= 0) iseed += 2147483647L; seed = (double)iseed; return seed*4.656612875e-10; } Real Random::Density(Real) const { Throw(Logic_error("density function not defined")); return 0.0; } #ifdef _MSC_VER static void DoNothing(int) {} #endif Real Random::Next() // get new mixed random number { if (!seed) Throw(Logic_error("Random number generator not initialised")); int i = (int)(Raw()*128); // 0 <= i < 128 #ifdef _MSC_VER DoNothing(i); DoNothing(i); #endif Real f = Buffer[i]; Buffer[i] = Raw(); // Microsoft release gets this wrong return f; // return Mother(&iseed); } double Random::Get() // get random number seed { return seed/2147483648L; } void Random::Set(double s) // set random number seed // s must be between 0 and 1 { if (s>=1.0 || s<=0.0) Throw(Logic_error("Newran: seed out of range")); //iseed = 2147483648L * s; // for Mother seed = (long)(s*2147483648L); for (int i = 0; i<128; i++) Buffer[i] = Raw(); } PosGen::PosGen() // Constructor { #ifdef MONITOR cout << "constructing PosGen\n"; #endif NotReady=true; } PosGen::~PosGen() { if (!NotReady) { #ifdef MONITOR cout << "freeing PosGen arrays\n"; #endif delete [] sx; delete [] sfx; } #ifdef MONITOR cout << "destructing PosGen\n"; #endif } void PosGen::Build(bool sym) // set up arrays { #ifdef MONITOR cout << "building PosGen arrays\n"; #endif int i; NotReady=false; sx=new Real[60]; sfx=new Real[60]; if (!sx || !sfx) ErrorNoSpace(); Real sxi=0.0; Real inc = sym ? 0.01 : 0.02; for (i=0; i<60; i++) { sx[i]=sxi; Real f1=Density(sxi); sfx[i]=f1; if (f1<=0.0) goto L20; sxi+=inc/f1; } Throw(Runtime_error("Newran: area too large")); L20: if (i<50) Throw(Runtime_error("Newran: area too small")); xi = sym ? 2*i : i; return; } Real PosGen::Next() { Real ak,y; int ir; if (NotReady) Build(false); do { Real r1=Random::Next(); ir = (int)(r1*xi); Real sxi=sx[ir]; ak=sxi+(sx[ir+1]-sxi)*Random::Next(); y=sfx[ir]*Random::Next(); } while ( y>=sfx[ir+1] && y>=Density(ak) ); return ak; } Real SymGen::Next() { Real s,ak,y; int ir; if (NotReady) Build(true); do { s=1.0; Real r1=Random::Next(); if (r1>0.5) { s=-1.0; r1=1.0-r1; } ir = (int)(r1*xi); Real sxi=sx[ir]; ak=sxi+(sx[ir+1]-sxi)*Random::Next(); y=sfx[ir]*Random::Next(); } while ( y>=sfx[ir+1] && y>=Density(ak) ); return s*ak; } AsymGen::AsymGen(Real modex) // Constructor { #ifdef MONITOR cout << "constructing AsymGen\n"; #endif mode=modex; NotReady=true; } void AsymGen::Build() // set up arrays { #ifdef MONITOR cout << "building AsymGen arrays\n"; #endif int i; NotReady=false; sx=new Real[121]; sfx=new Real[121]; if (!sx || !sfx) ErrorNoSpace(); Real sxi=mode; for (i=0; i<120; i++) { sx[i]=sxi; Real f1=Density(sxi); sfx[i]=f1; if (f1<=0.0) goto L20; sxi+=0.01/f1; } Throw(Runtime_error("Newran: area too large (a)")); L20: ic=i-1; sx[120]=sxi; sfx[120]=0.0; sxi=mode; for (; i<120; i++) { sx[i]=sxi; Real f1=Density(sxi); sfx[i]=f1; if (f1<=0.0) goto L30; sxi-=0.01/f1; } Throw(Runtime_error("Newran: area too large (b)")); L30: if (i<100) Throw(Runtime_error("Newran: area too small")); xi=i; return; } Real AsymGen::Next() { Real ak,y; int ir1; if (NotReady) Build(); do { Real r1=Random::Next(); int ir=(int)(r1*xi); Real sxi=sx[ir]; ir1 = (ir==ic) ? 120 : ir+1; ak=sxi+(sx[ir1]-sxi)*Random::Next(); y=sfx[ir]*Random::Next(); } while ( y>=sfx[ir1] && y>=Density(ak) ); return ak; } AsymGen::~AsymGen() { if (!NotReady) { #ifdef MONITOR cout << "freeing AsymGen arrays\n"; #endif delete [] sx; delete [] sfx; } #ifdef MONITOR cout << "destructing AsymGen\n"; #endif } PosGenX::PosGenX(PDF fx) { f=fx; } SymGenX::SymGenX(PDF fx) { f=fx; } AsymGenX::AsymGenX(PDF fx, Real mx) : AsymGen(mx) { f=fx; } Normal::Normal() { if (count) { NotReady=false; xi=Nxi; sx=Nsx; sfx=Nsfx; } else { Build(true); Nxi=xi; Nsx=sx; Nsfx=sfx; } count++; } Normal::~Normal() { count--; if (count) NotReady=true; // disable freeing arrays } Real Normal::Density(Real x) const // normal density { return (fabs(x)>8.0) ? 0 : 0.398942280 * exp(-x*x / 2); } ChiSq1::ChiSq1(Real d) : Normal() // chisquare with 1 df { deltasq=d; delta=sqrt(d); } Real ChiSq1::Next() { Real z=Normal::Next()+delta; return z*z; } ChiSq::ChiSq(int df, Real noncen) { if (df<=0 || noncen<0.0) Throw(Logic_error("Newran: illegal parameters")); else if (df==1) { version=0; c1=new ChiSq1(noncen); } else if (noncen==0.0) { if (df==2) { version=1; c1=new Exponential(); } else { version=2; c1=new Gamma2(0.5*df); } } else if (df==2) { version=3; c1=new ChiSq1(noncen/2.0); } else if (df==3) { version=4; c1=new Exponential(); c2=new ChiSq1(noncen); } else { version=5; c1=new Gamma2(0.5*(df-1)); c2=new ChiSq1(noncen); } if (!c1 || (version>3 && !c2)) ErrorNoSpace(); mean=df+noncen; var=2*df+4.0*noncen; } ChiSq::~ChiSq() { delete c1; if (version>3) delete c2; } Real ChiSq::Next() { switch(version) { case 0: return c1->Next(); case 1: case 2: return c1->Next()*2.0; case 3: return c1->Next() + c1->Next(); case 4: case 5: Real s1 = c1->Next()*2.0; Real s2 = c2->Next(); return s1 + s2; // this is to make it work with Microsoft VC5 } return 0; } Pareto::Pareto(Real shape) : Shape(shape) { if (Shape <= 0) Throw(Logic_error("Newran: illegal parameter")); RS = -1.0 / Shape; } Real Pareto::Next() { return pow(Random::Next(), RS); } ExtReal Pareto::Mean() const { if (Shape > 1) return Shape/(Shape-1.0); else return PlusInfinity; } ExtReal Pareto::Variance() const { if (Shape > 2) return Shape/(square(Shape-1.0))/(Shape-2.0); else return PlusInfinity; } Real Cauchy::Density(Real x) const // Cauchy density function { return (fabs(x)>1.0e15) ? 0 : 0.31830988618 / (1.0+x*x); } Poisson1::Poisson1(Real mux) : AsymGen(mux) // Constructor { mu=mux; ln_mu=log(mu); } Real Poisson1::Density(Real x) const // Poisson density function { if (x < 0.0) return 0.0; double ix = floor(x); // use integer part double l = ln_mu * ix - mu - ln_gamma(1.0 + ix); return (l < -40.0) ? 0.0 : exp(l); } Binomial1::Binomial1(int nx, Real px) : AsymGen((nx + 1) * px), p(px), q(1.0 - px), n(nx) { ln_p = log(p); ln_q = log(q); ln_n_fac = ln_gamma(n+1); } Real Binomial1::Density(Real x) const // Binomial density function { double ix = floor(x); // use integer part if (ix < 0.0 || ix > n) return 0.0; double l = ln_n_fac - ln_gamma(ix+1) - ln_gamma(n-ix+1) + ix * ln_p + (n-ix) * ln_q; return (l < -40.0) ? 0.0 : exp(l); } Poisson2::Poisson2(Real mux) { Real probs[40]; probs[0]=exp(-mux); for (int i=1; i<40; i++) probs[i]=probs[i-1]*mux/i; dg=new DiscreteGen(40,probs); if (!dg) ErrorNoSpace(); } Poisson2::~Poisson2() { delete dg; } Binomial2::Binomial2(int nx, Real px) { Real qx = 1.0 - px; Real probs[40]; int k = (int)(nx * px); probs[k] = exp(ln_gamma(nx+1) - ln_gamma(k+1) - ln_gamma(nx-k+1) + k * log(px) + (nx-k) * log(qx)); int i; int m = (nx >= 40) ? 39 : nx; for (i=k+1; i<=m; i++) probs[i]=probs[i-1] * px * (nx-i+1) / qx / i; for (i=k-1; i>=0; i--) probs[i]=probs[i+1] * qx * (i+1) / px / (nx-i); dg = new DiscreteGen(m + 1, probs); if (!dg) ErrorNoSpace(); } Binomial2::~Binomial2() { delete dg; } Real Exponential::Density(Real x) const // Negative exponential { return (x > 40.0 || x < 0.0) ? 0.0 : exp(-x); } Poisson::Poisson(Real mu) { if (mu <= 8.0) method = new Poisson2(mu); else method = new Poisson1(mu); if (!method) ErrorNoSpace(); } Binomial::Binomial(int nx, Real px) { if (nx < 40 || nx * px <= 8.0) method = new Binomial2(nx, px); else method = new Binomial1(nx, px); if (!method) ErrorNoSpace(); } NegativeBinomial::NegativeBinomial(Real NX, Real PX) : AsymGen(0.0), N(NX), P(PX), Q(1.0 + PX) { p = 1.0 / Q; ln_q = log(1.0 - p); c = N * log(p) - ln_gamma(N); mode = (N - 1) * P; if (mode < 1.0) mode = 0.0; } Real NegativeBinomial::Next() { return floor(AsymGen::Next()); } Real NegativeBinomial::Density(Real x) const { if (x < 0.0) return 0.0; Real ix = floor(x); Real l = c + ln_gamma(ix + N) - ln_gamma(ix + 1) + ix * ln_q; return (l < -40.0) ? 0.0 : exp(l); } Gamma1::Gamma1(Real alphax) // constructor (Real=shape) { ralpha=1.0/alphax; ln_gam=ln_gamma(alphax+1.0); alpha=alphax; } Real Gamma1::Density(Real x) const // density function for { // transformed gamma Real l = - pow(x,ralpha) - ln_gam; return (l < -40.0) ? 0.0 : exp(l); } Real Gamma1::Next() // transform variable { return pow(PosGen::Next(),ralpha); } Gamma2::Gamma2(Real alphax) : AsymGen(alphax-1.0) // constructor (Real=shape) { alpha=alphax; ln_gam=ln_gamma(alpha); } Real Gamma2::Density(Real x) const // gamma density function { if (x<=0.0) return 0.0; double l = (alpha-1.0)*log(x) - x - ln_gam; return (l < -40.0) ? 0.0 : exp(l); } Gamma::Gamma(Real alpha) // general gamma generator { if (alpha<1.0) method = new Gamma1(alpha); else if (alpha==1.0) method = new Exponential(); else method = new Gamma2(alpha); if (!method) ErrorNoSpace(); } DiscreteGen::DiscreteGen(int n1, Real* prob) // discrete generator // values on 0,...,n1-1 { #ifdef MONITOR cout << "constructing DiscreteGen\n"; #endif Gen(n1, prob); val=0; mean=0.0; var=0.0; { for (int i=0; i=px) { pmin=px; jmin=j; } } } if ((jmax<0) || (jmin<0)) Throw(Runtime_error("Newran: method fails")); ialt[jmin]=jmax; px=rn-pmin; p[jmax]+=px; px*=n; p[jmin]=px; if ((px>1.00001)||(px<-.00001)) Throw(Runtime_error("Newran: probs don't add to 1 (a)")); } if (px>0.00001) Throw(Runtime_error("Newran: probs don't add to 1 (b)")); } DiscreteGen::~DiscreteGen() { delete [] p; delete [] ialt; delete [] val; #ifdef MONITOR cout << "destructing DiscreteGen\n"; #endif } Real DiscreteGen::Next() // Next discrete random variable { int i = (int)(n*Random::Next()); if (Random::Next()Next(); } ExtReal NegatedRandom::Mean() const { return - rv->Mean(); } ExtReal NegatedRandom::Variance() const { return rv->Variance(); } Real ScaledRandom::Next() { return rv->Next() * s; } ExtReal ScaledRandom::Mean() const { return rv->Mean() * s; } ExtReal ScaledRandom::Variance() const { return rv->Variance() * (s*s); } Real ShiftedRandom::Next() { return rv->Next() + s; } ExtReal ShiftedRandom::Mean() const { return rv->Mean() + s; } ExtReal ShiftedRandom::Variance() const { return rv->Variance(); } Real ReverseShiftedRandom::Next() { return s - rv->Next(); } ExtReal ReverseShiftedRandom::Mean() const { return - rv->Mean() + s; } ExtReal ReverseShiftedRandom::Variance() const { return rv->Variance(); } Real ReciprocalRandom::Next() { return s / rv->Next(); } ExtReal RepeatedRandom::Mean() const { return rv->Mean() * (Real)n; } ExtReal RepeatedRandom::Variance() const { return rv->Variance() * (Real)n; } RepeatedRandom& Random::operator()(int n) { RepeatedRandom* r = new RepeatedRandom(*this, n); if (!r) ErrorNoSpace(); return *r; } NegatedRandom& operator-(Random& rv) { NegatedRandom* r = new NegatedRandom(rv); if (!r) ErrorNoSpace(); return *r; } ShiftedRandom& operator+(Random& rv, Real s) { ShiftedRandom* r = new ShiftedRandom(rv, s); if (!r) ErrorNoSpace(); return *r; } ShiftedRandom& operator-(Random& rv, Real s) { ShiftedRandom* r = new ShiftedRandom(rv, -s); if (!r) ErrorNoSpace(); return *r; } ScaledRandom& operator*(Random& rv, Real s) { ScaledRandom* r = new ScaledRandom(rv, s); if (!r) ErrorNoSpace(); return *r; } ShiftedRandom& operator+(Real s, Random& rv) { ShiftedRandom* r = new ShiftedRandom(rv, s); if (!r) ErrorNoSpace(); return *r; } ReverseShiftedRandom& operator-(Real s, Random& rv) { ReverseShiftedRandom* r = new ReverseShiftedRandom(rv, s); if (!r) ErrorNoSpace(); return *r; } ScaledRandom& operator*(Real s, Random& rv) { ScaledRandom* r = new ScaledRandom(rv, s); if (!r) ErrorNoSpace(); return *r; } ScaledRandom& operator/(Random& rv, Real s) { ScaledRandom* r = new ScaledRandom(rv, 1.0/s); if (!r) ErrorNoSpace(); return *r; } ReciprocalRandom& operator/(Real s, Random& rv) { ReciprocalRandom* r = new ReciprocalRandom(rv, s); if (!r) ErrorNoSpace(); return *r; } AddedRandom& operator+(Random& rv1, Random& rv2) { AddedRandom* r = new AddedRandom(rv1, rv2); if (!r) ErrorNoSpace(); return *r; } MultipliedRandom& operator*(Random& rv1, Random& rv2) { MultipliedRandom* r = new MultipliedRandom(rv1, rv2); if (!r) ErrorNoSpace(); return *r; } SubtractedRandom& operator-(Random& rv1, Random& rv2) { SubtractedRandom* r = new SubtractedRandom(rv1, rv2); if (!r) ErrorNoSpace(); return *r; } DividedRandom& operator/(Random& rv1, Random& rv2) { DividedRandom* r = new DividedRandom(rv1, rv2); if (!r) ErrorNoSpace(); return *r; } Real AddedRandom::Next() { return rv1->Next() + rv2->Next() ; } ExtReal AddedRandom::Mean() const { return rv1->Mean() + rv2->Mean() ; } ExtReal AddedRandom::Variance() const { return rv1->Variance() + rv2->Variance() ; } Real SubtractedRandom::Next() { return rv1->Next() - rv2->Next() ; } ExtReal SubtractedRandom::Mean() const { return rv1->Mean() - rv2->Mean() ; } ExtReal SubtractedRandom::Variance() const { return rv1->Variance() + rv2->Variance() ; } Real MultipliedRandom::Next() { return rv1->Next() * rv2->Next() ; } ExtReal MultipliedRandom::Mean() const { return rv1->Mean() * rv2->Mean() ; } ExtReal MultipliedRandom::Variance() const { ExtReal e1 = square(rv1->Mean()); ExtReal e2 = square(rv2->Mean()); ExtReal v1 = rv1->Variance(); ExtReal v2 = rv2->Variance(); ExtReal r=v1*v2+v1*e2+e1*v2; return r; } Real DividedRandom::Next() { return rv1->Next() / rv2->Next() ; } void Random::load(int*,Real*,Random**) { Throw(Logic_error("Newran: illegal combination")); } void SelectedRandom::load(int* i, Real* probs, Random** rvx) { probs[*i]=p; rvx[*i]=rv; (*i)++; delete this; } Real SelectedRandom::Next() { Throw(Logic_error("Newran: Next not defined")); return 0.0; } Real AddedSelectedRandom::Next() { Throw(Logic_error("Newran: Next not defined")); return 0.0; } Real RepeatedRandom::Next() { Real sum=0.0; for (int i=0; iNext(); return sum; } MixedRandom::MixedRandom(int nx, Real* probs, Random** rvx) { n = nx; rv = new Random*[n]; if (!rv) ErrorNoSpace(); for (int i=0; iMean()*probs[i]; for (i=0; iVariance(); ExtReal mudif=(rv[i])->Mean()-mean; var = var + (sigsq+square(mudif))*probs[i]; } } MixedRandom::~MixedRandom() { for (int i=0; itDelete(); delete [] rv; delete dg; } Real MixedRandom::Next() { int i = (int)(dg->Next()); return (rv[i])->Next(); } int AddedSelectedRandom::nelems() const { return rv1->nelems() + rv2->nelems(); } void AddedSelectedRandom::load(int* i, Real* probs, Random** rvx) { rv1->load(i, probs, rvx); rv2->load(i, probs, rvx); delete this; } AddedSelectedRandom& operator+(SelectedRandom& rv1, SelectedRandom& rv2) { AddedSelectedRandom* r = new AddedSelectedRandom(rv1, rv2); if (!r) ErrorNoSpace(); return *r; } AddedSelectedRandom& operator+(AddedSelectedRandom& rv1, SelectedRandom& rv2) { AddedSelectedRandom* r = new AddedSelectedRandom(rv1, rv2); if (!r) ErrorNoSpace(); return *r; } AddedSelectedRandom& operator+(SelectedRandom& rv1, AddedSelectedRandom& rv2) { AddedSelectedRandom* r = new AddedSelectedRandom(rv1, rv2); if (!r) ErrorNoSpace(); return *r; } AddedSelectedRandom& operator+(AddedSelectedRandom& rv1, AddedSelectedRandom& rv2) { AddedSelectedRandom* r = new AddedSelectedRandom(rv1, rv2); if (!r) ErrorNoSpace(); return *r; } SelectedRandom& Random::operator()(double p) { SelectedRandom* r = new SelectedRandom(*this, p); if (!r) ErrorNoSpace(); return *r; } // Identification routines for each class - may not work on all compilers? char* Random::Name() { return "Random"; } char* Uniform::Name() { return "Uniform"; } char* Constant::Name() { return "Constant"; } char* PosGen::Name() { return "PosGen"; } char* SymGen::Name() { return "SymGen"; } char* AsymGen::Name() { return "AsymGen"; } char* PosGenX::Name() { return "PosGenX"; } char* SymGenX::Name() { return "SymGenX"; } char* AsymGenX::Name() { return "AsymGenX"; } char* Normal::Name() { return "Normal"; } char* ChiSq::Name() { return "ChiSq"; } char* Cauchy::Name() { return "Cauchy"; } char* Exponential::Name() { return "Exponential"; } char* Poisson::Name() { return "Poisson"; } char* Binomial::Name() { return "Binomial"; } char* NegativeBinomial::Name() { return "NegativeBinomial"; } char* Gamma::Name() { return "Gamma"; } char* Pareto::Name() { return "Pareto"; } char* DiscreteGen::Name() { return "DiscreteGen"; } char* SumRandom::Name() { return "SumRandom"; } char* MixedRandom::Name() { return "MixedRandom"; } // ********************** permutation generator *************************** void RandomPermutation::Next(int N, int M, int p[], int start) { // N = size of urn; M = number of draws if (N < M) Throw(Logic_error("Newran: N < M in RandomPermutation")); int i; int* q = new int [N]; if (!q) ErrorNoSpace(); for (i = 0; i < N; i++) q[i] = start + i; for (i = 0; i < M; i++) { int k = i + (int)(U.Next() * (N - i)); // uniform on i ... N-1 p[i] = q[k]; q[k] = q[i]; // swap i and k terms // but put i-th term into p } delete [] q; } void RandomCombination::SortAscending(int n, int gm[]) { // from numerical recipies in C - Shell sort const double aln2i = 1.442695022; const double tiny = 1.0e-5; int m = n; int lognb2 = (int)(aln2i * log((double)n) + tiny); while (lognb2--) { m >>= 1; for (int j = m; j=0 && *gmi>t) { *gmj = *gmi; gmj = gmi; gmi -= m; i -= m; } *gmj = t; } } } #ifdef use_namespace } #endif p[jmax]+=px; px*=n; p[jmin]=px; if ((px>1.00001)||(px<-.00001)) Throw(Runtime_error("Newran: probs don't add to 1 (a)")); } if (px>0.00001) Throw(Runtime_error("Newran: probs don't add to 1 (b)")); } DiscreteGen::~DiscreteGen() { delete [] p; delete [] ialt; delete [] val; #ifdef MONITOR cout << "destructing DiscreteGen\n"; #endif } Real DiscreteGen::Next() // Next discrete random variable { int i = (int)(n*./scope1.0.2000.11.14/rnd/newran.h010064400007730000024000000437030720365251400154600ustar00patarg00001250000004// newran.h ------------------------------------------------------------ // NEWRAN02 #ifndef NEWRAN_LIB #define NEWRAN_LIB 0 //******************* utilities and definitions ************************* #include "include.h" #include "boolean.h" #include "myexcept.h" #include "extreal.h" #ifdef use_namespace namespace NEWRAN { using namespace RBD_COMMON; } namespace RBD_LIBRARIES { using namespace NEWRAN; } namespace NEWRAN { #endif typedef Real (*PDF)(Real); // probability density function Real ln_gamma(Real); // log gamma function //**************** uniform random number generator ********************** class RepeatedRandom; class SelectedRandom; class Random // uniform random number generator { static double seed; // seed //static unsigned long iseed; // for Mother static Real Buffer[128]; // for mixing random numbers static Real Raw(); // unmixed random numbers void operator=(const Random&) {} // private so can't access public: static void Set(double s); // set seed (0 < seed < 1) static double Get(); // get seed virtual Real Next(); // get new value virtual char* Name(); // identification virtual Real Density(Real) const; // used by PosGen & Asymgen Random() {} // do nothing virtual ~Random() {} // make destructors virtual SelectedRandom& operator()(double); // used by MixedRandom RepeatedRandom& operator()(int); // for making combinations virtual ExtReal Mean() const { return 0.5; } // mean of distribution virtual ExtReal Variance() const { return 1.0/12.0; } // variance of distribution virtual void tDelete() {} // delete components of sum virtual int nelems() const { return 1; } // used by MixedRandom virtual void load(int*,Real*,Random**); friend class RandomPermutation; }; //****************** uniform random number generator ********************* class Uniform : public Random { void operator=(const Uniform&) {} // private so can't access public: char* Name(); // identification Uniform() {} // set value Real Next() { return Random::Next(); } ExtReal Mean() const { return 0.5; } ExtReal Variance() const { return 1.0/12.0; } Real Density(Real x) const { return (x < 0.0 || x > 1.0) ? 0 : 1.0; } }; //************************* return constant ****************************** class Constant : public Random { void operator=(const Constant&) {} // private so can't access Real value; // value to be returned public: char* Name(); // identification Constant(Real v) { value=v; } // set value Real Next() { return value; } ExtReal Mean() const { return value; } ExtReal Variance() const { return 0.0; } }; //**************** positive random number generator ********************** class PosGen : public Random // generate positive rv { void operator=(const PosGen&) {} // private so can't access protected: Real xi, *sx, *sfx; bool NotReady; void Build(bool); // called on first call to Next public: char* Name(); // identification PosGen(); // constructor ~PosGen(); // destructor Real Next(); // to get a single new value ExtReal Mean() const { return (ExtReal)Missing; } ExtReal Variance() const { return (ExtReal)Missing; } }; //**************** symmetric random number generator ********************** class SymGen : public PosGen // generate symmetric rv { void operator=(const SymGen&) {} // private so can't access public: char* Name(); // identification Real Next(); // to get a single new value }; //**************** normal random number generator ********************** class Normal : public SymGen // generate standard normal rv { void operator=(const Normal&) {} // private so can't access static Real Nxi, *Nsx, *Nsfx; // so we need initialise only once static long count; // assume initialised to 0 public: char* Name(); // identification Normal(); ~Normal(); Real Density(Real) const; // normal density function ExtReal Mean() const { return 0.0; } ExtReal Variance() const { return 1.0; } }; //*********** chi-square random number generator ********************** class ChiSq : public Random // generate non-central chi-sq rv { void operator=(const ChiSq&) {} // private so can't access Random* c1; // pointers to generators Random* c2; // pointers to generators int version; // indicates method of generation Real mean, var; public: char* Name(); // identification ChiSq(int, Real=0.0); // df and non-centrality parameter ~ChiSq(); ExtReal Mean() const { return mean; } ExtReal Variance() const { return var; } Real Next(); }; //**************** Cauchy random number generator ********************** class Cauchy : public SymGen // generate standard cauchy rv { void operator=(const Cauchy&) {} // private so can't access public: char* Name(); // identification Real Density(Real) const; // Cauchy density function ExtReal Mean() const { return Indefinite; } ExtReal Variance() const { return PlusInfinity; } }; //**************** Exponential random number generator ********************** class Exponential : public PosGen // generate standard exponential rv { void operator=(const Exponential&) {} // private so can't access public: char* Name(); // identification Real Density(Real) const; // Exponential density function ExtReal Mean() const { return 1.0; } ExtReal Variance() const { return 1.0; } }; //**************** asymmetric random number generator ********************** class AsymGen : public Random // generate asymmetric rv { void operator=(const AsymGen&) {} // private so can't access Real xi, *sx, *sfx; int ic; bool NotReady; void Build(); // called on first call to Next protected: Real mode; public: char* Name(); // identification AsymGen(Real); // constructor (Real=mode) ~AsymGen(); // destructor Real Next(); // to get a single new value ExtReal Mean() const { return (ExtReal)Missing; } ExtReal Variance() const { return (ExtReal)Missing; } }; //**************** Gamma random number generator ********************** class Gamma : public Random // generate gamma rv { void operator=(const Gamma&) {} // private so can't access Random* method; public: char* Name(); // identification Gamma(Real); // constructor (Real=shape) ~Gamma() { delete method; } Real Next() { return method->Next(); } ExtReal Mean() const { return method->Mean(); } ExtReal Variance() const { return method->Variance(); } }; //**************** Generators with pointers to pdf *********************** class PosGenX : public PosGen { void operator=(const PosGenX&) {} // private so can't access PDF f; public: char* Name(); // identification PosGenX(PDF fx); Real Density(Real x) const { return (*f)(x); } }; class SymGenX : public SymGen { void operator=(const SymGenX&) {} // private so can't access PDF f; public: char* Name(); // identification SymGenX(PDF fx); Real Density(Real x) const { return (*f)(x); } }; class AsymGenX : public AsymGen { void operator=(const AsymGenX&) {} // private so can't access PDF f; public: char* Name(); // identification AsymGenX(PDF fx, Real mx); Real Density(Real x) const { return (*f)(x); } }; //***************** Pareto random number generator ************************ class Pareto : public Random // Use definition of Kotz and Johnson: "Continuous univariate distributions 1", // chapter 19 with k = 1. { void operator=(const Pareto&) {} // private so can't access Real Shape, RS; public: char* Name(); // identification Pareto(Real shape); // constructor (Real=shape) ~Pareto() {} Real Next(); ExtReal Mean() const; ExtReal Variance() const; }; //**************** discrete random number generator ********************** class DiscreteGen : public Random // discrete random generator { void operator=(const DiscreteGen&) {} // private so can't access Real *p; int *ialt; int n; Real *val; void Gen(int, Real*); // called by constructors Real mean, var; // calculated by the constructor public: char* Name(); // identification DiscreteGen(int,Real*); // constructor DiscreteGen(int,Real*,Real*); // constructor ~DiscreteGen(); // destructor Real Next(); // new single value ExtReal Mean() const { return mean; } ExtReal Variance() const { return var; } }; //***************** Poisson random number generator ******************* class Poisson : public Random // generate poisson rv { void operator=(const Poisson&) {} // private so can't access Random* method; public: char* Name(); // identification Poisson(Real); // constructor (Real=mean) ~Poisson() { delete method; } Real Next() { return method->Next(); } ExtReal Mean() const { return method->Mean(); } ExtReal Variance() const { return method->Variance(); } }; //***************** binomial random number generator ******************* class Binomial : public Random // generate binomial rv { void operator=(const Binomial&) {} // private so can't access Random* method; public: char* Name(); // identification Binomial(int p, Real n); // constructor (int=n, Real=p) ~Binomial() { delete method; } Real Next() { return method->Next(); } ExtReal Mean() const { return method->Mean(); } ExtReal Variance() const { return method->Variance(); } }; //************** negative binomial random number generator ***************** class NegativeBinomial : public AsymGen // generate negative binomial rv { Real N, P, Q, p, ln_q, c; public: char* Name(); NegativeBinomial(Real NX, Real PX); // constructor Real Density(Real) const; // Negative binomial density function Real Next(); ExtReal Mean() const { return N * P; } ExtReal Variance() const { return N * P * Q; } }; //************************ sum of random numbers ************************ class NegatedRandom : public Random { protected: Random* rv; NegatedRandom(Random& rvx) : rv(&rvx) {} void tDelete() { rv->tDelete(); delete this; } public: Real Next(); ExtReal Mean() const; ExtReal Variance() const; friend NegatedRandom& operator-(Random&); }; class ScaledRandom : public Random { protected: Random* rv; Real s; ScaledRandom(Random& rvx, Real sx) : rv(&rvx), s(sx) {} void tDelete() { rv->tDelete(); delete this; } public: Real Next(); ExtReal Mean() const; ExtReal Variance() const; friend ScaledRandom& operator*(Real, Random&); friend ScaledRandom& operator*(Random&, Real); friend ScaledRandom& operator/(Random&, Real); }; class ReciprocalRandom : public Random { protected: Random* rv; Real s; ReciprocalRandom(Random& rvx, Real sx) : rv(&rvx), s(sx) {} void tDelete() { rv->tDelete(); delete this; } public: Real Next(); ExtReal Mean() const { return Missing; } ExtReal Variance() const { return Missing; } friend ReciprocalRandom& operator/(Real, Random&); }; class ShiftedRandom : public ScaledRandom { ShiftedRandom(Random& rvx, Real sx) : ScaledRandom(rvx, sx) {} public: Real Next(); ExtReal Mean() const; ExtReal Variance() const; friend ShiftedRandom& operator+(Real, Random&); friend ShiftedRandom& operator+(Random&, Real); friend ShiftedRandom& operator-(Random&, Real); }; class ReverseShiftedRandom : public ScaledRandom { ReverseShiftedRandom(Random& rvx, Real sx) : ScaledRandom(rvx, sx) {} public: Real Next(); ExtReal Mean() const; ExtReal Variance() const; friend ReverseShiftedRandom& operator-(Real, Random&); }; class RepeatedRandom : public Random { Random* rv; int n; void tDelete() { rv->tDelete(); delete this; } RepeatedRandom(Random& rvx, int nx) : rv(&rvx), n(nx) {} public: Real Next(); ExtReal Mean() const; ExtReal Variance() const; friend class Random; }; class MultipliedRandom : public Random { protected: Random* rv1; Random* rv2; void tDelete() { rv1->tDelete(); rv2->tDelete(); delete this; } MultipliedRandom(Random& rv1x, Random& rv2x) : rv1(&rv1x), rv2(&rv2x) {} public: Real Next(); ExtReal Mean() const; ExtReal Variance() const; friend MultipliedRandom& operator*(Random&, Random&); }; class AddedRandom : public MultipliedRandom { AddedRandom(Random& rv1x, Random& rv2x) : MultipliedRandom(rv1x, rv2x) {} public: Real Next(); ExtReal Mean() const; ExtReal Variance() const; friend AddedRandom& operator+(Random&, Random&); }; class SubtractedRandom : public MultipliedRandom { SubtractedRandom(Random& rv1x, Random& rv2x) : MultipliedRandom(rv1x, rv2x) {} public: Real Next(); ExtReal Mean() const; ExtReal Variance() const; friend SubtractedRandom& operator-(Random&, Random&); }; class DividedRandom : public MultipliedRandom { DividedRandom(Random& rv1x, Random& rv2x) : MultipliedRandom(rv1x, rv2x) {} public: Real Next(); ExtReal Mean() const { return Missing; } ExtReal Variance() const { return Missing; } friend DividedRandom& operator/(Random&, Random&); }; class SumRandom : public Random // sum of random variables { void operator=(const SumRandom&) {} // private so can't access Random* rv; public: char* Name(); // identification SumRandom(NegatedRandom& rvx) : rv(&rvx) {} SumRandom(AddedRandom& rvx) : rv(&rvx) {} SumRandom(MultipliedRandom& rvx) : rv(&rvx) {} SumRandom(SubtractedRandom& rvx) : rv(&rvx) {} SumRandom(DividedRandom& rvx) : rv(&rvx) {} SumRandom(ShiftedRandom& rvx) : rv(&rvx) {} SumRandom(ReverseShiftedRandom& rvx) : rv(&rvx) {} SumRandom(ScaledRandom& rvx) : rv(&rvx) {} SumRandom(ReciprocalRandom& rvx) : rv(&rvx) {} SumRandom(RepeatedRandom& rvx) : rv(&rvx) {} Real Next() { return rv->Next(); } ExtReal Mean() const { return rv->Mean(); } ExtReal Variance() const { return rv->Variance(); } ~SumRandom() { rv->tDelete(); } }; //******************** mixtures of random numbers ************************ class SelectedRandom : public Random { friend class Random; Random* rv; Real p; SelectedRandom(Random& rvx, Real px) : rv(&rvx), p(px) {} void tDelete() { rv->tDelete(); delete this; } public: void load(int*, Real*, Random**); Real Next(); }; class AddedSelectedRandom : public Random { friend class Random; protected: Random* rv1; Random* rv2; AddedSelectedRandom(Random& rv1x, Random& rv2x) : rv1(&rv1x), rv2(&rv2x) {} void tDelete() { rv1->tDelete(); rv2->tDelete(); delete this; } public: int nelems() const; void load(int*, Real*, Random**); Real Next(); friend AddedSelectedRandom& operator+(SelectedRandom&, SelectedRandom&); friend AddedSelectedRandom& operator+(AddedSelectedRandom&, SelectedRandom&); friend AddedSelectedRandom& operator+(SelectedRandom&, AddedSelectedRandom&); friend AddedSelectedRandom& operator+(AddedSelectedRandom&, AddedSelectedRandom&); }; class MixedRandom : public Random // mixtures of random numbers { void operator=(const MixedRandom&) {} // private so can't access int n; // number of components DiscreteGen* dg; // discrete mixing distribution Random** rv; // array of pointers to rvs ExtReal mean, var; void Build(Real*); // used by constructors public: char* Name(); // identification MixedRandom(int, Real*, Random**); MixedRandom(AddedSelectedRandom&); ~MixedRandom(); Real Next(); ExtReal Mean() const { return mean; } ExtReal Variance() const { return var; } }; //******************* Permutation generator ******************************* class RandomPermutation // generate permutation of integers { Random U; public: void Next(int N, int M, int p[], int start = 0); // select permutation of M numbers // from start, ..., start+N-1 // results to p void Next(int N, int p[], int start = 0) { Next(N, N, p, start); } }; class RandomCombination : public RandomPermutation // generate combination of integers // sorted - ascending { void SortAscending(int n, int gm[]); public: void Next(int N, int M, int p[], int start = 0) { RandomPermutation::Next(N, M, p, start); SortAscending(M, p); } void Next(int N, int p[], int start = 0) { Next(N, N, p, start); } }; #ifdef use_namespace } #endif #endif or=(const SymGenX&) {} // private so can't access PDF./scope1.0.2000.11.14/rnd/nr02doc.htm010064400007730000024000001225710720365251500160000ustar00patarg00001250000004 Newran - random number generator library

Newran02A - a random number generator library

30 August, 1998

Copyright (C) 1989, 1995, 1998: R B Davies

Permission is granted to use or distribute but not to sell.

This is a C++ library for generating sequences of random numbers from a wide variety of distributions. It is particularly appropriate for the situation where one requires sequences of identically distributed random numbers since the set up time for each type of distribution is relatively long but it is efficient when generating each new random number. The library includes classes for generating random numbers from a number of distributions and is easily extended to be able to generate random numbers from almost any of the standard distributions.

Newran02, fixes some bugs, includes more extensive testing, has been updated to be compatible with newmat09 and includes some additional distributions. Newran02A includes an updated version of the exception library.

Comments and bug reports to mailto:robertd@netlink.co.nz.

For updates and notes see http://webnz.com/robert/.

 

Overview

The following are the classes for generating random numbers from particular distributions 

Uniform uniform distribution
Constant return a constant
Exponential negative exponential distribution
Cauchy Cauchy distribution
Normal normal distribution
ChiSq non-central chi-squared distribution
Gamma gamma distribution
Pareto Pareto distribution
Poisson Poisson distribution
Binomial binomial distribution
NegativeBinomial negative binomial distribution

The following classes are available to the user for generating numbers from other distributions  

PosGenX Positive random numbers with a decreasing density
SymGenX Random numbers from a symmetric unimodal density
AsymGenX Random numbers from an asymmetric unimodal density
PosGen Positive random numbers with a decreasing density
SymGen Random numbers from a symmetric unimodal density
AsymGen Random numbers from an asymmetric unimodal density
DiscreteGen Random numbers from a discrete distribution
SumRandom Sum and/or product of random numbers
MixedRandom Mixture of random numbers

Each of these classes has the following member functions  

Real Next() Get a new random number
char* Name() Name of the distribution
ExtReal Mean() Mean of the distribution
ExtReal Variance() Variance of the distribution

These 4 functions are declared virtual so it is easy to write simulation programs that can be run with different distributions.

Real is typedefed to be either float or double. See customising. Note that Next() always returns a Real even for discrete distributions.

ExtReal is a class which is, in effect either a Real or one of the following: PlusInfinity, MinusInfinity, Indefinite or Missing. I use ExtReal so that I can return infinite or indefinite values for the mean or variance of a distribution.

There are two static functions in the class Random. 

   void Random::Set(double)

must be called with an argument between 0 and 1 to set up the base random number generator before Next() is called in any class. 

   double Random::Get()

returns the current value of the seed.

There are two classes for doing combinations and permutations.
 

RandomPermutation Draw numbers without replacement
RandomCombination Draw numbers without replacement and sort

Further details of all these classes including the constructors are given below.

 

Getting started

Customising

The file include.h sets a variety of options including several compiler dependent options. You may need to edit include.h to get the options you require. If you are using a compiler different from one I have worked with you may have to set up a new section in include.h appropriate for your compiler.

Borland, Turbo, Gnu, Microsoft and Watcom are recognised automatically. If none of these are recognised a default set of options is used. These are fine for AT&T, HPUX and Sun C++. If you using a compiler I don't know about, you may have to write a new set of options.

There is an option in include.h for selecting whether you use compiler supported exceptions, simulated exceptions, or disable exceptions. Use the option for compiler supported exceptions if and only if you have set the option on your compiler to recognise exceptions. Disabling exceptions sometimes helps with compilers that are incompatible with my exception simulation scheme.
 

This version of newran does not do memory clean-up with the simulated exceptions.

If your compiler recognises bool as required by the standard activate the statement #define bool_LIB. This will deactivate my Boolean class. (I have included a command in the make file to do this automatically with Gnu G++).

Activate the appropriate statement to make the element type Real to mean float or double.

Activate the namespace option if your want to use namespaces and have a compiler that really does support them.

Compiling

You will need to compile newran.cpp, myexcept.cpp and extreal.cpp and link the resulting object files to your programs. Your source files which access newran will need to have newran.h as an include file.

Compilers

I have tested newran02 with the following compilers (all PC ones in 32 bit console mode)

Borland 5.01A OK
Borland 3.1 See notes on 16 bit under testing
Microsoft 5.0 OK
Watcom 10A OK
Sun CC 4.2 OK
Gnu G++ 2.7.2 (Linux), 2.8.0 (Sun) OK

I have included make files for Watcom 10A, CC and Gnu G++. See files section.

Testing

The files tryrand.cpp, tryrand1.cpp, tryrand2.cpp, tryrand3.cpp, tryrand4.cpp, hist.cpp run the generators in the library and print histograms of the resulting distributions. Sample means and variances are also calculated and can be compared with the population values. The correct results are in tryrand.txt (although there might be slight differences in the format of the output from different compilers).
 

If you are compiling on a PC with a 16 bit compiler you will need to set n_large to be 8000 rather than 1000000 and n to 8000 rather than 200000 in tryrand.cpp. This will change the output from the test program from that given in tryrand.txt although the general appearance should be the same.

The test program tryrand.cpp includes a simple test for memory leaks. This is valid for only some compilers. It seems to work for Borland C++ in console mode but not for Gnu G++ or Microsoft C++, where it almost always (presumably incorrectly) suggests an error.

 

Descriptions of the classes to be accessed by the user:

Random:

This is the basic uniform random number generator, used to drive all the others. The Lewis-Goodman-Miller algorithm is used with Marsaglia mixing. While not perfect, and now superseded, the LGM generator has given me acceptable results in a wide variety of simulations. See Numerical Recipes in C by Press, Flannery, Teukolsky, Vetterling published by the Cambridge University Press for details. The LGM generator does pass the Marsaglia diehard tests when you include the mixing. (It doesn't pass without the mixing). Nevertheless it should be upgraded. Ideally the basic generator should be recoded in assembly language to give the maximum speed to all the generators in this package. You can access the numbers directly using Next() but I suggest you use class Uniform for uniform random numbers and reserve Random for setting the starting seed and as the base class for the random number generators.

Uniform:

Return a uniform random number from the range (0, 1). The constructor has no parameters. For example 

   Uniform U;
   for (int i=0; i<100; i++) cout << U.Next() << "\n";

prints a column of 100 numbers drawn from a uniform distribution.

Constant:

This returns a constant. The constructor takes one Real parameter; the value of the constant to be returned. So 

   Constant C(5.5);
   cout << C.Next() << "\n";

prints 5.5.

Exponential:

This generates random numbers with density exp(-x) for x>=0. The constructor takes no arguments. 

   Exponential E;
   for (int i=0; i<100; i++) cout << E.Next() << "\n";

Cauchy:

Generates random numbers from a standard Cauchy distribution. The constructor takes no parameters. 

   Cauchy C;
   for (int i=0; i<100; i++) cout << C.Next() << "\n";

Normal:

Generates standard normal random numbers. The constructor has no arguments. This class has been augmented to ensure only one copy of the arrays generated by the constructor exist at any given time. That is, if the constructor is called twice (before the destructor is called) only one copy of the arrays is generated. 

   Normal Z;
   for (int i=0; i<100; i++) cout << Z.Next() << "\n";

ChiSq:

Non-Central chi-squared distribution. The method uses ChiSq1 to generate the non-central part and Gamma2 or Exponential to generate the central part. The constructor takes as arguments the number of degrees of freedom (>=1) and the non-centrality parameter (omit if zero). 

   int df = 10; Real noncen = 2.0;
   ChiSq CS(df, noncen);
   for (int i=0; i<100; i++) cout << CS.Next() << "\n";

Gamma:

Gamma distribution. The constructor takes the shape parameter as argument. Uses Gamma1, Gamma2 or Exponential. 

   Real shape = 0.75;
   Gamma G(shape);
   for (int i=0; i<100; i++) cout << G.Next() << "\n";

Pareto:

Pareto distribution. The constructor takes the shape parameter as argument. I follow the definition of Kotz and Johnson's Continuous univariate distributions 1, chapter 19, page 234, with k = 1. The generator uses a power transform of a uniform random number. 

   Real shape = 0.75;
   Pareto P(shape);
   for (int i=0; i<100; i++) cout << P.Next() << "\n";

Poisson:

Poisson distribution: uses Poisson1 or Poisson2. Constructor takes the mean as its argument. 

   Real mean = 5.0;
   Poisson P(mean);
   for (int i=0; i<100; i++) cout << (int)P.Next() << "\n";

Binomial:

Binomial distribution: uses Binomial1 or Binomial2. Constructor takes n and p as its arguments. 

   int n = 50; Real p = 0.25;
   Binomial B(n, p);
   for (int i=0; i<100; i++) cout << (int)B.Next() << "\n";

NegativeBinomial:

Negative binomial distribution. Constructor takes N and P as its arguments. I use the notation of Kotz and Johnson's Discrete distributions. Some people use p = 1/(P+1) in place of the second parameter. 

   Real N = 12.5; Real P = 3.0;
   NegativeBinomial NB(N, P);
   for (int i=0; i<100; i++) cout << (int)NB.Next() << "\n";

PosGenX:

This uses an arbitrary density satisfying the previous conditions to generate random numbers from that density. Suppose Real pdf(Real) is the density. Then use pdf as the argument of the constructor. For example 

   PosGenX P(pdf);
   for (int i=0; i<100; i++) cout << P.Next() << "\n";
Note that the probability density pdf must drop to exactly 0 for the argument large enough. For example, include a statement in the program for pdf that, if the value is less than 1.0E-15, then return 0.

SymGenX:

This corresponds to PosGenX for symmetric distributions.
 

Note that the probability density pdf must drop to exactly 0 for the argument large enough. For example, include a statement in the program for pdf that, if the value is less than 1.0E-15, then return 0.

AsymGenX:

Corresponds to PosGenX. The arguments of the constructor are the name of the density function and the location of the mode. 

   Real pdf(Real);
   Real mode;
   .....
   AsymGenX X(pdf, mode);
   for (int i=0; i<100; i++) cout << X.Next() << "\n";
Note that the probability density pdf must drop to exactly 0 for the argument large (large positive and large negative) enough. For example, include a statement in the program for pdf that, if the value is less than 1.0E-15, then return 0.

PosGen:

PosGen is not used directly. It is used as a base class for generating a random number from an arbitrary probability density p(x). p(x) must be non-zero only for x>=0, be monotonically decreasing for x>=0, and be finite. For example, p(x) could be exp(-x) for x>=0.

The method is to cover the density in a set of rectangles of equal area as in the diagram (indicated by ---). 

   |
   x
   |xx------
   |  xx    |
   |    xxx |
   |.......xxx---------
   |        | xxxx     |
   |        |     xxxx |
   |        |.........xxxxx------------
   |        |          |   xxxxx       |
   |        |          |        xxxxxx |
   |        |          |..............xxxxxx----------------------
   |        |          |               |    xxxxxxx               |
   |        |          |               |           xxxxxxx        |
   |        |          |               |                  xxxxxxxx|
   +===========================================================================

The numbers are generated by generating a pair of numbers uniformly distributed over these rectangles and then accepting the X coordinate as the next random number if the pair corresponds to a point below the density function. The acceptance can be done in two stages, the first being whether the number is below the dotted line. This means that the density function need be checked only very occasionally and on the average only just over 3 uniform random numbers are required for each of the random numbers produced by this generator.

See PosGenX or Exponential for the method of deriving a class to generate random numbers from a given distribution.
 

Note that the probability density p(x) must drop to exactly 0 for the argument, x, large enough. For example, include a statement in the program for p(x) that, if the value is less than 1.0E-15, then return 0.

SymGen:

SymGen is a modification of PosGen for unimodal distributions symmetric about the origin, such as the standard normal.

AsymGen:

A general random number generator for unimodal distributions following the method used by PosGen. The constructor takes one argument: the location of the mode of the distribution.

DiscreteGen:

This is for generating random numbers taking just a finite number of values. There are two alternative forms of the constructor: 

   DiscreteGen D(n,prob);
   DiscreteGen D(n,prob,val);

where n is an integer giving the number of values, prob a Real array of length n giving the probabilities and val a Real array of length n giving the set of values that are generated. If val is omitted the values are 0,1,...,n-1.

The method requires two uniform random numbers for each number it produces. This method is described by Kronmal and Peterson, American Statistician, 1979, Vol 33, No 4, pp214-218.

SumRandom:

This is for building a random number generator as a linear or multiplicative combination of existing random number generators. Suppose RV1, RV2, RV3, RV4 are random number generators defined with constructors given above and r1, r2, r0 are Reals and i1, i3 are integers.

Then the generator S defined by something like 

   SumRandom S = RV1(i1)*r1 - RV2*r2 + RV3(i3)*RV4 + r0;

has the obvious meaning. RV1(i1) means that the sum of i1 independent values from RV1 should be used. Note that RV1*RV1 means the product of two independent numbers generated from RV1. Remember that SumRandom is slow if the number of terms or copies is large. I support the four arithmetic operators +, -, * and / but cannot calculate the means and variances if you divide by a random variable.

Use SumRandom to quickly set up simple combinations of the existing generators. But if the combination is going to be used extensively, then it is probably better to write a new class to do this.

Example: normal with mean = 10, standard deviation = 5: 

   Normal N;
   SumRandom Z = 10 + 5 * N;
   for (int i=0; i<100; i++) cout << Z.Next() << "\n";

Example: F distribution with m and n degrees of freedom: 

   int m, n;
   ... put values in m and n
   ChiSq Num(m); ChiSq Den(n);
   SumRandom F = (double)n/(double)m * Num / Den;
   for (int i=0; i<100; i++) cout << F.Next() << "\n";

MixedRandom:

This is for mixtures of distributions. Suppose rv1, rv2, rv3 are random number generators and p1, p2, p3 are Reals summing to 1. Then the generator M defined by 

   MixedRandom M = rv1(p1) + rv2(p2) + rv3(p3);

produces a random number generator with selects its next random number from rv1 with probability p1, rv2 with probability p2, rv3 with probability p3.

Alternatively one can use the constructor 

   MixedRandom M(n, prob, rv);

where n is the number of distributions in the mixture, prob the Real array of probabilities, rv an array of pointers to random variables.

Normal with outliers: 

   Normal N; Cauchy C;
   MixedRandom Z = N(0.9) + C(0.1);
   for (int i=0; i<100; i++) cout << Z.Next() << "\n";

or: 

   Normal N;
   MixedRandom Z = N(0.9) + (10*N)(0.1);
   for (int i=0; i<100; i++) cout << Z.Next() << "\n";

RandomPermutation:

To draw M numbers without replacement from start, start+1, ..., start+N-1 use 

   RandomPermutation RP;
   RP.Next(N, M, p, start);

where p is an int* pointing to an array of length M or longer. Results are returned to that array. 

   RP.Next(N, p, start);

assumes M = N. The parameter, start, has a default value of 0.

The method is rather inefficient if N is very large and M is much smaller.

RandomCombination:

To draw M numbers without replacement from start, start+1, ..., start+N-1 and then sort use 

   RandomCombination RC;
   RC.Next(N, M, p, start);

where p is an int* pointing to an array of length M or longer. Results are returned to that array. 

   RC.Next(N, p, start);

assumes M = N. The parameter, start, has a default value of 0.

The method is rather inefficient if N is large. A better approach for large N would be to generate the sorted combination directly. This would also provide a better way of doing permutations with large N, small M.

ExtReal

A class consisting of a Real and an enumeration, EXT_REAL_CODE, taking the following values:

  • Finite
  • PlusInfinity
  • MinusInfinity
  • Indefinite
  • Missing

The arithmetic functions +, -, *, / are defined in the obvious ways, as is << for printing. The constructor can take either a Real or a value of EXT_REAL_CODE as an argument. If there is no argument the object is given the value Missing. Member function IsReal() returns true if the enumeration value is Finite and in this case value of the Real can be found with Value(). The enumeration value can be found with member function Code().

ExtReal is used at the type for values returned from the Mean and Variance member functions since these values may be infinite, indefinite or missing.

 

Descriptions of the supporting classes:

ChiSq1:

Non-central chi-squared with one degree of freedom. Used as part of ChiSq.

Gamma1:

This generates random numbers from a gamma distribution with shape parameter alpha < 1. Because the density is infinite at x = 0 a power transform is required. The constructor takes alpha as an argument.

Gamma2:

Gamma distribution for the shape parameter, alpha, greater than 1. The constructor takes alpha as the argument.

Poisson1:

Poisson distribution; derived from AsymGen. The constructor takes the mean as the argument. Used by Poisson for values of the mean greater than 10.

Poisson2:

Poisson distribution with mean less than or equal to 10. Uses DiscreteGen. Constructor takes the mean as its argument.

Binomial1:

Binomial distribution; derived from AsymGen. Used by Binomial for n >= 40. Constructor takes n and p as arguments.

Binomial2:

Binomial distribution with n < 40. Uses DiscreteGen. Constructor takes n and p as arguments.

AddedRandom, SubtractedRandom, MultipliedRandom, ShiftedRandom, ReverseShiftedRandom, ScaledRandom, RepeatedRandom, SelectedRandom, AddedSelectedRandom:

These are used by SumRandom and MixedRandom.

 

Generating numbers from other distributions:

Distribution type Method Example
Continuous finite unimodal density (no parameters, can calculate density) Use PosGenX, SymGenX or AsymGenX.
Continuous finite unimodal density (with parameters, can calculate density) Derive a new class from PosGen, SymGen or AsymGen, over-ride Density. Gamma2
Can calculate inverse of distribution Transform uniform random number. Pareto
Transformation of supported random number Derive a new class from the existing class ChiSq1
Transformation of several random numbers Derive new class from Random; generate the new random number from the existing generators. ChiSq
Density with infinite singularity Transform a random variable generated by PosGen, SymGen or AsymGen. Gamma1
Distribution with several modes Breakdown into a mixture of unimodal distributions.
Linear or quadratic combination of supported random numbers Use SumRandom.
Mixture of supported random numbers Use MixedRandom.
Discrete distribution (< 100 possible values) Use DiscreteGen. Poisson2
Discrete distribution (many possible values) Use PosGen, SymGen or AsymGen. Poisson1

 

Other people's code:

The gamma function and Shell sort routines are adapted from Numerical Recipes in C by Press, Flannery, Teukolsky, Vetterling published by the Cambridge University Press.

 

Files included in this package:

readme.txt readme file
newran.htm this file
newran.h header file for newran
newran.cpp main code file
extreal.h header file for extended reals
extreal.cpp code file for extended reals
boolean.h definition of bool
include.h option file
tryrand.cpp test file
tryrand1.cpp called by tryrand - histograms of simple examples
tryrand2.cpp called by tryrand - histograms of advanced examples
tryrand3.cpp called by tryrand - statistical tests
tryrand4.cpp called by tryrand - test permutations
hist.cpp called by tryrand - draw histogram
tryrand.txt output from tryrand
nrcc.mak make file for CC compiler
nrgnu.mak make file for gnu G++ compiler
nrwat.mak makefile for Watcom 32 bit 10a compiler

 

Class structure:

The following diagram gives the class hierarchy of the package. 

ExtReal.......................... Extended real numbers

Random........................... Uniform random number generator
 |
 +---Constant.................... Return a constant
 |
 +---PosGen...................... Used by PosGenX etc
 |    |
 |    +---PosGenX................ Positive random #s from decreasing density
 |    |
 |    +---Exponential............ Negative exponential rng
 |    |
 |    +---Gamma1................. Used by Gamma (shape parameter < 1)
 |    |
 |    +---SymGen................. Used by SymGenX etc
 |         |
 |         +---SymGenX........... Random numbers from symmetric density
 |         |
 |         +---Cauchy............ Cauchy random number generator
 |         |
 |         +---Normal............ Standard normal random number generator
 |              |
 |              +---ChiSq1....... Used by ChiSq (one df)
 | 
 +---AsymGen..................... Used by AsymGenX etc
 |    |
 |    +---AsymGenX............... Random numbers from asymmetric density
 |    |
 |    +---Poisson1............... Used by Poisson (mean > 8)
 |    |
 |    +---Binomial1.............. Used by Binomial (n >= 40)
 |    |
 |    +---NegativeBinomial....... Negative binomial random number generator
 |    |
 |    +---Gamma2................. Used by Gamma (shape parameter > 1)
 |
 +---ChiSq....................... Non-central chi-squared rng
 |
 +---Gamma....................... Gamma random number generator
 |
 +---Pareto...................... Pareto random number generator
 |
 +---DiscreteGen................. Discrete random number generator
 |
 +---Poisson2.................... Used by Poisson (mean <= 8)
 |
 +---Binomial2................... Used by Binomial (n < 40)
 |
 +---Poisson..................... Poisson random number generator
 |
 +---Binomial.................... Binomial random number generator
 |
 +---SumRandom................... Sum of random numbers
 |
 +---MixedRandom................. Mixture of random numbers
 |
 +---MultipliedRandom............ Used by SumRandom
 |    |
 |    +---AddedRandom............ Used by SumRandom
 |    |
 |    +---SubtractedRandom....... Used by SumRandom
 |
 +---ShiftedRandom............... Used by SumRandom
 |    |
 |    +---ReverseShiftedRandom... Used by SumRandom
 |    |
 |    +---ScaledRandom........... Used by SumRandom
 |
 +---NegatedRandom.......... .... Used by SumRandom
 |
 +---RepeatedRandom.............. Used by SumRandom
 |
 +---AddedSelectedRandom......... Used by MixedRandom
 |
 +---SelectedRandom.............. Used by MixedRandom

RandomPermutation................ Random permutation
 |
 +---RandomCombination........... Sorted random permutation

 

To do:

  • More modern alternatives to the LGM generator;
  • Additional generator classes;
  • Better methods for combinations and permutations with large N and small M;
  • An alternative (slower) class for Poisson with short setup time.

 

History:

August, 1998 - update exception package; work around problem with MS VC++ 5

January, 1998 - version compatible with newmat09

1995 - newran version, additional distributions

1989 - initial version

Go to top

To online documentation page 

SelectedRandom, AddedSelectedRandom:

These are used by SumRandom and MixedRandom.

 

8.0) ? 0 : 0.398942280 * exp(-x*x / 2); } Real NORMAL10(Real x) { return 0.5*phi(0.5*(x-10.0)); } Real UNIF(Real x) { return (x>=0.0 && x<=1.0) ? 1.0 : 0.0; } Real TRIANG(Real x) { return (x>1.0) ? 0.0 : 1.0-x; } void test1(int n) { Normal nn; Uniform uniform; { for (int i=0; i<20; i++) cout << nn.Next() << "\n" << flush; } { Constant c(5.0); Histogram(&c, n); } { Uniform u; Histogram(&u, n); } { SumRandom sr=uniform(3)-1.5; Histogram(&sr, n); } { SumRandom sr=uniform-uniform; Histogram(&sr, n); } { Normal normal; Histogram(&normal, n); } { Cauchy cauchy; Histogram(&cauchy, n); } { AsymGenX normal10(NORMAL10, 10.0); Histogram(&normal10, n); } cout << "Mean and variance should be 10.0 and 4.0" << endl; { AsymGenX uniform2(UNIF,0.5); Histogram(&uniform2, n); } cout << "Mean and variance should be 0.5 and 0.083333" << endl; { SymGenX triang(TRIANG); Histogram(&triang, n); } cout << "Mean and variance should be 0 and 0.16667" << endl; { Poisson p(0.25); Histogram(&p, n); } { Poisson p(10.0); Histogram(&p, n); } { Poisson p(16.0); Histogram(&p, n); } { Binomial b(18,0.3); Histogram(&b, n); } { Binomial b(19,0.3); Histogram(&b, n); } { Binomial b(20,0.3); Histogram(&b, n); } { Binomial b(58,0.3); Histogram(&b, n); } { Binomial b(59,0.3); Histogram(&b, n); } { Binomial b(60,0.3); Histogram(&b, n); } { Binomial b(18,0.05); Histogram(&b, n); } { Binomial b(19,0.05); Histogram(&b, n); } { Binomial b(20,0.05); Histogram(&b, n); } { Binomial b(98,0.01); Histogram(&b, n); } { Binomial b(99,0.01); Histogram(&b, n); } { Binomial b(100,0.01); Histogram(&b, n); } { Binomial b(18,0.95); Histogram(&b, n); } { Binomial b(19,0.95); Histogram(&b, n); } { Binomial b(20,0.95); Histogram(&b, n); } { Binomial b(98,0.99); Histogram(&b, n); } { Binomial b(99,0.99); Histogram(&b, n); } { Binomial b(100,0.99); Histogram(&b, n); } { NegativeBinomial nb(100,6.0); Histogram(&nb, n); } { NegativeBinomial nb(11,9.0); Histogram(&nb, n); } { NegativeBinomial nb(11,1.9); Histogram(&nb, n); } { NegativeBinomial nb(11,0.10); Histogram(&nb, n); } { NegativeBinomial nb(1.5,1.9); Histogram(&nb, n); } { NegativeBinomial nb(1.0,1.9); Histogram(&nb, n); } { NegativeBinomial nb(0.3,19); Histogram(&nb, n); } { NegativeBinomial nb(0.3,1.9); Histogram(&nb, n); } { NegativeBinomial nb(0.3,0.05); Histogram(&nb, n); } { NegativeBinomial nb(100.8,0.18); Histogram(&nb, n); } { ChiSq c(1,2.0); Histogram(&c, n); } { ChiSq c(2,2.0); Histogram(&c, n); } { ChiSq c(3,2.0); Histogram(&c, n); } { ChiSq c(4,2.0); Histogram(&c, n); } { ChiSq c(1 ); Histogram(&c, n); } { ChiSq c(2 ); Histogram(&c, n); } { ChiSq c(3 ); Histogram(&c, n); } { ChiSq c(4 ); Histogram(&c, n); } { Gamma g1(1.0); Histogram(&g1, n); } { Gamma g2(0.5); Histogram(&g2, n); } { Gamma g3(1.01); Histogram(&g3, n); } { Gamma g4(2.0); Histogram(&g4, n); } { Pareto p1(0.5); Histogram(&p1, n); } { Pareto p2(1.5); Histogram(&p2, n); } { Pareto p3(2.5); Histogram(&p3, n); } { Pareto p4(4.5); Histogram(&p4, n); } Real probs[]={.1,.3,.05,.11,.05,.04,.05,.05,.1,.15}; Real val[]={2,3,4,6,8,12,16,24,32,48}; { DiscreteGen discrete(10,probs); Histogram(&discrete, n); } { DiscreteGen discrete(10,probs,val); Histogram(&discrete, n); } } ./scope1.0.2000.11.14/rnd/tryrand2.cpp010064400007730000024000000055640720365252100162670ustar00patarg00001250000004#define WANT_STREAM #include "include.h" #include "newran.h" #ifdef use_namespace using namespace NEWRAN; #endif void Histogram(Random*, int); // draw histogram with n obsv void test2(int n) { { Uniform u; SumRandom sr1 = -u; SumRandom sr2 = 5.0-u; SumRandom sr3 = 5.0-2*u; MixedRandom sr4 = u(0.5) + (-u)(0.5); Histogram(&sr1,n); cout << "Mean and variance should be -0.5 and 0.083333" << endl; Histogram(&sr2,n); cout << "Mean and variance should be 4.5 and 0.083333" << endl; Histogram(&sr3,n); cout << "Mean and variance should be 4.0 and 0.33333" << endl; Histogram(&sr4,n); cout << "Mean and variance should be 0.0 and 0.33333" << endl; } { Uniform u; SumRandom sr1 = u*u; SumRandom sr2 = (u-0.5)*(u-0.5); Histogram(&sr1,n); cout << "Mean and variance should be 0.25 and 0.048611" << endl; Histogram(&sr2,n); cout << "Mean and variance should be 0.0 and 0.006944" << endl; } { static Real probs[]={.4,.2,.4}; DiscreteGen discrete(3,probs); Normal nn; SumRandom sr=discrete+(nn*0.25)(2)+10.0; Histogram(&discrete,n); Histogram(&sr,n); } { static Real probs[]={.2,.8}; Random* rv[2]; Normal nn; SumRandom snn=nn*10.0; rv[0]=&snn; rv[1]=&nn; MixedRandom mr(2,probs,rv); MixedRandom mr2=snn(.2)+nn(.8); Histogram(&mr2,n); Histogram(&mr,n); } { Normal nn; Constant c1(0.0); Constant c2(10.0); MixedRandom mr=c1(0.25)+(nn+5.0)(0.5)+c2(0.25); Histogram(&mr,n); } { Cauchy cy; Normal nn; SumRandom sr = cy*.01+nn+2.0; MixedRandom mr=sr(0.1)+nn(0.9); Histogram(&sr,n); Histogram(&mr,n); } { Constant c0(0.0); Constant c1(1.0); Constant c2(2.0); Constant c3(3.0); Constant c4(4.0); Constant c5(5.0); MixedRandom mr=c0(.1)+c1(.2)+c2(.2)+c3(.2)+c4(.2)+c5(.1); Histogram(&mr,n); } { Uniform u; Normal nl; MixedRandom m=( u(3)-1.5 )(0.5)+( nl*0.5+10.0 )(0.5); Histogram(&m,n); } { Real prob[] = { .25, .25, .25, .25 }; Real val[] = { 3, 1.5, 1, 0.75 }; DiscreteGen X(4, prob, val); SumRandom Y = 1/X; Histogram(&Y,n); // mean should be 0.83333, variance should be 0.13889 cout << "Mean and variance should be 0.83333 and 0.13889" << endl; Uniform U; SumRandom Z = U/X; Histogram(&Z,n); // mean should be 0.41667, variance should be 0.10417 cout << "Mean and variance should be 0.41667 and 0.10417" << endl; } { int M = 5, N = 9; ChiSq Num(M); ChiSq Den(N); SumRandom F = (double)N/(double)M * Num / Den; Histogram(&F,n); cout << "Mean and variance should be " << N / (double)(N-2) << " and " << 2 * N * N * (M+N-2) / (double)(M * (N-2) * (N-2) * (N-4)) << endl; } } ./scope1.0.2000.11.14/rnd/tryrand3.cpp010064400007730000024000000356130720365252200162670ustar00patarg00001250000004#define WANT_STREAM #define WANT_MATH #include "include.h" #include "newran.h" #ifdef use_namespace using namespace NEWRAN; #endif void SortAscending(Real* data, int max); Real KS(Real* data, int n); Real NormalDF(Real x); double invchi95(int N); double invchi99(int N); void ChiSquaredTest(int* Observed, Real* Prob, int N, int n); void TestBinomial(int N, Real p, int n); void TestPoisson(Real mu, int n); void TestNegativeBinomial(Real NX, Real p, int n); void TestDiscreteGen(int N, Real* prob, int n); inline Real square(Real x) { return x*x; } inline Real cube(Real x) { return x*x*x; } void test3(int n) { cout << endl; // Do chi-squared tests to discrete data cout << "ChiSquared tests" << endl; { Real p[] = { 0.05, 0.10, 0.05, 0.5, 0.01, 0.01, 0.03, 0.20, 0.05 }; TestDiscreteGen(9, p, n); } { Real p[] = { 0.4, 0.2, 0.1, 0.05, 0.025, 0.0125, 0.00625, 0.00625, 0.2 }; TestDiscreteGen(9, p, n); } TestNegativeBinomial(200.3, 0.05, n); TestNegativeBinomial(150.3, 0.15, n); TestNegativeBinomial(100.8, 0.18, n); TestNegativeBinomial(100.8, 1.22, n); TestNegativeBinomial(100.8, 9.0, n); TestNegativeBinomial(10.5, 0.18, n); TestNegativeBinomial(10.5, 1.22, n); TestNegativeBinomial(10.5, 9.0, n); TestNegativeBinomial(0.35, 0.18, n); TestNegativeBinomial(0.35, 1.22, n); TestNegativeBinomial(0.35, 9.0, n); TestBinomial(100, 0.45, n); TestBinomial(100, 0.25, n); TestBinomial(100, 0.02, n); TestBinomial(100, 0.01, n); TestBinomial(49, 0.60, n); TestBinomial(21, 0.70, n); TestBinomial(10, 0.90, n); TestBinomial(10, 0.25, n); TestBinomial(10, 0.10, n); TestPoisson(0.75, n); TestPoisson(4.3, n); TestPoisson(10, n); TestPoisson(100, n); Real* data = new Real[n]; if (!data) Throw(Bad_alloc()); // Apply KS test to a variety of continuous distributions // - use cdf transform to convert to uniform cout << endl; cout << "Kolmogorov-Smirnoff tests" << endl; cout << "25%, 5%, 1%, .1% upper points are 1.019, 1.358, 1.628, 1.950" << endl; cout << "5% lower point is 0.520" << endl; { ChiSq X(1, 1.44); for (int i = 0; i < n; i++) { Real x = sqrt(X.Next()); data[i] = NormalDF(x - 1.2) - NormalDF(-x - 1.2); } cout << X.Name() << ": " << KS(data, n) << endl; } { ChiSq X(4); for (int i = 0; i < n; i++) { Real x = 0.5 * X.Next(); data[i] = (1+x)*exp(-x); } cout << X.Name() << ": " << KS(data, n) << endl; } { ChiSq X(2); for (int i = 0; i < n; i++) data[i] = exp(-0.5 * X.Next()); cout << X.Name() << ": " << KS(data, n) << endl; } { Pareto X(0.5); for (int i = 0; i < n; i++) { Real x = X.Next(); data[i] = 1.0 / sqrt(x); } cout << X.Name() << ": " << KS(data, n) << endl; } { Pareto X(1.5); for (int i = 0; i < n; i++) { Real x = X.Next(); data[i] = 1.0 / (x * sqrt(x)); } cout << X.Name() << ": " << KS(data, n) << endl; } { Normal X; for (int i = 0; i < n; i++) { Real x = X.Next(); data[i] = NormalDF(x); } cout << X.Name() << ": " << KS(data, n) << endl; } { Normal N; SumRandom X = 10 + 5 * N; for (int i = 0; i < n; i++) { Real x = X.Next(); data[i] = NormalDF((x-10)/5); } cout << X.Name() << ": " << KS(data, n) << endl; } { Normal N; Cauchy C; MixedRandom X = N(0.9) + C(0.1); for (int i = 0; i < n; i++) { Real x = X.Next(); data[i] = 0.9*NormalDF(x)+0.1*(atan(x)/3.141592654 + 0.5); } cout << X.Name() << ": " << KS(data, n) << endl; } { Normal N; MixedRandom X = N(0.9) + (10*N)(0.1); for (int i = 0; i < n; i++) { Real x = X.Next(); data[i] = 0.9*NormalDF(x)+0.1*NormalDF(x/10); } cout << X.Name() << ": " << KS(data, n) << endl; } { Normal X0; SumRandom X = X0 * 0.6 + X0 * 0.8; for (int i = 0; i < n; i++) { Real x = X.Next(); data[i] = NormalDF(x); } cout << X.Name() << ": " << KS(data, n) << endl; } { Normal X1; MixedRandom X = X1(0.2) + (X1 * 2.5 + 1.1)(0.35) + (X1 + 2.3)(0.45); for (int i = 0; i < n; i++) { Real x = X.Next(); data[i] = 0.20 * NormalDF(x) + 0.35 * NormalDF((x - 1.1) / 2.5) + 0.45 * NormalDF(x - 2.3); } cout << X.Name() << ": " << KS(data, n) << endl; } { Gamma X(0.5); for (int i = 0; i < n; i++) { Real x = X.Next(); data[i] = 2.0 * NormalDF(-sqrt(2 * x)); } cout << X.Name() << ": " << KS(data, n) << endl; } { Gamma X(3); for (int i = 0; i < n; i++) { Real x = X.Next(); data[i] = (1+x+0.5*x*x)*exp(-x); } cout << X.Name() << ": " << KS(data, n) << endl; } { Gamma X1(0.85); Gamma X2(2.15); SumRandom X = X1 + X2; for (int i = 0; i < n; i++) { Real x = X.Next(); data[i] = (1+x+0.5*x*x)*exp(-x); } cout << X.Name() << ": " << KS(data, n) << endl; } { Gamma X1(0.75); Gamma X2(0.25); SumRandom X = X1 + X2; for (int i = 0; i < n; i++) data[i] = exp(-X.Next()); cout << X.Name() << ": " << KS(data, n) << endl; } { Gamma X(2); for (int i = 0; i < n; i++) { Real x = X.Next(); data[i] = (1+x)*exp(-x); } cout << X.Name() << ": " << KS(data, n) << endl; } { Exponential X; for (int i = 0; i < n; i++) data[i] = exp(-X.Next()); cout << X.Name() << ": " << KS(data, n) << endl; } { Cauchy X; for (int i = 0; i < n; i++) data[i] = atan(X.Next())/3.141592654 + 0.5; cout << X.Name() << ": " << KS(data, n) << endl; } { Cauchy X0; SumRandom X = X0 * 0.3 + X0 * 0.7; for (int i = 0; i < n; i++) data[i] = atan(X.Next())/3.141592654 + 0.5; cout << X.Name() << ": " << KS(data, n) << endl; } { Uniform X; for (int i = 0; i < n; i++) data[i] = X.Next(); cout << X.Name() << ": " << KS(data, n) << endl; } delete [] data; } /*************************** Kolmogorov Smirnov Test ************************/ // test the data in the array (length n) for being uniform (0,1) Real KS(Real* data, int n) { SortAscending(data, n); Real D = 0.0; for (int i = 0; i < n; i++) { Real d1 = (Real)(i+1) / (Real)n - data[i]; Real d2 = data[i] - (Real)i / (Real)n; if (D < d1) D = d1; if (D < d2) D = d2; } return D * (sqrt(n) + 0.12 + 0.11 / sqrt(n)); } /******************************** Quick sort ********************************/ // Quicksort. // Essentially the method described in Sedgewick's algorithms in C++ // My version is still partially recursive, unlike Segewick's, but the // smallest segment of each split is used in the recursion, so it should // not overlead the stack. // If the process does not seems to be converging an exception is thrown. #define DoSimpleSort 17 // when to switch to insert sort #define MaxDepth 50 // maximum recursion depth static Real SortThreeDescending(Real* a, Real* b, Real* c); static void MyQuickSortAscending(Real* first, Real* last, int depth); static void InsertionSortAscending(Real* first, const int length, int guard); static Real SortThreeDescending(Real* a, Real* b, Real* c) { // sort *a, *b, *c; return *b; optimise for already sorted if (*a >= *b) { if (*b >= *c) return *b; else if (*a >= *c) { Real x = *c; *c = *b; *b = x; return x; } else { Real x = *a; *a = *c; *c = *b; *b = x; return x; } } else if (*c >= *b) { Real x = *c; *c = *a; *a = x; return *b; } else if (*a >= *c) { Real x = *a; *a = *b; *b = x; return x; } else { Real x = *c; *c = *a; *a = *b; *b = x; return x; } } void SortAscending(Real* data, int max) { if (max > DoSimpleSort) MyQuickSortAscending(data, data + max - 1, 0); InsertionSortAscending(data, max, DoSimpleSort); } static void InsertionSortAscending(Real* first, const int length, int guard) // guard gives the length of the sequence to scan to find first // element (eg guard = length) { if (length <= 1) return; // scan for first element Real* f = first; Real v = *f; Real* h = f; if (guard > length) guard = length; int i = guard - 1; while (i--) if (v > *(++f)) { v = *f; h = f; } *h = *first; *first = v; // do the sort i = length - 1; f = first; while (i--) { Real* g = f++; h = f; v = *h; while (*g > v) *h-- = *g--; *h = v; } } static void MyQuickSortAscending(Real* first, Real* last, int depth) { for (;;) { const int length = last - first + 1; if (length < DoSimpleSort) return; if (depth++ > MaxDepth) Throw(Exception("QuickSortAscending fails")); Real* centre = first + length/2; const Real test = SortThreeDescending(last, centre, first); Real* f = first; Real* l = last; for (;;) { while (*(++f) < test) {} while (*(--l) > test) {} if (l <= f) break; const Real temp = *f; *f = *l; *l = temp; } if (f > centre) { MyQuickSortAscending(l+1, last, depth); last = f-1; } else { MyQuickSortAscending(first, f-1, depth); first = l+1; } } } Real NormalDF(Real x) { // from Abramowitz and Stegun - accuracy 7.5E-8 // accuracy is absolute; not relative // eventually will need a better method // but good enough here Real t = 1.0 / (1.0 + 0.2316419 * fabs(x)); t = ( 0.319381530 + (-0.356563782 + ( 1.781477937 + (-1.821255978 + 1.330274429 * t) * t) * t) * t) * t; t = 0.3989422804014326779399461 * exp(-0.5 * x * x) * t; return (x < 0) ? t : 1.0 - t; } void ChiSquaredTest(int* Observed, Real* Prob, int N, int n) { // go for at least two expected observations per cell // work in from ends if (N <= 0) { cout << "no categories" << endl; return; } if (n <= 0) { cout << "no data" << endl; return; } int O1 = 0; Real E1 = 0.0; int O2 = 0; Real E2 = 0.0; Real CS = 0.0; int df = 0; int i = 0; int Ni = N; Real ToGo = n; for (;;) { O1 += Observed[i]; Real e1 = n * Prob[i]; E1 += e1; ToGo -= e1; if (E1 >= 2.0 && ToGo + E2 >= 2.0) { CS += square(O1 - E1) / E1; df += 1; O1 = 0; E1 = 0.0; } if (i == Ni) break; ++i; O2 += Observed[Ni]; Real e2 = n * Prob[Ni]; E2 += e2; ToGo -= e2; if (E2 >= 2.0 && ToGo + E1 >= 2.0) { CS += square(O2 - E2) / E2; df += 1; O2 = 0; E2 = 0.0; } if (i == Ni) break; --Ni; } E1 += E2; O1 += O2; if (E1 > 0.0) { CS += square(O1 - E1) / E1; df += 1; } if (fabs(ToGo) >= 0.01) cout << "chi-squared program fails - "; cout << "chisq = " << CS << "; df = " << (df-1) << "; 95% pt. = " << invchi95(df-1) << "; 99% pt. = " << invchi99(df-1) << endl; } void TestBinomial(int N, Real p, int n) { Binomial X(N, p); Real q = 1.0 - p; Real ln_p = log(p); Real ln_q = log(q); int* obs = new int [N+1]; if (!obs) Throw(Bad_alloc()); Real* prob = new Real [N+1]; if (!prob) Throw(Bad_alloc()); int i; for (i = 0; i <= N; i++) { obs[i] = 0; prob[i] = exp(ln_gamma(N+1) - ln_gamma(i+1) - ln_gamma(N-i+1) + i * ln_p + (N-i) * ln_q); } for (i = 0; i < n; i++) { int b = (int)X.Next(); if (b < 0 || b > N) Throw(Logic_error("Binomial error")); obs[b]++; } cout << "Binomial: "; ChiSquaredTest(obs, prob, N, n); delete [] obs; delete [] prob; } void TestPoisson(Real mu, int n) { Poisson X(mu); Real ln_mu = log(mu); int N = (int)(20 + mu + 10 * sqrt(mu)); // set upper bound if (N > n) { cout << "Poisson: range too large" << endl; return; } int* obs = new int [N+1]; if (!obs) Throw(Bad_alloc()); Real* prob = new Real [N+1]; if (!prob) Throw(Bad_alloc()); int i; for (i = 0; i <= N; i++) { obs[i] = 0; prob[i] = exp(i * ln_mu - mu - ln_gamma(i+1)); } for (i = 0; i < n; i++) { int b = (int)(X.Next()); if (b < 0 || b > N) Throw(Logic_error("Poisson error")); obs[b]++; } cout << "Poisson: "; ChiSquaredTest(obs, prob, N, n); delete [] obs; delete [] prob; } void TestNegativeBinomial(Real NX, Real P, int n) { NegativeBinomial X(NX, P); Real Q = 1.0 + P; Real p = 1.0 / Q; Real q = 1.0 - p; Real ln_p = log(p); Real ln_q = log(q); Real mean = NX * P; Real var = mean * Q; int N = (int)(20 + mean + 100 * sqrt(var)); // set upper bound // won't be good enough for large P if (N > n) { cout << "NegativeBinomial: range too large" << endl; return; } int* obs = new int [N+1]; if (!obs) Throw(Bad_alloc()); Real* prob = new Real [N+1]; if (!prob) Throw(Bad_alloc()); int i; for (i = 0; i <= N; i++) { obs[i] = 0; prob[i] = exp(ln_gamma(NX+i) - ln_gamma(i+1) - ln_gamma(NX) + NX * ln_p + i * ln_q); } for (i = 0; i < n; i++) { int b = (int)X.Next(); if (b < 0 || b > N) Throw(Logic_error("NegativeBinomial error")); obs[b]++; } cout << "NegativeBinomial: "; ChiSquaredTest(obs, prob, N, n); delete [] obs; delete [] prob; } void TestDiscreteGen(int N, Real* prob, int n) { DiscreteGen X(N, prob); int* obs = new int [N]; if (!obs) Throw(Bad_alloc()); int i; for (i = 0; i < N; i++) obs[i] = 0; for (i = 0; i < n; i++) { int b = (int)X.Next(); if (b < 0 || b >= N) Throw(Logic_error("DiscreteGen error")); obs[b]++; } cout << "DiscreteGen: "; ChiSquaredTest(obs, prob, N-1, n); delete [] obs; } // Calculate 95% point of chi-squared distribution double invchi95(int N) // upper 95% point of chi-squared distribution { if (N < 0) Throw(Logic_error("Error in invchi95 arg")); if (N < 30) { double Q[] = { 0, 3.841459, 5.991465, 7.814728, 9.487729, 11.0705, 12.59159, 14.06714, 15.50731, 16.91898, 18.30704, 19.67506, 21.02601, 22.36199, 23.68475, 24.99576, 26.2962, 27.58709, 28.86928, 30.14351, 31.4104, 32.6705, 33.9244, 35.1725, 36.4151, 37.6525, 38.8852, 40.1133, 41.3372, 42.5569 }; return Q[N]; } else { double A = 1.0/(4.5 * N); double H = (-0.0002 * 60)/N; double Q = N * cube(1 - A + (1.645 - H) * sqrt(A)); return Q; } } // Calculate 99% point of chi-squared distribution double invchi99(int N) // upper 99% point of chi-squared distribution { if (N < 0) Throw(Logic_error("Error in invchi99 arg")); if (N < 30) { double Q[] = { 0, 6.63490, 9.21034, 11.3449, 13.2767, 15.0863, 16.8119, 18.4753, 20.0902, 21.6660, 23.2093, 24.7250, 26.2170, 27.6883, 29.1413, 30.5779, 31.9999, 33.4087, 34.8053, 36.1908, 37.5662, 38.9321, 40.2894, 41.6384, 42.9798, 44.3141, 45.6417, 46.9630, 48.2782, 49.5879 }; return Q[N]; } else { double A = 1.0/(4.5 * N); double H = (0.0008 * 60)/N; double Q = N * cube(1 - A + (2.326 - H) * sqrt(A)); return Q; } } .15); SumRandom X = X1 + X2; for (int i = 0; i < n; i++) { Real x = X.Next(); data[i] = (1+x+0.5*x*x)*./scope1.0.2000.11.14/rnd/tryrand4.cpp010064400007730000024000000026540720365252200162670ustar00patarg00001250000004#define WANT_STREAM #include "include.h" #include "newran.h" #ifdef use_namespace using namespace NEWRAN; #endif void test4(int) { cout << endl << endl; { cout << "Doing permutations" << endl; RandomPermutation RP; int i, j; int p[10]; cout << "... select 10 items from 100...119 without replacement" << endl; for (i = 1; i <= 10; i++) { RP.Next(20,10,p,100); for (j = 0; j < 10; j++) cout << p[j] << " "; cout << "\n"; } cout << "\n"; cout << "... select 10 items from 100...109 without replacement" << endl; for (i = 1; i <= 10; i++) { RP.Next(10,10,p,100); for (j = 0; j < 10; j++) cout << p[j] << " "; cout << "\n"; } cout << "\n"; } cout << endl << endl; { cout << "Doing combinations" << endl; RandomCombination RC; int i, j; int p[10]; cout << "... select 10 items from 100...119 without replacement" << endl; for (i = 1; i <= 10; i++) { RC.Next(20,10,p,100); for (j = 0; j < 10; j++) cout << p[j] << " "; cout << "\n"; } cout << "\n"; cout << "... select 10 items from 100...109 without replacement" << endl; for (i = 1; i <= 10; i++) { RC.Next(10,10,p,100); for (j = 0; j < 10; j++) cout << p[j] << " "; cout << "\n"; } cout << "\n"; } } ./scope1.0.2000.11.14/GNUmakefile010064400007730000024000000007720720365247300153070ustar00patarg00001250000004 TARG := sim OBJS := sim.o station.o source.o param.o SRCS := $(OBJS:%.o=%.cc) HDRS := station.hh source.hh param.hh DEPS := $(OBJS:%.o=%.d) CPPFLAGS := -Irnd CXXFLAGS := -O LDFLAGS := -Lrnd -lnewran -lm .PHONY: clean .PHONY: tidy .PHONY: depend .SECONDARY: $(OBJS) .SECONDARY: $(DEPS) $(TARG): $(OBJS) rnd/libnewran.a $(CXX) $(CXXFLAGS) -o $@ $(OBJS) $(LDFLAGS) clean: tidy rm -f $(TARG) rm -f $(DEPS) tidy: rm -f $(OBJS) %.d: %.cc $(CXX) -MM $(CPPFLAGS) $(CXXFLAGS) $< > $@ include $(DEPS) ./scope1.0.2000.11.14/README010064400007730000024000000003270720423721300141010ustar00patarg00001250000004To make any real use of this code, you'll have to edit the main loop in sim.cc to output the quantities that interest you. Currently, the main loop is set up to plot mean squared-error vs. the number of detectors. ./scope1.0.2000.11.14/param.cc010064400007730000024000000045320720365247400146430ustar00patarg00001250000004 #include #include #include "param.hh" bool Param::usePoisson = true; unsigned int Param::stationCount = 8192; double Param::sampleRate = 400.0; unsigned int Param::sources = 1; double Param::detectorDeviation = 800.0; double Param::heightDeviation = 0.8; double Param::timeDeviation = 0.001; double Param::sourceOffset = 1024.0; double Param::sourceAmplitude = 2.0; double Param::sourceFrequency = 100.0; double Param::radiusOfEarth = 6378136.0; /* at the equator */ double Param::speedOfLight = 299792458.0; void Param::ReadParams( istream& in ) { for ( ;; ) { char buf[8192]; in >> buf; if ( !in.good() ) { break; } string name( buf ); if ( name == "usePoisson" ) { usePoisson = true; } else if ( name == "noUsePoisson" ) { usePoisson = false; } else if ( name == "stationCount" ) { in >> stationCount; } else if ( name == "sampleRate" ) { in >> sampleRate; } else if ( name == "sources" ) { in >> sources; } else if ( name == "detectorDeviation" ) { in >> detectorDeviation; } else if ( name == "heightDeviation" ) { in >> heightDeviation; } else if ( name == "timeDeviation" ) { in >> timeDeviation; } else if ( name == "sourceOffset" ) { in >> sourceOffset; } else if ( name == "sourceAmplitude" ) { in >> sourceAmplitude; } else if ( name == "sourceFrequency" ) { in >> sourceFrequency; } else if ( name == "radiusOfEarth" ) { in >> radiusOfEarth; } else if ( name == "speedOfLight" ) { in >> speedOfLight; } else { cerr << "Unknown param: " << name << endl; } } } void Param::WriteParams( ostream& out ) { if ( usePoisson ) { out << "# usePoisson" << endl; } else { out << "# noUsePoisson" << endl; } out << "# stationCount " << stationCount << endl; out << "# sampleRate " << sampleRate << endl; out << "# sources " << sources << endl; out << "# detectorDeviation " << detectorDeviation << endl; out << "# heightDeviation " << heightDeviation << endl; out << "# timeDeviation " << timeDeviation << endl; out << "# sourceOffset " << sourceOffset << endl; out << "# sourceAmplitude " << sourceAmplitude << endl; out << "# sourceFrequency " << sourceFrequency << endl; out << "# radiusOfEarth " << radiusOfEarth << endl; out << "# speedOfLight " << speedOfLight << endl; } ./scope1.0.2000.11.14/param.hh010064400007730000024000000010210720365247400146430ustar00patarg00001250000004 class Param { public: static bool usePoisson; static unsigned int stationCount; static double sampleRate; static unsigned int sources; static double detectorDeviation; static double heightDeviation; static double timeDeviation; static double sourceOffset; static double sourceAmplitude; static double sourceFrequency; static double radiusOfEarth; static double speedOfLight; public: static void ReadParams( istream& in ); static void WriteParams( ostream& out ); }; ./scope1.0.2000.11.14/params.in010064400007730000024000000003040720423721400150300ustar00patarg00001250000004usePoisson stationCount 500 sampleRate 1024 sources 1 detectorDeviation 2000.0 heightDeviation 0.8 timeDeviation 0.01 sourceOffset 10000 sourceAmplitude 10 sourceFrequency 100 speedOfLight 3e+09 ./scope1.0.2000.11.14/sim.cc010064400007730000024000000036460720423721400143300ustar00patarg00001250000004 #include #include #include #include "param.hh" #include "source.hh" #include "station.hh" int compare( const void* a, const void* b ) { double aa = *(const double*)a; double bb = *(const double*)b; double dif = aa - bb; if ( dif > 0.000001 ) { return 1; } else if ( dif < -0.000001 ) { return -1; } else { return 0; } } int main( void ) { Random::Set(0.46875); Normal norm; Param::ReadParams( cin ); Param::WriteParams( cout ); Source* srcs = 0; if ( Param::sources > 0 ) { srcs = new Source[ Param::sources ]; Source mainSource( 0.0, 0.0, 1.0 ); srcs[0] = mainSource; } for ( unsigned int kk=10; kk < 1000; kk += 10 ) { double errorAccum = 0.0; unsigned int samples = 0; Param::stationCount = kk; Station* stations = new Station[ Param::stationCount ]; double* detected = new double[ Param::stationCount ]; for ( unsigned int ii=0; ii < Param::stationCount; ++ii ) { stations[ ii ].init( norm ); } double scale = Param::sampleRate / ( Param::sourceAmplitude * Param::sourceFrequency ); for ( double tt = 0.0; tt < 16.0 * M_PI / Param::sourceFrequency; tt += 2.0 * M_PI / Param::sampleRate ) { double signal = Param::sourceOffset / Param::sampleRate; unsigned int dd = 0; if ( Param::sources > 0 ) { signal += srcs[0].signal( tt ); } for ( unsigned int ii=0; ii < Param::stationCount; ++ii ) { detected[dd] = stations[ii].detect( srcs, Param::sources, tt ); if ( detected[dd] >= -0.5 ) { ++dd; } } qsort( detected, dd, sizeof(double), compare ); double res = detected[ dd/2 ]; double err = ( signal - res ); errorAccum += err * err; ++samples; #if 0 cout << tt << " " << res * scale << endl; #endif } cout << kk << " " << errorAccum / samples << endl; delete[] detected; delete[] stations; } delete[] srcs; return 0; } ./scope1.0.2000.11.14/source.cc010064400007730000024000000026450720365247600150500ustar00patarg00001250000004 #include #include #include #include "param.hh" #include "source.hh" Source::Source() { Normal norm; for ( ;; ) { double xx = norm.Next(); double yy = norm.Next(); double zz = norm.Next(); double mag2 = xx*xx + yy*yy + zz*zz; if ( mag2 > 0.000001 ) { double mag = 1.0 / sqrt( mag2 ); dx = xx * mag; dy = yy * mag; dz = zz * mag; break; } } Uniform uu; periodOffset = 2.0 * M_PI * uu.Next(); amplitude = 4.0 * Param::sourceAmplitude * uu.Next() - 2.0 * Param::sourceAmplitude; frequency = 1.5 * Param::sourceFrequency * uu.Next() + 0.1 * Param::sourceFrequency; } Source::Source( double dxx, double dyy, double dzz ) { dx = dxx; dy = dyy; dz = dzz; periodOffset = 0.0; amplitude = Param::sourceAmplitude; frequency = Param::sourceFrequency; } Source::Source( const Source& a ) { dx = a.dx; dy = a.dy; dz = a.dz; periodOffset = a.periodOffset; amplitude = a.amplitude; frequency = a.frequency; } double Source::signal( double t ) { /* ** Integral of A + B sin( t ) ** is: At - B cos( t ) */ double t1 = t - 0.5 / Param::sampleRate; double t2 = t + 0.5 / Param::sampleRate; double a1 = frequency * t1 + periodOffset; double a2 = frequency * t2 + periodOffset; double ideal = - amplitude * ( cos( a2 ) - cos( a1 ) ) / frequency; return ideal; } ./scope1.0.2000.11.14/source.hh010064400007730000024000000004240720365247600150530ustar00patarg00001250000004 class Source { public: double dx; double dy; double dz; double periodOffset; double amplitude; double frequency; public: Source(); Source( double dxx, double dyy, double dzz ); Source( const Source& a ); double signal( double t ); }; ./scope1.0.2000.11.14/station.cc010064400007730000024000000032420720413662600152160ustar00patarg00001250000004 #include #include #include #include "param.hh" #include "source.hh" #include "station.hh" void Station::init( Normal& nn ) { norm = &nn; double s3 = sqrt(3.0); ex = Param::heightDeviation * norm->Next() / s3; ey = Param::heightDeviation * norm->Next() / s3; ez = Param::heightDeviation * norm->Next() / s3; for ( ;; ) { double xx = norm->Next(); double yy = norm->Next(); double zz = norm->Next(); double mag2 = xx*xx + yy*yy + zz*zz; if ( mag2 > 0.000001 ) { double mag = Param::radiusOfEarth / sqrt( mag2 ); x = xx * mag; y = yy * mag; z = zz * mag; /* ** hack to keep all of the detectors in the ** northern hemisphere */ if ( x < 0.0 ) { z = -z; } break; } } timeOffset = z / Param::speedOfLight; } double Station::detect( Source* srcs, unsigned int nSrcs, double t ) { double ideal = Param::sourceOffset / Param::sampleRate; for ( unsigned int ii=0; ii < nSrcs; ++ii ) { double srcDT = ( srcs[ii].dx * x + srcs[ii].dy * y + srcs[ii].dz * z ) / Param::speedOfLight; double eh = ( srcs[ii].dx * ex + srcs[ii].dy * ey + srcs[ii].dz * ez ) / Param::speedOfLight; double et = Param::timeDeviation * norm->Next(); if ( srcDT > 0.0 ) { ideal += srcs[ii].signal( t + timeOffset - srcDT + eh + et ); } else if ( ii == 0 ) { /* bail if this detector cannot possibly see the primary */ return -1.0; } } double detectorNoise = norm->Next() * Param::detectorDeviation / Param::sampleRate; if ( Param::usePoisson ) { Poisson pp( ideal ); return pp.Next() + detectorNoise; } else { return ideal + detectorNoise; } } ./scope1.0.2000.11.14/station.hh010064400007730000024000000004070720365247700152360ustar00patarg00001250000004 class Station { Normal* norm; double ex; double ey; double ez; double timeOffset; public: double x; double y; double z; public: void init( Normal& nn ); double detect( Source* srcs, unsigned int nSrcs, double t ); }; ./scope1.0.2000.11.14/data/004075500007730000024000000000000720425474700141465ustar00patarg00001250000004./scope1.0.2000.11.14/data/a.dat010064400007730000024000000007170720407057200150520ustar00patarg00001250000004# usePoisson # stationCount 1 # sampleRate 1000 # detectorDeviation 0 # heightDeviation 0.8 # timeDeviation 1e-05 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # speedOfLight 3e+09 0 -6 0.00628319 5 0.0125664 4 0.0188496 -4 0.0251327 -1 0.0314159 -4 0.0376991 -7 0.0439823 -5 0.0502655 1 0.0565487 -6 0.0628319 0 0.069115 -1 0.0753982 -2 0.0816814 2 0.0879646 5 0.0942478 2 0.100531 0 0.106814 -2 0.113097 -5 0.119381 0 0.125664 0 # MSE 134.876 ./scope1.0.2000.11.14/data/a.in010064400007730000024000000003170720365247700147150ustar00patarg00001250000004usePoisson stationCount 1 sampleRate 1000 detectorDeviation 100.0 detectorDeviation 0.0 heightDeviation 0.8 timeDeviation 0.00001 sourceOffset 10000 sourceAmplitude 10 sourceFrequency 100 speedOfLight 3e+09 ./scope1.0.2000.11.14/data/b.dat010064400007730000024000000010110720407057300150400ustar00patarg00001250000004# usePoisson # stationCount 50 # sampleRate 1000 # detectorDeviation 0 # heightDeviation 0.8 # timeDeviation 1e-05 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # speedOfLight 3e+09 0 -0.02 0.00628319 0.48 0.0125664 1 0.0188496 0.64 0.0251327 0.94 0.0314159 0.08 0.0376991 0.14 0.0439823 -0.64 0.0502655 -0.36 0.0565487 -0.6 0.0628319 0.48 0.069115 1.02 0.0753982 1.16 0.0816814 0.82 0.0879646 0.22 0.0942478 0.26 0.100531 -0.24 0.106814 -1.16 0.113097 -0.44 0.119381 -0.74 0.125664 -1.16 # MSE 98.3853 ./scope1.0.2000.11.14/data/b.in010064400007730000024000000003200720365250000146730ustar00patarg00001250000004usePoisson stationCount 50 sampleRate 1000 detectorDeviation 100.0 detectorDeviation 0.0 heightDeviation 0.8 timeDeviation 0.00001 sourceOffset 10000 sourceAmplitude 10 sourceFrequency 100 speedOfLight 3e+09 ./scope1.0.2000.11.14/data/c.dat010064400007730000024000000010330720407057400150460ustar00patarg00001250000004# usePoisson # stationCount 200 # sampleRate 1000 # detectorDeviation 0 # heightDeviation 0.8 # timeDeviation 1e-05 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # speedOfLight 3e+09 0 -0.125 0.00628319 0.78 0.0125664 1.09 0.0188496 0.85 0.0251327 -0.08 0.0314159 0.51 0.0376991 -0.585 0.0439823 -1.16 0.0502655 -0.95 0.0565487 -0.57 0.0628319 -0.175 0.069115 0.665 0.0753982 0.755 0.0816814 0.985 0.0879646 0.94 0.0942478 0.045 0.100531 -0.835 0.106814 -0.875 0.113097 -1.255 0.119381 -0.495 0.125664 0.25 # MSE 100.284 ./scope1.0.2000.11.14/data/c.in010064400007730000024000000003210720365250100146760ustar00patarg00001250000004usePoisson stationCount 200 sampleRate 1000 detectorDeviation 100.0 detectorDeviation 0.0 heightDeviation 0.8 timeDeviation 0.00001 sourceOffset 10000 sourceAmplitude 10 sourceFrequency 100 speedOfLight 3e+09 ./scope1.0.2000.11.14/data/chiVsN.dat010064400007730000024000000015600720407057500160240ustar00patarg00001250000004# usePoisson # stationCount 500 # sampleRate 1000 # detectorDeviation 2000 # heightDeviation 0.8 # timeDeviation 0.001 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # speedOfLight 3e+09 10 2.87684 30 0.708638 50 0.982015 70 0.369256 90 0.228938 110 0.124272 130 0.116697 150 0.162936 170 0.106925 190 0.191803 210 0.132243 230 0.102674 250 0.164785 270 0.116414 290 0.107714 310 0.0874356 330 0.081715 350 0.0787132 370 0.0703118 390 0.0369384 410 0.0463798 430 0.0447759 450 0.0888952 470 0.0457344 490 0.0986193 510 0.0592167 530 0.0877788 550 0.066042 570 0.0567818 590 0.0432314 610 0.0421138 630 0.0292363 650 0.0345613 670 0.0429515 690 0.0321661 710 0.0711995 730 0.0481838 750 0.0384789 770 0.0377185 790 0.0237208 810 0.0597428 830 0.0329693 850 0.0222681 870 0.0343899 890 0.024384 910 0.0386616 930 0.0374559 950 0.0272407 970 0.0314027 990 0.0156045 ./scope1.0.2000.11.14/data/d.dat010064400007730000024000000010430720407057500150510ustar00patarg00001250000004# usePoisson # stationCount 1000 # sampleRate 1000 # detectorDeviation 0 # heightDeviation 0.8 # timeDeviation 1e-05 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # speedOfLight 3e+09 0 0.085 0.00628319 0.771 0.0125664 0.857 0.0188496 0.928 0.0251327 0.56 0.0314159 0.048 0.0376991 -0.513 0.0439823 -1.104 0.0502655 -0.992 0.0565487 -0.498 0.0628319 -0.036 0.069115 0.649 0.0753982 1.004 0.0816814 0.956 0.0879646 0.533 0.0942478 0.183 0.100531 -0.681 0.106814 -0.783 0.113097 -0.99 0.119381 -0.602 0.125664 -0.157 # MSE 99.8019 ./scope1.0.2000.11.14/data/d.in010064400007730000024000000003220720365250100147000ustar00patarg00001250000004usePoisson stationCount 1000 sampleRate 1000 detectorDeviation 100.0 detectorDeviation 0.0 heightDeviation 0.8 timeDeviation 0.00001 sourceOffset 10000 sourceAmplitude 10 sourceFrequency 100 speedOfLight 3e+09 ./scope1.0.2000.11.14/data/e.dat010064400007730000024000000010650720407057600150570ustar00patarg00001250000004# usePoisson # stationCount 10000 # sampleRate 1000 # detectorDeviation 0 # heightDeviation 0.8 # timeDeviation 1e-05 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # speedOfLight 3e+09 0 0.0028 0.00628319 0.5778 0.0125664 0.9714 0.0188496 0.9646 0.0251327 0.6061 0.0314159 -0.0216 0.0376991 -0.5975 0.0439823 -0.9715 0.0502655 -0.9093 0.0565487 -0.5924 0.0628319 -0.0081 0.069115 0.568 0.0753982 0.9492 0.0816814 0.9484 0.0879646 0.6 0.0942478 0.0204 0.100531 -0.542 0.106814 -0.9968 0.113097 -0.9229 0.119381 -0.5929 0.125664 -0.0007 # MSE 99.95 ./scope1.0.2000.11.14/data/e.in010064400007730000024000000003230720365250200147030ustar00patarg00001250000004usePoisson stationCount 10000 sampleRate 1000 detectorDeviation 100.0 detectorDeviation 0.0 heightDeviation 0.8 timeDeviation 0.00001 sourceOffset 10000 sourceAmplitude 10 sourceFrequency 100 speedOfLight 3e+09 ./scope1.0.2000.11.14/data/m.dat010064400007730000024000000011440720407060000150510ustar00patarg00001250000004# usePoisson # stationCount 1000 # sampleRate 1000 # detectorDeviation 800 # heightDeviation 0.8 # timeDeviation 1e-05 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # speedOfLight 3e+09 0 0.0956305 0.00628319 0.777361 0.0125664 0.856029 0.0188496 0.937875 0.0251327 0.55556 0.0314159 0.0348116 0.0376991 -0.537708 0.0439823 -1.10936 0.0502655 -0.997524 0.0565487 -0.493043 0.0628319 -0.0300001 0.069115 0.608937 0.0753982 1.07028 0.0816814 0.963807 0.0879646 0.508887 0.0942478 0.15822 0.100531 -0.719986 0.106814 -0.777276 0.113097 -0.973905 0.119381 -0.599707 0.125664 -0.141996 # MSE 99.832 ./scope1.0.2000.11.14/data/m.in010064400007730000024000000002740720365250200147200ustar00patarg00001250000004usePoisson stationCount 1000 sampleRate 1000 detectorDeviation 800.0 heightDeviation 0.8 timeDeviation 0.00001 sourceOffset 10000 sourceAmplitude 10 sourceFrequency 100 speedOfLight 3e+09 ./scope1.0.2000.11.14/data/mseVsDet.dat010064400007730000024000000024630720407060000163540ustar00patarg00001250000004# usePoisson # stationCount 500 # sampleRate 1000 # detectorDeviation 2000 # heightDeviation 0.8 # timeDeviation 0.01 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # speedOfLight 3e+09 8000 0.1737 7900 0.283226 7800 0.235634 7700 0.153077 7600 0.189554 7500 0.244342 7400 0.16102 7300 0.279567 7200 0.147272 7100 0.218059 7000 0.231106 6900 0.0803982 6800 0.16652 6700 0.188984 6600 0.193616 6500 0.12522 6400 0.144131 6300 0.19382 6200 0.221264 6100 0.177118 6000 0.235105 5900 0.143669 5800 0.134221 5700 0.0803078 5600 0.200442 5500 0.145119 5400 0.184531 5300 0.146121 5200 0.217478 5100 0.133495 5000 0.093807 4900 0.11181 4800 0.17982 4700 0.113697 4600 0.143492 4500 0.0960508 4400 0.173482 4300 0.0789954 4200 0.149637 4100 0.0948892 4000 0.140942 3900 0.152005 3800 0.13091 3700 0.173286 3600 0.116053 3500 0.121821 3400 0.0749776 3300 0.113119 3200 0.0927124 3100 0.140165 3000 0.102604 2900 0.0789656 2800 0.122326 2700 0.105572 2600 0.13093 2500 0.143619 2400 0.111319 2300 0.1191 2200 0.108044 2100 0.104117 2000 0.10838 1900 0.0860719 1800 0.0984613 1700 0.107648 1600 0.132635 1500 0.0909576 1400 0.0864446 1300 0.100855 1200 0.0957384 1100 0.105285 1000 0.0940391 900 0.100475 800 0.10964 700 0.105815 600 0.0994155 500 0.0891124 400 0.0875405 300 0.0517354 200 0.098168 100 0.0882781 0 0.0944781 ./scope1.0.2000.11.14/data/mseVsN.dat010064400007730000024000000027470720407060100160430ustar00patarg00001250000004# usePoisson # stationCount 500 # sampleRate 1000 # detectorDeviation 2000 # heightDeviation 0.8 # timeDeviation 0.01 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # speedOfLight 3e+09 10 1.7169 20 0.665542 30 0.564112 40 0.436826 50 0.375329 60 0.163143 70 0.24064 80 0.18085 90 0.213563 100 0.144017 110 0.144299 120 0.209372 130 0.193874 140 0.192396 150 0.109359 160 0.176825 170 0.212456 180 0.127122 190 0.091795 200 0.125547 210 0.23874 220 0.149376 230 0.15186 240 0.0791212 250 0.149212 260 0.098251 270 0.119118 280 0.173336 290 0.0884824 300 0.105343 310 0.100772 320 0.189867 330 0.104944 340 0.106046 350 0.0957653 360 0.134654 370 0.102564 380 0.107301 390 0.118695 400 0.148695 410 0.136322 420 0.0817939 430 0.120541 440 0.127387 450 0.10699 460 0.09781 470 0.0868396 480 0.114774 490 0.0925008 500 0.103579 510 0.120038 520 0.117107 530 0.0996217 540 0.0515901 550 0.091209 560 0.0986935 570 0.112528 580 0.097744 590 0.0877787 600 0.0843094 610 0.0725686 620 0.0714266 630 0.104549 640 0.112211 650 0.113616 660 0.108287 670 0.0900392 680 0.0794829 690 0.0556752 700 0.0486801 710 0.105936 720 0.0978727 730 0.0968357 740 0.087711 750 0.0767197 760 0.0966775 770 0.0778375 780 0.0690664 790 0.0752379 800 0.0641825 810 0.109918 820 0.0869738 830 0.0786739 840 0.0948154 850 0.0806635 860 0.0816084 870 0.113721 880 0.106498 890 0.0818988 900 0.0828869 910 0.0954147 920 0.0858041 930 0.0959702 940 0.086786 950 0.108266 960 0.0959751 970 0.104992 980 0.0787114 990 0.0848416 ./scope1.0.2000.11.14/data/mseVsNMany.dat010064400007730000024000000027250720423721500166720ustar00patarg00001250000004# usePoisson # stationCount 500 # sampleRate 1024 # sources 50 # detectorDeviation 2000 # heightDeviation 0.8 # timeDeviation 0.01 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # radiusOfEarth 6.37814e+06 # speedOfLight 3e+09 10 3.17925 15 3.01636 20 1.51714 25 1.8936 30 0.97877 35 1.44742 40 1.57328 45 0.679806 50 0.447274 55 0.684184 60 0.877994 65 0.706024 70 0.63357 75 0.410291 80 0.465111 85 0.437462 90 0.424298 95 0.591949 100 0.341429 105 0.61831 110 0.425415 115 0.333699 120 0.35464 125 0.366124 130 0.291807 135 0.251794 140 0.246714 145 0.208878 150 0.324004 155 0.239412 160 0.247114 165 0.247625 170 0.233536 175 0.258259 180 0.263147 185 0.22118 190 0.221316 195 0.253433 200 0.233705 205 0.23379 210 0.196907 215 0.172688 220 0.205666 225 0.215936 230 0.195241 235 0.145642 240 0.166879 245 0.233473 250 0.155709 255 0.138247 260 0.150498 265 0.152505 270 0.192599 275 0.168793 280 0.140209 285 0.149535 290 0.193127 295 0.161306 300 0.11808 305 0.110158 310 0.138842 315 0.173547 320 0.108393 325 0.141591 330 0.128301 335 0.136284 340 0.144904 345 0.127237 350 0.127645 355 0.121963 360 0.115942 365 0.137101 370 0.157046 375 0.147746 380 0.117393 385 0.110111 390 0.111178 395 0.0907117 400 0.14644 405 0.116588 410 0.110431 415 0.141817 420 0.106418 425 0.0925801 430 0.139185 435 0.109116 440 0.108055 445 0.0915732 450 0.087494 455 0.0986122 460 0.10552 465 0.0967573 470 0.0878666 475 0.101248 480 0.0866599 485 0.111534 490 0.0788912 495 0.0974695 ./scope1.0.2000.11.14/data/mseVsTimeOrder.dat010064400007730000024000000013370720407060200175330ustar00patarg00001250000004# usePoisson # stationCount 500 # sampleRate 1000 # detectorDeviation 2000 # heightDeviation 0.8 # timeDeviation 0.01 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # speedOfLight 3e+09 0 0.513134 -0.176091 0.484958 -0.352183 0.554647 -0.528274 0.523193 -0.704365 0.493363 -0.880456 0.457995 -1.05655 0.494245 -1.23264 0.568152 -1.40873 0.506658 -1.58482 0.520552 -1.76091 0.324363 -1.937 0.103151 -2.1131 0.0564423 -2.28919 0.0449245 -2.46528 0.0275774 -2.64137 0.0193579 -2.81746 0.0217389 -2.99355 0.0301066 -3.16964 0.0377322 -3.34573 0.0302859 -3.52183 0.0230891 -3.69792 0.0287838 -3.87401 0.0224737 -4.0501 0.0265036 -4.22619 0.0229736 -4.40228 0.027127 -4.57837 0.0306034 -4.75446 0.0275075 -4.93056 0.0260642 ./scope1.0.2000.11.14/data/n.in010064400007730000024000000002750720365250300147230ustar00patarg00001250000004usePoisson stationCount 10000 sampleRate 1000 detectorDeviation 800.0 heightDeviation 0.8 timeDeviation 0.00001 sourceOffset 10000 sourceAmplitude 10 sourceFrequency 100 speedOfLight 3e+09 ./scope1.0.2000.11.14/data/v.dat010064400007730000024000000010400720407060200150570ustar00patarg00001250000004# usePoisson # stationCount 500 # sampleRate 1000 # detectorDeviation 0 # heightDeviation 0.8 # timeDeviation 0.01 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # speedOfLight 3e+09 0 0.008 0.00628319 0.442 0.0125664 0.508 0.0188496 0.56 0.0251327 0.452 0.0314159 0.166 0.0376991 -0.062 0.0439823 -0.496 0.0502655 -0.402 0.0565487 -0.266 0.0628319 -0.126 0.069115 0.478 0.0753982 0.622 0.0816814 0.536 0.0879646 0.366 0.0942478 -0.102 0.100531 -0.382 0.106814 -0.63 0.113097 -0.642 0.119381 -0.404 0.125664 0.24 # MSE 99.2706 ./scope1.0.2000.11.14/data/v.in010064400007730000024000000003160720365250300147270ustar00patarg00001250000004usePoisson stationCount 500 sampleRate 1000 detectorDeviation 100.0 detectorDeviation 0.0 heightDeviation 0.8 timeDeviation 0.01 sourceOffset 10000 sourceAmplitude 10 sourceFrequency 100 speedOfLight 3e+09 ./scope1.0.2000.11.14/data/w.dat010064400007730000024000000010370720407060300150670ustar00patarg00001250000004# usePoisson # stationCount 500 # sampleRate 1000 # detectorDeviation 0 # heightDeviation 0.8 # timeDeviation 0.001 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # speedOfLight 3e+09 0 -0.206 0.00628319 0.75 0.0125664 0.88 0.0188496 1.086 0.0251327 0.76 0.0314159 0.056 0.0376991 -0.742 0.0439823 -0.918 0.0502655 -0.838 0.0565487 -0.638 0.0628319 -0.092 0.069115 0.738 0.0753982 1.05 0.0816814 0.878 0.0879646 0.684 0.0942478 -0.046 0.100531 -0.53 0.106814 -0.91 0.113097 -0.996 0.119381 -0.442 0.125664 0.292 # MSE 99.2389 ./scope1.0.2000.11.14/data/w.in010064400007730000024000000003170720365250400147320ustar00patarg00001250000004usePoisson stationCount 500 sampleRate 1000 detectorDeviation 100.0 detectorDeviation 0.0 heightDeviation 0.8 timeDeviation 0.001 sourceOffset 10000 sourceAmplitude 10 sourceFrequency 100 speedOfLight 3e+09 ./scope1.0.2000.11.14/data/x.dat010064400007730000024000000010370720407060400150710ustar00patarg00001250000004# usePoisson # stationCount 500 # sampleRate 1000 # detectorDeviation 0 # heightDeviation 0.8 # timeDeviation 0.0001 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # speedOfLight 3e+09 0 -0.124 0.00628319 0.648 0.0125664 0.9 0.0188496 1.034 0.0251327 0.692 0.0314159 -0.038 0.0376991 -0.662 0.0439823 -0.966 0.0502655 -0.842 0.0565487 -0.542 0.0628319 -0.094 0.069115 0.796 0.0753982 1.182 0.0816814 0.918 0.0879646 0.702 0.0942478 0 0.100531 -0.558 0.106814 -0.91 0.113097 -1.058 0.119381 -0.536 0.125664 0.332 # MSE 99.1823 ./scope1.0.2000.11.14/data/x.in010064400007730000024000000003200720365250400147250ustar00patarg00001250000004usePoisson stationCount 500 sampleRate 1000 detectorDeviation 100.0 detectorDeviation 0.0 heightDeviation 0.8 timeDeviation 0.0001 sourceOffset 10000 sourceAmplitude 10 sourceFrequency 100 speedOfLight 3e+09 ./scope1.0.2000.11.14/data/y.dat010064400007730000024000000010430720407060500150700ustar00patarg00001250000004# usePoisson # stationCount 500 # sampleRate 1000 # detectorDeviation 0 # heightDeviation 0.8 # timeDeviation 1e-05 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # speedOfLight 3e+09 0 -0.122 0.00628319 0.604 0.0125664 0.902 0.0188496 1.04 0.0251327 0.74 0.0314159 -0.032 0.0376991 -0.662 0.0439823 -0.978 0.0502655 -0.806 0.0565487 -0.552 0.0628319 -0.044 0.069115 0.784 0.0753982 1.204 0.0816814 0.918 0.0879646 0.726 0.0942478 -0.018 0.100531 -0.554 0.106814 -0.894 0.113097 -1.066 0.119381 -0.448 0.125664 0.31 # MSE 99.0141 ./scope1.0.2000.11.14/data/y.in010064400007730000024000000003210720365250500147300ustar00patarg00001250000004usePoisson stationCount 500 sampleRate 1000 detectorDeviation 100.0 detectorDeviation 0.0 heightDeviation 0.8 timeDeviation 0.00001 sourceOffset 10000 sourceAmplitude 10 sourceFrequency 100 speedOfLight 3e+09 ./scope1.0.2000.11.14/data/z.dat010064400007730000024000000010400720407060500150660ustar00patarg00001250000004# usePoisson # stationCount 500 # sampleRate 1000 # detectorDeviation 0 # heightDeviation 0.8 # timeDeviation 1e-06 # sourceOffset 10000 # sourceAmplitude 10 # sourceFrequency 100 # speedOfLight 3e+09 0 -0.12 0.00628319 0.604 0.0125664 0.902 0.0188496 1.04 0.0251327 0.74 0.0314159 -0.032 0.0376991 -0.662 0.0439823 -0.978 0.0502655 -0.808 0.0565487 -0.552 0.0628319 -0.044 0.069115 0.784 0.0753982 1.204 0.0816814 0.918 0.0879646 0.726 0.0942478 -0.02 0.100531 -0.554 0.106814 -0.894 0.113097 -1.066 0.119381 -0.448 0.125664 0.31 # MSE 99.016 ./scope1.0.2000.11.14/data/z.in010064400007730000024000000003220720365250600147330ustar00patarg00001250000004usePoisson stationCount 500 sampleRate 1000 detectorDeviation 100.0 detectorDeviation 0.0 heightDeviation 0.8 timeDeviation 0.000001 sourceOffset 10000 sourceAmplitude 10 sourceFrequency 100 speedOfLight 3e+09