simrisc-14.05.00/agegroup/0000755000175000017500000000000014051665273014220 5ustar frankfranksimrisc-14.05.00/agegroup/opinsert.cc0000644000175000017500000000052514034554241016365 0ustar frankfrank//#define XERR #include "agegroup.ih" std::ostream &operator<<(std::ostream &out, AgeGroup const &ageGroup) { out << setw(3) << ageGroup.d_beginAge << " - " << setw(2); if (Globals::isZero(ageGroup.d_endAge - END_AGE)) out << '*'; else out << ageGroup.d_endAge; return out; } simrisc-14.05.00/agegroup/agegroup.h0000644000175000017500000000260414034554241016175 0ustar frankfrank#ifndef INCLUDED_AGEGROUP_ #define INCLUDED_AGEGROUP_ #include #include #include #include "../typedefs/typedefs.h" #include "../hasagegroup/hasagegroup.h" // no errors, but if the configuration is incorrect then op>> fails class AgeGroup { friend std::istream &operator>>(std::istream &in, AgeGroup &ageGroup); friend std::ostream &operator<<(std::ostream &out, AgeGroup const &ageGroup); uint16_t d_beginAge; uint16_t d_endAge; public: uint16_t beginAge() const; uint16_t endAge() const; // Err::NOT_CONSECUTIVE if false template bool nextRange(std::vector const &vect) const; bool operator==(AgeGroup const &other) const; // we're not promoting private: std::istream &extract(std::istream &in); // error message if not connecting bool connects(AgeGroup const &previous) const; }; #include "nextrange.f" inline uint16_t AgeGroup::beginAge() const { return d_beginAge; } inline uint16_t AgeGroup::endAge() const { return d_endAge; } inline std::istream &operator>>(std::istream &in, AgeGroup &ageGroup) { return ageGroup.extract(in); } inline bool operator!=(AgeGroup const &lhs, AgeGroup const &rhs) { return not (lhs == rhs); } #endif simrisc-14.05.00/agegroup/connects.cc0000644000175000017500000000037314034554241016337 0ustar frankfrank//#define XERR #include "agegroup.ih" bool AgeGroup::connects(AgeGroup const &previous) const { if (d_beginAge == previous.d_endAge) return true; Err::msg(Err::NOT_CONSECUTIVE) << d_beginAge << " - ..." << endl; return false; } simrisc-14.05.00/agegroup/opequal.cc0000644000175000017500000000025414034554241016167 0ustar frankfrank//#define XERR #include "agegroup.ih" bool AgeGroup::operator==(AgeGroup const &other) const { return d_beginAge == other.d_beginAge and d_endAge == other.d_endAge; } simrisc-14.05.00/agegroup/icmconf0000644000175000017500000000007714034554241015556 0ustar frankfrank#define LIBRARY "agegroup" #include "../icmconf.lib" simrisc-14.05.00/agegroup/extract.cc0000644000175000017500000000076014034554241016175 0ustar frankfrank//#define XERR #include "agegroup.ih" // e.g., 40 - 50 // 70 - * // separating blanks are optional std::istream &AgeGroup::extract(std::istream &in) { char sep; in >> d_beginAge >> sep >> sep; // get '40 - 5', or '70 - *' if (sep == '*') d_endAge = END_AGE; // set endAge else { in.unget(); // or extract the age in >> d_endAge; } return in; // return } simrisc-14.05.00/agegroup/nextrange.f0000644000175000017500000000033714034554241016356 0ustar frankfranktemplate bool AgeGroup::nextRange(std::vector const &vect) const { return vect.empty() // no Type elements yet or connects(vect.back().ageGroup()); } simrisc-14.05.00/agegroup/agegroup.ih0000644000175000017500000000025014034554241016341 0ustar frankfrank#include "agegroup.h" #include "../xerr/xerr.ih" #include #include #include "../err/err.h" #include "../globals/globals.h" using namespace std; simrisc-14.05.00/agegroup/frame0000644000175000017500000000006614034554241015230 0ustar frankfrank//#define XERR #include "agegroup.ih" AgeGroup:: { } simrisc-14.05.00/agegroupvsd/0000755000175000017500000000000014051665273014735 5ustar frankfranksimrisc-14.05.00/agegroupvsd/fmt.cc0000644000175000017500000000044314034554241016024 0ustar frankfrank//#define XERR #include "agegroupvsd.ih" // static void AgeGroupVSD::fmt(unsigned indent, unsigned mIntWidth, unsigned mPrec, unsigned sdIntWidth, unsigned sdPrec) { s_indent = indent; VSD::fmt(mIntWidth, mPrec, sdIntWidth, sdPrec); } simrisc-14.05.00/agegroupvsd/vary.cc0000644000175000017500000000013114034554241016211 0ustar frankfrank//#define XERR #include "agegroupvsd.ih" void AgeGroupVSD::vary() { d_vsd.vary(); } simrisc-14.05.00/agegroupvsd/data.cc0000644000175000017500000000011314034554241016141 0ustar frankfrank//#define XERR #include "agegroupvsd.ih" unsigned AgeGroupVSD::s_indent; simrisc-14.05.00/agegroupvsd/vary2.cc0000644000175000017500000000067214034554241016305 0ustar frankfrank//#define XERR #include "agegroupvsd.ih" void AgeGroupVSD::vary(ostream &out, unsigned indent, char const *hdr, AgeGroupVSDvect &vect) { out << setw(indent) << ' ' << hdr << ":\n"; indent += 2; for (auto &ag: vect) { ag.vary(); out << setw(indent) << ' ' << "ageGroup: " << ag.d_ageGroup << " "; ag.d_vsd.showVary(out); } out.put('\n'); } simrisc-14.05.00/agegroupvsd/agegroupvsd.h0000644000175000017500000000536714034554241017440 0ustar frankfrank#ifndef INCLUDED_AGEGROUPVSD_ #define INCLUDED_AGEGROUPVSD_ #include #include "../agegroup/agegroup.h" #include "../vsd/vsd.h" class AgeGroupVSD { friend std::istream &operator>>(std::istream &in, AgeGroupVSD &group); friend std::ostream &operator<<(std::ostream &out, std::vector const &vect); friend std::ostream &operator<<(std::ostream &out, AgeGroupVSD const &group); AgeGroup d_ageGroup; VSD d_vsd; double d_stdDev; // if negative: std dev not used static unsigned s_indent; public: AgeGroupVSD(VaryType varyType, bool useStdDev); AgeGroup const &ageGroup() const; uint16_t beginAge() const; uint16_t endAge() const; double value() const; double stdDev() const; void vary(); static void fmt(unsigned valueIntWidth, unsigned valuePrec, // inl unsigned distValueWdith, unsigned distPrec); static void fmt(unsigned indent, // indentation below topLabel unsigned mIntWidth, unsigned mPrec, unsigned sdIntWidth, unsigned sdPrec); static void vary(std::ostream &out, unsigned indent, // 2 char const *hdr, std::vector &vect); private: std::ostream &insert(std::ostream &out) const; // 1 static std::ostream &insert(std::ostream &out, // 2 std::vector const &vect); std::istream &extract(std::istream &in); }; typedef std::vector AgeGroupVSDvect; inline AgeGroup const &AgeGroupVSD::ageGroup() const { return d_ageGroup; } inline uint16_t AgeGroupVSD::beginAge() const { return d_ageGroup.beginAge(); } inline uint16_t AgeGroupVSD::endAge() const { return d_ageGroup.endAge(); } inline double AgeGroupVSD::value() const { return d_vsd.value(); } inline double AgeGroupVSD::stdDev() const { return d_stdDev; } // static inline void fmt(unsigned valueIntWidth, unsigned valuePrec, unsigned distValueWdith, unsigned distPrec) { VSD::fmt(valueIntWidth, valuePrec, distValueWdith, distPrec); } inline std::istream &operator>>(std::istream &in, AgeGroupVSD &ageGroupVSD) { return ageGroupVSD.extract(in); } inline std::ostream &operator<<(std::ostream &out, AgeGroupVSD const &ageGroupVSD) { return ageGroupVSD.insert(out); } inline std::ostream &operator<<(std::ostream &out, AgeGroupVSDvect const &vect) { return AgeGroupVSD::insert(out, vect); } #endif simrisc-14.05.00/agegroupvsd/insert1.cc0000644000175000017500000000060614034554241016624 0ustar frankfrank//#define XERR #include "agegroupvsd.ih" std::ostream &AgeGroupVSD::insert(std::ostream &out) const { out << d_ageGroup << ", "; // insert the age group if (d_stdDev >= 0) // then the sd.dev (if available) Globals::setPrecision(out, 3) << "std.dev: " << d_stdDev << "; "; return out << d_vsd; // then the VSD } simrisc-14.05.00/agegroupvsd/agegroupvsd.ih0000644000175000017500000000020414034554241017572 0ustar frankfrank#include "agegroupvsd.h" #include "../xerr/xerr.ih" #include "../globals/globals.h" #include "../err/err.h" using namespace std; simrisc-14.05.00/agegroupvsd/insert2.cc0000644000175000017500000000044014034554241016621 0ustar frankfrank//#define XERR #include "agegroupvsd.ih" // static ostream &AgeGroupVSD::insert(ostream &out, AgeGroupVSDvect const &vect) { for (unsigned idx = 0, end = vect.size(); idx != end; ++idx) out << setw(s_indent) << ' ' << "ageGroup: " << vect[idx] << '\n'; return out; } simrisc-14.05.00/agegroupvsd/icmconf0000644000175000017500000000010214034554241016260 0ustar frankfrank#define LIBRARY "agegroupvsd" #include "../icmconf.lib" simrisc-14.05.00/agegroupvsd/extract.cc0000644000175000017500000000102314034554241016703 0ustar frankfrank//#define XERR #include "agegroupvsd.ih" // e.g., 1 - 50 .61 4.38 .43 Normal // or: 1 - 50 4.38 .43 Normal std::istream &AgeGroupVSD::extract(std::istream &in) { if (d_stdDev < 0) in >> d_ageGroup >> d_vsd; else { in >> d_ageGroup >> d_stdDev >> d_vsd; // the default Distribution setting is VARY_OK: OK for AgeGroupVSD if (d_stdDev < 0) Err::msg(Err::NEGATIVE) << "(final std. dev.)" << endl; } return in; } simrisc-14.05.00/agegroupvsd/agegroupvsd1.cc0000644000175000017500000000024214034554241017642 0ustar frankfrank//#define XERR #include "agegroupvsd.ih" AgeGroupVSD::AgeGroupVSD(VaryType varyType, bool useStdDev) : d_vsd(varyType), d_stdDev(useStdDev ? 0 : -1) {} simrisc-14.05.00/agegroupvsd/frame0000644000175000017500000000007414034554241015744 0ustar frankfrank//#define XERR #include "agegroupvsd.ih" AgeGroupVSD:: { } simrisc-14.05.00/analysis/0000755000175000017500000000000014051665273014232 5ustar frankfranksimrisc-14.05.00/analysis/analysis.ih0000644000175000017500000000052014034554241016365 0ustar frankfrank#include "analysis.h" #include "../xerr/xerr.ih" #include #include #include #include #include "../options/options.h" #include "../loop/loop.h" using namespace std; using namespace FBB; extern Arg::LongOption const g_longOpts[]; extern Arg::LongOption const *g_longEnd; simrisc-14.05.00/analysis/run.cc0000644000175000017500000000055714034554241015345 0ustar frankfrank#define XERR #include "analysis.ih" void Analysis::run() { requireBase(); // the base directory must be (made) available Loop loop{ d_labels }; // errors may be set at Options, ConfFile if (emsg.count() != 0) // construction, or Loop construction return; loop.iterate(); } simrisc-14.05.00/analysis/requirebase.cc0000644000175000017500000000050314034554241017037 0ustar frankfrank//#define XERR #include "analysis.ih" void Analysis::requireBase() const { error_code ec; auto const &base = Options::instance().base(); if ( not filesystem::create_directory(base, ec) and ec.value() != 0 ) throw Exception{} << "Cannot create base directory " << base; } simrisc-14.05.00/analysis/actualize.cc0000644000175000017500000000246714034554241016524 0ustar frankfrank//#define XERR #include "analysis.ih" void Analysis::actualize(Parser::OptionsVect const &specs) { auto &options = Options::instance(); options.activate(); // activate the startup // (default/command-line) // options for (auto const &spec: specs) // visit all options specified { // in this analysis // visit all long options for (auto const *ptr = g_longOpts; ptr != g_longEnd; ++ptr) { string const &name = ptr->longName(); if (name == spec.name) // found an option to alter { // try to change it if (not options.alter(ptr->optionChar(), spec.value)) wmsg << "ignored analysis option specification " << spec.name << " (line " << spec.lineNr << ')' << endl; break; // done with this option } } } options.actualize(); // obtain the actual options } simrisc-14.05.00/analysis/analysis.h0000644000175000017500000000072414034554241016222 0ustar frankfrank#ifndef INCLUDED_ANALYSIS_ #define INCLUDED_ANALYSIS_ #include #include "../parser/parser.h" #include "../typedefs/typedefs.h" class Analysis { StringVect d_labels; public: // stream: the analysis: secifications Analysis(std::istream &&stream, uint16_t lineNr); void run(); private: void actualize(Parser::OptionsVect const &specs); void requireBase() const; }; #endif simrisc-14.05.00/analysis/icmconf0000644000175000017500000000007714034554241015570 0ustar frankfrank#define LIBRARY "analysis" #include "../icmconf.lib" simrisc-14.05.00/analysis/analysis1.cc0000644000175000017500000000063414034554241016441 0ustar frankfrank//#define XERR #include "analysis.ih" // the error count is reset by the Simulator Analysis::Analysis(std::istream &&stream, uint16_t lineNr) { Parser parser; Parser::OptionsVect options; parser.load(stream, lineNr, d_labels, options); // read the analysis specs actualize(options); parser.load(Options::instance().configFile()); // read the config file } simrisc-14.05.00/analysis/frame0000644000175000017500000000006614034554241015242 0ustar frankfrank//#define XERR #include "analysis.ih" Analysis:: { } simrisc-14.05.00/beir7/0000755000175000017500000000000014051665273013417 5ustar frankfranksimrisc-14.05.00/beir7/vary.cc0000644000175000017500000000021414034554241014675 0ustar frankfrank//#define XERR #include "beir7.ih" void Beir7::vary(ostream &out) { d_vsd.vary(); out << " beir7: "; d_vsd.showVary(out); } simrisc-14.05.00/beir7/icmconf0000644000175000017500000000007414034554241014752 0ustar frankfrank#define LIBRARY "beir5" #include "../icmconf.lib" simrisc-14.05.00/beir7/writeparameters.cc0000644000175000017500000000041114034554241017131 0ustar frankfrank//#define XERR #include "beir7.ih" void Beir7::writeParameters(ostream &out) const { VSD::fmt(1, 2, 1, 2); Globals::setWidthPrec(out, 2, 2) << " beir7:\n" " eta: " << d_eta << "\n" " beta: " << d_vsd << '\n'; } simrisc-14.05.00/beir7/beir7.h0000644000175000017500000000155314034554241014575 0ustar frankfrank#ifndef INCLUDED_BEIR7_ #define INCLUDED_BEIR7_ //Tumor: // # eta beta spread dist // Beir7: -2.0 .51 .32 Normal #include #include "../typedefs/typedefs.h" #include "../vsd/vsd.h" class Beir7 { double d_eta; // beta; VSD d_vsd; // contains beta and spread/distribution public: Beir7(); double beta() const; double eta() const; double spread() const; DistType distType() const; void vary(std::ostream &out); void writeParameters(std::ostream &out) const; }; inline double Beir7::beta() const { return d_vsd.value(); } inline double Beir7::eta() const { return d_eta; } inline double Beir7::spread() const { return d_vsd.spread(); } inline DistType Beir7::distType() const { return d_vsd.distType(); } #endif simrisc-14.05.00/beir7/beir7.ih0000644000175000017500000000022714034554241014743 0ustar frankfrank#include "beir7.h" #include "../xerr/xerr.ih" #include #include "../globals/globals.h" #include "../parser/parser.h" using namespace std; simrisc-14.05.00/beir7/beir71.cc0000644000175000017500000000040014034554241015002 0ustar frankfrank#define XERR #include "beir7.ih" //Tumor: // # eta beta spread dist. // beir7: -2.0 0.51 0.32 Normal Beir7::Beir7() : d_vsd(VARY_NONNEG) { Parser::extract( Parser::one({ "Tumor:", "beir7:" }), d_eta, d_vsd); } simrisc-14.05.00/beir7/frame0000644000175000017500000000006014034554241014421 0ustar frankfrank//#define XERR #include "beir7.ih" Beir7:: { } simrisc-14.05.00/bisonc++parser/0000755000175000017500000000000014034554241015220 5ustar frankfranksimrisc-14.05.00/bisonc++parser/parser.h0000644000175000017500000000234014034554241016664 0ustar frankfrank// Generated by Bisonc++ V6.04.00 on Fri, 20 Mar 2020 16:07:08 +0100 #ifndef Parser_h_included #define Parser_h_included // $insert baseclass #include "parserbase.h" // $insert scanner.h #include "../scanner/scanner.h" // $insert undefparser #undef Parser // CAVEAT: between the baseclass-include directive and the // #undef directive in the previous line references to Parser // are read as ParserBase. // If you need to include additional headers in this file // you should do so after these comment-lines. class Parser: public ParserBase { // $insert scannerobject Scanner d_scanner; public: Parser(char const *infile); int parse(); private: void error(); // called on (syntax) errors int lex(); // returns the next token from the // lexical scanner. void print(); // use, e.g., d_token, d_loc void exceptionHandler(std::exception const &exc); // support functions for parse(): void executeAction_(int ruleNr); void errorRecovery_(); void nextCycle_(); void nextToken_(); void print_(); }; #endif simrisc-14.05.00/bisonc++parser/parser1.cc0000644000175000017500000000013114034554241017077 0ustar frankfrank#include "parser.ih" Parser::Parser(char const *infile) : d_scanner(infile, "-") {} simrisc-14.05.00/bisonc++parser/parser.ih0000644000175000017500000000143014034554241017034 0ustar frankfrank// Generated by Bisonc++ V6.04.00 on Fri, 20 Mar 2020 16:07:08 +0100 // Include this file in the sources of the class Parser. // $insert class.h #include "parser.h" inline void Parser::error() { std::cerr << "Syntax error\n"; } // $insert lex inline int Parser::lex() { return d_scanner.lex(); } inline void Parser::print() { } inline void Parser::exceptionHandler(std::exception const &exc) { throw; // re-implement to handle exceptions thrown by actions } // Add here includes that are only required for the compilation // of Parser's sources. // UN-comment the next using-declaration if you want to use // int Parser's sources symbols from the namespace std without // specifying std:: using namespace std; simrisc-14.05.00/bisonc++parser/inc/0000755000175000017500000000000014034554241015771 5ustar frankfranksimrisc-14.05.00/bisonc++parser/inc/survival0000644000175000017500000000023014034554241017562 0ustar frankfranksurvivalSpec: TYPE number optDistribution ; survivalSpecs: survivalSpecs survivalSpec | // empty ; survival: SURVIVAL survivalSpecs ; simrisc-14.05.00/bisonc++parser/inc/scenario0000644000175000017500000000032214034554241017514 0ustar frankfrankscenarioSpec: CASES NR | SPREAD BOOL | GENERATOR GENTYPE | SEED NR | ITERATIONS NR ; scenarioSpecs: scenarioSpecs scenarioSpec | // empty ; scenario: SCENARIO scenarioSpecs ; simrisc-14.05.00/bisonc++parser/inc/costs0000644000175000017500000000062314034554241017050 0ustar frankfrankcostsDiscount: AGE NR | PROP NR ; costsDiscounts: costsDiscounts costsDiscount | costsDiscount ; costsDiameter: NR ':' NR ; costsDiameters: costsDiameters costsDiameter | costsDiameter ; costsSpec: BIOP NR | DIAMETERS costsDiameters | DISCOUNT costsDiscounts ; costsSpecs: costsSpecs costsSpec | // empty ; costs: COSTS costsSpecs ; simrisc-14.05.00/bisonc++parser/inc/agerange0000644000175000017500000000015014034554241017461 0ustar frankfranklastAge: NR | '*' ; ageRange: NR '-' lastAge ':' ; ageGroupRange: AGEGROUP ageRange ; simrisc-14.05.00/bisonc++parser/inc/mri0000644000175000017500000000022114034554241016476 0ustar frankfrankmriSpec: cost | SENSITIVITY REAL | SPECIFICITY REAL ; mriSpecs: mriSpecs mriSpec | // empty ; mri: MRI mriSpecs ; simrisc-14.05.00/bisonc++parser/inc/number0000644000175000017500000000003414034554241017201 0ustar frankfranknumber: NR | REAL ; simrisc-14.05.00/bisonc++parser/inc/carrierspecs0000644000175000017500000000032714034554241020403 0ustar frankfrankcarrierSpec: PROB number | LIFETIMERISK number optDistribution | MEANAGE number optDistribution | STDDEV number optDistribution ; carrierSpecs: carrierSpecs carrierSpec | carrierSpec ; simrisc-14.05.00/bisonc++parser/inc/breastdensities0000644000175000017500000000021614034554241021103 0ustar frankfrankbDAgeGroup: ageGroupRange biRads ; bDSpecs: bDSpecs bDAgeGroup | // empty ; breastDensities: BREASTDENSITIES bDSpecs ; simrisc-14.05.00/bisonc++parser/inc/dose0000644000175000017500000000003314034554241016642 0ustar frankfrankdose: DOSE biRads ; simrisc-14.05.00/bisonc++parser/inc/mammo0000644000175000017500000000031114034554241017015 0ustar frankfrankmammoSpec: cost | dose | specificity | BETA distributions | SYSERR distribution ; mammoSpecs: mammoSpecs mammoSpec | // empty ; mammo: MAMMO mammoSpecs ; simrisc-14.05.00/bisonc++parser/inc/distributions0000644000175000017500000000033214034554241020614 0ustar frankfrankdistribution: REAL NORMAL ; optDistribution: distribution | // empty ; optParenDistribution: '(' distribution ')' | // empty ; distributions: distributions distribution | distribution ; simrisc-14.05.00/bisonc++parser/inc/modalities0000644000175000017500000000034414034554241020047 0ustar frankfrank%include inc/mammo %include inc/tomo %include inc/mri modalitiesSpec: mammo | tomo | mri ; modalitiesSpecs: modalitiesSpecs modalitiesSpec | // empty ; modalities: MODALITIES modalitiesSpecs ; simrisc-14.05.00/bisonc++parser/inc/tumor0000644000175000017500000000036314034554241017064 0ustar frankfrank%include inc/beir7 %include inc/incidence %include inc/growth %include inc/survival tumorSpec: beir7 | incidence | growth | survival ; tumorSpecs: tumorSpecs tumorSpec | // empty ; tumor: TUMOR tumorSpecs ; simrisc-14.05.00/bisonc++parser/inc/tokens0000644000175000017500000000066714034554241017230 0ustar frankfrank%token SCENARIO BOOL SPREAD ITERATIONS NR GENERATOR GENTYPE SEED CASES COSTS BIOP DIAMETERS DISCOUNT AGE PROP REAL BREASTDENSITIES AGEGROUP MODALITIES MAMMO COST DOSE SPECIFICITY BETA NORMAL SYSERR TOMO SENSITIVITY MRI SCREENING ATTENDANCERATE ROUND TUMOR BEIR7 ETA INCIDENCE PROB LIFETIMERISK MEANAGE STDDEV BRCA1 BRCA2 GROWTH START SELFDETECTMU SELFDETECTSIGMA DOUBLINGTIME SURVIVAL TYPE simrisc-14.05.00/bisonc++parser/inc/screening0000644000175000017500000000053314034554241017672 0ustar frankfrankscreeningModality: MAMMO | TOMO | MRI ; screeningModalities: screeningModalities screeningModality | screeningModality ; screeningSpec: ROUND number screeningModalities | ATTENDANCERATE distribution ; screeningSpecs: screeningSpecs screeningSpec | // empty ; screening: SCREENING screeningSpecs ; simrisc-14.05.00/bisonc++parser/inc/agerangeprobs0000644000175000017500000000014614034554241020534 0ustar frankfrankageRangeProb: ageRange REAL ; ageRangeProbs: ageRangeProbs ageRangeProb | ageRangeProb ; simrisc-14.05.00/bisonc++parser/inc/doublingtime0000644000175000017500000000034614034554241020401 0ustar frankfrankdoublingTimeSpec: ageGroupRange number optParenDistribution number optParenDistribution ; doublingTimeSpecs: doublingTimeSpecs doublingTimeSpec | doublingTimeSpec ; doublingTime: DOUBLINGTIME doublingTimeSpecs ; simrisc-14.05.00/bisonc++parser/inc/tomo0000644000175000017500000000024014034554241016666 0ustar frankfranktomoSpec: cost | dose | specificity | SENSITIVITY biRads ; tomoSpecs: tomoSpecs tomoSpec | // empty ; tomo: TOMO tomoSpecs ; simrisc-14.05.00/bisonc++parser/inc/incidence0000644000175000017500000000035214034554241017635 0ustar frankfrank%include inc/carrierspecs incidenceSpec: NORMAL carrierSpecs | BRCA1 carrierSpecs | BRCA2 carrierSpecs ; incidenceSpecs: incidenceSpecs incidenceSpec | // empty ; incidence: INCIDENCE incidenceSpecs ; simrisc-14.05.00/bisonc++parser/inc/birads0000644000175000017500000000005214034554241017155 0ustar frankfrankbiRads: biRads number | number ; simrisc-14.05.00/bisonc++parser/inc/beir70000644000175000017500000000024014034554241016720 0ustar frankfrankbeir7Spec: BETA REAL | ETA REAL | SPREAD distribution ; beir7Specs: beir7Specs beir7Spec | // empty ; beir7: BEIR7 beir7Specs ; simrisc-14.05.00/bisonc++parser/inc/cost0000644000175000017500000000002414034554241016660 0ustar frankfrankcost: COST NR ; simrisc-14.05.00/bisonc++parser/inc/specificity0000644000175000017500000000005514034554241020227 0ustar frankfrankspecificity: SPECIFICITY ageRangeProbs ; simrisc-14.05.00/bisonc++parser/inc/growth0000644000175000017500000000042414034554241017226 0ustar frankfrank%include inc/doublingtime growthSpec: START number optDistribution | SELFDETECTMU number optDistribution | SELFDETECTSIGMA number optDistribution | doublingTime ; growthSpecs: growthSpecs growthSpec | // empty ; growth: GROWTH growthSpecs ; simrisc-14.05.00/bisonc++parser/inc/normal0000644000175000017500000000004614034554241017204 0ustar frankfranknormal: NORMAL carrierSpecs ; simrisc-14.05.00/bisonc++parser/grammar0000644000175000017500000000133414034554241016572 0ustar frankfrank%default-actions quiet %filenames parser %scanner ../scanner/scanner.h %token-path tokens.h // %print-tokens %baseclass-preinclude ../info/info.h %include inc/tokens %% // Define the start-rule below (the name `startrule' may be altered) startrule: startrule keywords | // empty ; %include inc/agerange %include inc/agerangeprobs %include inc/number %include inc/birads %include inc/distributions %include inc/cost %include inc/dose %include inc/specificity %include inc/scenario %include inc/costs %include inc/breastdensities %include inc/modalities %include inc/screening %include inc/tumor keywords: scenario | costs | breastDensities | modalities | screening | tumor | error ; simrisc-14.05.00/build0000755000175000017500000000727314052261536013440 0ustar frankfrank#!/usr/bin/icmake -t. #define LOGENV "SIMRISC" #include "icmconf" string g_logPath = getenv(LOGENV)[1], g_cwd = chdir(""); // initial working directory, ends in / int g_echo = ON; #include "icmake/cuteoln" #include "icmake/backtick" #include "icmake/setopt" #include "icmake/run" #include "icmake/md" #include "icmake/pathfile" #include "icmake/findall" #include "icmake/loginstall" #include "icmake/logzip" #include "icmake/logfile" #include "icmake/uninstall" #include "icmake/special" #include "icmake/clean" #include "icmake/manpage" #include "icmake/latexdoc" #include "icmake/pdf" #include "icmake/manual" #include "icmake/install" #include "icmake/gitlab" void main(int argc, list argv) { string option; int idx; for (idx = listlen(argv); idx--; ) { if (argv[idx] == "-q") { g_echo = OFF; argv -= (list)"-q"; } } echo(g_echo); option = argv[1]; if (option == "clean") clean(0); if (option == "distclean") clean(1); if (option != "") special(); if (option == "install") install(argv[2], argv[3]); if (option == "uninstall") uninstall(argv[2]); if (option == "gitlab") gitlab(); if (option == "man") manpage(); if (option == "manual") manual(); if (option == "pdf") // creates the pdf version of the pdf(); // tech manual if (option == "library") { system("icmbuild library"); exit(0); } if (option == "program") { system("icmbuild program"); if (argv[2] == "strip") system("strip " TMP_DIR "/bin/binary"); exit(0); } if (option == "oxref") { system("icmbuild program"); run("oxref -t main -r oxref/replace -fxs tmp/main.o tmp/lib" LIBRARY ".a > " PROGRAM ".xref"); exit(0); } printf("Usage: build [-q] what\n" "Where\n" " [-q]: run quietly, do not show executed commands\n" "`what' is one of:\n" " clean - clean up remnants of previous " "compilations\n" " distclean - clean + fully remove tmp/\n" " library - build " PROGRAM "'s library\n" " man - build the man-page (requires Yodl)\n" " manual - build the html manual (requires Yodl)\n" " pdf - build the pdf manual (requires Yodl)\n" " program [strip] - build " PROGRAM " (optionally strip the\n" " executable)\n" " oxref [strip] - same a `program', also builds xref file\n" " using oxref\n" " install selection [base] - to install the software in the \n" " locations defined in the INSTALL.im file,\n" " optionally below base\n" " selection can be\n" " x, to install all components,\n" " or a combination of:\n" " b (binary program),\n" " d (documentation),\n" " m (man-page)\n" " uninstall logfile - remove files and empty directories listed\n" " in the file 'logfile'\n" " gitlab - prepare gitlab's web-pages update\n" " (internal use only)\n" "\n" ); } simrisc-14.05.00/changelog0000644000175000017500000002026214052262437014257 0ustar frankfranksimrisc (14.05.00) * Added option --err (-e) to select the previously used but inorrect algorithm for computing the Beir7 risk vector, instead of using the (now default) correct algorithm for computing the risk vector. -- Frank B. Brokken Sat, 22 May 2021 22:09:08 +0200 simrisc (14.04.00) * Modalities support spread-variation. See the simriscparams(7) man-page for a description of how the configuration file was extended wrt the Modality-specifications. When 'spead: true' is specified then Loop::iterate() now calls d_modalities.vary(), calling ModBase vary for the various Modalities. Previously defined 'double' Modality values now use VSDs * Age range specifications do not end in ':'s anymore. E.g., ageGroup: 1 - 50 * Beir7's parameter specification first specifies eta, then beta. * The Case-specific data matrix defines an extra (18th) colum, showing the results of the screening rounds for each simulated case. * When 'spread: true' is specified the actually used and original parameter values are listed in a file, by default 'spread-$.txt', where $ is replaced by the loop iteration index. Use the option '-s' to specify a non-default filename (cf. simrisc(1)); * The man-pages were update -- Frank B. Brokken Sun, 11 Apr 2021 11:00:58 +0200 simrisc (14.03.00) * To specify no screening round ages 'round: none' should be specified. When 'round: none' is specified then the rounds file is not written. -- Frank B. Brokken Sun, 21 Feb 2021 13:30:38 +0100 simrisc (14.02.00) * Option --cases was renamed to --last-case (-l) to avoid confusion with the cases: specification in the configuration file * Default option values are reset at each Analysis: specification. * Analysis files now use (capitalized) Analysis: specifications. * Fixed some specification errors in the simriscparams(7) man-page * Updated the simrisc(1) man-page * Updated the usage info -- Frank B. Brokken Wed, 27 Jan 2021 16:39:02 +0100 simrisc (14.01.00) * 'm:' parameter specifications for the four bi-rad categories were added to the Mammo specifications in the default configuration file * The 'm:' parameter corresponding to the cases bi-rad category given the case's age is used when computing the sensitivity associated with the Mammo modality * The simriscparams(7) man-page was updated accordingly * The simrisc --help info lists the --cases (-c) option instead of --nCases (-n). -- Frank B. Brokken Fri, 22 Jan 2021 11:14:22 +0100 simrsic (14.00.00) * Case-specific data are reproducible when specifying 'generator: fixed' or 'generator: increasing' * Parameter variation when specifying 'spread: true' is available * The organization of the configuration file was drastically modified * The validity of parameter value specifications is checked -- Frank B. Brokken Wed, 20 Jan 2021 20:43:53 +0100 simrsic (13.03.00) * Redefined variables in the Costs class: the discount percentage in fact is a proportion, and its type was adapted accordingly * MRI simulation was incorrectly implemented in the original program. After fixing this error handling False Negatives is now using a standard procedure for all Modalities * The configuration file and the simriscparams man-page were adapted accordingly. * The classes Options, Random, and Error are now singletons. -- Frank B. Brokken Tue, 27 Oct 2020 19:56:12 +0100 simrsic (13.02.01) * Added a Copyright-notice file -- Frank B. Brokken Mon, 12 Oct 2020 09:34:04 +0200 simrsic (13.02.00) * Specifications using multiple analyses no longer overwrite existing files * Added specification 'generator' to the scenario specifications to specify the way the random number generator is initialized * The classes Pool, IDpool, and RandomPool are superfluous * MRI handling is activated. * The loop Status enum now uses 'PRESENT' instead of 'ALIVE' and Status enum values beginning with 'LEFT_' instead of 'NATURAL_' -- Frank B. Brokken Tue, 29 Sep 2020 16:04:26 +0200 simrsic (13.01.00) * Added missing registration of d_roundDetected to loop/maybedetect.cc * loop/selfdetected.cc and loop/treatmentdeath.cc are identical except for used Status values: now inline, calling new function in loop/characteristics.cc * Added a new section OUTPUT to the simrisc(3) man-page, containing descriptions of the content of generated files * By default the id-base option uses value 1 simrsic (13.00.00-pre) * Reorganized config/simrisc, costs associated with Modalities are now defined by the individual modality-specifications * Repaired the computation of d_prePeriod in tumor/reset.cc * Implemented Danielle's code and modified the handling of multiple modalities * Standardized the handling of Modalities by defining one standard interface * Updated the man-pages -- Frank B. Brokken Thu, 16 Jul 2020 13:45:32 +0200 simrsic (12.03.01) * Dropped 'oneAnalysis' and 'showAll' from Options, added specificAges(), fixing a bug in handling specific ages / N-cases specifications -- Frank B. Brokken Fri, 29 May 2020 15:52:30 +0200 simrsic (12.03.00) * Fixed handling of filename specifications in analysis: sections * The --one-analysis option no longer requires command-line arguments * Analysis: specifications may be empty * Minor update of the man-page -- Frank B. Brokken Fri, 29 May 2020 13:39:29 +0200 simrsic (12.02.02) * Changed the content of /usr/share/doc/simrisc: it now contains the README.hierarchy file and the default configuration file (simrisc.gz) -- Frank B. Brokken Tue, 26 May 2020 13:38:10 +0200 simrsic (12.02.01) * Updated the short option letters of the program's usage info -- Frank B. Brokken Tue, 26 May 2020 11:14:14 +0200 simrsic (12.02.00) * Added option --id-base to use id-based random numbers instead of random-pool based random numbers. * All options referring to filesystem entries use capitalized single letter options; all other options are lowercase * Updated the man-pages. * The default parameter specification file is available as the file 'simrisc' in the distribution's .config/ directory -- Frank B. Brokken Mon, 25 May 2020 15:48:49 +0200 simrsic (12.01.01) * New sub-minor release due to a man-page bug. -- Frank B. Brokken Sat, 23 May 2020 21:20:04 +0200 simrsic (12.01.00) * Reorganized the class hierarchy, preparing for multi-threading: see README.hierarcy. * Base directories are created if not available * Output files are provided with a timestamp and optionally analysis labels * Output files are cleaned up: improved table formats, and CSVs for the data files * The file echoing the used parameters is by default not produced. The --parameters option is used to specify the name of that file if requested. * When specifying configuration parameters in the context of an analysis either all, or none of the parameters of a category must be provided. This procedure is used to allow reduction of, e.g., screening rounds. -- Frank B. Brokken Sat, 23 May 2020 19:26:48 +0200 simrsic (12.00.00) * Following a request by Marcel Greuter (m.j.w.greuter@umcg.nl) SimRiSc was completely rewrittin in this release. Earlier specific changelog version information is not available. In the distribution earlier changelog info is available under 'legacy' * This is the initial conversion, offering the basic facilities. The current program produces the same results as the original program, for a single scenario, but specifying 100'000 women is OK. * Lots of work is still required to update the man-pages, and to completely generalize the program. * Debian package construction is (locally) operational. -- Frank B. Brokken Sun, 17 May 2020 17:47:06 +0200 simrisc-14.05.00/CLASSES0000644000175000017500000000045514034554241013424 0ustar frankfranksimulator analysis loop scenario tumor tumorinfo growth survival incidence beir7 costs modalities screening round densities configlines vsd distribution options random globals err tomo mammo mri modbase configlines density agegroup agegroupvsd // specificity.OBS parser //typedefs //enums simrisc-14.05.00/configlines/0000755000175000017500000000000014051665273014707 5ustar frankfranksimrisc-14.05.00/configlines/configlines2.cc0000644000175000017500000000023714034554241017573 0ustar frankfrank//#define XERR #include "configlines.ih" ConfigLines::ConfigLines(istream &in, uint16_t lineNr) : d_config(in, lineNr) { d_iter = d_config.begin(); } simrisc-14.05.00/configlines/get.cc0000644000175000017500000000152714034554241015773 0ustar frankfrank//#define XERR #include "configlines.ih" bool ConfigLines::get() { if (d_redo) { d_redo = false; return d_iter != d_config.end(); } while (d_iter != d_config.end()) { string const &line = d_iter->line(); if (line.empty() or isspace(line.front())) // skip empty lines { ++d_iter; continue; } d_line = d_iter->line(); d_lineNr = d_iter->lineNr(); d_tail = d_iter->tail(); d_value = d_iter->value(); d_key = d_iter->key(); if (d_key.empty()) // no key -> store d_key = d_line; // the line as key ++d_iter; return true; } return false; // end of file } simrisc-14.05.00/configlines/configlines1.cc0000644000175000017500000000022114034554241017563 0ustar frankfrank//#define XERR #include "configlines.ih" ConfigLines::ConfigLines(string const &fname) : d_config(fname) { d_iter = d_config.begin(); } simrisc-14.05.00/configlines/configlines.h0000644000175000017500000000275014034554241017355 0ustar frankfrank#ifndef INCLUDED_CONFIGLINES_ #define INCLUDED_CONFIGLINES_ #include #include #include "../options/options.h" class ConfigLines { typedef FBB::Config::const_iterator const_iterator; typedef FBB::CF_Line CF_Line; FBB::Config d_config; uint16_t d_lineNr; std::string d_key; std::string d_tail; std::string d_line; std::string d_value; const_iterator d_iter; // iterator to Config lines bool d_redo = false; // next get() returns d_line public: ConfigLines(std::string const &fname); ConfigLines(std::istream &in, uint16_t lineNr); // void load(); void redo(); bool get(); std::string const &line() const; // only after get() returns true std::string const &tail() const; std::string const &value() const; // 1st word of the key's value std::string const &key() const; uint16_t lineNr() const; private: }; inline uint16_t ConfigLines::lineNr() const { return d_lineNr; } inline void ConfigLines::redo() { d_redo = true; } inline std::string const &ConfigLines::key() const { return d_key; } inline std::string const &ConfigLines::line() const { return d_line; } inline std::string const &ConfigLines::value() const { return d_value; } inline std::string const &ConfigLines::tail() const { return d_tail; } #endif simrisc-14.05.00/configlines/icmconf0000644000175000017500000000010214034554241016232 0ustar frankfrank#define LIBRARY "configlines" #include "../icmconf.lib" simrisc-14.05.00/configlines/configlines.ih0000644000175000017500000000015414034554241017522 0ustar frankfrank#include "configlines.h" #include "../xerr/xerr.ih" #include "../options/options.h" using namespace std; simrisc-14.05.00/configlines/frame0000644000175000017500000000007414034554241015716 0ustar frankfrank//#define XERR #include "configlines.ih" ConfigLines:: { } simrisc-14.05.00/configlines/load.cc0000644000175000017500000000025614034554241016131 0ustar frankfrank////#define XERR //#include "configlines.ih" // //void ConfigLines::load() //{ // d_config.load(Options::instance().configFile()); // d_iter = d_config.begin(); //} // simrisc-14.05.00/Copyright-notice0000644000175000017500000000305614034554241015556 0ustar frankfrank-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA256 Simrisc is a program simulating the effects of cancer and cancer treatments. The program is a complete rewrite of the original simrisc program developed at the University Medical Center Groningen (UMCG) by a research group around Truuske de Bock and Marcel Greuter. The current program is developed in close collaboration with Truuske and Marcel. Copyright (C) 2020-now Frank B. Brokken (f.b.brokken@rug.nl) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. A copy of the GNU General Public License can be retrieved from http://www.gnu.org/licenses/. -----BEGIN PGP SIGNATURE----- iQEzBAEBCAAdFiEE3zIT3rFWdzLmXjtNfbKovurk2KoFAl+EBmMACgkQfbKovurk 2Ko+MwgAh6Z8SnvsasIF15lfxkeqSx2x8EGwb6Wz0fFVfbd6nl4kbcidZZcWHtok bd526YR/Py24cXfcMfkf4+NlB9tnaeHTyBleDCBJEh1L3MUDZdUzI4jN7UsLTjF8 VCxTCMbhqS0VBGGmvQ9ZZ8AOuRzzTK93Fi2IXa2g55PAINlCDFzmHOnKQ4j8vl3X bmFZoNfkKfypYD9XZkhURnZdMTc9athaGb+A5Ju3E2lt3ozeu5joCKYeOvlkFodX X4AQiqkwuzRnSK9oXat09h2xkII8pPJxnJBWrtYkzU834cn2WwXc9q0c7F+EUp51 lCcXFyr/POylSW0aoQHV60alq89NLw== =QWjm -----END PGP SIGNATURE----- simrisc-14.05.00/costs/0000755000175000017500000000000014051665273013542 5ustar frankfranksimrisc-14.05.00/costs/setbiop.cc0000644000175000017500000000020514034554241015504 0ustar frankfrank//#define XERR #include "costs.ih" void Costs::setBiop() { d_base.back() = "biop:"; Parser::nonNegative(d_base, d_biop); } simrisc-14.05.00/costs/setage.cc0000644000175000017500000000021614034554241015311 0ustar frankfrank//#define XERR #include "costs.ih" void Costs::setAge() { d_base.back() = "age:"; Parser::nonNegative(d_base, d_referenceAge); } simrisc-14.05.00/costs/costs.ih0000644000175000017500000000043314034554241015210 0ustar frankfrank#include "costs.h" #include "../xerr/xerr.ih" #include #include #include #include #include #include #include "../globals/globals.h" #include "../scenario/scenario.h" using namespace std; using namespace FBB; simrisc-14.05.00/costs/setdiameters.cc0000644000175000017500000000026514034554241016536 0ustar frankfrank#define XERR #include "costs.ih" void Costs::setDiameters() { d_base.back() = "diameters:"; if (not extractDiameters(Parser::one(d_base))) Err::specification(); } simrisc-14.05.00/costs/setdiscount.cc0000644000175000017500000000031614034554241016406 0ustar frankfrank//#define XERR #include "costs.ih" void Costs::setDiscount() { d_base.back() = "Discount:"; d_base.resize(d_base.size() + 1); setAge(); setProp(); d_base.resize(d_base.size() - 1); } simrisc-14.05.00/costs/extractdiameters.cc0000644000175000017500000000163514034554241017417 0ustar frankfrank#define XERR #include "costs.ih" bool Costs::extractDiameters(Parser::Lines &&lines) { if (not lines) return false; istringstream in{ lines.get()->tail }; // extract the diameters double lastAge = -1; // ages must increase CostPair spec; while (in >> spec.first) // begin diameter { if (spec.first <= lastAge) // not increasing return false; // ignore the : if (not (in.ignore() >> spec.second)) // followed by treatment return false; // cost. Ends at an // incomplete entry d_treatment.push_back(spec); lastAge = spec.first; } return d_treatment.size() > 0 and Globals::isPositiveZero(d_treatment.front().first); } simrisc-14.05.00/costs/costs.h0000644000175000017500000000316414034554241015043 0ustar frankfrank#ifndef INCLUDED_COSTS_ #define INCLUDED_COSTS_ // Costs: // biop: 176 // diameters: 0: 6438 20: 7128 50: 7701 // Discount: // age: 50 // prop: 0 #include "../typedefs/typedefs.h" #include "../parser/parser.h" class Costs { // lower diam., cost typedef std::pair CostPair; StringVect d_base; // costs of treatments given std::vector d_treatment; // tumor diam. double d_referenceAge; // discount reference age double d_discountProportion; uint16_t d_biop; // biopsy cost public: Costs(); double biopsy(double age) const; // .h double screening(double age, uint16_t cost) const; // .h double treatment(double age, double diameter) const; // .h void writeParameters(std::ostream &out) const; private: void setBiop(); void setDiameters(); bool extractDiameters(Parser::Lines &&lines); void setDiscount(); void setAge(); void setProp(); uint16_t cost(double diameter) const; double discount(double age, size_t cost) const; }; inline double Costs::biopsy(double age) const { return discount(age, d_biop); } inline double Costs::screening(double age, uint16_t cost) const { return discount(age, cost); } inline double Costs::treatment(double age, double diameter) const { return discount(age, biopsy(age) + cost(diameter)); } #endif simrisc-14.05.00/costs/icmconf0000644000175000017500000000007414034554241015075 0ustar frankfrank#define LIBRARY "costs" #include "../icmconf.lib" simrisc-14.05.00/costs/writeparameters.cc0000644000175000017500000000126214034554241017261 0ustar frankfrank//#define XERR #include "costs.ih" void Costs::writeParameters(ostream &out) const { Globals::setWidthPrec(out, 2, 1) << "Costs:\n" " biopsy: " << setw(4) << d_biop << "\n" " Discount:\n" " reference age: " << setw(4) << d_referenceAge << "\n" " proportion: " << setw(4) << d_discountProportion << "\n" " diameters:\n"; Globals::setWidthPrec(out, 2, 0); for (size_t idx = 0; idx != d_treatment.size(); ++idx) out << " diameter >= " << setw(6) << d_treatment[idx].first << " mm: " << setw(4) << d_treatment[idx].second << '\n'; out.put('\n'); } simrisc-14.05.00/costs/setprop.cc0000644000175000017500000000022714034554241015537 0ustar frankfrank//#define XERR #include "costs.ih" void Costs::setProp() { d_base.back() = "proportion:"; Parser::proportion(d_base, d_discountProportion); } simrisc-14.05.00/costs/discount.cc0000644000175000017500000000026014034554241015670 0ustar frankfrank//#define XERR #include "costs.ih" //code double Costs::discount(double age, size_t cost) const { return cost * pow(1 + d_discountProportion, d_referenceAge - age); } //= simrisc-14.05.00/costs/costs1.cc0000644000175000017500000000021314034554241015252 0ustar frankfrank//#define XERR #include "costs.ih" Costs::Costs() : d_base{ "Costs:", "" } { setBiop(); setDiameters(); setDiscount(); } simrisc-14.05.00/costs/frame0000644000175000017500000000006014034554241014544 0ustar frankfrank//#define XERR #include "costs.ih" Costs:: { } simrisc-14.05.00/costs/cost.cc0000644000175000017500000000066114034554241015015 0ustar frankfrank//#define XERR #include "costs.ih" uint16_t Costs::cost(double diameter) const { // reversed search: start at the max. diameter return find_if(d_treatment.rbegin(), d_treatment.rend(), [&](CostPair const &costPair) { return diameter >= costPair.first; } )->second; } // xerr("cost with diam. " << diameter << " = " << ret); simrisc-14.05.00/densities/0000755000175000017500000000000014051665273014376 5ustar frankfranksimrisc-14.05.00/densities/xerr/0000755000175000017500000000000014034554241015347 5ustar frankfranksimrisc-14.05.00/densities/xerr/xerr.ih0000644000175000017500000000132414034554241016651 0ustar frankfrank// define XERR to activate the xerr/xerr(2) macros: // xerr(insertion) // inserts the '<<' concatenated elements into std::cerr // preceded by the name of the source file, and ended by ' ' // xerr2(insertion, code) // performs the insertion if X is defined, and (unconditionally) // executes the statement(s) in `code'. `code' must be valid // C(++) code. // #ifdef XERR #include #define xerr(insertion) std::cerr << __FILE__": " << insertion << ' ' #define xerr2(insertion, code) { std::cerr << __FILE__": " << insertion << ' '; code; } #else #define xerr(insertion) #define xerr2(insertion, code) code #endif simrisc-14.05.00/densities/densities1.cc0000644000175000017500000000075014034554241016750 0ustar frankfrank//#define XERR #include "densities.ih" Densities::Densities() : d_base{ "BreastDensities:", "ageGroup:" } { // retrieve the Densities: ageGroup: lines auto lines = Parser::any(d_base); bool checkRange = true; // check whether age ranges connect. while (true) { LineInfo const *line = lines.get(); if (line == 0) break; add(&checkRange, *line); // some failure: don't check ranges } } simrisc-14.05.00/densities/densities.h0000644000175000017500000000245114034554241016531 0ustar frankfrank#ifndef INCLUDED_DENSITIES_ #define INCLUDED_DENSITIES_ // example config spec.: // BreastDensities: // // # bi-rad: a b c d // ageGroup: 0 - 40 .05 .30 .48 .17 // ageGroup: 40 - 50 .06 .34 .47 .13 // ageGroup: 50 - 60 .08 .50 .37 .05 // ageGroup: 60 - 70 .15 .53 .29 .03 // ageGroup: 70 - * .18 .54 .26 .02 #include #include "../density/density.h" #include "../typedefs/typedefs.h" class Densities { StringVect d_base; DensityVect d_densities; public: Densities(); // randomly determined bi-rad indices // for screening round ages Uint16Vect biRadIndices(DoubleVect const &ages) const; void writeParameters(std::ostream &out) const; private: void add(bool *checkRange, LineInfo const &ageGroup); bool nextRange(Density const &next) const; // birad idx for age, given // its probability uint16_t biradIdx(double age, double prob) const; static bool proportions(std::vector const &vect); }; #endif simrisc-14.05.00/densities/biradidx.cc0000644000175000017500000000064714034554241016473 0ustar frankfrank//#define XERR #include "densities.ih" uint16_t Densities::biradIdx(double age, double prob) const { for (Density const &density: d_densities) { if (density.contains(age)) return density.indexOf(prob); // find the prob. in the sequence } // of cumulative density probs throw Exception{} << "runtime-error: no age category for age " << age; } simrisc-14.05.00/densities/icmconf0000644000175000017500000000010014034554241015717 0ustar frankfrank#define LIBRARY "densities" #include "../icmconf.lib" simrisc-14.05.00/densities/densities.ih0000644000175000017500000000035714034554241016705 0ustar frankfrank#include "densities.h" #include "../xerr/xerr.ih" #include #include #include "../random/random.h" #include "../parser/parser.h" #include "../globals/globals.h" using namespace std; using namespace FBB; simrisc-14.05.00/densities/writeparameters.cc0000644000175000017500000000045314034554241020116 0ustar frankfrank//#define XERR #include "densities.ih" void Densities::writeParameters(std::ostream &out) const { out << "BreastDensities:\n"; Globals::setWidthPrec(out, 3, 2); for (Density const &density: d_densities) out << setw(2) << ' ' << density << '\n'; out.put('\n'); } simrisc-14.05.00/densities/proportions.cc0000644000175000017500000000070714034554241017300 0ustar frankfrank//#define XERR #include "densities.ih" // static bool Densities::proportions(vector const &vect) { return find_if(vect.begin(), vect.end(), [&](double value) { return value < 0 or 1 < value; // if not in [0..1] then } // not a proportion -> ) // vect.end() is not returned == vect.end(); } simrisc-14.05.00/densities/biradindices.cc0000644000175000017500000000041314034554241017314 0ustar frankfrank//#define XERR #include "densities.ih" Uint16Vect Densities::biRadIndices(DoubleVect const &ages) const { Uint16Vect ret; double prob = Random::instance().uniform(); for (double age: ages) ret.push_back(biradIdx(age, prob)); return ret; } simrisc-14.05.00/densities/frame0000644000175000017500000000007014034554241015401 0ustar frankfrank//#define XERR #include "densities.ih" Densities:: { } simrisc-14.05.00/densities/add.cc0000644000175000017500000000155414034554241015433 0ustar frankfrank//#define XERR #include "densities.ih" // # bi-rad: a b c d // ageGroup: 0 - 40: .05 .30 .48 .17 void Densities::add(bool *checkRange, LineInfo const &line) { Density density; if (not Parser::extract(line, density)) // density spec. error { *checkRange = false; return; } Err::Context context; if (not proportions(density.birad())) context = Err::RANGE_0_1; else if (not density.sumOne()) context = Err::PROB_SUM; else // so far all's OK { if (*checkRange) { if (density.ageGroup().nextRange(d_densities)) d_densities.push_back(density); else *checkRange = false; } return; } Err::msgTxt(context); } simrisc-14.05.00/density/0000755000175000017500000000000014051665273014066 5ustar frankfranksimrisc-14.05.00/density/insert.cc0000644000175000017500000000050014034554241015665 0ustar frankfrank//#define XERR #include "density.ih" std::ostream &Density::insert(ostream &out) const { out << "ageGroup: " << d_ageGroup << ", bi-rad: "; for (size_t idx = 0; idx != N_BIRADS; ++idx) out << static_cast('a' + idx) << ": " << setw(4) << d_birad[idx] << ", "; return out; } simrisc-14.05.00/density/indexof.cc0000644000175000017500000000045414034554241016025 0ustar frankfrank//#define XERR #include "density.ih" uint16_t Density::indexOf(double prob) const { return find_if(d_cumBirads.begin(), d_cumBirads.end(), [&](double cumProb) { return prob <= cumProb; } ) - d_cumBirads.begin(); } simrisc-14.05.00/density/icmconf0000644000175000017500000000007614034554241015423 0ustar frankfrank#define LIBRARY "density" #include "../icmconf.lib" simrisc-14.05.00/density/extract.cc0000644000175000017500000000071514034554241016043 0ustar frankfrank//#define XERR #include "density.ih" // ageGroup: 0 - 40: -> // .05 .30 .48 .17 istream &Density::extract(istream &in) { in >> d_ageGroup; double cumProb = 0; for (size_t idx = 0; idx != N_BIRADS; ++idx) { double probability; in >> probability; d_birad[idx] = probability; cumProb += probability; d_cumBirads[idx] = cumProb; } return in; } simrisc-14.05.00/density/density.ih0000644000175000017500000000023114034554241016054 0ustar frankfrank#include "density.h" #include "../xerr/xerr.ih" //#include #include #include #include using namespace std; simrisc-14.05.00/density/density1.cc0000644000175000017500000000016014034554241016123 0ustar frankfrank//#define XERR #include "density.ih" Density::Density() : d_birad(N_BIRADS), d_cumBirads(N_BIRADS) { } simrisc-14.05.00/density/density.h0000644000175000017500000000434714034554241015717 0ustar frankfrank#ifndef INCLUDED_DENSITY_ #define INCLUDED_DENSITY_ #include #include #include #include "../agegroup/agegroup.h" #include "../enums/enums.h" #include "../globals/globals.h" // BreastDensities: // // # bi-rad: a b c d // ageGroup: 0 - 40: .05 .30 .48 .17 class Density { enum { N_BIRADS = 4, // bi-rad categories (cf. tech man. section Densities) }; friend std::istream &operator>>(std::istream &in, Density &density); friend std::ostream &operator<<(std::ostream &out, Density const &density); AgeGroup d_ageGroup; std::vector d_birad; std::vector d_cumBirads; public: Density(); uint16_t beginAge() const; uint16_t endAge() const; double birad(size_t idx) const; AgeGroup const &ageGroup() const; bool contains(double age) const; // .ih uint16_t indexOf(double prob) const; std::vector const &birad() const; bool sumOne() const; private: std::istream &extract(std::istream &in); std::ostream &insert(std::ostream &out) const; }; typedef std::vector DensityVect; // ensure sorted by end-age // and that the full range is // covered inline bool Density::sumOne() const { return Globals::isZero(d_cumBirads[N_BIRADS - 1] - 1); } inline AgeGroup const &Density::ageGroup() const { return d_ageGroup; } inline uint16_t Density::beginAge() const { return d_ageGroup.beginAge(); } inline uint16_t Density::endAge() const { return d_ageGroup.endAge(); } inline double Density::birad(size_t idx) const { return d_birad[idx]; } inline std::vector const &Density::birad() const { return d_birad; } inline bool Density::contains(double age) const { return d_ageGroup.beginAge() <= age and age < d_ageGroup.endAge(); } inline std::istream &operator>>(std::istream &in, Density &density) { return density.extract(in); } inline std::ostream &operator<<(std::ostream &out, Density const &density) { return density.insert(out); } #endif simrisc-14.05.00/density/frame0000644000175000017500000000006414034554241015074 0ustar frankfrank//#define XERR #include "density.ih" Density:: { } simrisc-14.05.00/distribution/0000755000175000017500000000000014051665273015126 5ustar frankfranksimrisc-14.05.00/distribution/fmt.cc0000644000175000017500000000031314034554241016211 0ustar frankfrank//#define XERR #include "distribution.ih" // static void Distribution::fmt(unsigned intWidth, unsigned precision) { s_width = intWidth + precision + (precision > 0); s_precision = precision; } simrisc-14.05.00/distribution/find.cc0000644000175000017500000000034714034554241016352 0ustar frankfrank#define XERR #include "distribution.ih" // static DistType Distribution::find(string const &name) { return static_cast( std::find(s_name.begin(), s_name.end(), name) - s_name.begin() ); } simrisc-14.05.00/distribution/insert.cc0000644000175000017500000000051614034554241016734 0ustar frankfrank//#define XERR #include "distribution.ih" std::ostream &Distribution::insert(std::ostream &out) const { if (d_type == N_DISTRIBUTIONS) out << setw(12) << ' '; else Globals::setWidthPrec(out, s_width, s_precision) << d_value << " (" << s_name[d_type] << ')'; return out; } simrisc-14.05.00/distribution/data.cc0000644000175000017500000000073014034554241016337 0ustar frankfrank//#define XERR #include "distribution.ih" StringVect Distribution::s_name // see enums.h { "Uniform" , // UNIFORM "Uniform" , // UNIFORM_CASE "LogNormal" , // LOGNORMAL "Normal", // NORMAL_VARY "Uniform" , // UNIFORM_VARY "LogNormal" , // LOGNORMAL_VARY }; // "Exponential", // EXPONENTIAL unsigned Distribution::s_width = 0; unsigned Distribution::s_precision = 0; simrisc-14.05.00/distribution/xlat.cc0000644000175000017500000000042214034554241016374 0ustar frankfrank//#define XERR #include "distribution.ih" // static DistType Distribution::xlat(LineInfo const &info, string const &name) { auto ret = find(name); if (ret == N_DISTRIBUTIONS) Err::msg(Err::UNDEFINED_DIST) << '`' << name << '\'' << endl; return ret; } simrisc-14.05.00/distribution/distribution1.cc0000644000175000017500000000043214034554241020225 0ustar frankfrank//#define XERR #include "distribution.ih" Distribution::Distribution(VaryType varyType) : d_vary(varyType == VARY_NONNEG ? &Distribution::varyNonNeg : varyType == VARY_PROB ? &Distribution::varyProb : &Distribution::varyMean) {} simrisc-14.05.00/distribution/varynonneg.cc0000644000175000017500000000106614034554241017617 0ustar frankfrank#define XERR #include "distribution.ih" double Distribution::varyNonNeg(double orgValue) const { for (unsigned count = 0; count != MAX_VARY_TRIES; ++count) { // try to obtain a valid spreaded SD if (double ret = varyMean(orgValue); ret >= 0) return ret; } throw Exception{} << "failed to obtain non-negative spread value for " << orgValue << " (spread = " << d_value << ", distribution: " << name(d_type) << ')'; } simrisc-14.05.00/distribution/icmconf0000644000175000017500000000010314034554241016452 0ustar frankfrank#define LIBRARY "distribution" #include "../icmconf.lib" simrisc-14.05.00/distribution/extract.cc0000644000175000017500000000134614034554241017104 0ustar frankfrank#define XERR #include "distribution.ih" // the Distribution is extracted if d_value is present. // if present it must be >= 0 istream &Distribution::extract(istream &in) { if (not (in >> d_value)) // nothing there to extract { d_type = NORMAL_VARY; prepareVary(); in.clear(); return in; } if (d_value < 0) { Err::msgTxt(Err::NEGATIVE); in.fail(); return in; } // value was extracted, so dist must be present. string dist; if (in >> dist and (d_type = find(dist)) != N_DISTRIBUTIONS) { prepareVary(); return in; } Err::msgTxt(Err::UNDEFINED_DIST); in.fail(); return in; } simrisc-14.05.00/distribution/preparevary.cc0000644000175000017500000000056714034554241017776 0ustar frankfrank//#define XERR #include "distribution.ih" void Distribution::prepareVary() { switch (d_type) { case NORMAL_VARY: break; case UNIFORM: d_type = UNIFORM_VARY; break; case LOGNORMAL: d_type = LOGNORMAL_VARY; break; default: return; } Random::instance().use(d_type); } simrisc-14.05.00/distribution/varymean.cc0000644000175000017500000000137314034554241017254 0ustar frankfrank#define XERR #include "distribution.ih" // in the original code refreshing is handled by reloading the complete config // file. So the argument passed to this member should be the initial value // and not the updated value. double Distribution::varyMean(double orgValue) const { Random &random = Random::instance(); switch (d_type) { case NORMAL_VARY: return orgValue + random.normalVary() * d_value; case UNIFORM_VARY: return orgValue + d_value * (random.uniformVary() - .5); case LOGNORMAL_VARY: return random.logNormalVary(orgValue, d_value); default: return orgValue; } } // case EXPONENTIAL: // return orgValue + random.exponential(orgValue); simrisc-14.05.00/distribution/distribution.h0000644000175000017500000000543714034554241020020 0ustar frankfrank#ifndef INCLUDED_DISTRIBUTION_ #define INCLUDED_DISTRIBUTION_ #include #include "../typedefs/typedefs.h" // The Distribution receives the spread value and distribution name, // Either both or none most be specified. If none is specified then // spread = 0, and calling vary() simply returns the received argument class Distribution { enum { MAX_VARY_TRIES = 10, // max #attempts to obtain a valid varied value }; friend std::istream &operator>>(std::istream &in, Distribution &dist); friend std::ostream &operator<<(std::ostream &out, Distribution const &dist); double d_value = 0; // used as defaults DistType d_type = N_DISTRIBUTIONS; // with, e.g., vectors double (Distribution::*d_vary)(double orgValue) const = &Distribution::varyMean; static StringVect s_name; static unsigned s_width; static unsigned s_precision; public: Distribution(VaryType varyType); double value() const; DistType type() const; double vary(double orgValue) const; // obtain varied value or // throw an exception // returns ABSENT if // an undefined name is used static DistType find(std::string const &distName); // must succeed or err static DistType xlat(LineInfo const &lineInfo, std::string const &distName); static std::string const &name(DistType dist); // intWidth: width of the // integral part static void fmt(unsigned intWidth, unsigned precision); private: std::istream &extract(std::istream &in); std::ostream &insert(std::ostream &out) const; void prepareVary(); double varyMean(double orgValue) const; // these members are double varyNonNeg(double orgValue) const; // called via d_vary double varyProb(double orgValue) const; }; // static inline std::string const &Distribution::name(DistType dist) { return s_name[dist]; } inline double Distribution::vary(double orgValue) const { return (this->*d_vary)(orgValue); } inline std::istream &operator>>(std::istream &in, Distribution &dist) { return dist.extract(in); } inline std::ostream &operator<<(std::ostream &out, Distribution const &dist) { return dist.insert(out); } inline double Distribution::value() const { return d_value; } inline DistType Distribution::type() const { return d_type; } #endif simrisc-14.05.00/distribution/frame0000644000175000017500000000007614034554241016137 0ustar frankfrank//#define XERR #include "distribution.ih" Distribution:: { } simrisc-14.05.00/distribution/distribution.ih0000644000175000017500000000044214034554241020160 0ustar frankfrank#include "distribution.h" #include "../xerr/xerr.ih" #include #include #include #include #include #include "../err/err.h" #include "../globals/globals.h" #include "../random/random.h" using namespace std; using namespace FBB; simrisc-14.05.00/distribution/varyprob.cc0000644000175000017500000000102614034554241017271 0ustar frankfrank#define XERR #include "distribution.ih" double Distribution::varyProb(double orgValue) const { for (unsigned count = 0; count != MAX_VARY_TRIES; ++count) { if ( double ret = varyMean(orgValue); Globals::proportion(ret) ) return ret; } throw Exception{} << "failed to obtain spread proportion for " << orgValue << " (spread = " << d_value << ", distribution: " << name(d_type) << ')'; } simrisc-14.05.00/documentation/0000755000175000017500000000000014034554241015251 5ustar frankfranksimrisc-14.05.00/documentation/man/0000755000175000017500000000000014052261030016013 5ustar frankfranksimrisc-14.05.00/documentation/man/include/0000755000175000017500000000000014034554241017447 5ustar frankfranksimrisc-14.05.00/documentation/man/include/trailer.yo0000644000175000017500000000030714034554241021462 0ustar frankfrank manpagesection(COPYRIGHT) This is free software, distributed under the terms of the GNU General Public License (GPL). manpageauthor() Frank B. Brokken (bf(f.b.brokken@rug.nl)),nl() simrisc-14.05.00/documentation/man/include/configfiles.yo0000644000175000017500000000103014034554241022302 0ustar frankfrankmanpagefiles() itemization( it() tt(~/.config/simrisc): the default location of the program's configuration file; it() the sr() distribution archive contains the default configuration file as tt(simrisc-VERSION/stdconfig/simrisc), where tt(VERSION) is replaced by sr()'s actual release version; it() when installing sr() using Linux distribution archives (e.g., tt(.deb) files) the default configuration file is commonly available as tt(/usr/shared/doc/simrisc/simrisc.gz) ) simrisc-14.05.00/documentation/man/include/header.yo0000644000175000017500000000143714034554241021255 0ustar frankfrankDEFINEMACRO(Manpage)(1)(\ whenman((Manpage: bf(man -e simrisc ARG1)))\ whenhtml((Manpage: url(ARG1(3simrisc))(ARG1.3.html)))\ ) DEFINEMACRO(itb)(1)(it() bf(ARG1):nl()) DEFINEMACRO(itt)(1)(it() tt(ARG1)) DEFINEMACRO(itrange)(2)(tt(CHAR(91)ARG1, ARG2+CHAR(41))) includefile(../../../release.yo) htmlbodyopt(text)(#27408B) htmlbodyopt(bgcolor)(#FFFAF0) whenhtml(mailto(Frank B. Brokken: f.b.brokken@rug.nl)) DEFINEMACRO(lsoption)(3)(\ bf(--ARG1)=tt(ARG3) (bf(-ARG2))\ ) DEFINEMACRO(laoption)(2)(\ bf(--ARG1)=tt(ARG2)\ ) DEFINEMACRO(loption)(1)(\ bf(--ARG1)\ ) DEFINEMACRO(soption)(1)(\ bf(-ARG1)\ ) DEFINEMACRO(sr)(0)(bf(simrisc)) DEFINEMACRO(Sr)(0)(bf(Simrisc)) DEFINEMACRO(Cpp)(0)(bf(C++)) DEFINEMACRO(prot)(0)(tt((prot))) DELETEMACRO(tt) DEFINEMACRO(tt)(1)(em(ARG1)) simrisc-14.05.00/documentation/man/include/changes.yo0000644000175000017500000000267514034554241021442 0ustar frankfrank manpagesection(Changes introduced in version 14.04.00) itemization( it() Parameters affected by tt(spread: true)nl() Parameters that may vary are specified using triplets: value, spread and distribution. In all cases the spread values and distribution names are optional: they can both be omitted or both must be specified. If these parameters are not specified then their tt(value) parameter won't vary if tt(spread: true) is specified; it() The tt(Mammo, Tomo,) and tt(MRI) modalities are provided with std.dev and distribution parameters for their tt(Dose, M, Beta, Specificity,) and tt(Sensitivity) parameters; it() When tt(spread: true) is specified the actually used and original parameter values are listed in a file, by default tt(spread-$.txt), where tt($) is replaced by the loop iteration index. Use the option tt(-s) to specify a non-default filename (cf. bf(simrisc)(1)); it() Age ranges no longer have trailing colons; it() The Case-specific data matrix defines an extra (18th) column, showing the results of the screening rounds for each simulated case; it() The order of the tt(beir7 beta) and tt(eta) parameters is reversed: tt(eta) is specified first, followed by tt(beta). The tt(spread) and tt(distribution) parameters following tt(beta) apply to tt(beta), and not to tt(eta), which is a fixed value. ) simrisc-14.05.00/documentation/man/simrisc.yo0000644000175000017500000004030514052261030020037 0ustar frankfrankNOUSERMACRO(simrisc line) includefile(../../release.yo) htmlbodyopt(text)(#27408B) htmlbodyopt(bgcolor)(#FFFAF0) whenhtml(mailto(Frank B. Brokken: f.b.brokken@rug.nl)) DEFINEMACRO(lsoption)(3)(\ bf(--ARG1)=tt(ARG3) (bf(-ARG2))\ ) DEFINEMACRO(laoption)(2)(\ bf(--ARG1)=tt(ARG2)\ ) DEFINEMACRO(loption)(1)(\ bf(--ARG1)\ ) DEFINEMACRO(soption)(1)(\ bf(-ARG1)\ ) DEFINEMACRO(sr)(0)(bf(simrisc)) DEFINEMACRO(Sr)(0)(bf(Simrisc)) DEFINEMACRO(Cpp)(0)(bf(C++)) DEFINEMACRO(prot)(0)(tt((prot))) IFDEF(man)( DELETEMACRO(tt) DEFINEMACRO(tt)(1)(em(ARG1)) )() def(itt)(1)(it()tt(ARG1)) COMMENT( man-request, section, date, distribution file, general name) manpage(simrisc)(1)(_CurYrs_)(simrisc._CurVers_) (simrisc breast cancer simulation program) manpagename(simrisc)(This program performs simulations in the context of breast cancer) COMMENT( all other: add after () ) manpagesynopsis() sr() [options] tt(analyses) The tt(analyses) argument is the name of the file specifying the analyses to perform. See section bf(ANALYSES) for details. manpagedescription() Sr() was originally designed around 2010 by Marcel Greuter at the University Medical Center Groningen, and thereafter modified in 2015 by Chris de Jonge. includefile(include/changes.yo) manpageoptions() Short options are provided between parentheses, immediately following their long option equivalents. Several parameters specify the path-names of files produced by sr(). If a path-name starts with a tilde character (~) then the tilde is replaced by the user's home directory. An initial + is replaced by the program's base directory (see option tt(base)). When an analysis uses multiple iterations then `$' characters in filename specifications are replaced by the analysis' interation index. All single-letter options referring to filesystem entries (directories, filenames) are capitalized, all other single-letter options are lowercase. itemization( it() lsoption(base)(B)(basedir)nl() the base directory where the output files will be written. By default tt(./). If tt(basedir) doesn't exist it is created by the program. If the directory cannot be created and exception is thrown, terminating the program. The tt(basedir) specifications may specify relative or absolute directory locations; it() lsoption(config)(C)(path)nl() the location of the configuration file. By default tt(~/.config/simrisc') is used. it() lsoption(data)(D)(path)nl() path name of the file to contain the data of the cases generated by the simulation (default: '/data-$.txt'). If a data file should not be written specify tt(!) (mnemonic: the logical not operator, i.e., tt(--data !)). See section bf(OUTPUT) for a description of the generated data; it() lsoption(death-age)(a)(age)nl() run one simulation using a specific natural death-age. This option also requires the specification of tt(tumor-age), and is mutually exclusive with the tt(case) option; it() loption(err) (soption(e))nl() before version 14.05.00 the Beir7 risk vector was computed using an incorrect algorithm. The error was fixed in simrisc 14.05.00. When it is required to use the erroneous algorithm, e.g., to compare the results of simulations with previously obtained results, option tt(-e) must be specified. However, option tt(-e) should not be used for real simulations; it() loption(help) (soption(h))nl() shows help information and terminates; it() lsoption(last-case)(l)(nCases)nl() perform simulations until tt(nCases) cases have been analyzed and only write the data for the final case to the data file. The tt(rounds) and tt(sensitivity) files contain the summarized results of all tt(nCases) analyzed cases; it() loption(one-analysis) (soption(o))nl() the program's arguments specify the parameters of a single analysis, rather than the name of an analyses-specification file. The program's arguments are optional and are used to alter the parameter values as defined in the config file or to define tt(label) specifications. See section bf(ANALYSES) for details; it() lsoption(parameters)(P)(path)nl() path name of the file showing the actually used parameter specifications. By default no parameter file is written; it() lsoption(rounds)(R)(path)nl() path name of the file to containing the summary info of the simulation rounds (default: '/rounds-$.txt'). If a rounds file should not be written specify tt(!) (i.e., tt(--rounds !)). See section bf(OUTPUT) for a description of the generated summary info; it() lsoption(spread)(s)(path)nl() path name of the file to contain the actually used and original parameter values when tt(spread: true) is specified (default: '/spread-$.txt'). If this file should not be written specify tt(!) (mnemonic: the logical not operator, i.e., tt(--spread !)). See section bf(OUTPUT) for a sample of its content; it() lsoption(sensitivity)(S)(path)nl() path name of the file to containing the summary info of the simulation's sensitivity data (default: '/sensitivity.txt'). If a sensitivity file should not be written specify tt(!) (i.e., tt(--sensitivity !)). See section bf(OUTPUT) for a description of the produced sensitivity summary; COMMENT( it() lsoption(totalrisk)(T)(path)nl() path name of the file to containing the cumulative total risk values (default: '/totalrisk.txt'). By default the cumulative total risk values are not written to file; END) it() lsoption(tumor-age)(t)(age)nl() run one simulation using a specific tumor self-detect age. This option also requires the specification of tt(death-age), and is mutually exclusive with the tt(case) option; it() loption(verbose) (soption(V))nl() provides additional information while running; it() loption(version) (soption(v))nl() shows sr()'s version information and terminates; ) manpagesection(ANALYSES) Unless the tt(one-analysis) option is used the program's first and only required argument is the name of a file providing the details of the analyses to perform. Those files are called analysis files and must be standard ascii text files. I.e., they only contain 7-bit ascii printable and white-space characters. The identifiers used in analysis files and in configuration files are interpreted case sensitively. Parameter specifications starting with uppercase letters (like tt(Analysis:) and tt(Scenario:)) specify (sub)sections and contain no additional specifications. Specifications starting with lowercase letters (like tt(ageGroup:)) are followed by actual parameter values. For a complete overview refer to the bf(simriscparams)(7) man-page. Analysis files may define multiple analyses. Each analysis specification em(must) begin with a line containing verb( Analysis: ) At each tt(Analysis:) specification the program's initial configuration is reset: the default option values are used unless redefined by explicitly provided command-line options. Explicitly provided command-line options cannot be altered by specifications in tt(Analysis:) sections and remain active while sr() is running. Following tt(Analysis:) lines the characteristics of the analysis are specified. These specifications may, in the following order: itemization( it() define em(label:) lines (label: lines, when used, must immediately follow tt(Analysis:) lines). The text following tt(label:) lines is written at the top of the output files; it() alter default sr() options; it() redefine parameter specifications of configuration files; ) All specifications in tt(Analysis:) sections are optional. An tt(Analysis:) specification merely containing the line tt(Analysis:) defines an analysis using the explicitly specified command-line options or the default program options and using the parameter specifications provided in the configuration file. Empty lines, trailing white-space, and all characters on lines starting at the hash-mark (tt(#)) are ignored and may be used anywhere in analysis files. Lines not conforming to the above description result in error messages, causing sr() to end. When parameters of configuration file sections (cf. bf(simriscparams)(7)) are omitted from tt(Analysis:) sections then the parameters as specified in the configuration file are used. When program options are specified their long option names must be used. E.g.: verb( base: /tmp/ last-case: 20 ) Command-line options always overrule options specified in analysis files. Multiple analysis sections should not use identically named output files, as the output files are (re)written for each separate analysis. Analysis sections are commonly used to alter the default specifications of the configuration file. E.g., the default number of iterations equals 1. By specifying verb( iterations: 3 ) the analysis performs 3 iterations. Parameters are either read from the configuration file or they are redefined in tt(Analysis:) sections. E.g., in de provided configuration file screening rounds use two-year intervals between the ages of 50 and 74. To use screening rounds using 5-year intervals, between ages 50 and 65, then an tt(Analysis:) specification could be, e.g., verb( Screening: round: 50 Mammo MRI round: 55 Mammo MRI round: 60 Mammo MRI round: 65 Mammo MRI ) When the tt(--one-analysis) option is used parameters may be altered by providing comma-separated parameter specifications as program command-line arguments. E.g., to perform one analysis, writing the data file to tt(/tmp/data), simulating 1000 cases, and using 20 as seed for the random number generator the command verb( simrisc -D /tmp/data -o Scenario:, cases: 1000, seed: 20 ) can be used. Note that when using the tt(one-analysis) option parameter section names must precede parameter specifications. E.g., since the parameters tt(cases) and tt(seed) are defined in the `Scenario' section (cf. bf(simriscparams)(7)) they must be preceded by the tt(Scenario:) specification. Subsequent tt(Analysis:) specifications in analysis files use the program options as specified on the command line (or, if not specified, the default program options) and uses the configuration file's parameter specifications. So when an tt(Analysis:) specification modifies parameters, then subsequent tt(Analysis:) sections start from the unmodified option and parameter specifications. When tt(Analysis:) sections specify tt(base:) directory locations then file specifications using an initial `tt(+)' character to represent the base directory (like tt(--data +/data.txt)) use the base directory specified at the tt(Analysis:)'s tt(base:) specification. manpagesection(OUTPUT) The first lines of the generated files contain time stamps showing the date and time when the files were written and the used tt(SimRisc) version. Here is an example, following the RFC 2822 format for the timestamp: verb( Thu, 08 Apr 2021 21:43:09 +0200 (SimRisc V. 14.04.00) ) If tt(label:) lines are used then the time stamp is followed by the label specifications, which is then followed by an empty line. After this header the file's specific data are shown. The data in all files (except for the file listing the actually used parameters (option tt(--parameters) (tt(P)))) are written using the standard comma-separated format (cf. RFC 4180). The initial lines contain table headings and column labels documenting the meanings of the various columns. Likewise there is a final line ending the tables. bf(Data of simulated cases) For each simulated case the values of the following variables are written to file (one line of comma-separated values per simulated case): itemization( itt(case:) the (0-based) case-index; itt(cause of death:) either tt(Natural) or tt(Tumor); itt(death age:) the case's age of death; itt(natural death age:) the case's natural age of death (if no tumor occurs); itt(death status:) a numeric index specifying how and at what stage the case died:nl() 1: natural death in the pre-screening phase,nl() 2: natural death in the screening phase,nl() 3: natural death in the post-screening phase,nl() 4: tumor caused death in the pre-screening phase,nl() 5: tumor caused death in the screening phase,nl() 6: tumor caused death in the post-screening phase; itt(tumor present:) tt(Yes) if the simulation resulted in a tumor, tt(No) if no tumor occurred; itt(tumor detected:) tt(Yes) if the tumor was detected, tt(No) if not; itt(interval tumor:) tt(Yes) if the tumor was an interval tumor, tt(No) if not; itt(tumor diameter:) the tumor's diameter in mm when it was detected. 0.00 is shown if no tumor occurred. In the exceptional case where the simulation produced a tumor whose diameter exceeded 1000 mm the value 1001 is shown. itt(tumor doubling days:) the time (in days) it takes for the tumor to double its size; itt(tumor preclinical period:) the age at which the tumor is potentially detectible by Mammographic screening; itt(tumor onset age:) the age at which the tumor first occurred; itt(tumor self-detect age:) the age at which the tumor was self-detected. This age is the result of the simulation, and may exceed the case's actual death age (if so, the case's data report that no tumor is present); itt(tumor death age:) the age at which the tumor caused or would have caused he case's death. The simulation process uses ages ranging from 0 through 100. If the age at which the tumor causes the case's death exceeds 100, then 100.00 is reported; itt(costs:) the case's screening and (if appliccable) treatment costs; itt(self-detection indicator): 1 if the tumor was self-detected, 0 if not (also if there's no tumor); itt(detection round): 0-based round index at which the tumor was detected (or 1) if the tumor was self-detected, 0 if not (also if there's no tumor). itt(screening rounds): this column contains show which screening rounds were attended by the simulated cases, and if so whether false negative or false positive diagnoses were made. The following digits are used: itemization( it() 0: the case did not attend this screening round; it() 1: the case did attend this screening round; it() 2: the case did attend this screening round, resulting in a false negative diagnosis; it() 3: the case did attend this screening round, resulting in a false positive diagnosis. ) There are as many digits as screening rounds. The leftmost digit refers to the first screening round, the rightmost digit to the last screening round. E.g., using 12 screening rounds the following indicators could be obtained: verb( 0011311110000 ) Using screening round indices (which are also used to refer to rounds in the tt(rounds-$.txt) files), this case did not attent screening rounds 0, 1, 9, 10, 11 and 12, and at 4 a false positive diagnosis was obtained. ) bf(Actually used spread-values) When tt(spread: true) is specified then by default the actually used and orgiginal parameter values are written to the file tt(spread-$.txt), where tt($) is replaced by the loop's iteration index. Here is a sample from the content of such a file, showing the values of modality tt(Mammo's Beta) parameters: verb( Beta: nr: 1 using -4.37906 (configured: -4.38) nr: 2 using 0.490436 (configured: 0.49) nr: 3 using -1.33749 (configured: -1.34) nr: 4 using -7.22025 (configured: -7.18) ) includefile(include/configfiles.yo) manpageseealso() bf(simriscparams)(7) COMMENT( manpagediagnostics() manpagebugs() too early for that... EDN) includefile(include/trailer.yo) simrisc-14.05.00/documentation/man/transitions.txt0000644000175000017500000001576114016451635021157 0ustar frankfrankHoi Marcel, hoi Truuske, Haast je langzaam, maar zodra je de tijd ervoor hebt, bestudeer dan even wat ik hieronder schrijf en laat me weten wat je ervan vindt: Transitiematrices: voorstel voor specificaties: ----------------------------------------------- De configuratieparameter 'Transitions:' is optioneel. Als-ie niet wordt gespecificeerd wordt de implementatie van simrisc 14.03.00 gebruikt, als-ie wel wordt gespecificeerd worden de transitiematrices gebruikt. Hieronder volgt een uitgewerkt specificatievoorbeeld, toelichting daarna. voorbeeld configuratiefile specificatie: ---------------------------------- Transitions: steps: 4 ages: 0-50 50-70:5 70-* file: file-lokatie (of: matrices: gevolgd door het vereiste aantal transitiematrices, rijgewijs gespecificeerd) ---------------------------------- 'steps' geeft het aantal transitiestappen. 4 betekent: een 4 x 4 matrix waarvan element [i, j] de waarschijnlijkheid definieert dat er een transitie van toestand i naar toestand j plaatsvindt. Rijgewijs moeten de transities sommeren tot 1. Stel dat 'steps: 2' is gespecificeerd, dan betekent dat bij bv. de matrix .95 .05 .01 .99 dat een case in toestand 1 een p = .05 heeft om naar toestand 2 over te gaan. Een case in toestand 2 heeft een p = .01 om terug te keren naar toestand 1. 'ages' definieert voor welke leeftijdsgroepen een transitiematrix beschikbaar is. a-b betekent: 1 transitiematrix die wordt toegepast vanaf leeftijd a tot leeftijd b. Als voor b * wordt gespecificeerd wordt de transitiematrix vanaf leeftijd a toegepast. a-b:c betekent: c transitiematrices die worden toegepast op de opeenvolgende leeftijdsblokken (b - a) / c. In het voorbeeld hierboven: 50-70:5 betekent dat er 5 transitiematrices zijn die, respectievelijk, worden toegepast in de leeftijdsintervallen: 50 tot 54 54 tot 58 58 tot 62 62 tot 66 66 tot 70 In het bovenstaande voorbeeld zijn er dus 7 4x4 matrices nodig. Het is mogelijk om die matrices in de configuratiefile zelf op te nemen, maar 't is wellicht handiger om ze in een file op te slaan, waardoor je bv makkelijk tussen transities kunt wisselen. Vandaar de 'file' optie: de naam die volgt op 'file:' geeft de locatie (pad + filenaam) van de file die de matrices bevat. Maar 't is ook nog steeds mogelijk om de matrices wel in de configuratiefile zelf op te nemen: na 'matrices:' wordt het vereiste aantal matrices verwacht. ---------------------------------------------------------------------------- Transitiematrices: implementatievoorstel: ------------------------------------------ Wanneer 'Transitions:' is gespecificeerd dan wordt er per case pas een tumor gesimuleerd zodra die case het laatste transitiestadium bereikt. Het proces (per case) zal dan alsvolgt verlopen: beginleeftijd: 1e leeftijd waarvoor een transitiematrix beschikbaar is (in 't voorbeeld dus: 0) eindleeftijd: laatste leeftijd waarvoor een transitiematrix beschikbaar is (in 't voorbeeld dus: de max. leeftijd (*, = 100). begin toestand: 1 simulatieproces: ---------------- deel 1: ======= vervolgens wordt geitereerd van begin naar eind, waarbij in elke stap ogv de van toepassing zijnde transitiematrix wordt bepaald wat de toestand is in die leeftijd. Wanneer gedurende deze iteraties std. screeningsleeftijden worden bereikt dan wordt/worden de bijbehorende screening/s uitgevoerd met wellicht als resultaat een fout-positieve diagnose. Wanneer de natuurlijke overlijdensleeftijd wordt bereikt stopt de simulatie van deze case. deel 1 wordt verlaten zodra de laatste toestand v.d. huidige transitiematrix is bereikt deel 2: ======= Tenzij de simulatie al bij deel 1 is gestopt gaat de simulatie alsvolgt verder: Zoals dat in de huidige versie v simrisc ook gebeurt wordt een tumor gesimuleerd, en de simulatie verloopt vanaf dat moment overeenkomstig de wijze waarop dat nu ook al gebeurt. Tevens wordt bij elk volgend jaar opnieuw een transitieberekening uitgevoerd, omdat een transitie naar een vorig stadium mogelijk is. ---------------------------------------------------------------------------- Transitiematrices: versnelling van simrisc: ------------------------------------------- Wanneer we bovenstaande procedure gaan toepassen betekent dat een toename van het werk dat het programma moet uitvoeren omdat de N screeningsrondes dan genest zijn binnen een omhullende iteratie van K leeftijden. Ik kan niet overzien hoeveel langer simrisc dan bezig zal zijn met een simulatie en of dat tot een wezenlijke vertraging zal leiden. Maar mocht dat zo zijn (niet onwaarschijnlijk) dan kan zo'n vertraging worden verminderd door simrisc multi-threaded te maken. Op dit moment verloopt 't simulatieproces alsvolgt: voor elke case: initialiseer de case, pre-screening, screening, post-screening. schrijf de resultaten naar file Zouden we simrisc multi-threaded maken dan kunnen de analyses voor een aantal cases parallel worden uitgevoerd: voor elke case: zodra mogelijk: verwerk de volgende case Stel dat er twee cases parallel kunnen worden verwerkt, dan bestaat zo'n verwerking uit deze stappen: (busy) - dwz in bovenstaande regel wordt bij 'zodra mogelijk' - gewacht totdat een verwerkings-thread beschikbaar is initialiseer de case, pre-screening, screening, post-screening, schrijf de resultaten naar file. (beschikbaar) Maar er treedt hier wellicht een probleempje op wanneer fixed en stapsgewijze seeds worden gebruikt bij het herinitialiseren van de random nr. generatoren: binnen de simulatiestappen (per case) worden random nrs gebruikt. Zou simrisc op de hier beschreven wijze multi-threaded worden dan ligt de volgorde waarin de random getallen worden bepaald niet meer vast, omdat thread 1 en thread 2 op onvoorspelbare momenten random getallen genereren, waardoor de sequentie binnen een case-gebonden simulatie dus niet meer vastligt, zoals dat wel het geval is wanneer je single-threaded (zoals nu) simuleert. Maar we zouden dat probleem kunnen oplossen door elke thread z'n eigen random nr. generatoren te geven, die dan worden geinitialiseerd met de seed die op dat moment van toepassing is + het case-nr dat bij de thread-run hoort. Op die manier handhaven we de herhaalbaarheid van de random nrs, en daarmee de herhaalbaarheid van de case-gebonden waarden wanneer bv verschillende modaliteiten met elkaar worden vergeleken. Er is op dit moment nog geen sprake van multi-threading, maar mocht 't aantrekkelijk worden om multi-threading te gaan toepassen dan zou een aanpak zoals hier beschreven m.i. mogelijk zijn: wel multi-threading, met handhaving van herhaalbare simulatieresultaten. simrisc-14.05.00/documentation/man/simriscparams.yo0000644000175000017500000004657614034554241021274 0ustar frankfrankNOUSERMACRO(simriscparams N U L) includefile(../../release.yo) htmlbodyopt(text)(#27408B) htmlbodyopt(bgcolor)(#FFFAF0) whenhtml(mailto(Frank B. Brokken: f.b.brokken@rug.nl)) DEFINEMACRO(itq)(2)(\ it() verb(ARG1)ARG2 ) DEFINEMACRO(itt)(1)(it() tt(ARG1)nl()) DEFINEMACRO(sr)(0)(bf(simrisc)) DEFINEMACRO(Sr)(0)(bf(Simrisc)) IFDEF(man)( DELETEMACRO(tt) DEFINEMACRO(tt)(1)(em(ARG1)) )() COMMENT( man-request, section, date, distribution file, general name) manpage(simriscparams)(7)(_CurYrs_)(simrisc._CurVers_) (simrisc configuration file organization) COMMENT( man-request, larger title ) manpagename(simriscparams)(The description of the sc() configuration files) manpagedescription() This page describes the organization of the sr() configuration files. These files are formatted like standard unix configuration files. Lines are interpreted after removing initial white-space (blanks and tabs). If a line ends in \ (a backslash), then the next line (initial white-space removed) is appended to the current line. While processing the configuration files trailing blanks and information on lines starting at the first # character are removed. Note that all parameter identifiers are interpreted case sensitively. E.g., tt(Costs:) is a different parameter than tt(costs:). The numeric values used in this man-page are for illustration purpose only. Some restrictions apply though: standard deviations cannot be negative; proportions and probabilities must lie in the range 0..1; multiple probabilities (like the ones used for breast densities) must add up to 1; etc. If restrictions apply then they are mentioned at the various parameter descriptions below. manpagesection(DEFAULT CONFIGURATION FILE) A configuration file provided in the sr() distribution is+nl() tt(/usr/share/doc/simrisc/simrisc.gz). Usually this file is unzipped to the tt(~/.config) directory: verb( gunzip < /usr/share/doc/simrisc/simrisc.gz > ~/.config/ ) whereafter tt(~/.config/simrisc) can be edited to contain local modifications. Various parameters specify probability distributions. Usually the tt(Normal) distribution is specified. The program also recognizes the tt(LogNormal) and tt(Uniform) COMMENT(and Exponential) distributions. Parameter specifications start with keywords, followed by a colon. The keywords are listed in the following overview. The format of the specifications is also fixed, but empty lines and white space may be used to improve the specifications' readabilities. Also, all characters starting at tt(#) characters until the end of the line are considered comment and are ignored. Parameter specifications starting with uppercase letters (like tt(Scenario:)) specify (sub)sections and contain no additional specifications. Specifications starting with lowercase letters (like tt(ageGroup:)) are followed by actual parameter values. The configuration file must define all parameters of all configuration sections, but configuration parameters can be modified using a separate analysis file or using overriding command-line parameters. includefile(include/changes) manpagesection(The Scenario section) This section starts with a line containing tt(Scenario:) and it defines some general parameters that are used during the simulation process. The default configuration file contains the following specifications: itemization( itt(spread: false) when specified as tt(true) then parameter spreading is used; itt(iterations: 1) the (positive) number of iterations used in a simulation loop; itt(generator: random) in addition to tt(random) modes tt(fixed) and tt(increasing) are available.nl() This parameter specificies the way tt(simrisc's) random number generators are initialized. When mode tt(random) is specified the random number generators are initialized using randomly selected seeds and tt(seed) (below) is not used. When mode tt(fixed) is used the random number generators are initialized with tt(seed's) value. When mode tt(increasing) is used the seeds of the random number generators are incremented using a fixed increment at each iteration; itt(seed: 1) the (positive) value to seed the random number generator with. This parameter is ignored when tt(generator: random) was specified; itt(cases: 100000) the (positive) number of cases to simulate; ) manpagesection(The Costs section) This section starts with a line containing tt(Costs:) and it defines several parameters used for cost-calculations. Modality-specific cost parameters are specified at the tt(Modalities) section. The default configuration file contains the following specifications: itemization( itt(biop: 176) the (positive) cost of performing a biopsy; itt(diameters: 0: 6438 20: 7128 50: 7701) pairs of tt(diameter: cost) values specifying the treatment cost starting at the specified tumor diameter, up to the next pair's diameter (if specified) or all diameters starting at the diameter specified at the last pair. The first diameter em(must) be 0. The second value of each pair specifies the (non-negative) treatment costs for that age-group. itt(Discount:) the costs discount proportion starting at some age. This line is followed by two additional lines specifying the starting age and discount proportion: verb( age: 50 proportion: 0 ) ) manpagesection(The BreastDensities section) This section starts with a line containing tt(BreastDensities:) and it defines breast density values for various age groups, covering ages 0 through the maximum age for simulated cases. The default configuration file contains the following specifications: verb( # bi-rad: a b c d ageGroup: 0 - 40 0.05 0.30 0.48 0.17 ageGroup: 40 - 50 0.06 0.34 0.47 0.13 ageGroup: 50 - 60 0.08 0.50 0.37 0.05 ageGroup: 60 - 70 0.15 0.53 0.29 0.03 ageGroup: 70 - * 0.18 0.54 0.26 0.02 ) Age groups are half-open ranges: they start at their first ages, and end at (not including) their second ages. The first ages of subsequent age groups must be equal to the second ages of their previous age groups. For the last age group the specification tt(*) can be used, indicating that all ages at or above the last age group's begin age are handled by that group.nl() For each age group the probabilities of the four bi-rad classifications must sum to 1.0. manpagesection(the Modalities section) This section starts with a line containing tt(Modalities:) and it specifies cancer-scanning modalities. Currently three modalities are supported: tt(Mammo, Tomo) and tt(MRI). Some modalities specify age groups, which are (like the age ranges used for tt(breastDensities)) half-open ranges: they start at their first ages, and end at (not including) their second-ages, while subsequent age ranges must connect. Also, the last age group may use the end-age specification tt(*). The default configuration file contains (below the line tt(Modalities:)) the following specifications (if modalities aren't used their specifications are optional): itemization( itt(Mammo:) For the tt(Mammo) modality the costs, radiation doses and em(m:) parameter specifications per bi-rad category, specificity probabilities for age groups, the parameters of the beta-function, and the systematic error probability must be specified.nl() The default configuration file contains (below the line tt(Mammo:)) the following specifications verb( costs: 64 # default: systematicError: 0.1 Dose: # mean spread dist bi-rad: a 3 1 Normal bi-rad: b 3 1 Normal bi-rad: c 3 1 Normal bi-rad: d 3 1 Normal M: # proportion spread dist bi-rad: a .061 .021 Normal bi-rad: b .163 .045 Normal bi-rad: c .400 .106 Normal bi-rad: d .826 .088 Normal Beta: # mean spread dist nr: 1 -4.38 .002 Normal nr: 2 .49 .0005 Normal nr: 3 -1.34 .0074 Normal nr: 4 -7.18 .0340 Normal Specificity: # range proportion spread dist ageGroup: 0 - 40 .961 .005 Normal ageGroup: 40 - * .965 .005 Normal ) For this modality the sensitivity is computed using the beta-function published by Isheden and Humphreys (2017, Statistical Methods in Medical Research, 28(3), 681-702). From a randomly generated probability and a case's age the case's bi-rad category is determined and that category is then used to select the m-parameter that is used in the beta-function; itt(Tomo:) For the tt(Tomo) modality the costs, radiation doses per bi-rad category, sensitivity probabilities per bi-rad category, and specificity probabilities for age groups must be specified.nl() The default configuration file contains (below the line tt(Tomo:)) the following specifications: verb( costs: 64 Dose: # mean spread dist bi-rad: a 3 1 Normal bi-rad: b 3 1 Normal bi-rad: c 3 1 Normal bi-rad: d 3 1 Normal Sensitivity: # proportion spread dist bi-rad: a .87 .05 Normal bi-rad: b .84 .05 Normal bi-rad: c .73 .05 Normal bi-rad: d .65 .05 Normal Specificity: # range proportion spread dist ageGroup: 0 - 40 .961 .0025 Normal ageGroup: 40 - * .965 .0025 Normal ) itt(MRI:) For the tt(MRI) modality the costs, and the sensitivity and specificity probabilities must be specified.nl() The default configuration file contains (below the line tt(MRI:)) the following specifications: verb( costs: 280 # proportion spread dist sensitivity: .94 .005 Normal specificity: .95 .005 Normal ) ) manpagesection(The Screening section) This section starts with a line containing tt(Screening:) and it defines the ages at which screenings are performed as well as the screenings attendance rate. If no screening rounds should be used then specify a single round-specification line verb( round: none ) Otherwise, each screening round is defined by the keyword tt(round:) followed by an age which in turn is followed by a list of at least one space delimited modality specification (currently tt(Mammo, Tomo) and tt(MRI)). The default configuration file contains (below the line tt(Screening:)) the following specifications: verb( round: 50 Mammo round: 52 Mammo round: 54 Mammo round: 56 Mammo round: 58 Mammo round: 60 Mammo round: 62 Mammo round: 64 Mammo round: 66 Mammo round: 68 Mammo round: 70 Mammo round: 72 Mammo round: 74 Mammo ) In addition to the tt(round) specification line(s) the tt(Screening) section specifies the attendance rate proportion. The default configuration file specifies: verb( # proportion: attendanceRate: .8 ) manpagesection(The Tumor section) This section starts with a line containing tt(Tumor:) and it defines the parameters specifying tumor characteristics. Several of the parameters in this section can be provided with a spread and distribution specification. When tt(spread: true) is specified then these spread and distribution specifications are used to apply statistical variations to these parameters. Supported distributions are tt(Normal, Uniform,) and tt(LogNormal). If tt(value) is the specified tt(value) parameter value, and tt(spread) the specified tt(spread) parameter then the values that are actually used during the simulations are: itemization( it() when using the tt(Normal) distribution tt(N(mean, stddev)): verb( N(value, spread)) it() when using the tt(Uniform) distribution tt(U(begin, end)): verb( U(value - spread / 2, value + spread / 2)) it() when using the tt(LogNormal) distribution tt(L(mean, stddev)): verb( L(value, spread)) ) The tt(spread) parameters may not be negative. If tt(spread) is specified then the distribution must also be specified. If tt(spread) is not specified, then the tt(value) parameter won't vary if tt(spread: true) is specified in the tt(Scenario) section. The tt(Tumor:) section has four subsections: tt(beir7:, Growth, Incidence:,) and tt(Survival:). They contain the following parameter specifications: bf(beir7:) BEIR (tumor induction) parameters: only tumor induction type 7 (i.e., beir7) is used. The default configuration file contains this specification: verb( # eta beta spread dist. beir7: -2.0 0.51 0.32 Normal ) If tt(spread: true) is specified then the actually used tt(beta) parameter is drawn from the specified distribution having the specified std.dev. (spread). bf(Growth:) Tumor growth specifications consist of three elements: the start diameter, the self-detect parameters and the doubling time specifications. The tt(start) parameter defines the start diameter of emerging tumors. The default configuration file contains the following specification: verb( start: 5 ) Four parameters are used to determine the diameter at which self-detection is possible. These parameters are: itemization( it() the standard deviation (tt(stdev), see below) used by the lognormal distribution to compute the diameter at which self-detection occurs. This parameter is required and cannot be negative; it() the tt(mean) (see below) used by the lognormal distribution. This parameter is required and cannot be negative. Its value will vary using the following two parameters if tt(spread: true) was specified; it() the spread (standard deviation) used by the distribution that is used to vary the mean if tt(spread: true) was specified. It can be omitted in which case the mean won't vary; it() the distribution used to vary the mean. If the previous parameter is omitted then this parameter must also be omitted. ) The actually used self-detect diameter is computed using: verb( diameter = L(mean, stdev) ) The default configuration file contains these parameter specifications: verb( # stdev value spread dist. selfDetect: .70 2.92 .084 Normal ) Finally, the tt(Growth:) subsection also defines tumor doubling times for various age groups. Doubling times are computed like the self-detect diameters, i.e., using lognormal distributions. Thus, age groups are followed by four parameter specifications (of which the last two are optional): the standard deviation of the lognormal distribution, the mean value of the lognormal distribution, and the spread and name of the distribution that is used when tt(spread: true) was specified. The age groups must cover ages 0 through the maximum age for simulated cases, and are specified as described at section tt(BreastDensities:). The default configuration file contains the following specifications: verb( DoublingTime: # stdev mean spread dist. ageGroup: 1 - 50 .61 4.38 .43 Normal ageGroup: 50 - 70 .26 5.06 .17 Normal ageGroup: 70 - * .45 5.24 .23 Normal ) bf(Incidence:) Three carrier types are supported: tt(Normal, BRCA1) and tt(BRCA2). Each having a probability of occurrence. The probabilities of specified carriers must add to 1. Each carrier is identified by its name (e.g., tt(Normal:)) followed by four parameter specifications: itemization( it() the probability that the carrier is observed; it() the standard deviation used when computing the risk of getting a tumor. As this standard deviation is used in the denominator of expressions it must be larger than zero. COMMENT(incidence/settumorrisk2.cc) it() the lifetime risk: three parameters specifying a probability, optionally followed by the standard deviation and distribution that is used to vary the probability when tt(spread: true) is specified; it() the mean age: three parameters specifying the mean age, optionally followed by the standard deviation and distribution that is used to vary the probability when tt(spread: true) is specified; ) The default configuration file specifies the tt(Normal) carrier's probability as 1, effectively suppressing the other carriers. The default configuration file contains (below the tt(Incidence:) parameter line) the following specifications: verb( Normal: probability: 1 stdDev: 21.1 # value spread distr. lifetimeRisk: .226 .0053 Normal meanAge: 72.9 .552 Normal BRCA1: probability: 0 stdDev: 16.51 # value spread distr. lifetimeRisk: .96 meanAge: 53.9 BRCA2: probability: 0 stdDev: 16.51 # value spread distr. lifetimeRisk: .96 meanAge: 53.9 ) bf(Survival:) Four types of survival parameters must be specified. Each type specifies a distribution type, (a..d), a mean, and an (optional) spread and distribution which is used when tt(spread: true) is specified. The default configuration file specifies: verb( # value spread dist: type: a .00004475 .000004392 Normal type: b 1.85867 .0420 Normal type: c -.271 .0101 Normal type: d 2.0167 .0366 Normal ) manpagesection(PARAMETER RESPECIFICATION) Parameters can be respecified by defining a separate parameter configuration file or by providing alternate parameter specifications in tt(analyses:) sections of the program's input file, or by providing alternative parameter specifications as command-line arguments (cf. the bf(simrisc)(3) man-page) manpagefiles() includefile(include/configfiles.yo) manpageseealso() bf(simrisc)(1) COMMENT( manpagebugs() too early for that ... END) includefile(include/trailer.yo) simrisc-14.05.00/documentation/manual/0000755000175000017500000000000014034554241016526 5ustar frankfranksimrisc-14.05.00/documentation/manual/html/0000755000175000017500000000000014034554241017472 5ustar frankfranksimrisc-14.05.00/documentation/manual/html/modalities/0000755000175000017500000000000014034554241021624 5ustar frankfranksimrisc-14.05.00/documentation/manual/html/modalities/modalities.jpg0000644000175000017500000003556114034554241024472 0ustar frankfrankÿØÿàJFIFHHÿâ ICC_PROFILE mntrRGB XYZ acspAPPLöÖÓ- descü|cprtx(wtpt bkpt´rXYZÈgXYZÜbXYZðrTRC gTRC bTRC desc"Artifex Software sRGB ICC Profile"Artifex Software sRGB ICC ProfiletextCopyright Artifex Software 2011XYZ óQÌXYZ XYZ o¢8õXYZ b™·…ÚXYZ $ „¶Ïcurv #(-27;@EJOTY^chmrw|†‹•šŸ¤©®²·¼ÁÆËÐÕÛàåëðöû %+28>ELRY`gnu|ƒ‹’š¡©±¹ÁÉÑÙáéòú &/8AKT]gqz„Ž˜¢¬¶ÁËÕàëõ !-8COZfr~Š–¢®ºÇÓàìù -;HUcq~Œš¨¶ÄÓáðþ +:IXgw†–¦µÅÕåö'7HYj{Œ¯ÀÑãõ+=Oat†™¬¿Òåø 2FZn‚–ª¾Òçû  % : O d y ¤ º Ï å û  ' = T j ˜ ® Å Ü ó " 9 Q i € ˜ ° È á ù  * C \ u Ž § À Ù ó & @ Z t Ž © Ã Þ ø.Id›¶Òî %A^z–³Ïì &Ca~›¹×õ1OmŒªÉè&Ed„£Ãã#Ccƒ¤Åå'Ij‹­Îð4Vx›½à&Il²ÖúAe‰®Ò÷@eŠ¯Õú Ek‘·Ý*QwžÅì;cŠ²Ú*R{£ÌõGp™Ãì@j”¾é>i”¿ê  A l ˜ Ä ð!!H!u!¡!Î!û"'"U"‚"¯"Ý# #8#f#”#Â#ð$$M$|$«$Ú% %8%h%—%Ç%÷&'&W&‡&·&è''I'z'«'Ü( (?(q(¢(Ô))8)k))Ð**5*h*›*Ï++6+i++Ñ,,9,n,¢,×- -A-v-«-á..L.‚.·.î/$/Z/‘/Ç/þ050l0¤0Û11J1‚1º1ò2*2c2›2Ô3 3F33¸3ñ4+4e4ž4Ø55M5‡5Â5ý676r6®6é7$7`7œ7×88P8Œ8È99B99¼9ù:6:t:²:ï;-;k;ª;è<' >`> >à?!?a?¢?â@#@d@¦@çA)AjA¬AîB0BrBµB÷C:C}CÀDDGDŠDÎEEUEšEÞF"FgF«FðG5G{GÀHHKH‘H×IIcI©IðJ7J}JÄK KSKšKâL*LrLºMMJM“MÜN%NnN·OOIO“OÝP'PqP»QQPQ›QæR1R|RÇSS_SªSöTBTTÛU(UuUÂVV\V©V÷WDW’WàX/X}XËYYiY¸ZZVZ¦Zõ[E[•[å\5\†\Ö]']x]É^^l^½__a_³``W`ª`üaOa¢aõbIbœbðcCc—cëd@d”dée=e’eçf=f’fèg=g“géh?h–hìiCišiñjHjŸj÷kOk§kÿlWl¯mm`m¹nnknÄooxoÑp+p†pàq:q•qðrKr¦ss]s¸ttptÌu(u…uáv>v›vøwVw³xxnxÌy*y‰yçzFz¥{{c{Â|!||á}A}¡~~b~Â#„å€G€¨ kÍ‚0‚’‚ôƒWƒº„„€„ã…G…«††r†×‡;‡ŸˆˆiˆÎ‰3‰™‰þŠdŠÊ‹0‹–‹üŒcŒÊ1˜ÿŽfŽÎ6žnÖ‘?‘¨’’z’ã“M“¶” ”Š”ô•_•É–4–Ÿ— —u—à˜L˜¸™$™™üšhšÕ›B›¯œœ‰œ÷dÒž@ž®ŸŸ‹Ÿú i Ø¡G¡¶¢&¢–££v£æ¤V¤Ç¥8¥©¦¦‹¦ý§n§à¨R¨Ä©7©©ªª««u«é¬\¬Ð­D­¸®-®¡¯¯‹°°u°ê±`±Ö²K²Â³8³®´%´œµµŠ¶¶y¶ð·h·à¸Y¸Ñ¹J¹Âº;ºµ».»§¼!¼›½½¾ ¾„¾ÿ¿z¿õÀpÀìÁgÁãÂ_ÂÛÃXÃÔÄQÄÎÅKÅÈÆFÆÃÇAÇ¿È=ȼÉ:ɹÊ8Ê·Ë6˶Ì5̵Í5͵Î6ζÏ7ϸÐ9кÑ<ѾÒ?ÒÁÓDÓÆÔIÔËÕNÕÑÖUÖØ×\×àØdØèÙlÙñÚvÚûÛ€ÜÜŠÝÝ–ÞÞ¢ß)߯à6à½áDáÌâSâÛãcãëäsäüå„æ æ–çç©è2è¼éFéÐê[êåëpëûì†ííœî(î´ï@ïÌðXðåñrñÿòŒóó§ô4ôÂõPõÞömöû÷Šøø¨ù8ùÇúWúçûwüü˜ý)ýºþKþÜÿmÿÿÿÛC       ÿÛC ÿÀ¯FÿÄ ÿÄR  !WX "1Av”•–´ÔÕ#2789uÒÓQaµ36BUw’“³Ñ$%5RSrt²q¡ÿÄÿÄ> !1QRaq‘¡Ñð23AST’±"#á4rÁ5BCÂÿÚ ?×ì.ÁÛëh¶‹Ä'ûD]¶¬vÔÊíZ¤³õ""ýS&˜ ´ ™ŠVB˜ˆœ>Ž\BKg°Äô͆6«-³ïåâjNNü^S(uháÀ¢óýë™Tfí »¶êˆf!}iØÿ|ÖUò‘éào ‰œ¸U[iòDQWs½@NüÊb®IÑÖQ8@DÂ!d‚Ømܺw[÷sߣm‹„mñt—*àʨXÖoUQTSx*6ù`¦pTH¢a ò¬aØýºd§E³Û‚èY»[œ¶ÚN‘†p·-[‰ÎÍ“N@Æ[4TdÌÃ¤Æ À°,Î#EZ— NÜw¬\]Õl;ºR<å²ê=t  Lq2jHé:`W鉗LæH4÷'8 îžÁqÊ–yÈ•Úªx‹NÌ”;Å–U#ª&ÔïÔ¤šŠÅ ”Ä!Ž%(ˆØ’ÄIF ¤Ùm×u»ÄHº&5ºè‚$9@Å)¤@Å„8‡„(=ù ñ;¯EÑæò sAâw^‹£Ì=å@æƒÄî½G˜{Ê͉Ýz.08÷•šºô]`qï*4'uèº<ÀãÞThS) îAµœKotaÞŽ‘6ŽT'ÈrÏw¤” Gl¯¼³ ,+¦øMìLÎaŠ_Å™šÊF?N5",':ê€.šq¢` '2ÙHÒ`ó ™'Où ¾Ý•—|vZ¥ebæŸ.™•ÆäR:Ó&Ywk§ETÀUCHëÌ¡6Úñà-˜ˆ ·s.£X·h¼‹¼·ïM2”Ë©— g^ @ P( @ P( @ P( @ P( -íá÷ƒ_.Æz³Z ß±õ´ßãÑ^±-AÒÚ@ P( @ P( @ P( @ P( @ P(8··‡Þ |x»êÍh'~ÄÖvÓEzĵà]ûWÚû?‡háö ÜVÉÛ% ¬$!]7Lë·MÂa¯xžíR÷À8çSÕW£kS1^ï–AøÅè°~­[G‰É”èg|,(ƒñ‹Ñ`ýZhñ92hg|,(ƒñ‹Ñ`ýZhñ92hg|,(ƒñ‹Ñ`ýZhñ92hg|,(ƒñ‹Ñ`ýZhñ92hg|,(ƒñ‹Ñ`ýZhñ92hg|>lÛ-³ÈæÓ8YŠ0èÉH5MܼT[‘g •$Àçxœå ­TÕL^¨“C>ɆÀÔ1( @ P( @ P( @ P( AŽ¼>ðkãÅØÏVkA;ö þ³¶›üz+Ö%¨'ø´®<þ+ü­vä[*tO«§¯êÈ¥¯‹n퀲$Þ)k7ŠF'¹0‘nJRbëÒST€ˆ²ÏH×dÕ1Ô[m\]ûÂÚowÄÜí‰xùXÖ®^›’•Ã„Îb SÞéטD¹} â…DWLÅǥNJvEªùË i‚o0y$ü†üÌÐl‘UPUM<ÔÌ)@¢&ÈráškˆÚ>£ñJÁöQK‰(Ä#\‘›À˜IHŬr”ä"‰º*g(˜¦)‹˜d`Ã:œúEÙ ª×u+ð[’-i.LWœ7‰™~N9d®ìVÌ26YqïÔÞ6 ˆ™¨yöa!,ÎE¨˜ÄÚ.E“ E ɉØ#¢™öÿŽ¶×ñFõÍ•ú®Æ˜{z¥¸ç9Š@ P( @ P( @ P( @ Pqoo¼øñv3ÕšÐNýˆ?¬í¦ÿŠõ‰j þí+?ŠÀk]¹Êêéëú©ñW ]b\ÄS¤§•†$tcöɾh?ímÜ,劅:@!§!M²é˜D@rW ÌD:«£9Fçg«ž:-Ó y®¹NêA³Ç+¦‹6r®QQI’GÍD“GI“Ò]Zò@ ˜ÓG1¹ûÑg“½žïuâ¥á klßƒCßñÖÚþ(Þ°ÊýWcL=½RÜ óœÅ@ P( @ P( @ P( @ P(8··‡Þ |x»êÍh'~ÄÖvÓEzĵÿö•ÇŸÅ`?‚5®Ü‹eN‰õtõýRw(P( G´óG/ðö)‹)G®]ÖêIM"1àC ý‚L‰™‡ždI()Vr-ˆá¢åY3ðbˆ€ÐVP( @ P( @ P( @ P([ÛÃï¾<]Œõf´¿bë;i¿Ç¢½bZƒp¯-“pþó¾§1 Kºÿ„•¸ŽÝIÁ\î#ÐXÈ D0¦€f ¦PÌsðþÚDÕO£3 iŪ˜ÍÔµüŒ¬Ž–1ÓÇßš­Ÿ_*{S¦ÑØ|Œ¬Ž–1ÓÇßš™õò§´ÓNèìG{D`fàVÞ˜´ïqtMnD¬åªk_ršÏ ’m’6“g‘×:D¿æ¦}|©í4Óº;GcVÜ·¶œÁ©0¼±k‰uÚ2bÍòLoWè¦f‹¨Ù]„ žK'ÑÏÃLúùSڈŘ‹Z;Š{HG[ä¸pDZjFR!`t¼#›õéI0Ô?•lš¢o™\K˜¤qÀá¤DJϯ•=¦šwGb¿vqÂ,O´X^¶–2c:ñïÊ`Òµðý%›ªC AdÌmIª™ÊbƒÄ¦(…3ëåOjtÓº;‰-‡0Òa›Ëb>-=I»LŽ/gŠ”‹$p:jD5å)€{à UUj™™DãU1kC)MžÐXZØÀÑê8¿ š„ ìÍâ®îµd°Y½8|Ø­G„Ç0ˆC&IfcmyÉ£mAÄЫ~Tkny¹£åJ–£”N ÕÈÊ4Íó‰ë †B ått‰Û9E5’P¢S¦¡@Å0|€…g+³Ê=RU2Š…’W-r6ð© ôÂá,L’¹‡€uf 0Á+Ú5XCßqä™ÎòYæ£û33”¹Xåûœ†~è?EÞÔöÉu8‰Ã{õŒÍÃËqÈ—Â%I@z™ÍÞà*¦þ!Þ üíû'\EÀ¼I·r0Ü3Š$ûlƒúe³¸WGýé{ù—.4{oh¬ ».-Ï„„ oƒ=+7å€LÕ} xq PH´ @ P( @ P( @ Pqoo¼øñv3ÕšÐNýˆ?¬í¦ÿŠõ‰j–Ð(^,àæã°•—Š&š‚Mê2`.–A5•KVìÝ¢r›V"%.`9PC[`>aöGbE•i% =p3rÆQV®*.ÓI껡:÷ZÈÈ ƒ<„h6f‚Ä(YŒºßãƒæBTåRþ·Y¦'Qr” P˜h˜wÝ$B”ª¦PùôKŸ &(9¸{–ÃoI¶‘Œ“n›¶o( $á” E`àbˆ~Ú ê rùÛâK ~Ú‘³PD®Ð™º¡ÞU#ý$”È `ðP`Ç°±–ÁVG q—< ŠŠ­w˜É÷"%M¤ša¾Hº€¥ÉÁ€ŽBPTÀím Ôà1>W gŽpHnB‘6n”ð4!ŒÕÀ@W.&L¼@S P(,÷-hÞŒ~ ¼mh‰Öy9<›%Ä2åBˆqÿ ìÛ-á+ÞY î @¥p=Šn@ðrDT¦Üd„ÁAôl:Ç‹xDö~ÐE—Hƒ™ÞvËg¹—þMó38~À9€âÒÏÇ]£íÑÜx!s @Ïi]$+…ÃþÍ"›rw)0~ðð‡ÂÛMÙ1Hª[ÞܽleŠQÉKŠØvFE6_Òzܪµïüöyˆf½à÷ew±ää'bÔ‚¾áÚïMm*è œ¡ÀàQä.LS÷ÀÚ8yÀ¢jJÔÓU“7Ê'ºµÉzQù«n/‹»½¦ŽžQò‰Ån­r^”Gþjq|]Ý掞Qò‰Ån­r^”Gþjq|]Ý掞Qò‰Ån­r^”Gþjq|]Ý掞Qò‰Ån­r^”Gþjq|]Ý掞Qò‰Ån­r^”Gþjq|]Ý掞Qò‰Ån­r^”Gþjq|]Ý掞Qò‰Ån­r^”Gþjq|]Ý掞Ró†Øû;yâIpÖè§֫ŠÝN7]YfϪH8n‰É’":G7D?°k:è«mT"¬8¦œè›¦J«"@ P( öðûÁ¯c=Y­ï؃úÎÚoñè¯X– ém@ ‰öYO“à„+õ Òì„ÝíbŒ›¤„Ùx3Ñž_¾‚X P@o5ì¹tžM0rå{©ê`Ï“\ùoÈôcÜ(`Ö_¢‚¦ðMCîÂ{€ Q ÀCÃAû@ ¡›ƒ…¹b]@Üpì¥c¦)9dõ¹Ar|§Là%0~á µL¸,6éŽÏ·ê¶£vçQP¶å‘4¤¢m9©œàá¡{ŒŠVë"j0îŒ"9‡±qÑý¡ Œ.5áü­¨e$‰>È %o®±À¡:H £`Ö&I"Qîr0ˆåA(EÊÆMÇ·–…’jý‹¢ˆ:j±UIRxÄ9D@ÁûÀh*¨ 7ˆö;½ufLnY‡Bm%uÂaÚ3÷í²ÕíÃðŒÒo"ã·à² ج%0$ÓXÊ JCÛ´õd&15Ucb›ÎÔ]w´{¶¬ÜL eŠ"“'AÙd[ªÒ-UíÀL.{°ÉÄÆdmØu:^o0›¯SØÉ9sÉ[±˜júM6s-íöîË$Ý"8|³4]†e0ê"EIQÔ~&̹†Ï0´×16°¥ÇS9höÞ·V#GPódq,zrª™&ƒ¸ €¹ÐrÊ”ª"—"œÆ‚'w›—c°¸ßˆÌ +ñŠ6à4z· †J-‚± ›(—%Eew«8\TûÄô¢(f&(PÎ#¨ÛÏ܆M%òiM»ŒÃ—ÒÍ (Ò“âÈ·@Ž¸d‹ÂˆâM"¤·tq6eÈløLâMõB_v¾<4ºßÅ*ÎÖzÞQË8â¿r±J©¹Ž#ôɸÓÝ*™M_Ê (”5ÔÆ%çavaf}¬ ÿ³ÉÏâQUÇ–zT­W«ëñlr0( @ Pqoo¼øñv3ÕšÐNýˆ?¬í¦ÿŠõ‰j †Å›ÿžm5‡V(#jÃÄ[‘’`AløʬáW$8‰•È@2D¼3¯Kƒ8>8Bª©š­k{/µá} á߸°pñ#?>f6ÚÖ·4ï[¹FÓýeô-‡úׯønŸ{=ŸËå0gá£æŸ”m?ÖQ/BØ­? Óïg³ù?0gá£æŸ”m?ÖQ/BØ­? Óïg³ù?0gá£æŸ–϶v†±à‰nÀíTÙ‘Ë·`SÙìŽ;Ç]AÌL#ÅEN?»<©ønŸ{ÝüŸ˜3ðÑóO‚õÊ6Ÿë(—¡l?ÖŸ†é÷³ÙüŸ˜3ðÑóOÊ6Ÿë(—¡l?ÖŸ†é÷³ÙüŸ˜3ðÑóOƒ Æ«Çik+ .‹î;1šlÊ=A^9͘Àt™²!“>y†‘a¹²ÎŒ—¬hĽ£wòô¸#íŸÞynI8N|ÚùÓ6îOv;ù,»#ðnév»›iQobM89”3%;áéCf:Š\ù*†í2 FQ2Š¿>ûTå@ P(? P0 L !€øh"·{<ÛÏŸ\A(÷ ¦ß—çR|àúÀâuãTj¡Ç#”)¨‚‡É@R&â¦4D˜Ç`):Ī jÜÖ;U]¢™ ;ç1¦;@ºà€ºÓ˜˜¹€PHveõfâ$"WrÇÍƬf¸( Nć L`4Ú‚Ú÷ìÝ|ÿà¥ë TKLNüµ/"ÞZR1n[5]’B° ˆ¬¢*(Q ÷&ÌíÑÄCG Ç?nb'jX̾ a¤â*!#àSYYW*2nÐùr…QÚjîÕ.ñ%NB‰’6i÷!‘@«8tÉej¸S`­ð,wm·@é`ù¹˜ï ˜?œ1Œ=üËŸs¦§26 Š–U²«õ$ÔÍʲ©Íûå8½#b¶*¹jË‚$)týåžcLØsàö¨hs ¥,FLZ&GîJ™›³>¶©®@P ä©DÄßô˜DCˆˆÔfR<¤0W¥[*Õü;“‘g2”¤\ u9r £´Œd”(LR‰’0Šc ¹”r MȽüGµ¹YŸIJ±¤Ò˜Ìª¨ÓlFÄP È2E2HžåžcS›ÓƒØw'-ª EµO—¹22-Aªj™()b·)RŒQSHj¨Š)‰¼ …™ö°ƒþÏ'?‰EWYéRµ^¯¯Å²5ÈÀ P( AŽ¼>ðkãÅØÏVkA;ö þ³¶›üz+Ö%¨'«Çí}yø—ë«é>ÍúÌNˆÿo‚þ m“ÿ•_JY-}còôt÷0ò>9i'.ÞPºf™ l"¯Â%PH Ïèd}}íurÎY…L^yY½oJž Êkª)ˆC?oýmõö[{!_°õ³©F.ox4œBy"™ß¤S5( " ÷9Å(çÞˆ†zÎ>LÄÕ¶ësFE”ÕÕsj¶j} (ü]Ã×Ñ_ «s0dÄÏœ°E÷I5Ì´œä6¡Oë0à!žYÕiÊp¦œëÚ/nÆ•ð~SMz8¢fmh‰Õ}üï |g°íö¤'¤ÌÁ³§Îã“Q`(f³wädpÐ'ïŽД ÄÂ\À*Ê°è‹Õ6×1Ù6ú­‡Á¹F4Í8qyˆ‰êšs£›g~˲f—5¸ü‹9èõ¹[ƒ´@ä‚*.RC$PÏ1P¤!Ì%ï€Â! k”NÉrÕ‹Eó©Q}žÍ—迵íSöy¾¿ ýË\<-ý–'CÛû+ÿ3“ÿ—ú–ãÞöMµˆÖ¤••wÆüLª"‹„„D¦ NC†FMBÄ9D C¦(€€ |öÔ}…—¥Ík܃x·(/.È͹<¨sÆ'–j@QÌ º`˜iX¡¤âR½@ P( öôÀ¬?¼çÂô¯mû°¥!ã·Ýš>Då dR,¢}Ë”Ê ®UŽE ²ŒÆ?a˧ \0Ñø•mXŽá+ Öä)DÅ!ÙœÜ؈÷:“Qw²HÙŽA”áö0áæ'‹Æ¶œøN0Àœ”CÄg%q À®.R¬–|rr„@(3: '°ùÞ*ámÇÌ%Qq4ØIÚÈŠÄHÀrœÄLÎY‡~¢V¢¬Ê¢QwjM§:JÂÿDä=á]\o›Ï[Lü=Óç¨íI´çIX_蜇¼)Æñy¼õ™ø{§ÏQÚ“iÎ’°¿Ñ9xSâóyë3ð÷Ož£µ&Ó%a¢rð§ÅæóÖgáîŸ=GjM§:JÂÿDä=áN7‹Íç¬ÏÃÝ>zŽÔ›Nt•…þ‰È{Âœo›ÏYŸ‡º|õ©6œé+ ý÷…8Þ/7ž³?tùê;Rm9ÒVú'!ï q¼^o=f~éóÔ»aŽ b|,¥‰¸‰zÚò€ÒÝyÙ¤,3†Yr‡-Veœ­«.K}*ǬY‰©WLÓ›L'£"@ P( öðûÁ¯c=Y­ï؃úÎÚoñè¯X– ž¯µõçâ\¬>¯¤û7ë1:#ý¾ úý¶OþU})dµõËÑ žÎ6üŠŽ¤þpœ«—Çw¾Ýf€¦FDs«ŠÀ-÷º³Ñà˹®²j¼ß]ÿúÎÙ¿Ùw³G âQFo鈷?¡™·wý­m½¯<’~á3%z³E¼L›¹˜þÔf®—”JDÜ Û𠂨é6“q0˜ádS3él™˜Õí™Îׯ^¾„ÑÂÔQðæõDSWêÛDÑ«V©´ß]õû-©ñ?³ì­ÃxW—Ëc&õyw2 )^JªÏ•*›Ò W%((ˆÀ‚¨ª8aâ*ò*«§6jÛ{êÕ¯šþÏeINÌØq{S´ÎnÉöÚÛëàkÂÆE5Ž»ÒIÜ;‡ÎYÄhªC(¼ÓYBë ,Q(´„À&‰³.ZFÓ’M¢"­qfú¢­üÖg)N}SUªˆ¶ÙETn¹×ÙªÖÖ¸[¶ ’x·1|I$dX•šDjˆèÜH¨™vô„)Ì)€¢ÝªEŽ ÉoÄMj0gO8“³ýûg²";YãetÎGN;o¯š˜¼ÓMí×5LÛVÍÚ¨v©û<ß_…þå¬x[û,N‡oÙ_ùœŸü¿Ô·’¾ûkÅL3ŠÅ;cà7œÅȲpIY–y¸™ÀwN‘á¨5¦(÷'!ÎC”æ .blµÌ¤Žb#FÑx‰j‘2Ì´C0nùæÉ3ÕÄÍ—ÐaÌL™Àéº&f .@ P( G0£ñ=ªH^vê.×j:ÙH"¡Û?b|„FÎѬÃP÷Iœ£ÄhÐaŠÛ¸ý†…GâEÄÏ ‘ ‚‘w:àÎd¹¨#š2)t¶E6"è‡v\ÖÌDh/væ=áôÝÐçv­ÚcœˆÁ\-Å‹—zM©óO=ð3s¨wòÀF P( @ P( @ Pqoo¼øñv3ÕšÐNýˆ?¬í¦ÿŠõ‰j ƒ¯k2ËÚêìVñ»¡`ˆê̓*“~“PTJáî (¨`Ô!˜g—{0¯€1ð°11'¨¦ñf#{ã>Ûä9V[“`FM‡Uvš¯›6Õm~Þ¸#Óé OÔ¯¦ãù'½§æç_qp¯Ãb|•x½pG¦;ÒŸ©N?’{Ú~hñ>âá_†Äù*ð;zàLv?¤-?Rœ$÷´üÑâ}Å¿ ‰òUàvõÁ˜ìHZ~¥8þIïiù£Äû‹…~ä«Àíë‚=1Øþ´ýJqü“ÞÓóG‰÷ ü6'ÉWÛ×zc±ý!iú”ãù'½§æî.ølO’¯i´¦/a4î^Qx¡iH¿u$A«I¶Ë,©µ—HS‰Œ?¸¸8S,ɱ2Íp?àp¶&.tÓk™¢¨ˆÕ;faÑø—ë…qŒZúô$eãdÉ£ ÚfQÅ¿&©DQP–ù‹²—Š”Š;¢ˆBdrh.8OŠø¡»±Ž^z!É£n'fsü€t—@@é¨ʉœ‡/PfÔ @ P(-7=©lÞ‘ @]Ðó1«€‚^·*ÉŽeç‘€rŒ!˜q Æ‚4O 1 Xø#ˆk8fPF×¼Ü-!‘@DD­Þqxß0ÈQ×L  ðSM b-â²aŽó¼3”x°·LòkÄBÊd\·Ri‡'0›I¸¢±„¦ù¬² Q‘p‰7TŠ¤©@ä9 )Š!˜pðÐ}Ð( @ P( AŽ¼>ðkãÅØÏVkA;ö þ³¶›üz+Ö%¨:'/dÙ—°=hÂÉ9`³Æ , 3ȺŽQ¸ßK&*˜Ø¡í[†][hoù*- ΫyÚ· º:¶<ÐßòRÐgU¼í[†][hoù)h3ªÞv­Ã.Ž­47ü”´Õo;Vá—GVÇšþJZ ê·«pË£«cÍ ÿ%-u[ÎÕ¸eÑÕ±æ†ÿ’–ƒ:­ì¢¥RA¥»~cJ›*»ŠÇ;ÒŸ5Þù¸Ä¼x”X­"Ó1Ý¡&¨»µ’8ï[œ3?Sú  Ê{Km³[ K¾eI;²Ù|¼,Ë•ÎQUÁŠ ¢ /¤Š„.¡úFLãß΃jh @ P(<²e$Íhùˆºjå3$² ¦MR21LQà`à <("Å0^L³X+yÊØf&+A·ÉÔ‚ P'Áêw »’”ºš™îC=\@CÅ,f¼ì"8OpéhvMÞè· ¤¬:…ÖB¨™JÚ˜Dà"HÉ”Â+F‚M·.krð†mqZSñÓQO ­»è÷Dp‚¥ý¥P‚%7ÿCAs P( @ P( -íá÷ƒ_.Æz³Z ß±õ´ßãÑ^±-AÒÚ@ P( ‚ÚÊFaž¥,¬i§®88K¤Š*›’‘* àÍÓI§Ü¦™@Nn Pï×tæU4DZLXˆ˜´{EU‘@ P(#›gûBEû‹’Å’ÃË™ÂÆt¬Å®r6kœÌñ±ŠfÏsÐ@]#˜ bæ#ABâõÆŒ6Y&÷ÕŠ7ÜH‘ pZ(é|Cˆäc8‰PÂmúlªÆ#º pͬŒK°q!»—65Û1ÈU"Ý`ß´T@S]ÉDO™G¹9J?ºƒ& P( @ P(8··‡Þ |x»êÍh'~ÄÖvÓEzĵKh @ P( Sko«‹ÇËSøÃjµ=1õkƒéODýì…W5ÝhaÛÉ˳G3Å}Õ’È&Ic.ý1È@CQU1@Ù÷" 9Y +™Šo¢'{KܲOî©«TXÖA½¼¥¾ëàWR+.›¹2²t°·nrª¸”ûâ$ò6¤@{­ZC=,Íæ6jEÙîbµÁ|½€JA ÞA¥ÆuIŠÍ9I£ä¶Ib"±…TÅY]I©™€Àr7¢¹ªÝi„±Z–Ê?ðÌIþÐdÿÈk^F/¬«¥8Ûc¡9ÖlJ@ Pa¦ aíó(•Ë' ®VÈ—Z‚ÎU±LQ.DtžGä#ÜLA³(Ðb¤Kh,-hp"¨âü2'OvCòx«…$§×™û–oO˜'¤ý#fcT=“X}}HÞe(´UÈ(‹…-ɦç–H€&0µXæ ó„&9f ’>붥§¥­hÙÖNf “`šÅÚbkDʾRœ "QË!Òl‡2ŽAv P( AŽ¼>ðkãÅØÏVkA;ö þ³¶›üz+Ö%¨:[@ P( @ PB›[}\[þ>ZŸÆU¨ôéé«\Jz'èø¯d((¥á£gš&ÆU¶ý6zBë1rYºÄ]fQîTL†Ë¼9d "gxke<ð™ ÓEÆ–)ê@æH Fo9b@¥qŽA™³áQ›Ú.µá®'wLty’‘x£•N}ñôΰ/¤™é.±f‡ úE1¸ Î&E1qU‚ƒËeøf$ÿh2ä5¯#ÖUÒœm±Ðœë6%@ P( [pÊÁÅ‚Ä_Ö|lò Ì*µIõ²¹(‚¡‘ÐSö3Áûh9)/…}‘{7li TÃëLÈÝŽY„™"ÕºÚ¿KàXPI“•œ¬NP@JQÌuæRœºL1WM¦×tv ±µÄ3%î-‘îÖR‡D¢ñ»k–dSW.è ¼(˜¹ç‰@rË0 ‹ÊÑM3š¾ªþÞ˜©ÕZöóô·Ró¹9”ò¾§oLTê­{yúÛ©yÜfSÊú½1Sªµíçèn¥çq™O+êvôÅNª×·Ÿ =º—Æe<¯©ÛÓ:«^Þ~€öê^w”ò¾«uÉ´¥ùhÛÒ—]ó ìÒ*’òœ|5¦éº$>’="”G"€ˆåÀj/;“tÌÚ*ú§ç©ÈǶH†)"EŠSwÀ Pýüj̧SŒ{x}à×Ç‹±ž¬Ö‚wìAýgm7øôW¬KPt¶@ P( @ °Þö%£ˆöú¶­ñÞ^%uYF«êÒ'Làr¹1@C|)µ4Õ4Íá|¶nèª7üw©QeôÕï>H[7tUþ;Ô¥5{Ï’ÍÝFÿŽãõ)cM^óä…³wEQ¿ã¸ýJXÓW¼ù!lÝÑToøî?R–4Õï>H[7tUþ;Ô¥5{Ï’ÍÝFÿŽãõ)cM^ö{aaÍ‘…ðª[¶ ºÚ9W'v¢ „¦XàP1ÄL"9ˆ¡ßðTìVª¦©¼²J*P( ŒÄLG&øZQ£.ZäŒÛr…Êžýsç¡"jÔsd98ŽCPÌD²gòQ¢¤wœ²«”ª¹Ý—R›²æ}%È â4Ó/dD³”h»èíß,l’å2­·…Ôžð€9“Q@D3Ì8…e-ö²_û;oüIjkOüúÒÊn’:º}i fcdàÔ³kËŒaĶ°ö èàŒÔ„w`Ë_óè$à‰8[r“UJÍ2‹s—v@xR€Èséá¤J¨f×^+]moØ›*Ͷb^ ®"CI«' £o›i64¢o!mÒ á¡CZDÞëÄüT"'fP˜íâÝV¤-ÐFænYˆöÏÁ#gš`ªe>‘̈j˽AˆíöyÅ&ýEj‰Ø¾§)nÖþlDà7ÿ,µ0¬íq¿o¼øñv3ÕšÑ ß±õ´ßãÑ^±-AÒÚ@ P( @ P( @ P( )ám‰Š>=A|'ñJàgtÃÿµ,%”k«p¿ÍºôïÜQ>%‚qam‰ußvŽ&OÁr«’ÄåÿÞò¥‰Èùj ‹¯›!Á55¦P/ÎÚr̹»…¶%©}ÝØ™ÉnKï|`{Ê–?,äHŠ-~lçÓЙ„¿6RêÏ3fŽgòÞ@ŽTEºo?7¥HÒ¤^9æ"­pO¢™e0+§$œ¿-Rá‘Q馛•Cº2â¹þ`æKIŽ%‘X†6â@Œ\ ½äHË.íaýo„¾E%ú´ýGíóŸv°þ·Â_"’ýZ~£öùÏ‹»X[á/‘I~­?Qû|çÅݬ?­ð—Ȥ¿VŸ¨ý¾sâîÖÖøKäR_«OÔ~ß:Ç}a–Ôwí‘pØÒ77iqE;‰]dHïMÂ&HÆ.jj8ˆfÒb©M5aÓ1:ÛÈѱ,£Žp9š·M0 JŸÿ•fs®\fÛÃï¾<]Œõf´CÀý¢qãdHÅ…ì,6€%ç9­q•sü6]ا£v±~—)6yçôC½Æ‚fç]Úç ‹ÊVöš:î×=X>R·´Ð9×v¹è"Áò•½¦Î»µÏA”­í4uÝ®z°|¥oi s®ísÐEƒå+{Mwkž‚,)[Úhë»\ô`ùJÞÓ@ç]Úç ‹ÊVöš:î×=X>R·´Ð9×v¹è"Áò•½¦Î»µÏA”­í4uÝ®z°|¥oi s®ísÐEƒå+{Mwkž‚,)[Úhë»\ô`ùJÞÓ@ç]Úç ‹ÊVöš:î×=X>R·´Ð9×v¹è"Áò•½¦Î»µÏA”­í4uÝ®z°|¥oi s®ísÐEƒå+{Mwkž‚,)[Úhë»\ô`ùJÞÓ@ç]Úç ‹ÊVöš:î×=X>R·´Ð9×v¹è"Áò•½¦Î»µÏA”­í4uÝ®z°|¥oi s®ísÐEƒå+{Mwkž‚,)[Úhë»\ô`ùJÞÓ@ç]Úç ‹ÊVöš:î×=X>R·´Ð9×v¹è"Áò•½¦Î»µÏA”­í4uÝ®z°|¥oi s®ísÐEƒå+{Mwkž‚,)[Úh5Þæ»qshí §q†ñ²£b$%"l£h÷% ‚)—-jÙˆ1Ì{ôÿÙsimrisc-14.05.00/documentation/manual/html/analysis/0000755000175000017500000000000014034554241021315 5ustar frankfranksimrisc-14.05.00/documentation/manual/html/analysis/data.jpg0000644000175000017500000001747014034554241022741 0ustar frankfrankÿØÿàJFIFHHÿâ ICC_PROFILE mntrRGB XYZ acspAPPLöÖÓ- descü|cprtx(wtpt bkpt´rXYZÈgXYZÜbXYZðrTRC gTRC bTRC desc"Artifex Software sRGB ICC Profile"Artifex Software sRGB ICC ProfiletextCopyright Artifex Software 2011XYZ óQÌXYZ XYZ o¢8õXYZ b™·…ÚXYZ $ „¶Ïcurv #(-27;@EJOTY^chmrw|†‹•šŸ¤©®²·¼ÁÆËÐÕÛàåëðöû %+28>ELRY`gnu|ƒ‹’š¡©±¹ÁÉÑÙáéòú &/8AKT]gqz„Ž˜¢¬¶ÁËÕàëõ !-8COZfr~Š–¢®ºÇÓàìù -;HUcq~Œš¨¶ÄÓáðþ +:IXgw†–¦µÅÕåö'7HYj{Œ¯ÀÑãõ+=Oat†™¬¿Òåø 2FZn‚–ª¾Òçû  % : O d y ¤ º Ï å û  ' = T j ˜ ® Å Ü ó " 9 Q i € ˜ ° È á ù  * C \ u Ž § À Ù ó & @ Z t Ž © Ã Þ ø.Id›¶Òî %A^z–³Ïì &Ca~›¹×õ1OmŒªÉè&Ed„£Ãã#Ccƒ¤Åå'Ij‹­Îð4Vx›½à&Il²ÖúAe‰®Ò÷@eŠ¯Õú Ek‘·Ý*QwžÅì;cŠ²Ú*R{£ÌõGp™Ãì@j”¾é>i”¿ê  A l ˜ Ä ð!!H!u!¡!Î!û"'"U"‚"¯"Ý# #8#f#”#Â#ð$$M$|$«$Ú% %8%h%—%Ç%÷&'&W&‡&·&è''I'z'«'Ü( (?(q(¢(Ô))8)k))Ð**5*h*›*Ï++6+i++Ñ,,9,n,¢,×- -A-v-«-á..L.‚.·.î/$/Z/‘/Ç/þ050l0¤0Û11J1‚1º1ò2*2c2›2Ô3 3F33¸3ñ4+4e4ž4Ø55M5‡5Â5ý676r6®6é7$7`7œ7×88P8Œ8È99B99¼9ù:6:t:²:ï;-;k;ª;è<' >`> >à?!?a?¢?â@#@d@¦@çA)AjA¬AîB0BrBµB÷C:C}CÀDDGDŠDÎEEUEšEÞF"FgF«FðG5G{GÀHHKH‘H×IIcI©IðJ7J}JÄK KSKšKâL*LrLºMMJM“MÜN%NnN·OOIO“OÝP'PqP»QQPQ›QæR1R|RÇSS_SªSöTBTTÛU(UuUÂVV\V©V÷WDW’WàX/X}XËYYiY¸ZZVZ¦Zõ[E[•[å\5\†\Ö]']x]É^^l^½__a_³``W`ª`üaOa¢aõbIbœbðcCc—cëd@d”dée=e’eçf=f’fèg=g“géh?h–hìiCišiñjHjŸj÷kOk§kÿlWl¯mm`m¹nnknÄooxoÑp+p†pàq:q•qðrKr¦ss]s¸ttptÌu(u…uáv>v›vøwVw³xxnxÌy*y‰yçzFz¥{{c{Â|!||á}A}¡~~b~Â#„å€G€¨ kÍ‚0‚’‚ôƒWƒº„„€„ã…G…«††r†×‡;‡ŸˆˆiˆÎ‰3‰™‰þŠdŠÊ‹0‹–‹üŒcŒÊ1˜ÿŽfŽÎ6žnÖ‘?‘¨’’z’ã“M“¶” ”Š”ô•_•É–4–Ÿ— —u—à˜L˜¸™$™™üšhšÕ›B›¯œœ‰œ÷dÒž@ž®ŸŸ‹Ÿú i Ø¡G¡¶¢&¢–££v£æ¤V¤Ç¥8¥©¦¦‹¦ý§n§à¨R¨Ä©7©©ªª««u«é¬\¬Ð­D­¸®-®¡¯¯‹°°u°ê±`±Ö²K²Â³8³®´%´œµµŠ¶¶y¶ð·h·à¸Y¸Ñ¹J¹Âº;ºµ».»§¼!¼›½½¾ ¾„¾ÿ¿z¿õÀpÀìÁgÁãÂ_ÂÛÃXÃÔÄQÄÎÅKÅÈÆFÆÃÇAÇ¿È=ȼÉ:ɹÊ8Ê·Ë6˶Ì5̵Í5͵Î6ζÏ7ϸÐ9кÑ<ѾÒ?ÒÁÓDÓÆÔIÔËÕNÕÑÖUÖØ×\×àØdØèÙlÙñÚvÚûÛ€ÜÜŠÝÝ–ÞÞ¢ß)߯à6à½áDáÌâSâÛãcãëäsäüå„æ æ–çç©è2è¼éFéÐê[êåëpëûì†ííœî(î´ï@ïÌðXðåñrñÿòŒóó§ô4ôÂõPõÞömöû÷Šøø¨ù8ùÇúWúçûwüü˜ý)ýºþKþÜÿmÿÿÿÛC       ÿÛC ÿÀŽaÿÄ  ÿÄE 7!Xv–´ÓÔ1Wuw—µ"28”Ò#ABQar• $6s34qÿÄÿÄ? R!1Q‘±3Ab¡"#2Baq’²ÑÒá45Cr‚ðñÁÿÚ ?Û¹xËÄ;@_˜…ˆXµŠž6¿îXðûÝë6¨µnôà˜`}’KÉÉ Pì\˭Նϱ:ãżp³ã#d±tY|EzS"Å0Pû&p“Æj  —‡Ù6‚Q 3î2é–d-ò]!Žøêâ4\*ÕE]³NNÙT‹´¡WM"èl”@Æ P€üŽËFIbr˜bŽ2ã0ºV.~5Ùq!é‘‘Iéä¤D@Ú”‘ª)®¼¥8}Ñ ;Ë~YÞKCÂGãÞ7¾w<Ù¬Aå0á1n²‡I”Q2˜ˆ¦¡ÓP¤:†)M°m‘€ñÛ¹zˬâŠ&Ƭo K¾>m«FW̳äÒnð¿±:‹¢QM4Î`9H¢‚BœHm= È ½mcgÄ'ÿª€<0ËÖÖ6|Bú¨È ½mcgÄ'ÿª€<0ËÖÖ6|Bú¨È ½mcgÄ'ÿª€ŠbÎIìK; /+ºñœ²–üŒ‹ARÿ~bȶQBmk”6Š…ñgÊ ½w_Ýe{ÞPkr™g©ˆ9xÅ{“+E';ˆ×s.Ò„n£ób“A)Œ˜œ `J&¢PAöW Ðzìö¥Õ-ÂAõ«"霃§RÚ­.‹ä…5®c§Â$·Ù(f)ÀñÝù`^æ½&g92êUhy›sŒ™'ÃFE1Ú*FpDÌå1‹:‰¬r¥úb¥Í÷„Ý•‹ŠÐ…²'å_M¶¶¬Ë2>mºmÛ+ç~EåŽuVÔ«Y7)ðIæ5PL@6tÆ*µ×jKÚ³q6Üe¨Œ{6äc¹dŒÅ©ö¾‚.Šè©±ÊšÔÙ¨%1€Åmå²fÙc†Q¬/¸ÔK‡ppg’k»yI$…:&\¯8 l¾Àꊈ­° «²m¡” í@@@@3¸\Iè„ÏbV€¬µ`ü‚nÊü÷£vvóP Í­ÏOc5ӌؗŽVÄ5±)Ń0ÑK¤V)›ƒˆÃU0Š‹¨<¦ä×@зȧ&Û,% …6Žî&ÇntWgW | oÈá¼ÌV ¼C‰±ÛÙÕèLŽÌV ¼C‰±ÛÙÕèLŽÌV ¼C‰±ÛÙÕèLŽÌV ¼C‰±ÛÙÕèLŽÌV ¼C‰±ÛÙÕèLŽÌV ¼L-Ã7Ž¶,•£&®a. ¦¯¯‡ŒÁC&“†ÎäPAb ’hE ©0”À!û†µN³©Pã&e("®n‡¬n*±\€f p¸“Ñ žÄ­YjÁùÝ•ùïFìíæ ša†ß¶6t†'ä1ÕzÇæÅí7¿2÷I0«¤MK˜ˆa˜ee°­äš4¹…wEuk9¸I>,~@:ˆCl锨Lbëü«\ÅZÐÌ Ño_RNÛ’ÛŸº!¢ÚÄYÍY·‚Ýsp•s@fsäÁª‚ŠâÎãj°$ zHm„GdßÐyk É-èoxÆZ‘í^¸ڠ£§Y…ÅQD‚¢Š)8JB€j&4å¬ärõ±Œµ#ŸÕÕÕëûÿÍ#ÜS#—­Œe©ÕÕÕëûÿÍ#ÜS#—­Œe©ÕÕÕëûÿÍ#ÜS#—­Œe©Ûò6ûÃøˆû¢/qâÈÜ0MLÝô¢J·U'[ªC”(ˆ jœ=!Z§Y¡—‰6fDéD9P¬@3¸\Iè„ÏbV€¬µ`ü‚nÊü÷£vvóP ͱ¶üCbÿýð_-%^±èˆ±èC´ç‹0“—&ݶý´¡É+% õ«=…83c¢b”€àÚÙÛRë¨r…[7 H£1î˨k§mˢʅ‡` af°+G»œÍÅ‘6H")–"@ˆ¤©ˆŠ¢!¦'ÓoúŒw4eÑ#ÞårÊûzñ;fôTÉpêm9@Ñ¥vÝ0Ð tˆm>@á4øMNiµ\ý Ëâ»ì[o3w…¨­äi€QÑ!ŠÉŠæŽ,W˜Àr J(È?lí¬') ÁŽƒ˜ñªéþÌEø× b¦a™M^ÒMbçtĤIùÜË hý¥Æ(™D ôÛ6vÅöL*,d¨ óªëE³YÓe[¬£tÌ¢+¢f†¥1ƒDD=#[–ƒ$¿àMzSl|ñhµsOgrôïà6Ì+ Ánz!3Ø• +-@X? ›²¿=èݼÔ3@,m¿Ø¿ÿ|ËIW¬z",zí%ÕtÒñ‹)Šƒöh9HŠ¤¹H²`r‚‰œª&pþ"œ¥1GÒ(r€VÝY@@kÜvÿ5éM±óÆ5^ÕÍ=œIËÓ¿€ØW0®@3¸\Iè„ÏbV€¬µ`ü‚nÊü÷£vvóP Í©ã=Õ÷˜µ= zå¢býº¢ÑgÆ’,-Td¥U22¦8þ0þéEB©b3ª*"Ãå ˜Ûðýö³ÈÅuî%å/ö‡”.bwoÃô;Úr1]{‡”¿Ú>P¹‰Ý¿ÐïiÈÅuîRÿhpùBæ'vü?C½§#׸yKý¡Ãå ˜ÛðýöœŒW^áå/ö‡”.bwoÃô;Úr1]{‡”¿Ú~£udæÒ|Âàs“‹’ßÏÚnl„M«ƒ®B"qS…û?µ14æ!XrÜ*®I¯67híЪ@3¸\Iè„ÏbV€¬µ`ü‚nÊü÷£vvóP ͬ2üNã?ö[}€ÕvÅél,~Ü;IlÔÌ]» þà›z›8èÆʼxáAЈ ™ç9¿ ¢#ÿʺÚJ¬†ÄȧìÝÉÏBÌZŒ[5JêàE6h¬™Í²SöÄ":› ¡©yj*5¥æmKª×Ie«rE‘T3¥g‰ˆ‰H2‚꘦z4@Ôª²1ëñ#‚Ý<»ƒÊ7Iã~-wI•ºªªš*ª»r¨Šs ¯ÙTä9@£¶R%BÅ TÏÄâ5©)þmY$ãYF(ÝkHˆ#¬Ù$0›gî:H=?xD9t©(•* "J¤ºDY ¢j C”u)Š<  !é 5fg÷8ûÛVÿÎÕk_2öq6Jó·ð:效`· ‰=™ìJЖ ,MÙ_žônÎÞj™ †_‰ÜgþËo°®Ø½-…Û‡išÄ I+òÆŸ²Öt-Bn9ÃpÛ ¢bR¨Ô6¶L m5åÓJ¹ÆM!¶Þ.Ý [ÒÓ–õŽgv´™dQfI‡fo s3rÝCækþßApEâA  ×j ÔN•¦`a0÷%lÄâܸViFW%¢S¢Ñd˜œIµ ª„Ùà„5Ö!—‹þõ ü=ÂV¼ÜD¤ÃõÔ<-o¢,äÝ"‚®ý02ˆÅMR.˜T)„9yNYC^¤r~¾˜Ù±Ì§c“˜‚™Œ”HpŠà„ŠN»UÈC‰¨© (t)ìÂ$&éþÕC7%n+hYP¶ºÊœæ‹f›_´¸-² €pM 04(&N@²ŠÙ ÅT2Bs?¹ÇÞÚ·þpδZù—³‰²W¿€á×4¬@3¸\Iè„ÏbV€¬µ`ü‚nÊü÷£vvóP ͬ2üNã?ö[}€ÕvÅél,~Ü;IÍ^ @@ªÌþç{jßùÃ:­kæ^Î&É^vþ‡\Ò±Ìáq'¢=‰Z²Ôƒò »+óÞÙÛÍ@34sï2ŒÛî…o<\Ä»rñ±Jq­°y´Ô­S3}±f“0ð*~ðé´>Ô*P(Ýq+²¦ÎYJ…(œ+UZÿÒÇ/ç¿œº<5N“úݦ2¹w ßÌ8ã%üã±÷ó—G†¥'õ»FW.ôáù‡d¿œv>þrèðÔ¤þ·hÊåÞƒ|?0㌗óŽÇßÎ]”ŸÖí\»Ðo‡æq’þqØûùË£ÃR“úÝ£+—z ðüÃŽ2_Î;9txjR[´erïA¾™Ä]dnMË&SõŒ²HûA#Yuî5ª¹W! ³n C…ôÚä×OEF52ž=ië©(-*7‹…¿SUâ?UQÌáq'¢=‰Z²Ôƒò »+óÞÙÛÍ@34~Óñ3Ž¾Ô€ù+Zõ}Íós=«ó_ÄvÏübâL«ÒŸ<     YfCtî½µóv•Éß™³âG¨î/õ¹?ßàˆvëŸe ‚Ü.$ôBg±+@VZ€°~A7e~{Ñ»;y¨f€OÚ~&q×Ú%k^¯¹¾ngµp>køƒÎÙÿŒ\I‚Æ)9Ì ¦R”DN}ÓÓË^•Ÿl.(\¼jA‰ fUP¦—ŒŸš›U¯Czs¶Î5Ý’XšÞÍð1€õ6„zÍFh„‹S3~š†ÛáTû+‚¤Š„ý’ºkì'²]®8§ruMlΩ¥xÕÓ›2};+ÏÁ’`²¹ôŠ©Zš•LúÑʘņ\Z±« iQ¥¥×S<~OÙ õÙauEÇ‹«ÿ¶uw}ÎO8¯ï/¤<Ÿ³Aë²Âê‹NÿÛ:»¾ãÀœ×÷—ÒOÙ õÙauEÇ‹§í]ßqàNëûËé'ìÐzì°º¢ãÅÓ¿öήï¸ð'õýåô‡“öh=vX]QqâéßûgWwÜxúþòúCÉû4»,.¨¸ñtïý³«»î< Àýy}&2ãÊž`/Xäà.¬g³”Š3æNÜ¥¬ºK¹MÁJS‹£u2E tA¯iÂÖ›\§&e(ýZu—pws87ÚaµÈQcCZU¦³¦µjck\Ó¼@3¸\Iè„ÏbV€¬µôÛ ¿ÔÖ*Ò…„òE!q,Ž ÜoÅê2älQŸ( ]HÃɧ§ZiçÅ´ù»Ëõ‰.â€<ø¶Ÿ7y~±%ÜPŸÓæï/Ö$»ŠóâÚ|ÝåúÄ—q@|[O›¼¿X’î(Ï‹iów—ë]Åyñm>nòýbK¸ >-§ÍÞ_¬IwçÅ´ù»Ëõ‰.â€<ø¶Ÿ7y~±%ÜPìEÿY»^úÃëžÉG%Z)pÃ=Š+ƒO¦pDW@éļj·®š†ºP-¨ÿÙsimrisc-14.05.00/documentation/manual/html/spread/0000755000175000017500000000000014034554241020750 5ustar frankfranksimrisc-14.05.00/documentation/manual/html/spread/spread.jpg0000644000175000017500000007014314034554241022735 0ustar frankfrankÿØÿàJFIFHHÿâ ICC_PROFILE mntrRGB XYZ acspAPPLöÖÓ- descü|cprtx(wtpt bkpt´rXYZÈgXYZÜbXYZðrTRC gTRC bTRC desc"Artifex Software sRGB ICC Profile"Artifex Software sRGB ICC ProfiletextCopyright Artifex Software 2011XYZ óQÌXYZ XYZ o¢8õXYZ b™·…ÚXYZ $ „¶Ïcurv #(-27;@EJOTY^chmrw|†‹•šŸ¤©®²·¼ÁÆËÐÕÛàåëðöû %+28>ELRY`gnu|ƒ‹’š¡©±¹ÁÉÑÙáéòú &/8AKT]gqz„Ž˜¢¬¶ÁËÕàëõ !-8COZfr~Š–¢®ºÇÓàìù -;HUcq~Œš¨¶ÄÓáðþ +:IXgw†–¦µÅÕåö'7HYj{Œ¯ÀÑãõ+=Oat†™¬¿Òåø 2FZn‚–ª¾Òçû  % : O d y ¤ º Ï å û  ' = T j ˜ ® Å Ü ó " 9 Q i € ˜ ° È á ù  * C \ u Ž § À Ù ó & @ Z t Ž © Ã Þ ø.Id›¶Òî %A^z–³Ïì &Ca~›¹×õ1OmŒªÉè&Ed„£Ãã#Ccƒ¤Åå'Ij‹­Îð4Vx›½à&Il²ÖúAe‰®Ò÷@eŠ¯Õú Ek‘·Ý*QwžÅì;cŠ²Ú*R{£ÌõGp™Ãì@j”¾é>i”¿ê  A l ˜ Ä ð!!H!u!¡!Î!û"'"U"‚"¯"Ý# #8#f#”#Â#ð$$M$|$«$Ú% %8%h%—%Ç%÷&'&W&‡&·&è''I'z'«'Ü( (?(q(¢(Ô))8)k))Ð**5*h*›*Ï++6+i++Ñ,,9,n,¢,×- -A-v-«-á..L.‚.·.î/$/Z/‘/Ç/þ050l0¤0Û11J1‚1º1ò2*2c2›2Ô3 3F33¸3ñ4+4e4ž4Ø55M5‡5Â5ý676r6®6é7$7`7œ7×88P8Œ8È99B99¼9ù:6:t:²:ï;-;k;ª;è<' >`> >à?!?a?¢?â@#@d@¦@çA)AjA¬AîB0BrBµB÷C:C}CÀDDGDŠDÎEEUEšEÞF"FgF«FðG5G{GÀHHKH‘H×IIcI©IðJ7J}JÄK KSKšKâL*LrLºMMJM“MÜN%NnN·OOIO“OÝP'PqP»QQPQ›QæR1R|RÇSS_SªSöTBTTÛU(UuUÂVV\V©V÷WDW’WàX/X}XËYYiY¸ZZVZ¦Zõ[E[•[å\5\†\Ö]']x]É^^l^½__a_³``W`ª`üaOa¢aõbIbœbðcCc—cëd@d”dée=e’eçf=f’fèg=g“géh?h–hìiCišiñjHjŸj÷kOk§kÿlWl¯mm`m¹nnknÄooxoÑp+p†pàq:q•qðrKr¦ss]s¸ttptÌu(u…uáv>v›vøwVw³xxnxÌy*y‰yçzFz¥{{c{Â|!||á}A}¡~~b~Â#„å€G€¨ kÍ‚0‚’‚ôƒWƒº„„€„ã…G…«††r†×‡;‡ŸˆˆiˆÎ‰3‰™‰þŠdŠÊ‹0‹–‹üŒcŒÊ1˜ÿŽfŽÎ6žnÖ‘?‘¨’’z’ã“M“¶” ”Š”ô•_•É–4–Ÿ— —u—à˜L˜¸™$™™üšhšÕ›B›¯œœ‰œ÷dÒž@ž®ŸŸ‹Ÿú i Ø¡G¡¶¢&¢–££v£æ¤V¤Ç¥8¥©¦¦‹¦ý§n§à¨R¨Ä©7©©ªª««u«é¬\¬Ð­D­¸®-®¡¯¯‹°°u°ê±`±Ö²K²Â³8³®´%´œµµŠ¶¶y¶ð·h·à¸Y¸Ñ¹J¹Âº;ºµ».»§¼!¼›½½¾ ¾„¾ÿ¿z¿õÀpÀìÁgÁãÂ_ÂÛÃXÃÔÄQÄÎÅKÅÈÆFÆÃÇAÇ¿È=ȼÉ:ɹÊ8Ê·Ë6˶Ì5̵Í5͵Î6ζÏ7ϸÐ9кÑ<ѾÒ?ÒÁÓDÓÆÔIÔËÕNÕÑÖUÖØ×\×àØdØèÙlÙñÚvÚûÛ€ÜÜŠÝÝ–ÞÞ¢ß)߯à6à½áDáÌâSâÛãcãëäsäüå„æ æ–çç©è2è¼éFéÐê[êåëpëûì†ííœî(î´ï@ïÌðXðåñrñÿòŒóó§ô4ôÂõPõÞömöû÷Šøø¨ù8ùÇúWúçûwüü˜ý)ýºþKþÜÿmÿÿÿÛC       ÿÛC ÿÀ×gÿÄ ÿÄ\  !W"1X”–ÒÓÔ#268AQTVu’•—³´Ñ (7agtvw“¥µ$3Bqã5CRb4H‡År„‘¡¢ÿÄ ÿÄL  !1AQSa‘"2RTq’¡¢ÑÒb±áâ35Bdr“ðU²Á#sÂ46‚ƒñÿÚ ?±0‡l¬@²ºí»Fá{*öbd«®[šM0'&å"'!@B‡×»]UÕuY-6FUªÉq§y óŽpšô»¯J¶k5\,nZukIÌ´JšsoÂx\^ËùÕl;‡`èýîù­=/¾›àgÒœÛðŸÞ…²þuNáØ:?{¾iÏKï¦øô§6ü'÷…Åál¿S¸vÞïšsÒûé¾})Í¿ ýáqx[/çT÷»æœô¾úoŸJsoÂx\^ËùÕ;‡`èýîù§=/¾›àgÒœÛðŸÞ…²þuNáØ:?{¾iÏKï¦øô§6ü'÷…Åál¿S¸vÞïšsÒûé¾}*%ˆ¸MfáêÍÍhŒû)®ø ©îY'Ô‘@‡(‘UÌC”Â@{u­½®»%–ÊjÒdFÓ¿¬®‹‚Ü$¼ï+ɶ{ULL!ÙahÐ3 B+—^†”E_m '% €8™3 儃 >eÓGmU2K7XŒ•1Lå1SB¨tS¦%àë›í,{3jÃL=ÇLgå£Û¹WEÿ"ÖtÊcdΘld¦ZjûŸ v-¯ b:cWÒRätúûU8Ρ؞Šté_H>=9>¾Ôã:‡bz)Ó¦5} HøôätúûSŒê‰è§N˜Õô#ãÓ‘ÓëíN3¨v' b:cWÒNGO¯µ8Ρ؞Šté_H>=9>¾Ôã:‡bz)Ó¦5} HøôätúûSŒê‰è§N˜Õô#ãÓ‘ÓëíN3¨v' b:cWÒNGO¯µ8ΡجÎ;Û™ŒõÏ7>x{æ~%³¹™^ºäÍÝ iʪ"cdR‡·îÖ¼Œ. l%B´b¸+¥(‰DJ"Qˆ”D¢%(‰DJ"Qˆ”D¢%(‰DJ"Qlßù'kñÔ÷õwuÝ\û ~¿÷ã\4ý÷[ÿ§û¶ ±EQ±l»ŒÖÛ¹kͳS4`dËšê33£—x±ÈB©¦ æcŽÌD³E£þ›]DíZwXG(«K ¦L“¸;ÈIÌ‘¢Ã¶±Öߺ¤#ÑŒ·æ‰ éÐ’\ˆ‘$_¨Ð®ÊØäÞo5f( ÊQ&±‡ˆ„iÛPˆS× uâç @Îì3¤k²f3…ŸbâÜmö,HÞÕ¸b$Á¤«b¿IÍ“”Õ:Kˆ¢ª€BúH”@€%ì€jTm"´CHq¡ô­Ú®÷Yf^Óƒ¨"F`oÙ”JÈL`”e–hg­ÝI0F@ íT‰J¦ó$Ê™ÔP‚‘·…L¦Ñ¨‚>¨*\ q‚œfDìÿ=;”y ¸‡WÄŒ¤é@€ å:æ´q¸õ %o§=Ö]ÐÜî›C¼bÅdÚr‡ˆI¹+vÇ&—™}0á¬9 @â!ÚÎÓmsqa; ež#j¾û¥ì©Åãi‚àNp ™ðgM ^P[FXs³’0 "ÉÌr ¨GR Jp;7n“9qD¦Ôe4ÀC˜  Æ2ÝMî-Ò'hٮܽjUnkE*m©¨8tþ,ÁÓ?T‘ Däµ+í-þTÖÅŸ6îf5ŒƒÕ4wI$ÕN+‰ÅR‚©¹D9»<ƒ Ìm›xsN™û£=zÆŠð¹Êã^Ihœõ$ˆÓ#‘×!’÷Ç»¢&/ ík–æ•cØn‹iÒë¸X¨¢˜ä8ê0ð”§0ñàö†±oÇM€“¶>õ´àcp_` ÜBâoáfÙ6ÆTÑÖœ´åÿ&&Ýãïh +8Ê`˲OyÛ ³ã—½u]˜u´æ\v||íý~áÍ©2ù=òÐÉ^ÌŸ‘GÔ¦¢À$)”Ë-@P”DJ8¡"ÐíŽx')³æ'FFcíã»6iíиZ(ªÊŠÅ)R¨"cˆb#•Pè§OÇ•O]—=åkX¶$ŒdŒÔU°•¾ ÌÉÃC%&᪄E¸£¼Dàc}äÇ2i˜ù¦P̹ñÚÉ ¡Mþ1R‰,dêJWLÐÛê<µì–‡RZdŽŠUTŒ“yýݾœ”LSU/L3? Êj™|IØ%Fší8œ†ý¼=š„˸æo¤¤B&}«–è5j›E b.Sˆ;Ð ²Q#€ˆ#ŒxÞ¤•“}í1dKH6-¸âb=ƒ%\ –TçŠÁG…ELÑR1ȘëóP‚$Ò:ª®ªRVòG& –‘ ‹YÉdRe¸ˆMtÔ)]È¿tÑ™ÁC (™4„æÈ@¡ê@ÃÀj^FÄR JúutG¹qÖ«ä\°|1¯ItTL®èè,9ŒA9S) °˜J\ÓP @2š“-ZéE>;»)nB’Ì)ÝÂL4†mÕRúçq"V)¬ª' ˜Ç B> 9ö53\’W”îÐÉÀF%$îÆ9Z3}8R:K(Ô¢WE'"9oµ Å2yf^&ÑÇ!©c¹%y!´tc»eÄ«ø—’åQ‹,fEòk™DpUjŠ¦XÀ]`b12J”5‹É%cÄãÜîîÖukÛXÃHM²‹~åØ*ËG à(˜5¥)Ò.÷0>`ÓÙBè„•mìeë"ûýåÝn5kã»ÒUkj=_õe(‰DJ"Qˆ”D¢%(‰DJ"Qˆ”D¢%(‰DJ"Qˆ¸“fÿÉ;_Ž§¿«»®êãÿØSõÿ¸¯á§ïºßý?ØÕ´i‚Ö(V¶ût'A”yÐ;5Ë$u™$Ž‘º¦p*!éj¨AݘºŠm&Ì8Vp²Ò LÎ^Œòõ-3¯;Cžj“3à·9 ™0sE‘„y*Îb"ÍVaº3tˆõÇ&"‰·ÄX[‰÷FXOz$é UVÙ©1ÁÍzcHÓIº¨Ô¼m5XX÷H:ä'31119ÄÄì^8y„vÎÅD³^EÓÈÆ rÅäœUMºGL„Ðe R¤Õ ú‚˜J ‚ZP³2ƒ@€§güuh«l¼*Ûç:$˜´ƒ»\†zö•²_íwrqRω(íxPK‘‘ÌËÅ)Ò)ŠEL‰ÕÔTÂ;Ó”ÇÈD 4HqœºÏÝ:õ«bÙU­s:fÐsÔLH@ÂÓÙx-fÙöÜtíÜ’ŒZŶ3§oWPæêz…U¾€2†Ýª—X$AqÈ@C…[¥e§IºÄoÙ§¿b½i¼ëÚjº¦BKŒ?‹#³3IÍmÃ5P˜HìŸ iäܤý—UƒEAÀˆ®`o¼ÝÇÂr¦Ôc<ÄF§Ééç–³9˜Ï\´V…º¸ÂdKb ËLâLn&6-[¬ Ã7©ÞDH¬³‚¬GO8ü\9MTÈš‰,¶ûxªf"IS9ŒAÉñ  ltN£Þ~jëo[S|W `A$"œÆy•©ÇبÕìk~Ë`{¶ÛlvËLéuI¹D†)³C€€ç˜V¾ýapÇÞ·Ü %×Ë Üÿö•bâoàÞÙNw§ÂÔ-YAä-U¢&ÏQROû¾¬øæ)×½}\–ÅÙöœ}³8å ¥Är|œ²ÒQÍÊñÊEàApb ¢ ”—VYˆf""EÚRÕ¶ÙÓBÛ‹MDì©Ãäf˜¦+ ¡ÑNŸŽ=*­‰°-«ßítî"I¨A6ntZ˼f’éj"ÄARbŽYiP  ƒ´aÜ5¡Í¹\ŒVå|1²\IÈÊ) ]°µ‘jG«‘“ÄÅCÓšà‚ƒ¹§¨Äi)<Š\¥€j¢¾áe˜Õ#¤vÒwŒÆ ä&ž½S’¹ÝoÒ®©ÌmÂ]¡á¤tå¨Ù°ZéŒ Âé÷.]KÛ«¸åeU”vVâqiÉPDʯ'ô­è§†ª¡¦Ò·Ó–%«rAY˜±]I4·r¡\*™Ä­QvÂCÀ)5U9Êri8!ϱ.U-T^0¸uiÛÌÅ„KG¨¤u]MRn”:Š¦äîACœê Žs,¡ÌsDTÒ œ h"Ð\øhÜ,ß$šÒÞI<Žpá겯¬TZ¿IæámMŠ&L@7B@ ˆt€TM0Ré–X¬X'X0pHGœ¸UÈ®ƒå£ÀXʘ°ªtÈcâcCÇ!ä/ð–ÌuÚ!×W—M“¾\ÙunI#»AmÑÒÍ7"¾ø€)¨¡D p(͘cTÀ4.á…» ÆFÚ33ƨŠÍQMûžL’É!ÉÓXŠ›¡Tô­à—^€ˆäÚ4HRŒ½d_¼»£íÆ­KüwzJ­mG +þ¢¬¥(‰DJ"Qˆ”D¢%(‰DJ"Qˆ”D¢%(‰DJ"Qóúº®¬Ã÷‘W–âi„}4ýÛä-ã¡[ó—¨(&Ä8G.k¦»o‹=’ÊÚ5‘;7’w®„\¶Þ—•K]7 °Ä“94 Û™¡Š³îMËlÅåX€¢g-®aC0}¡ Îç“s»Íi9‹yùLí?JûôN¹{žñƒÁcxôç“s»Í9‰yùLí?Jz'\½ÏxÁà±¼zs‚ɹ݃æœÄ¼ü¦vŸ¥=®^ç¼`ðXÞ=9ÁdÜîÁóNb^~S;OÒž‰×/sÞ0x,oœà²nw`ù§1/?)§éODë—¹ï<7NpY7;°|Ó˜—Ÿ”ÎÓô§¢uËÜ÷Œ ǧ8,›Ø>iÌKÏÊgiúTfú”¾q+v݉ÀœPd©n¨7ª¸·N‹tQAú*¨sŸPäB{^ÕkïKÚ…²ÌiSLj:ý+}Á¾ [n›Á¶ªîn2$œÁ‚ïæ×x”ELj ‹¯±Ö·™ä¬Å©/ű eœ*ÍR&@ Œ`"ƨtS¦@x%s­±sã\·¾Ë7êŠG±A©ÎG‘zLdÓ)DC7]¡Ê³›lhAWˆi3ˆ-—_˜ÍÜ«ˆùçU^Zß$ªao”¯ÌfîUÄü‹óªrÖù%0·Ê ×æ3w*â~EùÕ9k|’˜[åëó»•q¿"üꜵ¾IL-ò‚uùŒÝʸߑ~uNZß$¦ùA:üÆnå\@ïÈ¿:§-o’S | ~c7r® wä_S–·É)…¾PN¿1›¹W;ò/ΩË[ä”Âß('_˜ÍÜ«ˆùçTå­òJao”‡²=¯xÛ}p÷µ^[¯æï)¹Ä£Ý¨‘ÖI»§"ªz…#¹ä9B/Ê´¼ô§æßåNEµçu\_Ñã?/N{žƒâü©ÏJ~mñþTä[^wUÅý3òôç¹è>/Êœô§æßåNEµçu\_Ñã?/N{žƒâü©ÏJ~mñþTä[^wUÅý3òôç¹è>/Êœô§æßåNEµçu\_Ñã?/N{žƒâü©ÏJ~mñþTä[^wUÅý3òôç¹è>/Êœô§æßåNEµçu\_Ñã?/N{žƒâü©ÏJ~mñþTä[^wUÅý3òôç¹è>/Êœô§æßåNEµçu\_Ñã?/N{žƒâü©ÏJ~mñþU+ÙjÿÅéÌKÅ<;Å[õ­ÙÖ‚0*°x„21ÙrÄ@ÓgþaÄÃêxe˜×Yt^ó³ Anœ¦t>€º{µ·‘–¦³)ÊgCÀ]#[5””D¢%(‰DJ"Qˆ”D¢/ç&ì[âç¾,F’²‡¾î áEÖ!„„x}!‘Ã1ö«åßÓ鄼á)°Ýv³N—ÄœÈ2si*5ª½Ž†•?æq³GE1ýôçÊW–÷ßá·Ÿ»ÙgÒ¬ñõ7§3š:)ï§>R÷ømçîöYô§Szs8Ù£¢˜þúså)߆Þ~ïeŸJqõ7§3š:)ï§>R÷ømçîöYô§Szs8Ù£¢˜þúså)߆Þ~ïeŸJqõ7§3š:)ï§>R÷ømçîöYô§Szs8Ù£¢˜þúså)߆Þ~ïeŸJqõ7§3š:)ï§>R÷ømçîöYô§Szs8Ù£¢˜þúså)߆Þ~ïeŸJqõ7§3š:)ï§>R÷ømçîöYô§Szµê 6Ù.Ël‰¤æl„({E ‡€_xQ{ªRcÞd–´žÀ²ßã.‡«Š DJ"Qˆ”EÚ ò ‰?²?bVˆ¥‡­8O‹›}Qh‹û¸å­NFå…´dn‡1Éoú“tÁÛ¢{2  Ju¹‰H&.¡ 9ˆQ †¿„{d\I\±£‰éZRàa"Ñ·Z‹U€ä$:ªwÕŸ ¨ "«`ï¨x¼DÚO¡Öo9õ¼²&bä‡MÚhÄ‘L“TJ:´äâkϸ[K¶Ð¥1‹.Òãx[K´Y©ÌHŽ×-™¶œ²R¸¡a0~D%à‰.gELU(ªi&Ãt@ÈR—vP‰@C² 滑XÓsÁÕ—N‘UË÷.©cžÈǪ&gwZÝÜñcBÛ¸;÷‹™œ‹´Ø9È8'".7äÄÍÊE„1Ô(¢röÀB­R»kT©Å˜@™áiç#0³NÁUõ02#=#<äf_’ëg±c4Lœ Ô-¾æá4bȨ‰—A€çݨrL˜¥Ô¼õwUs›ä¹Á³‘‚NЪÛWù%Á³é+41f+Ñ$Øfòk½X9SfÊ(Ý-ÚLÔ0*} Ÿ'ÚNf6‡"w'å#,‰Ï2á—²T9¸Ž>D{õpËÙKk,»ñM[=T\É Üàdš8;T×U ;+qp)”€  `Pm&Ò%)DÅU°V¥ˆ‘¢`3¤å¹*تÒÄHÈNÑ9˜'%°ÄËJãˆ æ ¾M‚ŒÔ’Aw1Ë W ÈRWOYNA*¤ˈçÀ*Ý[%ZOÀ虌ˆ0wÅ –Z”Ñ3ƒžïrøÅ>-{ˆœ¾"›e\̼çlÐ@ŽAP¤1Á}%ÌD  «lu^„ ~@H“&4ù#l•\áh$IÎ>ü—€ã†Vȸ3ÙBy>£© ß°yÉŒëvfÂŽø¾C+¨Äé óíT¹ yˆLâlDƳ媗#­1IÔDLk1®Z¯¨œZ²ç#ËD¸‘r݃DdKä ᢢ`I¬‘Å3ärf\‹«0(†±V¦à×@$Æ£"5þ§h}™ízÿv·Ò~ò½ƒŸºiz]÷®¢®•nRˆ”D¢%(‰DJ"‡Ý¸µ`XóMíËŽmTe5©´nÅÃ¥>PAϤº¸f9f4E¿6›µZÛ2¡‡îß-r ˆš=9K>tÌ–T¢»Pè¶ÔR˜K¬º´ˆ´˜H‘s6~ "¹e¶qC .›N\îy š3LÃ`PHç ¶b9äR$qüãDR”äÚÌÙ—\»\=¾gÜ#¿n¢ h;³5&¡JrCĦ(;B5ñ_éï>»þÕ?¸«6Ô±•ÄKÖÁ–ºbÓ«¨Ò>zn u8°Ò šTH‰*’bíŠ‘Ö f]FPJ'Y·5‚÷£geØF›ÝÿWcÞ!ÅÍs¸§4¿`CvÛ€tR«‹fÙ\ŠÚvÅ¢ÎRD³iC•K D„O´€œÆ** G$w`]#˜œ "´ö.ÙêÙE²×\±œY~LÄr¬ÚP{gÆÅ24ˆ%F2•¬.7-rÚŽn+B ʳ»u™wŽÊ‘Žùû†ûægÔ‘·{¤œ 6B9ªr€ÄÕYg‚Í°Ûe¶Ô‚EwdÒ| M~ˆpœNc°‰ˆh$¸:pÁÍ{²ÇfsV¤¥Õ ÙŠQmÒ”TÆRQáHab)¤‘Ô¦†zG3ª%&5[«Á7Ùm”ìußá8Ô&Ê9d¹Íl; ι5²1H ‡8^x[‹7!Lͦ½¸f&‹mŠÑg\‚fîFA³•7™›$Ú¦}€”KÛÿÁÛ-ÍB‰m\XËÈ|ÛÅQ{N^Ȳ™!l-Ýëˆs¶ƒÈŽUm Ú-âîúMÒë„"馈QEM±”ÐBh˜ÙˆV¾ë¹¬÷“*àªMF†á` ÄâZK£›!„a!²çLª*+ w$°Î]{5hûrN5¢SæU¡.𭉾[“¦d„úŒLà` ŠaòÜZx#e¡kuÚ\XÇWcœi€C¨0¼áoqD sH:õ¾¦v‚{tÌÂÉYN n“KH$Œƒ„+Ôâ½ET™™ nÄÓ \Ì&Ý©fàu;]Ž•zUÆ:¹±¤ÒipãM(Âê¡ØÌ@™F9’²¿a±Îè—20]`¢ÊãZâ, [¾;vàwౄRH&I#”©Šz³Ò#åKW,–`m¤º€¥ÆKZïÚŠXG„aλD$f-Mp†â•»pÊÛ¹g*Ïä˜×FBsgžZ ?ê•h¸Ib£w^Ö‹-œCâºzóíTpƒ C°'±FÏýrsúÃÚý³~Ÿô·ý¡g?UЕyE(‰DJ"Qˆ«í¡“MlÄÄVL§Lö|ÉLS``JæØQ^ÖÙSeçÄC‡7ajªªÁ¹ÎsÙñÆ1Œ)”DDEÄD}º"Ä¿6;À‰«JF&ÃÁ ·'%¹k,çcŸ˜r2¥@H@Pà\Ä ciÕ˜ %*k fÊAÓx2¿$#œe^òf€ {dnÔÈ¿öÇ "ÓX8cd±Ä¡ðªÜ‚io[ndZŤJ ¶#tV‹!N)” ¤ ٘وfÇ<Ƽ÷…õ]FÙF«un}…q|/¨h׳Tn ØT¾gÛf@²ÌJþ á_¹–ßFªB˜ÏÖ]ªæt ©pU’Ë@ö@b˜ !\½;ν6át8@îˆÊ68õî+”§xÖcp˜"ÏpFQ°ž¾µø÷àžG&Ì·uÊÝÉ’•nþA[‰¤NC»*Ù )—Q“LJ)1&€ @DÛÉítàlx03‡HÎvI¨ÛÁítáàÀÎ#9í&v¬6»7Y-”@“B„›9VBŸ÷RnI#Ÿ(œˆÔ7ÀV2š2…M×­ga0$¿Ã¦Øq¦o:¦ ‹NßáÓolD©8aœr7Á¯Ö3Òíªºë8E1@È.Ed‰Ò0# ”ssfSÚµöYAÊÜhñh#-ó‘q~ÑêXü©Æ—@#-û ŒëöŠÛû7áý±=qEoydz *ŽG¸Pê6h›T–ß(ØË&pIÿÂP„Ì¢:CQ³È«z׬ÃMÚÚá©$ˆ’uõ«õ/:ÕXXí ípÔÉ jv‚VêÍÂf¶:rÁ wÍ‚“¡—8¡‘H±ˆB•r$‹b"U  Â£#Š†Þ™EšöÓhÃ/êÓt—Ó”eͪÖÃ_&Œ¿«²I&=ylŒçS`{[½[¦i ‰òró¶ü„+b™6È ‡)m¹9Ñ@«ªRöÀQ@(ˆˆ`\®Ù¯C F¸¬ägiê\³ÛÍÆŒ-p;g#;LP {…Ѭ¤œ‘ž––“J[« :t(VT(Ĥ1H„ÁL9 :øˆ/¶9Í,k@'ÊÚI™ŠÓínsKžü[N²V+f 9„·žÛ1B«V®™:Q±„YºmW"È“x u.P2e"¶ ÏVb"#’ûÞÑR ¨ìÈ®ƒ"X²ÿë !÷­z™µÛDâËÕ !®Î–Ã%3K®æI7ÇAI$H«R§ d^ÚB –UU2w`%>‘(&ô¨á›[”ƹHÂvçÎõyTv­i®R íÜ6Îõ,Ù‹Ù-¿©Úf{^‡Á?Ý­ôŸ¼¯Dàçîš^—}먫¥[”¢%(‰DJ"QˆªOüÙíßÿ%DVßjBßVÌ¡q¤åX¹d ÕâMÞ,Ôê¢oTMê&*…e& Ê"ÀFˆ´Xs‚¸E„-–a­¹lSŽ¤lrH¬±Cµ¼TZƒÀ8œÂ<;tEËû4zß½¿xÛM_þŸ?ùƒ¿íSûŠ³iñýJ~Ç,·’2–5¾ÑÔ¹NAt#MG„PÂe ±ŠPƳÌG1¯(«|ÞV†S¥VÐ÷6œ‚÷ÒÐNP2 ÑX’½¡ì›2ÞE»x F1&‹ –é³`’%I]Ù“ÞP›AÎLÃŽ“˜;B!Ví7¥ºØç:ÓYï.q8™ 9‰Æð¡$•îÖ׶Y4Uƒ;v1˾5QI¢eLï`X\  »Ð5e¬ÙçÆ¡RßkªñR¥Wฒ‡gÅÃàáÓQ +ÄöUš¤CÛ}KJÑrNxñ°H[¹]E7‡UDôé9̧f&qÏL^–áY–‘Yück]ˆâk@Â3  2Ñ$£*ÍŒG“FÚPÍþî;´$™}!QU(¥¨cŸô˜DÁŽt«z[«»ZÏqð³.'Æ]©þ&€×o’Jò{`Ø’NY½‘² ]8]GLÕ^5ºê+¾QDÌ%̇2¾˜& „OÙ5*W½ãA§J»Ú×€œa€s¾ 2Ñ$¬+? ,ßkmÛÖ´j-[&І0´Kx¹Û *ª`(kP§( !˜² †²/+þñ½­.µZk8¸—€!Á¹äÒ ´dd*’JÏ”°ìy¹3MMYOäL› ·QȪ°¢%ŠbsM¤Jc—<²0‡·Xô/kÂËKˆ¡]ídÎç:Ì ×%I+ÐÓzŒks¬ o©'XŽ éHrqT¾¤âž:ƒÚ³ ¹ÝËÓå\¦§bÆìPu3hI+zѶhÇÆ2A£VäÑAÁ4Ó(vŠR— üÁZúµªWy«UÅÎ9’L“é%†ÀžÅ?õÉÏëkôÎÍû Òßö…žýWBUå¢%(‰DJ"€mùÄŸÙ Ÿ±+DR‹CÖœ'Å;¨´E·¢%ps\SÃŒ=Ú;ß´<Ï.õMó²$e 耈ÌkƒáeŠÓk¯LÐapè'jå8WwÚ­¯¢ë=2à˜µK¹ËlÿÓ ©ó’}r]Ǽ:vÉw óèØSœ¶Ïý0ÚŸ9'÷Ó¸÷‡Bî¼úvç-³ÿL6§ÎIýôî=áл°§p¯>Ý…9ËlÿÓ ©ó’};xt.ì)Ü+Ï waNrÛ?ôÃj|äŸßNãÞ » w óèØSœ¶Ïý0ÚŸ9'÷Ó¸÷‡Bî¼úvç-³ÿL6§ÎIýôî=áл°§p¯>Ý…9ËlÿÓ ©ó’};xt.ì)Ü+Ï waNrÛ?ôÃj|äŸßNãÞ » w óèØSœ¶Ïý0ÚŸ9'÷Ó¸÷‡Bî¼úv™±å×mÞ˜ý§6ÎZ5v¶™StÑPQ#‰[½)€ 8W¤ðj…K=´ê´´ÉÈúJô[ŽÏVËvÓ¥Y¥®ÙJëzèÍ(‰DJ"Qˆ”D¢*“ÿ6_ûwÿÉQ·DJ"á †Ð¸VµÙžÌ÷,ëw×lijgÍ¥¤š¨8ts¦ S©«ÔäØQµDJ"Qˆ”D¢%(‰DJ"Qˆ”D¢%(‰DJ"Qˆ A~Aq'öBgìJÑ¢Ðõ§ ñsoª-mè‰D\ è;†8´†9=¿lÈù¥ØÜ n£’˜E2= „8fÂð®ðµX«Ómå ƒ¢å¸SyÚì¢Û5BÐA˜ô©G4íœú$„ù'ñ«”îíãÓÊóŠôéܜӶsè’äŸÆ§wo˜§8¯NÉÍ;g>‰!>IüjwvñéŠsŠôéܜӶsè’äŸÆ§wo˜§8¯NÉÍ;g>‰!>IüjwvñéŠsŠôéܜӶsè’äŸÆ§wo˜§8¯NÉÍ;g>‰!>IüjwvñéŠsŠôéܜӶsè’äŸÆ§wo˜§8¯NÉÍ;g>‰!>IüjwvñéŠsŠôéܜӶsè’äŸÆ§wo˜§8¯NËo±¥›kØXóŽöÍ Þ*-»[Lé5@ALt˜Âˆô~ Ú*Ú¬ «YÒâN~²½åµV¶]´ê×v'ìÏ¥uÝo–É(‰DJ"Qˆ”D¢*ªCÙOû¿—þ£DV­(‹„ð]LwÄÌ,¶ïÉM§ovŽæ™•‘nÎ3vCjȺ›åÃÛù·†_¦û׃Wõªé¡e¤æRvN9"ÎTjVÀâÐ׬œhûÎ/Ík™ýbï¿3£ñýj£ì„ë';ª¯þó‹óZ~±wß™Ñøþ´åd'Y8ÑÝU÷œ_šÓõ‹¾üÎÇõ§(û!:ÉÆŽê«ÿ¼âüÖŸ¬]÷æt~?­9GÙ ÖN4wU_ýçæ´ýbï¿3£ñýiÊ>ÈN²q£ºªÿï8¿5§ë}ùëNQöBu“ÕWÿyÅù­?X»ïÌèüZr²¬œhûÎ/ÍiúÅß~gGãúÓ”}±¥-âc§‹‘IhLj9Ç ÙªÿìBˆ£ÎÔ»=5µ¢>,À¨²LÈ ±–WP&PÂ?èDZ\NÚâËaf?‘ÂkºFäh]ûhùˆÙÐ|ÌL€,DÃrs©PÀb€ä „LR.ÃÃ3€·ÄŒÅk&㱞ïŠ.ÜK,Å0"¢@E‡ý ‰¿Öˆ±íkÝî$ÝXç|à\©ßÕÅê9ÁQ+eœ3­Å}É^'¤ŠŠ®ï|M:´ê!Áp§‰å´¸ÿ ·ë²c8˜˜Î!®+”Yøï ·ë²c8˜˜ÍN-lNŸ’ê%±o´y+0óªÊ¾5Ôá» ƒ”]Ž’Šër˜S s0˜Ã‘MËV²1˜ª<€Ñ†0É$‚[sœ£w'VÊÆâ¨ó c qAðˆ1–Üú’g§â¢P‘5Œ¥Õ!lE‚]<1Å¡Þ•E×I»S¨MEba)*¼T1ˆcÞǸ·9®.øµ1Õ(Ë ì8ôhqÐk‡ K€þ-±ëXÖnÐ2×uÖÖÐÊv=PÝ„‰—ŽÞ°r«݈©›PH‰UM,ÔP‡6¡!JªUîÆФ_Æs#6æ£Ê™Êrl™U¯w62þ0H͹€cÊ™Êrl•ûicmÅsMY³6“xA»³•@Kr‹Wï—ж¶é‰NCµ 0@:òÔ¯wӢʮc±`‘˜ŒÃš2Ìë;{6¥k )2£šéÃ#1‡4e™ß·±yÆãåÈæÛk+#`G³}1!‚s†Y,«¢¶L®ä…5A6‚©˜c˜ðª¾í¦*µä€^ƒŸ€'!&di$*ºï`yk^HÀåä‰ÈI™õ)¥‘|Ïݬd\/i ÙXÙU"ŽI•dÔ:.΂ç)„…€¦BPÕ§¶X–‹;(8é‘:F¢FÓè÷¬ZôD€¨7‰/z?Æ{‚4óLÝZ,•i*Ê>:-ÛõÛ(á'2„`›£*f˜¤méÍîZ€ƒ‘«!¶ oÂCÎ $bŠ"frŒã~ŠûlLv`‚I†âˆ™œ£8ߢƚÇɈh•dÏb7\ÑQ׌Êi˘w‡]•+q3pe7Ú‹¨ËH²*wk*;=KËˉÏ(ŒõReÞ×»=KËˉÏ(Žµöž7ÜG·Up{ ÊS‡•$l{%I"œ°¸7Ù¦s JEŠ"bº ƒ0(ÐÝôøÈÇàÄ“-Ë8ÎFí¤ç¢¡°³cðbI–åœg=[g=žÞÇ»–þul¿„‚iòàcøT"ÎŽªÑ\¸é‚{­"‰”)Àâ$Ò½Ví§fkÝ. $e'aß®ZDuÊ»Rï§g2àÒFYdì;õêˆVvÌ^Él}ýNÐû3Úîø'ûµ¾“÷•Þðs÷M/K¾õÔUÒ­ÊQˆ”D¢%(‰DTmýyDY[MZïæYÎ8IÕ‘,Õ2Ä@¾•P/Øé³ES¦Lˆ9¨`‰@G3‹;±ÜسR~Îâkp2h£¦GœÃ«„Ì tÃP‘q#dÌBJ*» õ %.TÀÂ퉒¥µ.Mog3 \ì”FpªJn2MB€ö…A¢)&Ï·te“²³z˦àÌa­Õ,šIæ©Ê˜œÚJQË3YA˜‡n¾ý!]õonÚì4#J¡¢r@Ìõ JǬ&¡SF¸¢î³ç‘ f"É5ÃÊ«2å%ªDEDnEJsTÀºJrŽ¬Àr 딩p²Òö6ë{êbÆA{&Æ—9ÁÆ£š@ $Éi¤«q¹z5Ç,7t£€ WȤÝ5”å Ä»IAˆŠà™Ì˜Å%NR(ă«VZM”jpRô¦àLa#K› ;,m°ŸDL‰a+wðö%©VŽq!8¸Ê$Í£,²¤TPf¨˜4€W)~˜OXq«ÖNÞv‡áªL`Ç/s@ ÓuFíÔµŽŸ&<<)„¬”q®Ï%Å/mÌB1x·€Ìª­äPXÝNEø”V÷DPTÞ”'Ö;±Ì­;‚öÓe¥j¡…áíÅÌ‘ÿUÔ¼\X‹q4x@a™É0•½¸oûrÚÒ|£Åܬÿ©ˆµfÉg *ç“‹‘!HBˆŽH”íxçµö;žÕn“LÐÜd¹Íh Å‚I$65“»5@%c¡‰ö[‹¨öY$U7Ebb©é4Éš•Ø!Ê ˜"*òs•MÞ½Y{Y€…\uÃoeŒ[ËGF,žÂì!æž,Øð㸰ÄíUƒµQxí†ÓAx¹)5’“M¢è¬hG©&D]ŸCU”2‰Mcö)œÙÂÈr)„3-½l¸Åf48Êd˽ snHÊs"XJô˜Æì:·æÞÛs2Κɲ)L ãzçRÉ¢P@ LÖ*²D(L'.a˜Ôlܽ-–vZ¨0:›¿‹a°×8â3 ­q$ÄFprL%{A^í¯ë*~a£š$Õy(Ò‘bœªpc¦&1R™3”s †ej–‹©×Eãg ÷ nÊð À FzƒUX‚›²± ¿e˜}PWé_¬×øÅ[Õ¢%(‰DJ"Qh/È.$þÈLý‰Z"”Z´á>.mõE¢-N)a´F-Ù,+ŠZi”<žIÈ’)à´Uã|‡[sªPÖTÏžF L` "m"`(¶l«³¦ Š+ažÛPÎÛÿ‡!ÉÃâÿ÷K Öÿû¢.~€·àn|uÚå„a-­Ëe¾lEÑ9ŠÁD‡(ˆC‡óÎU}U'Ó$9Œ—à ¥Vƒ©’˜ËjŸ­‡–ˆ†0,k}X¸ÃŠŒY17j|Äu$˜—I1%íqÂÕ\<¼<ÉÔÉ“é\`´Ö/2u2dúVT…¥jËE)+lĽYs¹Q›†I¨Ö:‚¡”ÌQ0¨cL!˜˜Â=±Î¢ÚõXìmqIœ÷}Ù(¶µF;\Aß9îXÍì ¤“9†–L /ãÒ* '‰Vn‘@@¤Là]D(ˆ€cR6šîiayƒ¨“š‘´V--/0uVZµ°Ùf[[‘i-‘b¡¦S5H„9D„2¤QB€ œÀj&µB.9ëž¾žÀ¢jÔ ‚ãž¹ëéX3V ¯3o¹·:ŽÁ£gä‹J=ª€›Rz„JšÉ!L¾Ñ C3íTéÚjSx©$gS®üˆ3×2¤ËEF<>I3:wäAž¹•‹gáu—eC,\+UH+‹.ÙQUàîÐB”5T1Ó)JLG°Ô«Û+ZÇÞwAíïÚ¥ZÕV»ñ¸ýû öwí^R˜C†²±ò¦²áš£.ñ£Ù.HÁŒùFîJ䀸=4Bæ`6yÚΪËu¡ŽÆL“”ˆËvJ¬¶Wcƒ±“$å"2Ý’Þ±µ­˜ÆíÚÇ[±Qh‚ÍPM‰©"±ŠeS(p)ÌB˜À %ĬºµG’\âg=wiÙ±ZuZ$¹ÄÏ^í;°¸_†„‰aÝ°XÁpÅD77àQ(+»Ñ§XˆjË<„B®rËF,|c§I“1¹O•WÅ&LÂÈo`XŒåPžidÀ¡&Ù2"‹ÔãQ*é&P)  QJ"9cîÔM¦»šX^`ì“ †ÑYÍ,/0vI…‰³²[S´>Ìö½?‚»[é?y^ÁÏÝ4½.û×QWJ·)DJ"Qˆ”D¢%URÊxÝü¿õê"ŸÝV¥¹|@;µ®Ø†ò±ÊR;dä5"à€`6… Ú9@3!³)ƒ0 "ú¶­[b̉J϶âà£ÿ ”k4Ú ŸÅ4À  íµD\i³d]Ѳ­§mN6å1ÒÐ 2vŽ³xŠ‚¡]E̦ !í |úJµÖ°pîÛj³˜{*‡4ë`äsß’Ç­•B¥ 0j0ŽU1vÜOU0êÏ« á0.mõE¢-½(‹Œ%­ £ìlqÅ+–ÓÙõÍÝ wË4|ÅòW§»æœEMÉÎËg.–àþQüZwªáŸú}OwÍ8Š›“–Î]-Áü£ø´ïUÃ?ôúžïšq7,9­ªöws ý²±ul©P9ø˜H ê}Úȱþ‹xcJÓMï»ê Ó¥“¢¿¶Cö/áw쳪 ûÞ¯ŽVSüb­ê‚ŠQˆ”D¢%(Š´äd&~Ä­J-ZpŸ6ú¢ÑÞˆ”D¢%(‰DJ"Qˆ”D¢%(‰DJ"Qˆ”D¢%(‰DUUÇì§ÃÏÝýåýFÜ¢+Vˆ”D¢%(‰DJ"Qˆ”D¢%(‰DJ"Qˆ”D¢%@6‚ü‚âOì„ÏØ•¢)E¡ëNâæßTZ"Ûш¹ƒqSßã¥ß‡XmrÚPÑV´tC¬å!xªÇxEÄ{".˜P÷?Íù«A}_‚ç,˜±NØÒ>kW{^ô®vSsØ]Žt1GzÄël”0çÁ'>yZ>{7¡=¿‚ÒóÊÏÐh|“®=°:Pßœùå9ìÞ„öþ Ï+?@}¡òN¸öÀéC|sç”ç³zÛø'<¬ýö‡É:ãÛ¥ 9ðIÏžSžÍèOoàœò³ôÚ$ël”0çÁ'>yN{7¡=¿‚sÊÏÐh|“®=°:Pßœùå9ìÞ„öþ Ï+?@}¡òN¸öÀéC|sç”ç³zÛø'<¬ýö‡ÉxH]»_°`åñ±7Ž Ñ:¢P´œ­%ËÿùªMá£\àÞ$ç×ø)3†w¸7‰9ý¡òWžÞó8•‚¶Uÿq±dîF²Á±‰ª&6’ˆˆ€f=¬Æ»€d.¾£C\@SꪂQˆ”D¢%(‰DJ"QUqû)ðó÷yQ·(ŠÕ¢%r©v½Æ9»’튱6ek;jܲVØÈ+|¢Ì\*ÑaLÇݨ‰5²ÌrÏ,Ç,ë‰á'éƒ|¶ ë\²¡ht9ÙŒÀ#aUqc2qY<æö—îCúFmæµ ïÙÀŸ:wöŸòQÇO¹9Íí/܇ôŒÛÍiß³>tïí?ä˜éï÷'9½¥ûãþ‘›y­;öp'Îý§ü“=þäç7´¿rÒ3o5§~ÎùÓ¿´ÿ’c§¿Üœæö—îCúFmæ´ïÙÀŸ:wöŸòLt÷û“œÞÒýÈqÿHͼÖû8çNþÓþIŽžÿrs›Ú_¹?é·šÓ¿g|éßÚÉ1ÓßîNs{K÷!Çý#6óZwìàO;ûOù&:{ýÉÎoi~ä8ÿ¤fÞkNýœ ó§iÿ$ÇO¹9Íí/܇ôŒÛÍiß³>tïí?ä˜éï÷+og¼\WpŠ—¶‚ßR`ïSÜ‘Ÿ]‚"¹c#….Tè ÄHˆ*rO–zJc”r Ã:"¡°çð…l™ˆÏ \RkkM¢¡‘su¢x…Û¬QŠG2à‰ÀÀ %*†øvøQywâ ½im ‹÷³¡w!HYs¹‹lg€T ÞAC,;¬ý, A7kµî×Âû;­5hSaqjcÉ\Ÿ h:Ð,ÔØDœz˜òâý¶æ£M&.ÍB”™y"ÄMc‰PÄS!)9LRxJ ˆ p•,Õ)» O£=5ÓvÝË„©g¨Ça‰ôg¦½›W„v*á|Âí[DâE¬õgÊ-Sm0ÝC. €€Sˆ˜Â/Ìx‡»U}ŠÒÀK©¸F¹'Y- ¹„GQYˆv¾–ŒëÎ@ £©DŒý 3$S ÔQ\Ç°)3 B9s òΣÉkák°vC#Ÿ£Ò£É«C]„ôË_BÏŒ¹­É¶‰?†¸#_¶]AI%š»MTÎp(œJSD@ &È8ä=ªƒèÔ¦p½¤° êOa‡4ƒèZqÅ\2,WWUÄuÑr ÊñY4S@ë‰à™T1€¦!L`ÈG0(ˆp«¼ŠÓ‹¦f& Ì+¼’Ñ‹:ÄY‹‡Ñ*Kæßh¢¬‹$™“D†;CjÒ¹@M˜¦: ‘ñ#Ç€Õe®üÚÂs»½=J-³V~ma9Ƈ]Þ•ø㬑l§^pÈÇȉÊÕÒS*J‰@ùG.Ä@@ßôÈh,µÜâÀÃ#Q,Õ‹‹LŽ¥©œÄË1Ô›Û:i³ùƒ±~+¢ÕtÔ‚‚eÖU€ ¨†ôÀ ‡ˆYUÚvJÍh®á ‘®ÙÝدQ²Õk8Cdk¶NÅiì‡ì_ÂïÙfTí­Ñ{-oÚoUU´¢%(‰DJ"Qˆ”D¢*ªïô¥pÍÑ=Z¶½ÖÈÙö·gZ!Qÿ×R ñÿ_vˆ¤ø›ŠÖ.[xb<‘`á6ËH 5×A±Ôˆ+"rA6EÞ"ŒP0fE™eb6âLoVpö÷¹X†@g2 ;!D}£ f#ù‡!¢.-¬M°l«ƒ¢®»­„[·X«t\)¤Ê»6ZCÛõáÿhû•òOéÊ⼯NŠÖ:.{[E’@Ó7kÚ;Uªà—ܯ´EÒ ¹n %H!ƒ´bˆfÿâ¾z{MÅŽBÇ_u_¬‹„ÁT"„À C€ä9üáUs\ÃQxEJGÍųš‰tG,_·MÓeÉêUHåÁù„¢ÿ­\´P©e¬ê„=¤‚7`QE­·¯‹^ê#Õ`¥ÂqïÕ‹YS"¢I‹”Ì$91Ê®F.¢ ‹˜g²í·U®ï,†AsCÀN$%¹gƒ‚òµè¾]IvË&ªfÏIÈ`1G!Ë€…Iìu3…â /ÕUI̲Ê231Œ9º"5F´¸áh’‹ðË"E‰Õ!TS1!Àl»y·–t qÀda¥?´Ú¶âOJy[âˆL:R1Ì@6¬´ú¢2Ï0˵Y±×mœZœßœ õ€šèFq WîÀžÅ?õÉÏëkôºÍû Òßö…žýWBUå¢%(‰DJ"Ä—‰ŒŸ‰{4űò-Ôhí²ÅԚȨQ)È`öÊbˆ€‡¸4EY“e=œHP!0f×”9p "Ö];(`Êöóô,Ü&±ÚMªˆ‘“‰ÁUº PéÅ2€\ÄÚÅÔ ¨¹ê.w°¿îÏѲ‡¹1v鸱UÊÇ]Ú@$ˆŽTÆÇJ ½50*ÀP €(‹é¦Xv~'ãž a}¿jÃ>´`X “d„ÄHîHU>c©CflÄLa0åÛ®…ÕxŠöj¤NOai\— * .²U ab–\G/2øgv¶fÉÔl1y×ËnÙ>µ'[Ë‹Ž¸ëå=Þõ‚÷È6›ˆux6êKÖ7#HÔ‰Ò«SLªeW2Êo„†1´–a–¡0€¤ÛÈ4µáž,'=p–S·3Ô¤ÛÀ4µÁ¹‚Âs×e;uêVZ±/Žðî¤HÏEÈjŽ)£’z«¯Žó ô¯JÓŸ¦V¼=±é¿®wiÕ¿9Ø°CÄFzoëÚuoÎv*­¶bººPwtcž£Ü@ýTŽ_E³,KÆ»´PUÚ‹d'\€*ÀR€—I¥0dmÔ*ã/aØÔI8šs! lÝ'zØm˜ËÚD¶5N s! lÝžõ˜¾ÏMµ”· t,™Â"ÞAÒh¦¼KÕ¤®i*C ¢Àr…(é8‹y‘SŒÃµæ:žH̃R í "ñ"¦<;\} Ž­H3¹`MìæòfÖmk æŠmŒI>¨$³wîÛ¹YáˆnR]ùÌ &%8”U:¤ÍSŽ€Î§Nõꚸ3ðcų&ŒP-TéÞA• L9å#fM Z¬ØŒ³€_«v6{ÚxñÍK¹\½QW”, ¯½0  N”É؈jÔ!¨`û{kø!°\Y&rðD»\ÏT*h¬à0Á%²g/!?ä©n˸Õ­pæ[ч˜ò»q’Ü™•ÁºAÒÒ™7c¤¡íuì­ÑzíQ*ÐæõúqÅ¿ ¿Ûª«iÍëôã‹~·DNo_§[ð›ýº"szý8âß„ßíÑ›×éÇü&ÿnˆ½SÙî mr'(€k"viz˜vêgþWj Îbðö“L=opwßk™‰ˆ’vù ?'Ý9u,ùGÜ ‘!­EO™•XÆT‚cs0‰„G:ù7ôÕo¥aá5¡•fjÙÁÍLYõCJµ\ýK?×Ðé„TË{eX(ˑ与–Tï›9œBDɪˆ  •4Ξjâ!˜”@<ÞÇ» ­@Ô_I¬È4¹–wQ8>L¸‡L4´LI…h8ê;¹d•Ê…ºhhCOD\‘„]3¦Ul,t£»@‰*] `jÈœ "<3eWYÝjÇSŠ}ðè ñaün¤æòàd %Ù€˜–L..³¶+Ü6½žÆ-+¨³Ç·Xfâ=ɳ Àè&S¨e”"‚™ \ÀDÁ™¬Ú¸VÖ±í²Öªê†Æ»Áy&»jçq £Â$Ì@1,t6}x1ñ+¾ByÈKjÔ‰`üÀc(ÑÌc••rtTõ&S•RD¹ ²8eW]Ã|mVÓ/ªU´½ÍÊÚÌkX1A ¶H2­$ªâXW>ί׌äP6{À_®tÔAþ´ly7 ³g©>¥Û¤]ÞYr0U öSe^2ÓR«c“[.iá}3/l2£Ž-H‘%„èV½ŠêNÐ{l¹ƒ`ðÎ⥣•Pó+¢e¹J¥Äà´ À¡Ì0¢p(‰ƒš³^Ì¡me­µÜ/¤à8¶˜ÀÌbpx­1·ÂqiÉFsUDö ßRÅ‚€•´,ùU“ƒ¹Ú¤àà 6ˆQÊñü•b¨‹BîJ ¨mDE¤@J&7cdá=ßgã­4kÕ`5,ä]P1µ±´‡Uq 2ÔH2– ··¶Ïr“ïdnõ¢˜qrµ–×" wÌÒ‡E—'\ë5pB€.˜®RŠJ” Bi8ê&ºëá•:vj¤æ@Å q®ê¸šR™2Àœl0H2Üœ……5€´ZlP‘3[i„J-\¸‘vÍf®…EE’frQH!R%(”L)ŽcžE—† <¦£šìUTà¸=£'Upa’ìžH bÁHðKgpæHKÆÛl÷6ó3«²§REvê*c=_ZDÒ¢ pjVy¨~Z¾ð’Ï}Râè¾£¦«êCÀÁ Sl9ÒÖÄDC[¢£*ÒØØ£gþ¹9ýaí~€Ù¿aOú[þг_ªèJ¼¢”D¢%(‰DJ"Qˆ”EÈSW Ö±ÕÉÈøíü-­ºånHŽóJosÓ¨C<³ ò÷B¸NÒ©TÑÀÒ|mù+’á…•©Ùø¶“ôä©/¢ …ðÞç$|jáù%£È=…qŠÓÑ»°§¢ …ðÞç$|jrKG{ r+OF6Ãxœ‘ñ©É-Aì)È­=» z Ø_ à>rGƧ$´y°§"´ônì)èƒa|7€ùÉœ’ÑäÂœŠÓÑ»°§¢ …ðÞç$|jrKG{ r+OF6Ãxœ‘ñ©É-Aì)È­=» Áž¿¬U äSNõ9ÎÑb”¥’DDDH9ª+-pðK»Š¹FÇhM7j6dl‡ì_ÂïÙfTííÑ{%oÚoUU´¢%(‰DJ"Qˆ”D¢%(‰D\e€_ñ ^ýì]?k¯ŒÿõÿÊÙÿfŸÞõfÑã@V½xr°”D¢%(‰DJ"Qˆ”Eƒ°'±FÏýrsúÃÚý7³~Ÿô·ý¡g¿UЕyE(‰DJ"Qˆ”D¢%(Št`® ßÆŸ½p–̸$ÎB¦g²-]®b2)EEvƒ>HH=Í ÔsfÙ¿¹÷ |aä©W~òœÙ¶oî}Ã_y*@N5ûÊsfÙ¿¹÷ |aä©8×ï)Í›fþçÜ5ðQ‡’¤ã_¼§6m›ûŸp×ÁFJ~òœÙ¶oî}Ã_y*@N5ûÊsfÙ¿¹÷ |aä©8×ï)Í›fþçÜ5ðQ‡’¤ã_¼©ô<`Û<ûÖïð¶GËUžåÝþoOØoÉ1õ'0mž}ëwø[#å©Ü»¿Íéû ù&>¤æ ³Ï½nÿ d|µ;—wù½?a¿$ÇÔœÁ¶y÷­ßál–§rîÿ7§ì7ä˜ú”æÅø&–=ÄY$ë¸"Z2ª£×\†bå'¬Ó!µosàE” »\iÜ»¾g“ÓöòLJ}ÌgŸzÝþÈùjw.ïóz~Ã~I©9ƒlóï[¿ÂÙ-NåÝþoOØoÉ1õ'0mž}ëwø[#å©Ü»¿Íéû ù&>¤æ ³Ï½nÿ d|µ;—wù½?a¿$ÇÔœÁ¶y÷­ßál–§rîÿ7§ì7ä˜ú•Ç†8iia‡v+%šBE âÙœs”UXë3œDÆÌêx·•g“*„É’¥5ED¢%(‰DJ"Qˆ”D¢%(‰DJ"Qˆ”D¢%(‰DJ"Qˆ”D¢%(‰DJ"Ð]×å¡a’)[Ây´RsR$‰b£“i"®ÎšŠ-] 1Š‘À¹å¨ÚJ˜Å"¤pËö„ÅXVòvÜŽ(멱òØ‘IŽÁtXÅìA] 3Ô1 rˆ‘L¿/Ñ'ó*"~6_¢OæTDül¿DŸÌ¨‰øÙ~‰?™Qñ²ý2¢'ãeú$þeDQ¥ì©×Ć8/°¨1ƒuVÀYÙ“]tˆöõ·(v²0Ñ—ñ²ý2¢'ãeú$þeDOÆËôIüʈŸ—è“ù•?/Ñ'ó*"~6_¢OæTE©¹ngVýÿsYIóH-çP*9Íó¹RmŽÈÉ/é…]#ÅœN\€HõéÐ9t](‰DJ"Qˆ”D¢%(‰DJ"Qˆ”D¢%(‰DJ"Qˆ”D¢%(‰DJ"Q8þû \AØó™³(ø8ò\mÏ#"f •Ê†(ûFܦ©Cÿ«‡"Áü8Hl%Ù*ÎMúBrFºå Œ¢¯ˆ›> `l Ê ?æ)¨‹§(‰DJ"Qˆ”D¢%(‰DJ"Qˆ¿›xC²ÐÛ…¢ùºB9Tàbb—¾#”1},î% ( @;@²²}ÍǵD_ÒJ"Qˆ”D¢%(‰DJ"Qˆ”D¢%(‰DJ"Qˆ”D¢%(‰DJ"槚M\xÑ„V3[òï·"åãîg‚Ýq£ƒ V–³"`קYòÏ<µ›,³ÒðŠñ­u]δÙã-‰ÕgÝôY^¦Œ–¿›Ò]9ãgÒ ^sÏ»Ûì{!n»›gܜޒéÏ>d|zsîöûÈNæÙ÷'7¤ºsÆϤœû½¾Ç²¹¶}ËCf¨¹fbå1›^2x‰Û¸n½úýDÖH圇(Ÿ#@D€€ÓŸw·ØöBw6Ϲz7ÙÅ“6é4i˜Ð‚©¤’wüHBd(ò €œû½¾Ç²¹¶}ËÓ›Ò]9ãgÒ N}ÞßcÙ ÜÛ>äæô—NxÙôƒ#ãÓŸw·ØöBw6Ϲ9½%Óž6} ÈøôçÝíö=ͳîZûFÚ™Ã]¦°Þ†)b$ÜeÅq(ù•Át»‘@çl›QHÀš§€€¬~9{•ÙðJýµßl®mQàaˆ®)û‚ÖÞVZvv·×ð]m]jÔ%(‹—6ノº`Ý©4W EÌ_IµzŠ.•n+$,Ü”N‘Šp À;B{ZjØ®êöŠÖÈ9ýr]‰©X5Ú-G3->ÊxQ-çUäœô¿:ŸJ蹟É÷”æe³§À¹O %¼êœô¿:ŸJr ?“ï)ÌËgOržKyÕ9é~tÿ>”ä'ÞS™–Οå<(–óªsÒüéþ})È,þO¼§3->ÊxQ-çTç¥ùÓü úSYüŸy_±^Í¥\ÎKbÈ‚Ç!S2sËj1J" <§<€Llƒó»Nz_?ÀÏ¥9ŸÉû×ß3->ÊxQ-çTç¥ùÓü úSYüŸyNf[:| ”ð¢[ΩÏKó§øô§ ³ù>òœÌ¶tø)áD·Sž—çOð3éNAgò}å9™léð.S‰o:§=/ΟàgÒœ‚ÏäûÊ©1ßpã%ì œ9Š‘Šw!4飓šmóQ.§9>+¬r‡dRŽ`ðí×cÀËþð½íUi[*b²<Œä €, }š•`°Fkú+]ÊÐ¥(‰DJ"Qˆ”D¢%(‰DJ"Qˆ”D¢%(‰D\íÉœø¦îú¸êå¸iû™ÿÔß¼­¥ÓûoR‹¹ÇyxÆã†ôfÑ„÷ÎàH´Þ‚ÙŠ<œC57{½èC²È£å¢ìk¬bÒg vÈñ‹cY똽nÍr*àŒ¦=Óè_®Ô-üÈî-E€N Á"™v®L«Iéµ"‚š ‰‘0 ó1ÒtÀäG4êµîZöWE_·¼fÖ—múFG<ö£-L¨<¯yë"®×]Š6EšMæ ÐYÇÜ.Šƒ§fzdȹK¼:àSk1rÌK£Jï¤-N²×~m™-Å3‡@6jŽ¬î,T`×^šJ³›ÌoÖ*=KOP:j!‘Cp¨'Äsÿ™ž´ÿê(ð­a§dl÷‰÷hwRª™í9ö5¼£Käv’ÑÏåÕ#5£–U“6el+É9P%KÊÓC#+˜4æµuÍQ®-/hÌ ñ .˜1àœôëV¨ §fÈëëÑfÝ›GÚV“çlßBÉJ£„Šî˜´béâŒüU—pMêjœ¥(˜¢B‰Œ%)¡Bè«] µÂ`º!Ä€‡@ÝÓ¼ÀU}¥¬0GVÍÓ¿ró{´Ö5mjÈ “ÇŒn¦Í&«U¬£4ܪ Ë"E@(Pà@˜ cˆ·5¡Æ£LÂFr&äb4Ðk¾ ©‚õ°ÃŒ^{ˆ·G%B×{ êÜe?«ò& ºIʪ‚jíSJ)£ ÀU #ÙfVívd¥%À¸8´ÄÀ€2Ì »FGb•:Æ£¢ D¯©e† üKvý[ ï?G~%«ÿÏÿ5­¾2Ö†YWB¤®§Å~i¾Ò‘7HS.ý2Î9˜u@@§ÈuÙJ…ztòKÜ#,£nyƒ9M't¡Ïcž@zæ'rÃÅÍ n[䬛8ß´gF>LÄzS>»†<‘Ó"HJR†HÀ¦¼Ê#¤ Æ¥`º©ÚCZ]á½²2Èxx5uÙr©ZÐêr@È^’·qxÙ{J¶f× ÊI‰+ƒ¨ÈIi¶J%ÔÕÞò‚*åV8·:"ªÈÙ€Ue÷uãWÁ Å–6 >6νJb»ÌÜæ6“´ÂÙYø»=~JÆ3€µ ‡P£§eÅ䙊ª$v£„Á&å"F„†h°‰Ž)€ö¨ÂKv‹;+\j<Î'4@× 9å24¾º²±¨@`'×ÿñbàæ7ÍbÇ&wèy% ɬ£gª ñ$ŠÙtÕ0ÇpÙ$ÔT¢D@À‰”(ïó)ŒR +Âíe†G ‚2ÔFçºÁË1šQ®jç‡/_Én_âDôUïmM[-âcå›6~åÂÇ)ß-½3Lé¢dADÅ2ˆ¡7›ÐÐ 5e¶:o úŒtNB4á3vš‘ªCÃH‰ÿ!D¡6„¹¥-VS.0î1)xëjV1šW •@íæ‘©7ËòRŠFHO¬ÀTÔdSç–]Kª“*– †^ Ãœ±¸²³ŸHªÛm-œ9˜Û¼Æåõ´cÙsÊNØÎbâ`ÑšßÉn$UjŠñ‹ +Wˆ(dÖ1#(})ñ&³nËJ·KXòçaËÁ˜x‘È‘3=c2m¤™‘Nýž¥’ÚVúzÂä·˜X-¡îH8‰yEÔ$(‘6í´Tª¦C¢&D_& š¥!@¤1ƒPd²ç ×2£ªbc‹FBs%Âzx'1:ä2P6—Zº>kjWK½…Â'®­g *¡²ÔcDºƒ€qèÿGí ¼my?ùbò3E¥wMzjæÒˆ”D¢%(‰DJ"Qˆ”D¢%(‰DJ"Qˆ”D¢.vÇdÎüSw}\urÜ4ýÌÿêoÞVÒéý·©e¸ÂKÝÖ¥ææ>AY%d•9 0ðY™âH×›ÞO¬©¤˜·yæ@7ªã^B-õÛK‰D£f $ŒQ1$íêÑt‹ ±m×S÷h¾¢ð¢È‡†,d<Ž¹E’³lØíW"íÁŽ¨‘DÓ"`RäP(€—…n¯QØÜDæ&&D Iu2vê‚“ ié;a, U(ëbó‘…ž¢*D7ßœHˆ¢ÜíÒÕ˜ˆ©¥5 –±È oTP¶mUKª<œß3ë2}FÏFŠ¼[` Ú-šPl‘P"òbƒ¢€AÁÃ' ‡à'þQs"z "Q¶j8ˆËfÁ°FîÝç3%KUýšðåÝÄ”òƒ8pJÅ€‡¨rªá¡˜Ì À“õnUâÙ$ÀÍ`› 0¤ì6ZbѪÂáã Ûv’¢]"r—FE0—†aÇ.>_jÄ]ƺOÚ?5N&œFØ©Ý°SM Ã’!HB\NJR”2€E»È= ®ãôvfÝXŸ#ÿ °/OÙJíÊõÍ%(‰DJ"Qˆ”D¢%(‰DJ"Qˆ”D¢%(‰D\‰¶†,Z8//|ÞêºN-û©¹…²ªšÔ,p"…i¸CvZ/{¹ök4b%§3JØ]Õ[F¡s´P¯íÙ§ß÷Í&ñ«Î¹ƒ|îo´·}У֟Ú?³O¿î/šMãS˜7ÎæûIÝ =iý£û4ûþâù¤Þ59ƒ|îo´Ð£ÖŸÚ?³O¿î/šMãS˜7ÎæûIÝ =iý£û4ûþâù¤Þ59ƒ|îo´Ð£ÖŸÚ?³O¿î/šMãS˜7ÎæûIÝ =iý£û4ûþâù¤Þ59ƒ|îo´Ð£ÖŸÚ?³O¿î/šMãS˜7ÎæûIÝ =kß vÃM ¶°Ã_C·*õä圱 ¡–ý6»½9ˆçþ ó÷8{µÙðNà¶\l¯ÊÀððDÓýák/+C+µ¸6~ ºk«Zt¢%rÎݳi%„·ªñ³·ïb>v‹1K|d¢à:C¢9ˆpb^67ÞÖZd=°'O\÷,«AJ¨{´ ¿çí‡bð#<ö¼Ó½ÝçÒSíwз½Ô£¸ÿž´çí‡bð#<öîï>’Ÿk¾„î¥Çüõ§?l8èÛ?ç´ïwyô”û]ô'u(î?ç­9ûaÇFØüÏ=§{»Ï¤§Úï¡;©Gqÿ=iÏÛ:6ÄàFyí;ÝÞ}%>×} ÝJ;ùëN~ØqѶ 3ÏiÞîóé)ö»èNêQÜÏZsöÃŽ±øž{N÷wŸIOµßBwRŽãþzÓŸ¶tmˆÀŒóÚw»¼úJ}®úº”wóÖœý°ã£l@þgžÓ½ÝçÒSíwÐÔ£¸ÿž´çí‡bð#<öîï>’Ÿk¾„î¥ÇüõªóñògìxJ̹£Ö‰–rýu%JȉŠbÁÂytåAj8{@gƺž ðb×pÚ*V´½¤9±à’vƒµ£röÛ)ÚÙ_ÿÙsimrisc-14.05.00/documentation/manual/html/outer.jpg0000644000175000017500000003365514034554241021346 0ustar frankfrankÿØÿàJFIFHHÿâ ICC_PROFILE mntrRGB XYZ acspAPPLöÖÓ- descü|cprtx(wtpt bkpt´rXYZÈgXYZÜbXYZðrTRC gTRC bTRC desc"Artifex Software sRGB ICC Profile"Artifex Software sRGB ICC ProfiletextCopyright Artifex Software 2011XYZ óQÌXYZ XYZ o¢8õXYZ b™·…ÚXYZ $ „¶Ïcurv #(-27;@EJOTY^chmrw|†‹•šŸ¤©®²·¼ÁÆËÐÕÛàåëðöû %+28>ELRY`gnu|ƒ‹’š¡©±¹ÁÉÑÙáéòú &/8AKT]gqz„Ž˜¢¬¶ÁËÕàëõ !-8COZfr~Š–¢®ºÇÓàìù -;HUcq~Œš¨¶ÄÓáðþ +:IXgw†–¦µÅÕåö'7HYj{Œ¯ÀÑãõ+=Oat†™¬¿Òåø 2FZn‚–ª¾Òçû  % : O d y ¤ º Ï å û  ' = T j ˜ ® Å Ü ó " 9 Q i € ˜ ° È á ù  * C \ u Ž § À Ù ó & @ Z t Ž © Ã Þ ø.Id›¶Òî %A^z–³Ïì &Ca~›¹×õ1OmŒªÉè&Ed„£Ãã#Ccƒ¤Åå'Ij‹­Îð4Vx›½à&Il²ÖúAe‰®Ò÷@eŠ¯Õú Ek‘·Ý*QwžÅì;cŠ²Ú*R{£ÌõGp™Ãì@j”¾é>i”¿ê  A l ˜ Ä ð!!H!u!¡!Î!û"'"U"‚"¯"Ý# #8#f#”#Â#ð$$M$|$«$Ú% %8%h%—%Ç%÷&'&W&‡&·&è''I'z'«'Ü( (?(q(¢(Ô))8)k))Ð**5*h*›*Ï++6+i++Ñ,,9,n,¢,×- -A-v-«-á..L.‚.·.î/$/Z/‘/Ç/þ050l0¤0Û11J1‚1º1ò2*2c2›2Ô3 3F33¸3ñ4+4e4ž4Ø55M5‡5Â5ý676r6®6é7$7`7œ7×88P8Œ8È99B99¼9ù:6:t:²:ï;-;k;ª;è<' >`> >à?!?a?¢?â@#@d@¦@çA)AjA¬AîB0BrBµB÷C:C}CÀDDGDŠDÎEEUEšEÞF"FgF«FðG5G{GÀHHKH‘H×IIcI©IðJ7J}JÄK KSKšKâL*LrLºMMJM“MÜN%NnN·OOIO“OÝP'PqP»QQPQ›QæR1R|RÇSS_SªSöTBTTÛU(UuUÂVV\V©V÷WDW’WàX/X}XËYYiY¸ZZVZ¦Zõ[E[•[å\5\†\Ö]']x]É^^l^½__a_³``W`ª`üaOa¢aõbIbœbðcCc—cëd@d”dée=e’eçf=f’fèg=g“géh?h–hìiCišiñjHjŸj÷kOk§kÿlWl¯mm`m¹nnknÄooxoÑp+p†pàq:q•qðrKr¦ss]s¸ttptÌu(u…uáv>v›vøwVw³xxnxÌy*y‰yçzFz¥{{c{Â|!||á}A}¡~~b~Â#„å€G€¨ kÍ‚0‚’‚ôƒWƒº„„€„ã…G…«††r†×‡;‡ŸˆˆiˆÎ‰3‰™‰þŠdŠÊ‹0‹–‹üŒcŒÊ1˜ÿŽfŽÎ6žnÖ‘?‘¨’’z’ã“M“¶” ”Š”ô•_•É–4–Ÿ— —u—à˜L˜¸™$™™üšhšÕ›B›¯œœ‰œ÷dÒž@ž®ŸŸ‹Ÿú i Ø¡G¡¶¢&¢–££v£æ¤V¤Ç¥8¥©¦¦‹¦ý§n§à¨R¨Ä©7©©ªª««u«é¬\¬Ð­D­¸®-®¡¯¯‹°°u°ê±`±Ö²K²Â³8³®´%´œµµŠ¶¶y¶ð·h·à¸Y¸Ñ¹J¹Âº;ºµ».»§¼!¼›½½¾ ¾„¾ÿ¿z¿õÀpÀìÁgÁãÂ_ÂÛÃXÃÔÄQÄÎÅKÅÈÆFÆÃÇAÇ¿È=ȼÉ:ɹÊ8Ê·Ë6˶Ì5̵Í5͵Î6ζÏ7ϸÐ9кÑ<ѾÒ?ÒÁÓDÓÆÔIÔËÕNÕÑÖUÖØ×\×àØdØèÙlÙñÚvÚûÛ€ÜÜŠÝÝ–ÞÞ¢ß)߯à6à½áDáÌâSâÛãcãëäsäüå„æ æ–çç©è2è¼éFéÐê[êåëpëûì†ííœî(î´ï@ïÌðXðåñrñÿòŒóó§ô4ôÂõPõÞömöû÷Šøø¨ù8ùÇúWúçûwüü˜ý)ýºþKþÜÿmÿÿÿÛC       ÿÛC ÿÀÓëÿÄ ÿÄW !7v´Ò "16UWX„•–¤Ó#A”²ÑÔ28QT³µÕSVatuw$&34BCRqrs‚¶ÃÿÄÿÄ9 !1QR2Aa‘¡ð"3q’±Ñ#br45ÁBáÿÚ ?¨p3¦s¦©‰„ ™N¡3Ô―¼\X1ùñ¾Vœju:à2©” ªDX\nJ*B˜éÂr÷@erj­„×5[ÙåÄ;‚ضaN8Z69Q3†è63ƒ«¢C Ðk¹Ð1Éäz>Mü ùœV²eعfÔLÇ‘U\Ú.Vn›õȨœŒ¦ÛÕ!(—P϶ê|ÙΧ[ÄÏõèGl ¹—:Ì$ßT!\À"s¤AÚP…8™0×l  Ð`ÑÉn®mËç ¾Ñ_m’`ÙÄ#ä\îÒr³R•#ª1•M““¢&*z† bmbO©ÿgÁ»’g;Ÿy×÷ÙùªÍpùç_ßd?æ¨4mÃç}ÿš |Ñ·žuýöCþjóFÜ>y×÷ÙùªÍpùç_ßd?æ¨4mÃç}ÿš |Ñ·žuýöCþjóFÜ>y×÷ÙùªÍpùç_ßd?æ¨4mÃç}ÿš |Ñ·žuýöCþjóFÜ>y×÷Ùùªö"õ-®k®{ÙàߎԷ¡žÊ•¹›¨@XP@êÝt:ìi®ƒ¦´¾[ï‹ÕÞ Û®Þk*~»Ú:’ ˜Ã£µ€56½à »ú˜vŒ> Fæ¢Â¸ˆ©â®I³Ä>*GØ8·pWÉ(7ƒ²qÐ~¡ Ûû«/V'[æ¶1g‘šbÞR‘£ ºÅmÝóX¨ùÉŽáb¬±[®°T‰´²‚%ÐJR‡ÉÎ^ï¹,Gg‹ó§æé`¬IÛ-…M6mf›€€<Gt$ëƒje‡dé”{¢ŽÀBÏË¡-E5ÞK¨ò1IOK\lcžHçbö@\™s$}Öe §®@€Š „Â'÷-«*gËS{”‡T0ôlbL ”¦7czÌŠ q {½±ý›Cß È8À›Œí›/cÀAZiZ×"—–ÑPè·,‘Íþ8qK` %û`q‰lèeÇ–îfV¼åð-^ÜòÌc[C‘9Í ù'NΨ¦¡ ÙGÛ™þš{f6Ʀ àÖ(]XÊ\lÅìCȃ·jxÖˆšD"çw6Ï]O ¶Œ²†l`¦(”>…’¥q yÕŸb cee¹ÔB@¶È)& ÌGH2î]™È™t€ I.Ê ”@Då &øÀ‚^W”ÅÜ[˜ °ÙdŽé°6ôêòº‰÷@ÚÝÁpG¼žÆßÒk°“¿0êðœÄo¬›Ê"ü $ÄÑ”ƒVE%Ó~¼zÂpÝ7†Ž(p‰€AAà P…Heof.Òù9ˆR,fí œ ê$‘<ÃÄÞ¿9Éí¢…:Hª ¨ "Q)»“1w>R^O@ÊÚ±¬-±#h:´E8hI¨º Dž=»œŽˆ†ÑT …WèQ&í N˜„ø‡5‰„¶:VÖ¸/kjö™v³F “W1‡g´\]ƒ“%Ø›˜40í¨#»Å(Npß÷½Þ»féëííðý{Ú1Ü»#·Ø½ÒrÙìY´O»ÿ´v=ØZ´ @ P( A̸“É žd­!2ÍÄ·éœíj ¤êFøC˜žW¡÷ÞPtZ@ P( @ P( @ P( @ €f ˆ\Iä„Ï2Vƒ™fâFÛôÎvµÒu#|!ÌO+Ðûï(:-@ †ã%ü¶aM׈íã "­·âH¨¦U…" ¶À²§A¨™º/ZŠqÕª­öó9ä× ý¬þŸ\®IkÙ빦 =óë¼ßo3žMp¿ÚÉéôä–½ž»Œ{ç×y¾Þg<šáµ’ÓéÉ-{=w,÷Ï®ó}¼Îy5Âÿk$?§Ó’Zözî0YïŸ]æûyœòk…þÖHO§$µìõÜ`³ß>»Íöó9ä× ý¬þŸNIkÙë¸Ág¾}w›íæsÉ®ûY!ý>œ’׳×q‚Ï|úïJðCïl@¸¯ Nüµ áämnÇœ $³ÄW#¢*pî•E#—sïlý}úº&ά5+iDS1Ö·*¬ÊA­XŠY Ä{B:ö‡O ™²•*Š ƒ–²&T…*† „ªè#ÜýUX™mª¦Î™ºoH{7›/Þ°“ìr_žò¿·Úvo6_½a'Øä¾-=ãöûNÍæË÷¬$û—ŧ¼~ßiÙ¼Ù~õ„Ÿc’ø´÷Ûí;7›/Þ°“ìr_žñû}§fóeûÖ}ŽKâÓÞ?oµýZ“M1~ßìJBÉY•Å+"Šðh»MTŽÌí %6ì¡€@Ýwõ½Í/›õ¦i¦iš©^UfE‚˜.!q'’<ÉZBe›‰oÓ9ÚÔIÔð‡1<¯C＠赂¡Íçê¿Š<–ü!¨«cK‰ }w‰()™ "!·1Ôú”ZLοZ‹Û![¤ ÆåûŽ¼^ÿà·?€æº¼§âÊm:÷¶°bP( xÊßv‡ùe¹Â•Zv4µéÊÔ«3VwÝùmÙ8¹hü®¼ã`#^Û“úvFE6¨,¹ElÖ c”¦SO¬ÆÓ¾44þ<_ñòÏY¡xŲòòì¡ òE‚3˜£ p툪ª/´àA3‚…I3Áó¸ñú솊t†(A°@X^£d]5EB\êÆ»hœyÓd¢ uÀ€m*!´–ÈѳYW,Ðp»s7QTÊs¤aÔS0†¢QÚêµw'úÐa—%®¿âÄÔNÖ”ü:»¿ê÷©fP( ‚ây!3Ì• ä&Y¸‘¶ý3­A´HßsÊô>ûÊ‹P(*|سvÿ-˜ÉƒUœ¸^Ù|D‘D‚sœÂè(pˆÿ€TU±¥–ªáRvÁáOŽä½A!ð+´å6[Úhê;`ð§Çr^ øå6[ÍGløîKÔœ¦Ëy£©‰–Í^BJÄBÈÝ/‘y8²ˆ2LÐoÊ*‰‰Í¦¨†ºhÁ¨êbðpêSe½DÄÜû°Æ|‹{%"ÆBE'2îJíꃒ0ª©QI7 #³ôh$]@îuÓQ)±Ž´èê{û`ð§Çr^ øå6[ÍGløîKÔœ¦Ëy£©#Êäì}Չحrƒµ#’$]’ÍC&‹€8)Dt x>ºàÛ×Mv“4ìE¬]M1=­¬˜ ƒOð+,û -ûBꌽËF$².-‘4°Ûºƒ 6†!¸R˜C†©LÝ í,ꪩ˜ûÂyÛ'…ßÙÞÞÀÏ~N­ŠÑUê`í“Âïìïo`g¿'LPhªõ0À_9ÊÀì<·Vº.g7{V(*ŠF:Ö\»rꢅ wk¶!86µj  è¾6uSÏÞõñ×ÞM²¹—az) Á«†mWù pw®tN©@½i²;Fnˆê "Ž¬P^¦Ù<.þÎöö{òtÅŠ¯Slžg{{=ù:bƒEW©†2Ö½áñ'2V<¥©r”-µq¤ùÌ…·#’G]XÑD»nL &ÜUà(ˆ÷#®œß+aš(›û?ëeêÌJ0\BâO$&y’´„Ë76ߦsµ¨6“©áby^‡ßyAÑj@ Pr[ª@û2×vnìé|*Ã;ÅÔ~¸jÚÙvŒRÊ7šM&àÍ»0"ßdÅ&Ö Ðßó¨Ù×]ÖŒ%ØOc;5ÚG¬Ÿ$)9k»$U7%H E µ²bˆjŠ@ P( ƒžWHM]íÖÝ—nd»,ƒ}‰ÛE ¶ÊíŽÁƒPƒh#@ÁŒC–Ål4‡¿§0ö~Æ})׬ós ùžæáDƒu!ŠQ ²¦ P Jr×­Ú@ PT™®âéôz…·@ P( 0\BâO$&y’´„Ë76ߦsµ¨6“©áby^‡ßyAÑj†vj2Ú„¸¦œõ´tSU^»[`ÇÜÑH‚s›d & QGN&"ùºYÅÀEÒ"èM]J&¡@ä9,Yá)Š!¨3᩺wOƒM ~¦×nøÚìö{òtÃVéð45ú˜;p0'Æ×g°“ß“¦·O¡¯Ô¿ÄÌÌá4ý넲±+Ý®Ûw‹™IEÈœ/[µ5¿.Ôªhf€&ÕwHB€w®šˆ0Õº|¢¯ÔÂÀíÀÀŸ]žÂO~N˜jÝ> Ð×ê`íÀÀŸ]žÂO~N˜jÝ>†¿SnøÚìö{òtÃVéð45ú˜J°çpËå$a,‰‰⛢éÛgÐã”"*˜åLàÑOh¢dÔ K¯ F£f©V«:¨‹å>¢…@ ¥RÍ] õG}†ÃÌI—lÑë¦ò>ØYvê*Ýs ®Â€:DÎ]iF«‰¦ŠclÃéÛ= ä‡}‘_ñ¦#GÛ'lô/’YöEƘlx«üzÆï—ØO;iÛ¸9ŠªH>ë]ĪZ‹£°å% ¨ëÁÜÔÄhûcÅ`vÏBù!ÅŸdWüiˆÑöljÛ= ä‡}‘_ñ¦#GÛ'lô/’YöEƘlx½ö¶cm[žò‰±”³oˆ9ÀqÖ&šQš*Š) ªÃßGJœDÙÌE÷­z–e‚˜.!q'’<ÉZBe›‰oÓ9ÚÔIÔð‡1<¯C＠赂Ž\Iâ%¥¹¢µ±{>œ|ÕFxlÿ£²þ+¹££ *éJ=xâ’¶Æ"ÛvjErÅøÓODÂŽ+…:݇wÅw;I†¿ùMþ1UwU«ÑŒ6Ä´¤ŒRóH‡dÀŠ¸b)"ð̘@%>šw€À:€ˆÛ3ÄÍÂ1™k2qÒŽ£Ê ÅFÇI<˜8' ³3SGŽº ¢‰™=ÉøœÆ)‡d¦ ¬ZÄ—¤q’Ûot7³ØÅËÉȹzå™A¢IìhØõ e(‰™Òd0hû@} Q¶8¾áò·ñ‚.në%¼c÷’)ªð\¬Ù•»D|éªfSt8ÛGf¡DS)À ]Gd)ÄÍÂÁ«Œ6~³— à˜JW[•ü^ïÊkøqóü6¸ÌJA¯ylâ¸ü©ºŸ?¨§cK^—‡ÙéÆLZ[ ÂÄDÏ̘â^±…nP3çÜðH—Ö*]†¥›"\^¶ü_ÎÆe7Mä wÇ`b°ëÓ²+ ÷„âÀCê×¹ @ÁW3¤ƒ ¶X¹u+oÉCµ{eYc"öHŒöÈVê©Ý‡Ò&q)ÀÀM¢€5 ¬¦a¬FIÇ KiYÕ%ûXôã’Kþ(ï[.é$ÊuTL€pnÜʉLbŽÉ“ÙÚPz'q¦"Ú]ãwÑrÝ ÄºÁƒHW ¸¢(,(Ö â£šÅ´ÛÜ¢FémœNm‚ ˜xDtøðxqÿƒ_æg¿–ž«;a¥= —ÝY™@ €f ˆ\Iä„Ï2Vƒ™fâFÛôÎvµÒu#|!ÌO+Ðûï(:-@ ‹â”цWu³‘U/ý‹Rà@2Ê·9aà8G€*%j&ê¢e¯VÛ<ÄÁ[±PjeݧŽdƒC([ª8âš`Q ¾ t®m9\DDao8&oÅäÈõÎa¼Ü\ûWÓ«rÈáG¹ÅäuÎa¼Ü\ûWÓ§,ŽÜâòVÁ™+ó®K×¾°<ñïoù€‰Œ"—C!¹(œLMJ@@N%(Äuà§,ŽNÙ+?®s æâçÚ¸Þ9dp§Üâò:ç0Þn.}«éÓ–G îqys˜o7>ÕÆôéË#„÷8¼™ì ´±A<]º1ý°ÖhúÛ‹†h‘å[<:ª éâ§7ИvCG$Ø5Ŷ´Ò׊ëµ+i4áŠi›×õfÄ P("øy»Ã»rùeiJ\êA´3ÓEEŠ}vá2 ›(b”Æ)6³®¦ÙР&b寪7y\²lðW 2Âþîš“˜—‘oÿIŠÓe7rˆ««S•"&UöLsNç^ @*".^º±Ííè 1úÖ]£€tá½›ÿ¢ùÜœ4qy?~Qæ;ÍÞ;Ûfÿ—Îã ^GÊ<Çy»Ç{lßàRùÜa£‹ÈùG˜ï7xïm›ü _;Œ4qy(óæïí³Kçq†Ž/#åc¼Ý㽶oð)|î0ÑÅäñÄ[ø×vã‡u]Ø^ÂÙˆµO&«…Éq$øê †fD…2ˆwB 5̧ݦ™ˆ­…«2( Áq ‰<™æJÐr,ÜHÛ~™ÎÖ ÚN¤o„9‰åz}åE¨ AÌ®¨®Q³˜|}·.h¹ÛbÝ--XŽß. (¹›,õgJ4Ž †èš©k®ÐîIŽÎƒ­Dðäo3XÞøȶN릥›+SÑëàH ¸¦!À$6„?ÀB‚E@ P(¹È[j%ÔõÇ0Ê*1’b«—¯\ wÌu R‡øˆ€PU#Ž— ‰™åúÀqq &)~TM™HÈ”tÔè¨b ï¸5ët…#i ¬Mu ýK/¼–NK07‹¼EX‹ÂPÇG¬mÖÇÇÆ®‚ìî>¡ ç/QÂŒ¶ ÆúÅŠ)åî©7/ä$–L ®æ¢ÆQ6©è&‚``(wÄ6‡QÓ@¹h @ P( Áq ‰<™æJÐr,ÜHÛ~™ÎÖ ÚN¤o„9‰åz}åE¨ AUc—„Eþà!ü²F‚Õ P(;Êø³°ò {žúº# b›‡Ò;rD×ê( „6Œ=à(j"<4®ú˜«‰ (à¦&%tö“»¯VË4n =㶌î¸àÐCuÄ@æø{¢2ëk»•Fèʼn™JŸ@åY®ƒ°b¨wŒÒ<€ ú”Ø2Új¡‡„BØ P( @ P( `¸…ÄžHLó%h9 –n$m¿LçkPm'R7ÂÄò½¾òƒ¢Ô æ$^)aÞ]€»>NÙ…}2v¤PeÊÙª)„dM±¦ºš÷©:–¦1U£c3ARñ­%˜åqC¶z‚n0Þ¬€LC” QÐSÔ8+XÉíf/ˆk6TF¬^OOl~:ù¬ŸÛf_§“Úîó4Tqy±øëæ²m™|:r{]ÞfŠŽ/$BþÅ||¼¤¬×Èe ­q§8¡Oy³6îR´r†æ¹\ëÃú#ûiÉíwy£GO’_ÛŽ¾k'öٗç'µÝæ^Gl~:ù¬ŸÛf_œž×w™¢£‹ÈíÇ_5“ûlËáÓ“Úîó4TqyûÊ‹P(+\Ìþ­ø¯È‰Þ`µDì^˧5u‡æÙÃëlÚé Ìtá %w4ta¥])D°çœßÍ!¥ÏnÇ2‹¸—*QË#:“µ»¦«9ÜÖL… Éb‘é01´ÚèvF¢šñkVöJ0‚âqÖþŒt¬±ˆ ˆSp8”¤9uÕ3å!Oú&9€€"n ˜´¦vI{!=‰vÌ+V+¦ñ7ŠHË'‚)›C^È$Åa Cÿ U{¯ý£¥LÕ1·F8X6“…H+0áâOPb-™Â»YC™G)7§²žŠŠ.˜Si´R€ ÌRš&Ò˜/{äñs¡]ºe1s¢ÉV õß\"ªdl™[™ÉŠ©Ä»)¨ ÈeE#(6Îœ4šéR^ÁÍÅÜ‘Mæá]uË'e"®Á‰¶P @ :jõp÷ûÕh˜˜¾ZœGä}¿ÎWY•|^å«øqó–ËÖ @ P( @ P( ‚ây!3Ì• ä&Y¸‘¶ý3­A´HßsÊô>ûÊ‹P(+\Ìþ­ø¯È‰Þ`µDì^˧5s`”çÃËp‰)¹œÐ¬À§Ó]‘Ü  éõ×sGFUÒ”&Þ³Ä&¸•1? Ù4\¤³„¡`9› _#´±E¢uµ~c‚<&ȺUbÎê±J·= ðG­# |§ÛìU»·ÖZnÝŠz›­½7NçuÜö4áØ×]M¦•8?çð9À™—óL<¾šŒdLó‰Æ R‡¬¼²2J¦²Â¸‚ÚB™ R'²Sê`8‡ hæý¾¯.aÞå‘ë‹©[¹½çœ‚rJÉ4r¬ªäæ4’H›µÅÈÂiu¹!I¸€&=á¨Ñk¾ô\Ê^ù½‹<ÁÍæͬ]ÂáY7MÓ†ÕBÈž(#÷B)»é¸èTS‰ÄÀ!ºìŽ•5Yâëõrn\u¨‹`ëSˆü·ùÃêêò¯‹Üµ>rÙzÁ@ P( @ P( 0\BâO$&y’´„Ë76ߦsµ¨6“©áby^‡ßyAÑjk™ŸÕ¿ù;̨‹Ùtãæ«pþz ;ÛMI¦9b”Å3’€‚$Ô5®âŠ£ kkTN)g¾PÀxò?í$üjØ£z·Iò†Ç‘ÿi'ãLQ¼º_'m¨ÐÈ•Õ͉œ(¢ =L¢¢‚ Bênh:€?²˜£yt¾¿(`ªa„é­7¤¨y_ò dú¡/˜`ÓZo;Pò¿äÉõB_…0Á¦´Þ–X87…8X³Çq‡ÐVÚ²%!ž5™ŠA(d8@ÆÓÿQ¤DFÅj®ªúR™TªP( @ P( A̸“É žd­!2ÍÄ·éœíj ¤êFøC˜žW¡÷ÞPtZ@ P(^`ì«4“-ÂKJ²³ü"/‚@áâe*„)SgiB@ aðP\6ü «„ ± ×hdÁ± –Ñ„ÆÙL€.¦1„t®ƒ!@ P( @ P( @ P@3Ä.$òBg™+AÈL³q#múg;Zƒi:‘¾æ'•è}÷” P( M˜dÄáãÁÚâ ”¯é2%Óÿº¤ÿ–£AlÐ( @ P( @ P( `¸…ÄžHLó%h9 –n$m¿LçkPm'R7ÂÄò½¾òƒ¢Ô mȪ¨[²‹ ¡“Q6Kœ‡ ˆ¦Ä@@C¼4Lmh~X×í…–­Ý7ŽØÆ2ñMݹ¯ÉT9L ]Ó€5ú«ÖdY—%·Éèµ®ûæ"v¾kž=°Î9p¶É¬°á¦©ˆ÷cdJa¼óï.¸Ñíô‡N¹<ßÈû|]o>³¯ðú`Þy÷—\höúC§Noä}¾'>³¯ðúaã“ÀVóI ŒÆ1âóÔÛ9Eâ%^ú~pMtŽIR€Ÿ€å0Š=ð ~‘öø£ŸYÖx>—³yçÞ]q£Ûé9¿‘öø§ŸY×ø}0o<ûË®4{}!Ó§7ò>ߟY×ø}0o<ûË®4{}!Ó§7ò>ߟY×ø}0Ê`;†ÒÍ1lõ1.û¸"ØäŽÒá¸ÝI&W$‘d™T)V8”¦á¨ºÁ¯×Aò+,†Öšl¯ºc®^ãÙ|ñ”眖Ò×)ºújˆ‹¢íW^Ûêê^Œ P( @ P( ‚˜.!q'’<ÉZBe›‰oÓ9ÚÔIÔð‡1<¯C＠赃tø1/þAÇðÍILmiö\8…°Ðÿ +èY³ü;/ë…ûIþß)þõ}Ö=s+rÜÐÖ„Aç'œ,‹B.ݶ¨¶U†UuˆŠD*iÇ1Œ¢„(J<&ý•KKJl©ÅVÏΦ¶åèìöë±¢/stjˆGXã%…&/IöMu£ÐYu‘ì+ÔÔѦEŠP:A´t̪`r‡tA0mxk(ʬª¾ëõvO㫯s“VmÊ(»EÓwþ©ë¾î½“tÝ=}O6þ~f³måÅx©4×Ü–E«…V“zÙ–äTHÇ1…wi“NÔJ (‰‹®Êèª'Tü÷Äl»|­ú^SUg4ÝT]×M5U}ó7l¦gñ:’Ën击b‹3áU[UPY²­ÕMTÎb(C¤©J¢f)Š`˜ <µ¥6”â¥Ä¶°¯'¯¤kùÄí×L_ÜÉÕÙ#Øcúå³ÿld¿š±¯!íÇ£å?wÕ}ÿÛûÇÙµõçžà P( @ P( ‚˜.!q'’<ÉZBe›‰oÓ9ÚÔIÔð‡1<¯C＠赃tø1/þAÇðÍILmiö\8…°Ðÿ +èY³ü;/ë…ûIþß)þõ}Ö=s+pÀ3¹%ùU“M̤ )£W)¸LPäN‘@ß^ÈŽ‚®ˆ´‹§|O„ÞÖÆÖ«¦ªwLxÄÄùJ?¶¥Äš¤w#(™”píÈ‚Àª8zÕáû…1 £4€ r˜¢S Ô0¯$¢½³={ºæ'wc›c-¬gTFÈŽ¾ªj§ªbvU;:îºçë<µ™’8N]SÇ:UáNc¢QQU$>0˜¤H º±H¤€ÇîD¨É(‹µÎ¯ÌNíðŠ³¥­XµF¸»¯ªš©ßº©Û~»»åöýºÊÛEê,U\å~ýÄŠ›©€DXâshÜ€£§Ö5½E÷uÍþ.µµVÓWTDxje*ì‘ì1ýrÙÿ¶2_ÍX×öãÑòŸ»ê¾ÀÿƒmýãìÚúóÏpP( @ P( A̸“É žd­!2ÍÄ·éœíj ¤êFøC˜žW¡÷ÞPtZA¹SQ[rU$ˆcœì—)JPÔL"˜èXÑ1µ ø1ŠŒ,Ü(´íYûÑ‘Š‰nÑÒe³dŽP„0ŠŽƒÃõ…zì‹<ä–5uÕ7ÄDl—Ìsײ9Ó,ÎÙE14ÕTÌ{Ôì™ù¦{üÛ_ÜÌEö&Sà×+õì‹Š|%Ös#<ðSõSù7ù¶¿¹˜‹ìL§Á§ëÙøIÌŒóÁOÕOäßæÚþæb/±2ŸŸ¯d\Sá'23Ï?U?“›kû™ˆ¾ÄÊ|~½‘qO„œÈÏ<ýTþMþm¯îf"û)ðiúöEÅ>s#<ðSõSù7ù¶¿¹˜‹ìL§Á§ëÙøIÌŒóÁOÕOå”À å/lÖç¶.†1lðöA‚®e ]°'\I‘Ê™Lºe”¦ê(þÊóÙã-±ËmiªÆoˆ×u½ß²¹£*Ìù%¥žWUQ1tÄê»±¸uÔ=)@ P( @ P( 0\BâO$&y’´„Ë76ߦsµ¨63©WyZ­É˜4î‹®Î.äE¿|“qPGš‰vÌé¨k§í €o½„ÞT-/]¶éÐ7ÞÂo*—®Ûtèïa7• K×mºt ÷°›Ê…¥ë¶Ý:ûØMåBÒõÛn}ì&ò¡izí·N¾öyP´½vÛ§@ß{ ¼¨Z^»mÓ o½„ÞT-/]¶éÐ7ÞÂo*—®Ûtèïa7• K×mºt ÷°›Ê…¥ë¶Ý:ûØMåBÒõÛn}ì&ò¡izí·N¾öyP´½vÛ§@ß{ ¼¨Z^»mÓ o½„ÞT-/]¶éÐ7ÞÂo*—®Ûtèïa7• K×mºt ÷°›Ê…¥ë¶Ý:ûØMåBÒõÛn}ì&ò¡izí·N¾öyP´½vÛ§@ß{ ¼¨Z^»mÓ o½„ÞT-/]¶éÐ7ÞÂo*—®Ûtèïa7• K×mºt\yÅl.y¸ˆÍž$ZË®½§.šI'0ÜÇPæf¨J}DDD(9[–n$m¿LçkPWƒ…¶#‹öå]X-£©.ðæºX5Xâ?÷è0ÔX ÷¥út ê,{Òý:õˆ=é~z‹Äô¿N½Eâz_§@Þ¢Àñ½/Ó oQ`xƒÞ—éÐ7¨° ] def /f-0-0 currentdict end definefont pop %%EndResource %%EndSetup %%Page: 1 1 %%BeginPageSetup %%PageBoundingBox: 3 4 329 179 %%EndPageSetup q 3 4 326 175 rectclip 1 0 0 -1 0 182 cm q 0.85098 0.819608 0.905882 rg 105.473 125.406 59.742 22.578 re f 0.188235 0.109804 0.109804 rg 1.01661 w 0 J 0 j [] 0.0 d 4 M q 1 0 0 1 0 0 cm 105.473 125.406 59.742 22.578 re S Q 0.85098 0.819608 0.905882 rg 13.855 33.105 59.742 27.723 re f 0.188235 0.109804 0.109804 rg 1.126575 w q 1 0 0 1 0 0 cm 13.855 33.105 59.742 27.723 re S Q 0.501961 0.898039 1 rg 14.441 86.004 59.883 28.668 re f 0.188235 0.109804 0.109804 rg 1.14693 w q 1 0 0 1 0 0 cm 14.441 86.004 59.883 28.668 re S Q 0 g BT 9 0 0 -9 26.756537 103.233377 Tm /f-0-0 1 Tf (Modality)Tj 8.992397 0 0 -9.941295 127.817949 141.027663 Tm (MRI)Tj -11.784918 9.321288 Td (ModBase)Tj 9.999975 0 0 -9.999975 9.253024 15.36996 Tm (Modalities)Tj ET 3.194497 w q 1 0 0 1 0 0 cm 5.348 5.348 321.688 170.645 re S Q 0.75 w q 1 0 0 1 0 0 cm 55.598 60.828 m 110.477 124.926 l S Q 107.789 116.672 m 111.133 125.672 l 102.754 120.984 l 105.176 120.805 107.207 119.055 107.789 116.672 c h 107.789 116.672 m f* 0.39167 w 1 j q -0.856222 -1 1 -0.856222 0 0 cm -120.571 4.554 m -127.416 2.037 l -120.572 -0.482 l -121.664 1.004 -121.658 3.041 -120.571 4.554 c h -120.571 4.554 m S Q 0.75 w 0 j q 1 0 0 1 0 0 cm 44.207 86.004 m 43.898 60.828 l S Q 40.668 68.887 m 43.871 59.836 l 47.297 68.805 l 45.32 67.391 42.645 67.434 40.668 68.887 c h 40.668 68.887 m f* 0.515586 w 1 j q 0.0122919 1 -1 0.0122919 0 0 cm 69.376 -39.815 m 60.366 -43.129 l 69.376 -46.444 l 67.937 -44.485 67.948 -41.809 69.376 -39.815 c h 69.376 -39.815 m S Q 0.85098 0.819608 0.905882 rg 178.199 72.016 69.203 22.543 re f 0.188235 0.109804 0.109804 rg 1.09329 w 0 j q 1 0 0 1 0 0 cm 178.199 72.016 69.203 22.543 re S Q 0 g BT 8.992397 0 0 -9.941295 181.778453 84.628443 Tm /f-0-0 1 Tf [(MammoT)170(omo)]TJ ET 0.75 w q 1 0 0 1 0 0 cm 73.598 53.383 m 178.199 75.852 l S Q 171.062 70.914 m 179.176 76.051 l 169.668 77.398 l 171.488 75.785 172.043 73.168 171.062 70.914 c h 171.062 70.914 m f* 0.504125 w 1 j q -1 -0.214809 0.214809 -1 0 0 cm -178.078 -32.661 m -186.889 -35.905 l -178.077 -39.146 l -179.486 -37.23 -179.478 -34.614 -178.078 -32.661 c h -178.078 -32.661 m S Q 0.937255 g 254.926 144.309 59.742 22.578 re f 0.188235 0.109804 0.109804 rg 1.01661 w 0 j q 1 0 0 1 0 0 cm 254.926 144.309 59.742 22.578 re S Q 0 g BT 8.992397 0 0 -9.941295 266.273171 156.940633 Tm /f-0-0 1 Tf [(\(futur)22(e\))]TJ 20.000025 0 0 -20.000025 222.294012 156.946931 Tm (...)Tj ET 0.75 w [ 6 0.75] 0 d q 1 0 0 1 0 0 cm 73.598 60.426 m 259.746 144.309 l S Q 253.801 137.98 m 260.66 144.707 l 251.078 144.023 l 253.195 142.832 254.289 140.387 253.801 137.98 c h 253.801 137.98 m f* 0.4701 w 1 j [] 0.0 d q -1 -0.450621 0.450621 -1 0 0 cm -262.645 -19.627 m -270.866 -22.649 l -262.646 -25.67 l -263.959 -23.887 -263.952 -21.444 -262.645 -19.627 c h -262.645 -19.627 m S Q Q Q showpage %%Trailer end %%EOF simrisc-14.05.00/documentation/manual/latex/analysis/0000755000175000017500000000000014034554241021466 5ustar frankfranksimrisc-14.05.00/documentation/manual/latex/analysis/data.eps0000644000175000017500000004024414034554241023114 0ustar frankfrank%!PS-Adobe-3.0 EPSF-3.0 %%Creator: cairo 1.16.0 (https://cairographics.org) %%CreationDate: Mon Aug 31 11:20:06 2020 %%Pages: 1 %%DocumentData: Clean7Bit %%LanguageLevel: 2 %%BoundingBox: 3 4 100 146 %%EndComments %%BeginProlog 50 dict begin /q { gsave } bind def /Q { grestore } bind def /cm { 6 array astore concat } bind def /w { setlinewidth } bind def /J { setlinecap } bind def /j { setlinejoin } bind def /M { setmiterlimit } bind def /d { setdash } bind def /m { moveto } bind def /l { lineto } bind def /c { curveto } bind def /h { closepath } bind def /re { exch dup neg 3 1 roll 5 3 roll moveto 0 rlineto 0 exch rlineto 0 rlineto closepath } bind def /S { stroke } bind def /f { fill } bind def /f* { eofill } bind def /n { newpath } bind def /W { clip } bind def /W* { eoclip } bind def /BT { } bind def /ET { } bind def /BDC { mark 3 1 roll /BDC pdfmark } bind def /EMC { mark /EMC pdfmark } bind def /cairo_store_point { /cairo_point_y exch def /cairo_point_x exch def } def /Tj { show currentpoint cairo_store_point } bind def /TJ { { dup type /stringtype eq { show } { -0.001 mul 0 cairo_font_matrix dtransform rmoveto } ifelse } forall currentpoint cairo_store_point } bind def /cairo_selectfont { cairo_font_matrix aload pop pop pop 0 0 6 array astore cairo_font exch selectfont cairo_point_x cairo_point_y moveto } bind def /Tf { pop /cairo_font exch def /cairo_font_matrix where { pop cairo_selectfont } if } bind def /Td { matrix translate cairo_font_matrix matrix concatmatrix dup /cairo_font_matrix exch def dup 4 get exch 5 get cairo_store_point /cairo_font where { pop cairo_selectfont } if } bind def /Tm { 2 copy 8 2 roll 6 array astore /cairo_font_matrix exch def cairo_store_point /cairo_font where { pop cairo_selectfont } if } bind def /g { setgray } bind def /rg { setrgbcolor } bind def /d1 { setcachedevice } bind def /cairo_data_source { CairoDataIndex CairoData length lt { CairoData CairoDataIndex get /CairoDataIndex CairoDataIndex 1 add def } { () } ifelse } def /cairo_flush_ascii85_file { cairo_ascii85_file status { cairo_ascii85_file flushfile } if } def /cairo_image { image cairo_flush_ascii85_file } def /cairo_imagemask { imagemask cairo_flush_ascii85_file } def %%EndProlog %%BeginSetup %%BeginResource: font DejaVuSans 11 dict begin /FontType 42 def /FontName /DejaVuSans def /PaintType 0 def /FontMatrix [ 1 0 0 1 0 0 ] def /FontBBox [ 0 0 0 0 ] def /Encoding 256 array def 0 1 255 { Encoding exch /.notdef put } for Encoding 65 /A put Encoding 67 /C put Encoding 69 /E put Encoding 70 /F put Encoding 79 /O put Encoding 83 /S put Encoding 97 /a put Encoding 99 /c put Encoding 101 /e put Encoding 102 /f put Encoding 105 /i put Encoding 108 /l put Encoding 110 /n put Encoding 111 /o put Encoding 112 /p put Encoding 114 /r put Encoding 115 /s put Encoding 116 /t put Encoding 121 /y put /CharStrings 20 dict dup begin /.notdef 0 def /E 1 def /r 2 def /o 3 def /S 4 def /c 5 def /e 6 def /n 7 def /a 8 def /i 9 def /O 10 def /p 11 def /t 12 def /s 13 def /C 14 def /f 15 def /F 16 def /l 17 def /A 18 def /y 19 def end readonly def /sfnts [ <0001000000090080000300106376742000691d3900000e3c000001fe6670676d7134766a0000 103c000000ab676c796633129ee60000009c00000da0686561641b3ee6ec000010e800000036 686865610d9f07810000112000000024686d747858bf0a0500001144000000506c6f63610000 7fb400001194000000546d61787004810671000011e800000020707265703b07f10000001208 0000056800020066fe96046605a400030007001a400c04fb0006fb0108057f0204002fc4d4ec 310010d4ecd4ec301311211125211121660400fc73031bfce5fe96070ef8f2720629000100c9 0000048b05d5000b002e401506950402950081089504ad0a05010907031c00040c10fcec32d4 c4c431002fececf4ec10ee30b21f0d01015d132115211121152111211521c903b0fd1a02c7fd 3902f8fc3e05d5aafe46aafde3aa0000000100ba0000034a047b001100304014060b0700110b 03870eb809bc070a06080008461210fcc4ec3231002fe4f4ecc4d4cc11123930b450139f1302 015d012e012322061511231133153e0133321617034a1f492c9ca7b9b93aba85132e1c03b412 11cbbefdb20460ae66630505000000020071ffe30475047b000b0017004a401306b91200b90c b8128c1809120f51031215451810fcecf4ec310010e4f4ec10ee3040233f197b007b067f077f 087f097f0a7f0b7b0c7f0d7f0e7f0f7f107f117b12a019f01911015d01220615141633323635 3426273200111000232200111000027394acab9593acac93f00112feeef0f1feef011103dfe7 c9c9e7e8c8c7e99cfec8feecfeedfec70139011301140138000000010087ffe304a205f00027 007e403c0d0c020e0b021e1f1e080902070a021f1f1e420a0b1e1f0415010015a11494189511 049500942591118c281e0a0b1f1b0700221b190e2d071914222810dcc4ecfcece41112393939 39310010e4f4e4ec10eef6ee10c6111739304b535807100eed11173907100eed1117395922b2 0f2901015db61f292f294f29035d01152e012322061514161f011e0115140421222627351e01 3332363534262f012e01353424333216044873cc5fa5b377a67ae2d7feddfee76aef807bec72 adbc879a7be2ca0117f569da05a4c53736807663651f192bd9b6d9e0302fd04546887e6e7c1f 182dc0abc6e4260000010071ffe303e7047b0019003f401b00860188040e860d880ab91104b9 17b8118c1a07120d004814451a10fce432ec310010e4f4ec10fef4ee10f5ee30400b0f1b101b 801b901ba01b05015d01152e0123220615141633323637150e0123220011100021321603e74e 9d50b3c6c6b3509d4e4da55dfdfed6012d010655a20435ac2b2be3cdcde32b2baa2424013e01 0e0112013a23000000020071ffe3047f047b0014001b00704024001501098608880515a90105 b90c01bb18b912b80c8c1c1b1502081508004b02120f451c10fcecf4ecc4111239310010e4f4 ece410ee10ee10f4ee1112393040293f1d701da01dd01df01d053f003f013f023f153f1b052c 072f082f092c0a6f006f016f026f156f1b095d71015d0115211e0133323637150e0123200011 1000333200072e0123220607047ffcb20ccdb76ac76263d06bfef4fec70129fce20107b802a5 889ab90e025e5abec73434ae2a2c0138010a01130143feddc497b4ae9e00000100ba00000464 047b001300364019030900030e0106870e11b80cbc0a010208004e0d09080b461410fcec32f4 ec31002f3ce4f4c4ec1112173930b46015cf1502015d0111231134262322061511231133153e 013332160464b87c7c95acb9b942b375c1c602a4fd5c029e9f9ebea4fd870460ae6564ef0002 007bffe3042d047b000a002500bc4027191f0b17090e00a91706b90e1120861fba1cb923b811 8c170c001703180d09080b1f030814452610fcecccd4ec323211393931002fc4e4f4fcf4ec10 c6ee10ee11391139123930406e301d301e301f3020302130223f27401d401e401f4020402140 22501d501e501f50205021502250277027851d871e871f8720872185229027a027f0271e301e 301f30203021401e401f40204021501e501f50205021601e601f60206021701e701f70207021 801e801f80208021185d015d0122061514163332363d01371123350e01232226353436332135 342623220607353e0133321602bedfac816f99b9b8b83fbc88accbfdfb0102a79760b65465be 5af3f00233667b6273d9b4294cfd81aa6661c1a2bdc0127f8b2e2eaa2727fc00000200c10000 0179061400030007002b400e06be04b100bc020501080400460810fc3cec3231002fe4fcec30 400b1009400950096009700905015d1333112311331523c1b8b8b8b80460fba00614e9000002 0073ffe305d905f0000b00170023401306951200950c91128c1809190f33031915101810fcec fcec310010e4f4ec10ee300122001110003332001110002720001110002120001110000327dc fefd0103dcdc0101feffdc013a0178fe88fec6fec5fe870179054cfeb8fee5fee6feb8014801 1a011b0148a4fe5bfe9efe9ffe5b01a40162016201a50000000200bafe5604a4047b0010001c 003e401b1ab9000e14b90508b80e8c01bd03bc1d11120b471704000802461d10fcec3232f4ec 310010e4e4e4f4c4ec10c4ee304009601e801ea01ee01e04015d2511231133153e0133320011 10022322260134262322061514163332360173b9b93ab17bcc00ffffcc7bb10238a79292a7a7 9292a7a8fdae060aaa6461febcfef8fef8febc6101ebcbe7e7cbcbe7e7000000000100370000 02f2059e0013003840190e05080f03a9001101bc08870a0b08090204000810120e461410fc3c c4fc3cc432393931002fecf43cc4ec3211393930b2af1501015d01112115211114163b011523 22263511233533110177017bfe854b73bdbdd5a28787059efec28ffda0894e9a9fd202608f01 3e0000000001006fffe303c7047b002700e7403c0d0c020e0b531f1e080902070a531f1f1e42 0a0b1e1f041500860189041486158918b91104b925b8118c281e0a0b1f1b0700521b080e0708 1422452810fcc4ecd4ece4111239393939310010e4f4ec10fef5ee10f5ee121739304b535807 100eed111739070eed1117395922b2002701015d406d1c0a1c0b1c0c2e092c0a2c0b2c0c3b09 3b0a3b0b3b0c0b200020012402280a280b2a132f142f152a16281e281f292029212427860a86 0b860c860d12000000010202060a060b030c030d030e030f03100319031a031b031c041d0927 2f293f295f297f2980299029a029f029185d005d7101152e012322061514161f011e01151406 23222627351e013332363534262f012e01353436333216038b4ea85a898962943fc4a5f7d85a c36c66c661828c65ab40ab98e0ce66b4043fae282854544049210e2a99899cb62323be353559 514b50250f2495829eac1e00000000010073ffe3052705f000190036401a0da10eae0a951101 a100ae04951791118c1a07190d003014101a10fcec32ec310010e4f4ecf4ec10eef6ee30b40f 1b1f1b02015d01152e0123200011100021323637150e01232000111000213216052766e782ff 00fef00110010082e7666aed84feadfe7a0186015386ed0562d55f5efec7fed8fed9fec75e5f d34848019f01670168019f4700000001002f000002f8061400130059401c0510010c08a90601 8700970e06bc0a02130700070905080d0f0b4c1410fc4bb00a5458b9000b004038594bb00e54 58b9000bffc038593cc4fc3cc4c412393931002fe432fcec10ee321239393001b640155015a0 15035d01152322061d012115211123112335333534363302f8b0634d012ffed1b9b0b0aebd06 14995068638ffc2f03d18f4ebbab000100c90000042305d50009002940120695040295008104 ad08050107031c00040a10fcec32d4c431002fecf4ec10ee30b20f0b01015d13211521112115 211123c9035afd700250fdb0ca05d5aafe48aafd3700000100c100000179061400030022b700 9702010800460410fcec31002fec30400d10054005500560057005f00506015d13331123c1b8 b80614f9ec00000200100000056805d50002000a00c240410011010004050402110505040111 0a030a0011020003030a0711050406110505040911030a08110a030a42000307950103810905 09080706040302010009050a0b10d4c4173931002f3ce4d4ec1239304b5358071005ed0705ed 071005ed0705ed071008ed071005ed071005ed071008ed5922b2200c01015d40420f010f020f 070f080f005800760070008c000907010802060309041601190256015802500c670168027801 76027c0372047707780887018802800c980299039604175d005d090121013301230321032302 bcfeee0225fe7be50239d288fd5f88d5050efd1903aefa2b017ffe8100000001003dfe56047f 0460000f018b40430708020911000f0a110b0a00000f0e110f000f0d110c0d00000f0d110e0d 0a0b0a0c110b0b0a420d0b0910000b058703bd0e0bbc100e0d0c0a09060300080f040f0b1010 d44bb00a544bb008545b58b9000b004038594bb0145458b9000bffc03859c4c4111739310010 e432f4ec113911391239304b5358071005ed071008ed071008ed071005ed071008ed0705ed17 3259220140f0060005080609030d160a170d100d230d350d490a4f0a4e0d5a095a0a6a0a870d 800d930d120a000a09060b050c0b0e0b0f1701150210041005170a140b140c1a0e1a0f270024 0124022004200529082809250a240b240c270d2a0e2a0f201137003501350230043005380a36 0b360c380d390e390f30114100400140024003400440054006400740084209450a470d490e49 0f40115400510151025503500450055606550756085709570a550b550c590e590f5011660166 02680a690e690f60117b08780e780f89008a09850b850c890d890e890f9909950b950c9a0e9a 0fa40ba40cab0eab0fb011cf11df11ff11655d005d050e012b01353332363f01013309013302 934e947c936c4c543321fe3bc3015e015ec368c87a9a488654044efc94036c000000013500b8 00cb00cb00c100aa009c01a600b800660000007100cb00a002b20085007500b800c301cb0189 022d00cb00a600f000d300aa008700cb03aa0400014a003300cb000000d9050200f4015400b4 009c01390114013907060400044e04b4045204b804e704cd0037047304cd04600473013303a2 055605a60556053903c5021200c9001f00b801df007300ba03e9033303bc0444040e00df03cd 03aa00e503aa0404000000cb008f00a4007b00b80014016f007f027b0252008f00c705cd009a 009a006f00cb00cd019e01d300f000ba018300d5009803040248009e01d500c100cb00f60083 0354027f00000333026600d300c700a400cd008f009a0073040005d5010a00fe022b00a400b4 009c00000062009c0000001d032d05d505d505d505f0007f007b005400a406b80614072301d3 00b800cb00a601c301ec069300a000d3035c037103db0185042304a80448008f013901140139 0360008f05d5019a0614072306660179046004600460047b009c00000277046001aa00e90460 0762007b00c5007f027b000000b4025205cd006600bc00660077061000cd013b01850389008f 007b0000001d00cd074a042f009c009c0000077d006f0000006f0335006a006f007b00ae00b2 002d0396008f027b00f600830354063705f6008f009c04e10266008f018d02f600cd03440029 006604ee00730000140000960000b707060504030201002c2010b002254964b040515820c859 212d2cb002254964b040515820c859212d2c20100720b00050b00d7920b8ffff5058041b0559 b0051cb0032508b0042523e120b00050b00d7920b8ffff5058041b0559b0051cb0032508e12d 2c4b505820b0fd454459212d2cb002254560442d2c4b5358b00225b0022545445921212d2c45 442d2cb00225b0022549b00525b005254960b0206368208a108a233a8a10653a2d0000010000 00025eb83123fac65f0f3cf5001f080000000000daed9e8700000000daed9e87f7d6fc4c0e59 09dc00000008000200010000000000010000076dfe1d00000efef7d6fa510e59000100000000 00000000000000000000001404cd0066050e00c9034a00ba04e50071051400870466007104ec 0071051200ba04e7007b023900c1064c0073051400ba03230037042b006f0596007302d1002f 049a00c9023900c10579001004bc003d0000000000000044000000a400000114000001b80000 02b0000003480000041c00000494000005c0000006100000069c0000073c000007b800000918 000009b000000a4800000a9c00000ad800000bd400000da00001000000140354002b0068000c 000200100099000800000415021600080004b8028040fffbfe03fa1403f92503f83203f79603 f60e03f5fe03f4fe03f32503f20e03f19603f02503ef8a4105effe03ee9603ed9603ecfa03eb fa03eafe03e93a03e84203e7fe03e63203e5e45305e59603e48a4105e45303e3e22f05e3fa03 e22f03e1fe03e0fe03df3203de1403dd9603dcfe03db1203da7d03d9bb03d8fe03d68a4105d6 7d03d5d44705d57d03d44703d3d21b05d3fe03d21b03d1fe03d0fe03cffe03cefe03cd9603cc cb1e05ccfe03cb1e03ca3203c9fe03c6851105c61c03c51603c4fe03c3fe03c2fe03c1fe03c0 fe03bffe03befe03bdfe03bcfe03bbfe03ba1103b9862505b9fe03b8b7bb05b8fe03b7b65d05 b7bb03b78004b6b52505b65d40ff03b64004b52503b4fe03b39603b2fe03b1fe03b0fe03affe 03ae6403ad0e03acab2505ac6403abaa1205ab2503aa1203a98a4105a9fa03a8fe03a7fe03a6 fe03a51203a4fe03a3a20e05a33203a20e03a16403a08a4105a096039ffe039e9d0c059efe03 9d0c039c9b19059c64039b9a10059b19039a1003990a0398fe0397960d0597fe03960d03958a 410595960394930e05942803930e0392fa039190bb0591fe03908f5d0590bb039080048f8e25 058f5d038f40048e25038dfe038c8b2e058cfe038b2e038a8625058a410389880b0589140388 0b03878625058764038685110586250385110384fe038382110583fe0382110381fe0380fe03 7ffe0340ff7e7d7d057efe037d7d037c64037b5415057b25037afe0379fe03780e03770c0376 0a0375fe0374fa0373fa0372fa0371fa0370fe036ffe036efe036c21036bfe036a1142056a53 0369fe03687d036711420566fe0365fe0364fe0363fe0362fe03613a0360fa035e0c035dfe03 5bfe035afe0359580a0559fa03580a035716190557320356fe03555415055542035415035301 1005531803521403514a130551fe03500b034ffe034e4d10054efe034d10034cfe034b4a1305 4bfe034a4910054a1303491d0d05491003480d0347fe0346960345960344fe0343022d0543fa 0342bb03414b0340fe033ffe033e3d12053e14033d3c0f053d12033c3b0d053c40ff0f033b0d 033afe0339fe033837140538fa033736100537140336350b05361003350b03341e03330d0332 310b0532fe03310b03302f0b05300d032f0b032e2d09052e10032d09032c32032b2a25052b64 032a2912052a25032912032827250528410327250326250b05260f03250b0324fe0323fe0322 0f03210110052112032064031ffa031e1d0d051e64031d0d031c1142051cfe031bfa031a4203 1911420519fe031864031716190517fe031601100516190315fe0314fe0313fe031211420512 fe0311022d05114203107d030f64030efe030d0c16050dfe030c0110050c16030bfe030a1003 09fe0308022d0508fe030714030664030401100504fe03401503022d0503fe0302011005022d 0301100300fe0301b80164858d012b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b002b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b1d00> ] def /f-0-0 currentdict end definefont pop %%EndResource %%EndSetup %%Page: 1 1 %%BeginPageSetup %%PageBoundingBox: 3 4 100 146 %%EndPageSetup q 3 4 97 142 rectclip 1 0 0 -1 0 149 cm q 0.85098 0.819608 0.905882 rg 21.973 45.102 59.742 22.578 re f 0.188235 0.109804 0.109804 rg 1.01661 w 0 J 0 j [] 0.0 d 4 M q 1 0 0 1 0 0 cm 21.973 45.102 59.742 22.578 re S Q 0.85098 0.819608 0.905882 rg 22.008 72.969 59.742 27.727 re f 0.188235 0.109804 0.109804 rg 1.126575 w q 1 0 0 1 0 0 cm 22.008 72.969 59.742 27.727 re S Q 0.85098 0.819608 0.905882 rg 21.617 21.723 59.633 18.535 re f 0.188235 0.109804 0.109804 rg 0.920205 w q 1 0 0 -1 0 0 cm 21.617 -21.723 59.633 -18.535 re S Q 0 g BT 8.992397 0 0 -9.941295 39.216781 33.499638 Tm /f-0-0 1 Tf [(Er)18(r)22(or)]TJ ET 0.501961 0.898039 1 rg 21.867 105.797 59.887 28.668 re f 0.188235 0.109804 0.109804 rg 1.14693 w q 1 0 0 1 0 0 cm 21.867 105.797 59.887 28.668 re S Q 0 g BT 9 0 0 -9 33.800539 123.028269 Tm /f-0-0 1 Tf (Scenario)Tj 8.992397 0 0 -9.941295 33.04189 57.733424 Tm (Options)Tj -0.050979 -3.067473 Td [(ConfF)73(ile)]TJ 9.999975 0 0 -9.999975 9.253024 15.369961 Tm (Analysis)Tj ET 1.566465 w q 1 0 0 1 0 0 cm 4.535 4.535 94.586 139.547 re S Q Q Q showpage %%Trailer end %%EOF simrisc-14.05.00/documentation/manual/latex/spread/0000755000175000017500000000000014034554241021121 5ustar frankfranksimrisc-14.05.00/documentation/manual/latex/spread/spread.eps0000644000175000017500000005677314034554241023132 0ustar frankfrank%!PS-Adobe-3.0 EPSF-3.0 %%Creator: cairo 1.16.0 (https://cairographics.org) %%CreationDate: Sun Dec 27 16:55:12 2020 %%Pages: 1 %%DocumentData: Clean7Bit %%LanguageLevel: 2 %%BoundingBox: 3 4 362 219 %%EndComments %%BeginProlog 50 dict begin /q { gsave } bind def /Q { grestore } bind def /cm { 6 array astore concat } bind def /w { setlinewidth } bind def /J { setlinecap } bind def /j { setlinejoin } bind def /M { setmiterlimit } bind def /d { setdash } bind def /m { moveto } bind def /l { lineto } bind def /c { curveto } bind def /h { closepath } bind def /re { exch dup neg 3 1 roll 5 3 roll moveto 0 rlineto 0 exch rlineto 0 rlineto closepath } bind def /S { stroke } bind def /f { fill } bind def /f* { eofill } bind def /n { newpath } bind def /W { clip } bind def /W* { eoclip } bind def /BT { } bind def /ET { } bind def /BDC { mark 3 1 roll /BDC pdfmark } bind def /EMC { mark /EMC pdfmark } bind def /cairo_store_point { /cairo_point_y exch def /cairo_point_x exch def } def /Tj { show currentpoint cairo_store_point } bind def /TJ { { dup type /stringtype eq { show } { -0.001 mul 0 cairo_font_matrix dtransform rmoveto } ifelse } forall currentpoint cairo_store_point } bind def /cairo_selectfont { cairo_font_matrix aload pop pop pop 0 0 6 array astore cairo_font exch selectfont cairo_point_x cairo_point_y moveto } bind def /Tf { pop /cairo_font exch def /cairo_font_matrix where { pop cairo_selectfont } if } bind def /Td { matrix translate cairo_font_matrix matrix concatmatrix dup /cairo_font_matrix exch def dup 4 get exch 5 get cairo_store_point /cairo_font where { pop cairo_selectfont } if } bind def /Tm { 2 copy 8 2 roll 6 array astore /cairo_font_matrix exch def cairo_store_point /cairo_font where { pop cairo_selectfont } if } bind def /g { setgray } bind def /rg { setrgbcolor } bind def /d1 { setcachedevice } bind def /cairo_data_source { CairoDataIndex CairoData length lt { CairoData CairoDataIndex get /CairoDataIndex CairoDataIndex 1 add def } { () } ifelse } def /cairo_flush_ascii85_file { cairo_ascii85_file status { cairo_ascii85_file flushfile } if } def /cairo_image { image cairo_flush_ascii85_file } def /cairo_imagemask { imagemask cairo_flush_ascii85_file } def %%EndProlog %%BeginSetup %%BeginResource: font DejaVuSans 11 dict begin /FontType 42 def /FontName /DejaVuSans def /PaintType 0 def /FontMatrix [ 1 0 0 1 0 0 ] def /FontBBox [ 0 0 0 0 ] def /Encoding 256 array def 0 1 255 { Encoding exch /.notdef put } for Encoding 55 /seven put Encoding 58 /colon put Encoding 66 /B put Encoding 71 /G put Encoding 73 /I put Encoding 76 /L put Encoding 77 /M put Encoding 83 /S put Encoding 84 /T put Encoding 97 /a put Encoding 99 /c put Encoding 100 /d put Encoding 101 /e put Encoding 102 /f put Encoding 103 /g put Encoding 104 /h put Encoding 105 /i put Encoding 108 /l put Encoding 109 /m put Encoding 110 /n put Encoding 111 /o put Encoding 112 /p put Encoding 114 /r put Encoding 115 /s put Encoding 116 /t put Encoding 117 /u put Encoding 118 /v put Encoding 119 /w put /CharStrings 29 dict dup begin /.notdef 0 def /S 1 def /c 2 def /e 3 def /n 4 def /a 5 def /r 6 def /i 7 def /o 8 def /colon 9 def /s 10 def /p 11 def /d 12 def /L 13 def /M 14 def /l 15 def /t 16 def /g 17 def /T 18 def /u 19 def /m 20 def /I 21 def /f 22 def /v 23 def /G 24 def /w 25 def /h 26 def /B 27 def /seven 28 def end readonly def /sfnts [ <0001000000090080000300106376742000691d3900001420000001fe6670676d7134766a0000 1620000000ab676c796657fc6c210000009c00001384686561641b3ee6ec000016cc00000036 686865610d9f078a0000170400000024686d74788673100000001728000000746c6f63610001 16580000179c000000786d617870048a06710000181400000020707265703b07f10000001834 0000056800020066fe96046605a400030007001a400c04fb0006fb0108057f0204002fc4d4ec 310010d4ecd4ec301311211125211121660400fc73031bfce5fe96070ef8f272062900010087 ffe304a205f00027007e403c0d0c020e0b021e1f1e080902070a021f1f1e420a0b1e1f041501 0015a11494189511049500942591118c281e0a0b1f1b0700221b190e2d071914222810dcc4ec fcece4111239393939310010e4f4e4ec10eef6ee10c6111739304b535807100eed1117390710 0eed1117395922b20f2901015db61f292f294f29035d01152e012322061514161f011e011514 0421222627351e013332363534262f012e01353424333216044873cc5fa5b377a67ae2d7fedd fee76aef807bec72adbc879a7be2ca0117f569da05a4c53736807663651f192bd9b6d9e0302f d04546887e6e7c1f182dc0abc6e4260000010071ffe303e7047b0019003f401b00860188040e 860d880ab91104b917b8118c1a07120d004814451a10fce432ec310010e4f4ec10fef4ee10f5 ee30400b0f1b101b801b901ba01b05015d01152e0123220615141633323637150e0123220011 100021321603e74e9d50b3c6c6b3509d4e4da55dfdfed6012d010655a20435ac2b2be3cdcde3 2b2baa2424013e010e0112013a23000000020071ffe3047f047b0014001b0070402400150109 8608880515a90105b90c01bb18b912b80c8c1c1b1502081508004b02120f451c10fcecf4ecc4 111239310010e4f4ece410ee10ee10f4ee1112393040293f1d701da01dd01df01d053f003f01 3f023f153f1b052c072f082f092c0a6f006f016f026f156f1b095d71015d0115211e01333236 37150e01232000111000333200072e0123220607047ffcb20ccdb76ac76263d06bfef4fec701 29fce20107b802a5889ab90e025e5abec73434ae2a2c0138010a01130143feddc497b4ae9e00 000100ba00000464047b001300364019030900030e0106870e11b80cbc0a010208004e0d0908 0b461410fcec32f4ec31002f3ce4f4c4ec1112173930b46015cf1502015d0111231134262322 061511231133153e013332160464b87c7c95acb9b942b375c1c602a4fd5c029e9f9ebea4fd87 0460ae6564ef0002007bffe3042d047b000a002500bc4027191f0b17090e00a91706b90e1120 861fba1cb923b8118c170c001703180d09080b1f030814452610fcecccd4ec32321139393100 2fc4e4f4fcf4ec10c6ee10ee11391139123930406e301d301e301f3020302130223f27401d40 1e401f402040214022501d501e501f50205021502250277027851d871e871f87208721852290 27a027f0271e301e301f30203021401e401f40204021501e501f50205021601e601f60206021 701e701f70207021801e801f80208021185d015d0122061514163332363d01371123350e0123 2226353436332135342623220607353e0133321602bedfac816f99b9b8b83fbc88accbfdfb01 02a79760b65465be5af3f00233667b6273d9b4294cfd81aa6661c1a2bdc0127f8b2e2eaa2727 fc00000100ba0000034a047b001100304014060b0700110b03870eb809bc070a060800084612 10fcc4ec3231002fe4f4ecc4d4cc11123930b450139f1302015d012e01232206151123113315 3e0133321617034a1f492c9ca7b9b93aba85132e1c03b41211cbbefdb20460ae666305050000 000200c100000179061400030007002b400e06be04b100bc020501080400460810fc3cec3231 002fe4fcec30400b1009400950096009700905015d1333112311331523c1b8b8b8b80460fba0 0614e90000020071ffe30475047b000b0017004a401306b91200b90cb8128c1809120f510312 15451810fcecf4ec310010e4f4ec10ee3040233f197b007b067f077f087f097f0a7f0b7b0c7f 0d7f0e7f0f7f107f117b12a019f01911015d0122061514163332363534262732001110002322 00111000027394acab9593acac93f00112feeef0f1feef011103dfe7c9c9e7e8c8c7e99cfec8 feecfeedfec701390113011401380000000200f0000001c3042300030007001c400e068304a6 0083020501030400180810fc3cec3231002fecf4ec303733152311331523f0d3d3d3d3fefe04 23fe00000001006fffe303c7047b002700e7403c0d0c020e0b531f1e080902070a531f1f1e42 0a0b1e1f041500860189041486158918b91104b925b8118c281e0a0b1f1b0700521b080e0708 1422452810fcc4ecd4ece4111239393939310010e4f4ec10fef5ee10f5ee121739304b535807 100eed111739070eed1117395922b2002701015d406d1c0a1c0b1c0c2e092c0a2c0b2c0c3b09 3b0a3b0b3b0c0b200020012402280a280b2a132f142f152a16281e281f292029212427860a86 0b860c860d12000000010202060a060b030c030d030e030f03100319031a031b031c041d0927 2f293f295f297f2980299029a029f029185d005d7101152e012322061514161f011e01151406 23222627351e013332363534262f012e01353436333216038b4ea85a898962943fc4a5f7d85a c36c66c661828c65ab40ab98e0ce66b4043fae282854544049210e2a99899cb62323be353559 514b50250f2495829eac1e000000000200bafe5604a4047b0010001c003e401b1ab9000e14b9 0508b80e8c01bd03bc1d11120b471704000802461d10fcec3232f4ec310010e4e4e4f4c4ec10 c4ee304009601e801ea01ee01e04015d2511231133153e013332001110022322260134262322 061514163332360173b9b93ab17bcc00ffffcc7bb10238a79292a7a79292a7a8fdae060aaa64 61febcfef8fef8febc6101ebcbe7e7cbcbe7e700000000020071ffe3045a06140010001c0038 40191ab9000e14b905088c0eb801970317040008024711120b451d10fcecf4ec323231002fec e4f4c4ec10c4ee30b6601e801ea01e03015d0111331123350e01232202111000333216011416 33323635342623220603a2b8b83ab17ccbff00ffcb7cb1fdc7a79292a8a89292a703b6025ef9 eca86461014401080108014461fe15cbe7e7cbcbe7e7000100c90000046a05d500050025400c 0295008104011c033a00040610fcecec31002fe4ec304009300750078003800404015d133311 211521c9ca02d7fc5f05d5fad5aa000100c90000061f05d5000c00bf40340311070807021101 0208080702110302090a0901110a0a09420a070203080300af080b050908030201050a061c04 3e0a1c00040d10fcecfcec11173931002f3cc4ec32111739304b5358071005ed071008ed0710 08ed071005ed5922b2700e01015d405603070f080f09020a15021407130a260226072007260a 200a3407350a69027c027b07790a80028207820a90021604010b0313011b0323012c03270828 0934013c035608590965086a097608790981018d0395019b03145d005d132109012111231101 23011123c9012d017d017f012dc5fe7fcbfe7fc405d5fc0803f8fa2b051ffc000400fae10000 000100c100000179061400030022b7009702010800460410fcec31002fec30400d1005400550 0560057005f00506015d13331123c1b8b80614f9ec0000010037000002f2059e001300384019 0e05080f03a9001101bc08870a0b08090204000810120e461410fc3cc4fc3cc432393931002f ecf43cc4ec3211393930b2af1501015d01112115211114163b01152322263511233533110177 017bfe854b73bdbdd5a28787059efec28ffda0894e9a9fd202608f013e00000000020071fe56 045a047b000b0028004a4023190c1d0912861316b90f03b92623b827bc09b90fbd1a1d261900 080c4706121220452910fcc4ecf4ec323231002fc4e4ece4f4c4ec10fed5ee1112393930b660 2a802aa02a03015d01342623220615141633323617100221222627351e013332363d010e0123 220211101233321617353303a2a59594a5a59495a5b8fefefa61ac51519e52b5b439b27ccefc fcce7cb239b8023dc8dcdcc8c7dcdcebfee2fee91d1eb32c2abdbf5b6362013a01030104013a 6263aa000001fffa000004e905d50007004a400e0602950081040140031c0040050810d4e4fc e431002ff4ec3230014bb00a5458bd00080040000100080008ffc03811373859401300091f00 100110021f071009400970099f09095d03211521112311210604effdeecbfdee05d5aafad505 2b00000200aeffe30458047b00130014003b401c030900030e0106870e118c0a01bc14b80c0d 0908140b4e020800461510fcecf439ec3231002fe4e432f4c4ec1112173930b46f15c0150201 5d1311331114163332363511331123350e0123222601aeb87c7c95adb8b843b175c1c801cf01 ba02a6fd619f9fbea4027bfba0ac6663f003a800000100ba0000071d047b0022005a40260612 09180f00061d07150c871d2003b81bbc19100700110f0808065011080f501c18081a462310fc ec32fcfcfcec11123931002f3c3ce4f43cc4ec32111217393040133024502470249024a024a0 24bf24df24ff2409015d013e0133321615112311342623220615112311342623220615112311 33153e01333216042945c082afbeb972758fa6b972778da6b9b93fb0797aab03897c76f5e2fd 5c029ea19cbea4fd87029ea29bbfa3fd870460ae67627c000000000100c90000019305d50003 002eb700af02011c00040410fc4bb0105458b9000000403859ec31002fec3001400d30054005 500560058f059f05065d13331123c9caca05d5fa2b000001002f000002f8061400130059401c 0510010c08a906018700970e06bc0a02130700070905080d0f0b4c1410fc4bb00a5458b9000b 004038594bb00e5458b9000bffc038593cc4fc3cc4c412393931002fe432fcec10ee32123939 3001b640155015a015035d01152322061d012115211123112335333534363302f8b0634d012f fed1b9b0b0aebd0614995068638ffc2f03d18f4ebbab0001003d0000047f0460000600fb4027 03110405040211010205050402110302060006011100000642020300bf050605030201050400 0710d44bb00a5458b90000004038594bb014544bb015545b58b90000ffc03859c4173931002f ec3239304b5358071005ed071008ed071008ed071005ed592201408e48026a027b027f028602 80029102a402080600060109030904150015011a031a0426002601290329042008350035013a 033a043008460046014903490446054806400856005601590359045008660066016903690467 0568066008750074017b037b0475057a068500850189038904890586069600960197029a0398 0498059706a805a706b008c008df08ff083e5d005d133309013301233dc3015e015ec3fe5cfa 0460fc5403acfba0000000010073ffe3058b05f0001d0039402000051b0195031b950812a111 ae15950e91088c1e02001c1134043318190b101e10fcecfce4fcc4310010e4f4ecf4ec10fed4 ee11393930251121352111060423200011100021320417152e0123200011100021323604c3fe b6021275fee6a0fea2fe75018b015e9201076f70fc8bfeeefeed011301126ba8d50191a6fd7f 53550199016d016e01994846d75f60fecefed1fed2fece25000000010056000006350460000c 01eb404905550605090a0904550a0903550a0b0a025501020b0b0a0611070807051104050808 07021103020c000c011100000c420a050203060300bf0b080c0b0a09080605040302010b0700 0d10d44bb00a544bb011545b4bb012545b4bb013545b4bb00b545b58b9000000403859014bb0 0c544bb00d545b4bb010545b58b90000ffc03859cc173931002f3cec32321739304b53580710 05ed071008ed071008ed071005ed071008ed071005ed0705ed071008ed59220140ff05021602 1605220a350a49024905460a400a5b025b05550a500a6e026e05660a79027f0279057f058702 99029805940abc02bc05ce02c703cf051d0502090306040b050a080b09040b050c1502190316 041a051b081b09140b150c2500250123022703210425052206220725082709240a210b230c39 0336043608390c300e460248034604400442054006400740084409440a440b400e400e560056 015602500451055206520750085309540a550b6300640165026a0365046a056a066a076e0961 0b670c6f0e7500750179027d0378047d057a067f067a077f07780879097f097b0a760b7d0c87 0288058f0e97009701940293039c049b05980698079908402f960c9f0ea600a601a402a403ab 04ab05a906a907ab08a40caf0eb502b103bd04bb05b809bf0ec402c303cc04ca05795d005d13 331b01331b013301230b012356b8e6e5d9e6e5b8fedbd9f1f2d90460fc96036afc96036afba0 0396fc6a000100ba000004640614001300344019030900030e0106870e11b80c970a01020800 4e0d09080b461410fcec32f4ec31002f3cecf4c4ec1112173930b2601501015d011123113426 2322061511231133113e013332160464b87c7c95acb9b942b375c1c602a4fd5c029e9f9ebea4 fd870614fd9e6564ef00000300c9000004ec05d5000800110020004340231900950a09951281 01950aad1f110b080213191f05000e1c1605191c2e09001c12042110fcec32fcecd4ec111739 393931002fececf4ec10ee3930b20f2201015d01112132363534262301112132363534262325 213216151406071e01151404232101930144a39d9da3febc012b94919194fe0b0204e7fa807c 95a5fef0fbfde802c9fddd878b8c850266fe3e6f727170a6c0b189a21420cb98c8da000100a8 0000046805d5000600634018051102030203110405044205a0008103050301040100060710fc ccc411393931002ff4ec304b5358071005ed071005ed5922014bb0165458bd00070040000100 070007ffc03811373859401258020106031a05390548056703b000b006075d005d1321150123 0121a803c0fde2d301fefd3305d556fa81052b000000013500b800cb00cb00c100aa009c01a6 00b800660000007100cb00a002b20085007500b800c301cb0189022d00cb00a600f000d300aa 008700cb03aa0400014a003300cb000000d9050200f4015400b4009c01390114013907060400 044e04b4045204b804e704cd0037047304cd04600473013303a2055605a60556053903c50212 00c9001f00b801df007300ba03e9033303bc0444040e00df03cd03aa00e503aa0404000000cb 008f00a4007b00b80014016f007f027b0252008f00c705cd009a009a006f00cb00cd019e01d3 00f000ba018300d5009803040248009e01d500c100cb00f600830354027f00000333026600d3 00c700a400cd008f009a0073040005d5010a00fe022b00a400b4009c00000062009c0000001d 032d05d505d505d505f0007f007b005400a406b80614072301d300b800cb00a601c301ec0693 00a000d3035c037103db0185042304a80448008f0139011401390360008f05d5019a06140723 06660179046004600460047b009c00000277046001aa00e904600762007b00c5007f027b0000 00b4025205cd006600bc00660077061000cd013b01850389008f007b0000001d00cd074a042f 009c009c0000077d006f0000006f0335006a006f007b00ae00b2002d0396008f027b00f60083 0354063705f6008f009c04e10266008f018d02f600cd03440029006604ee0073000014000096 0000b707060504030201002c2010b002254964b040515820c859212d2cb002254964b0405158 20c859212d2c20100720b00050b00d7920b8ffff5058041b0559b0051cb0032508b0042523e1 20b00050b00d7920b8ffff5058041b0559b0051cb0032508e12d2c4b505820b0fd454459212d 2cb002254560442d2c4b5358b00225b0022545445921212d2c45442d2cb00225b0022549b005 25b005254960b0206368208a108a233a8a10653a2d000001000000025eb88bd4f1005f0f3cf5 001f080000000000daed9e8700000000daed9e87f7d6fc4c0e5909dc00000008000200010000 000000010000076dfe1d00000efef7d6fa510e5900010000000000000000000000000000001d 04cd0066051400870466007104ec0071051200ba04e7007b034a00ba023900c104e5007102b2 00f0042b006f051400ba05140071047500c906e700c9023900c1032300370514007104e3fffa 051200ae07cb00ba025c00c902d1002f04bc003d06330073068b0056051200ba057d00c90517 00a800000000000000440000013c000001d4000002a8000003200000044c000004bc0000050c 000005b0000005f000000750000007f000000888000008cc000009c800000a0400000a800000 0b4800000bb800000c3c00000d0000000d4800000de000000f0400000fac000011d000001248 000012f80000138400010000001d0354002b0068000c00020010009900080000041502160008 0004b8028040fffbfe03fa1403f92503f83203f79603f60e03f5fe03f4fe03f32503f20e03f1 9603f02503ef8a4105effe03ee9603ed9603ecfa03ebfa03eafe03e93a03e84203e7fe03e632 03e5e45305e59603e48a4105e45303e3e22f05e3fa03e22f03e1fe03e0fe03df3203de1403dd 9603dcfe03db1203da7d03d9bb03d8fe03d68a4105d67d03d5d44705d57d03d44703d3d21b05 d3fe03d21b03d1fe03d0fe03cffe03cefe03cd9603cccb1e05ccfe03cb1e03ca3203c9fe03c6 851105c61c03c51603c4fe03c3fe03c2fe03c1fe03c0fe03bffe03befe03bdfe03bcfe03bbfe 03ba1103b9862505b9fe03b8b7bb05b8fe03b7b65d05b7bb03b78004b6b52505b65d40ff03b6 4004b52503b4fe03b39603b2fe03b1fe03b0fe03affe03ae6403ad0e03acab2505ac6403abaa 1205ab2503aa1203a98a4105a9fa03a8fe03a7fe03a6fe03a51203a4fe03a3a20e05a33203a2 0e03a16403a08a4105a096039ffe039e9d0c059efe039d0c039c9b19059c64039b9a10059b19 039a1003990a0398fe0397960d0597fe03960d03958a410595960394930e05942803930e0392 fa039190bb0591fe03908f5d0590bb039080048f8e25058f5d038f40048e25038dfe038c8b2e 058cfe038b2e038a8625058a410389880b05891403880b038786250587640386851105862503 85110384fe038382110583fe0382110381fe0380fe037ffe0340ff7e7d7d057efe037d7d037c 64037b5415057b25037afe0379fe03780e03770c03760a0375fe0374fa0373fa0372fa0371fa 0370fe036ffe036efe036c21036bfe036a1142056a530369fe03687d036711420566fe0365fe 0364fe0363fe0362fe03613a0360fa035e0c035dfe035bfe035afe0359580a0559fa03580a03 5716190557320356fe035554150555420354150353011005531803521403514a130551fe0350 0b034ffe034e4d10054efe034d10034cfe034b4a13054bfe034a4910054a1303491d0d054910 03480d0347fe0346960345960344fe0343022d0543fa0342bb03414b0340fe033ffe033e3d12 053e14033d3c0f053d12033c3b0d053c40ff0f033b0d033afe0339fe033837140538fa033736 100537140336350b05361003350b03341e03330d0332310b0532fe03310b03302f0b05300d03 2f0b032e2d09052e10032d09032c32032b2a25052b64032a2912052a25032912032827250528 410327250326250b05260f03250b0324fe0323fe03220f03210110052112032064031ffa031e 1d0d051e64031d0d031c1142051cfe031bfa031a42031911420519fe031864031716190517fe 031601100516190315fe0314fe0313fe031211420512fe0311022d05114203107d030f64030e fe030d0c16050dfe030c0110050c16030bfe030a100309fe0308022d0508fe03071403066403 0401100504fe03401503022d0503fe0302011005022d0301100300fe0301b80164858d012b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b002b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b1d00> ] def /f-0-0 currentdict end definefont pop %%EndResource %%EndSetup %%Page: 1 1 %%BeginPageSetup %%PageBoundingBox: 3 4 362 219 %%EndPageSetup q 3 4 359 215 rectclip 1 0 0 -1 0 222 cm q 0.85098 0.819608 0.905882 rg 98.711 4.801 82 27.801 re f 0.188235 0.109804 0.109804 rg 1.32171 w 0 J 0 j [] 0.0 d 4 M q 1 0 0 1 0 0 cm 98.711 4.801 82 27.801 re S Q 0 g BT 8.992397 0 0 -9.941295 102.080918 21.443433 Tm /f-0-0 1 Tf [(Scenario::spr)22(ead)]TJ ET 0.501961 0.898039 1 rg 4.367 4.367 69.254 28.668 re f 0.188235 0.109804 0.109804 rg 1.233398 w q 1 0 0 1 0 0 cm 4.367 4.367 69.254 28.668 re S Q 0 g BT 9 0 0 -9 9.865194 21.183749 Tm /f-0-0 1 Tf [(L)18(oop::spr)22(ead)]TJ ET 0.75 w q 1 0 0 1 0 0 cm 73.621 18.699 m 98.711 18.699 l S Q 81.121 18.699 m 84.121 15.699 l 73.621 18.699 l 84.121 21.699 l h 81.121 18.699 m f* 0.8 w q 1 0 0 1 0 0 cm 81.121 18.699 m 84.121 15.699 l 73.621 18.699 l 84.121 21.699 l h 81.121 18.699 m S Q 0.596078 1 0.501961 rg 37.641 54.012 88.508 28.586 re f 0.188235 0.109804 0.109804 rg 1.39236 w q 1 0 0 1 0 0 cm 37.641 54.012 88.508 28.586 re S Q 0 g BT 9 0 0 -9 40.517817 69.958128 Tm /f-0-0 1 Tf [(Modalities::spr)22(ead)]TJ ET 0.596078 1 0.501961 rg 37.641 91.594 88.59 28.586 re f 0.188235 0.109804 0.109804 rg 1.393043 w q 1 0 0 1 0 0 cm 37.641 91.594 88.59 28.586 re S Q 0 g BT 9 0 0 -9 40.381392 108.412297 Tm /f-0-0 1 Tf [(Scr)22(eening::spr)22(ead)]TJ ET 0.596078 1 0.501961 rg 38.277 134.551 69.254 28.668 re f 0.188235 0.109804 0.109804 rg 1.233398 w q 1 0 0 1 0 0 cm 38.277 134.551 69.254 28.668 re S Q 0 g BT 9 0 0 -9 40.454926 150.617123 Tm /f-0-0 1 Tf [(T)152(umor)17(::spr)22(ead)]TJ ET 0.789097 w q 1 0 0 1 0 0 cm 10.648 33.492 m 10.672 148.148 l S Q 0.75 w q 1 0 0 1 0 0 cm 10.883 147.859 m 37.121 147.613 l S Q 29.621 147.613 m 26.621 150.613 l 37.121 147.613 l 26.621 144.613 l h 29.621 147.613 m f* 0.8 w q -1 0 0 -1 0 0 cm -29.621 -147.613 m -26.621 -150.613 l -37.121 -147.613 l -26.621 -144.613 l h -29.621 -147.613 m S Q 0.75 w q 1 0 0 1 0 0 cm 9.859 106.195 m 36.094 105.949 l S Q 28.594 105.949 m 25.594 108.949 l 36.094 105.949 l 25.594 102.949 l h 28.594 105.949 m f* 0.8 w q -1 0 0 -1 0 0 cm -28.594 -105.949 m -25.594 -108.949 l -36.094 -105.949 l -25.594 -102.949 l h -28.594 -105.949 m S Q 0.75 w q 1 0 0 1 0 0 cm 10.422 67.605 m 36.66 67.359 l S Q 29.16 67.359 m 26.16 70.359 l 36.66 67.359 l 26.16 64.359 l h 29.16 67.359 m f* 0.8 w q -1 0 0 -1 0 0 cm -29.16 -67.359 m -26.16 -70.359 l -36.66 -67.359 l -26.16 -64.359 l h -29.16 -67.359 m S Q 0.8 1 0 rg 220.77 135.773 87.359 28.594 re f 0.160784 0.109804 0.188235 rg 1.383473 w q 1 0 0 1 0 0 cm 220.77 135.773 87.359 28.594 re S Q 0 g BT 9 0 0 -9 222.479162 152.482476 Tm /f-0-0 1 Tf [(T)152(umorInfo::spr)22(ead)]TJ ET 0.8 1 0 rg 220.719 51.82 87.359 28.594 re f 0.160784 0.109804 0.188235 rg q 1 0 0 1 0 0 cm 220.719 51.82 87.359 28.594 re S Q 0 g BT 9 0 0 -9 227.383642 67.851065 Tm /f-0-0 1 Tf [(Survival::spr)22(ead)]TJ ET 0.8 1 0 rg 219.867 93.555 79.707 28.656 re f 0.160784 0.109804 0.188235 rg 1.32291 w q 1 0 0 1 0 0 cm 219.867 93.555 79.707 28.656 re S Q 0 g BT 9 0 0 -9 224.708746 109.856346 Tm /f-0-0 1 Tf [(Gr)22(owth::spr)22(ead)]TJ ET 1 0.901961 0.501961 rg 167.699 188.629 71.961 28.648 re f 0.160784 0.109804 0.188235 rg 1.256842 w q 1 0 0 1 0 0 cm 167.699 188.629 71.961 28.648 re S Q 0 g BT 9 0 0 -9 171.822737 204.687218 Tm /f-0-0 1 Tf [(Beir7::spr)22(ead)]TJ ET 1 0.901961 0.501961 rg 272.746 188.215 87.988 28.59 re f 0.160784 0.109804 0.188235 rg 1.38834 w q 1 0 0 1 0 0 cm 272.746 188.215 87.988 28.59 re S Q 0 g BT 9 0 0 -9 275.925726 204.245201 Tm /f-0-0 1 Tf [(Incidence::spr)22(ead)]TJ ET 0.75 w q 1 0 0 1 0 0 cm 107.438 148.988 m 219.676 148.742 l S Q 212.176 148.742 m 209.176 151.742 l 219.676 148.742 l 209.176 145.742 l h 212.176 148.742 m f* 0.8 w q -1 0 0 -1 0 0 cm -212.176 -148.742 m -209.176 -151.742 l -219.676 -148.742 l -209.176 -145.742 l h -212.176 -148.742 m S Q 0.665554 w q 1 0 0 1 0 0 cm 198.891 65.898 m 219.551 65.652 l S Q 212.895 65.652 m 210.234 68.316 l 219.551 65.652 l 210.234 62.992 l h 212.895 65.652 m f* 0.709925 w q -1 0 0 -1 0 0 cm -212.895 -65.652 m -210.234 -68.316 l -219.551 -65.652 l -210.234 -62.992 l h -212.895 -65.652 m S Q 0.63887 w q 1 0 0 1 0 0 cm 199.957 105.449 m 218.996 105.203 l S Q 212.605 105.203 m 210.051 107.758 l 218.996 105.203 l 210.051 102.648 l h 212.605 105.203 m f* 0.681461 w q -1 0 0 -1 0 0 cm -212.605 -105.203 m -210.051 -107.758 l -218.996 -105.203 l -210.051 -102.648 l h -212.605 -105.203 m S Q 0.75 w q 1 0 0 1 0 0 cm 198.891 65.898 m 199.691 148.371 l S Q 0.642 w q 1 0 0 1 0 0 cm 202.836 187.23 m 203.445 175.043 l 318.445 175.012 l 318.648 187.062 l S Q 203.156 180.816 m 200.723 178.125 l 202.836 187.23 l 205.852 178.383 l h 203.156 180.816 m f* 0.683941 w q 0.0501216 -1 1 0.0501216 0 0 cm -170.206 211.687 m -167.643 209.125 l -176.62 211.688 l -167.644 214.254 l h -170.206 211.687 m S Q 318.539 180.645 m 315.93 178.117 l 318.648 187.062 l 321.062 178.031 l h 318.539 180.645 m f* 0.684703 w q -0.0168174 -1 1 -0.0168174 0 0 cm -185.949 315.412 m -183.378 312.846 l -192.367 315.413 l -183.379 317.979 l h -185.949 315.412 m S Q 0.75 w q 1 0 0 1 0 0 cm 263.367 164.246 m 263.27 174.766 l S Q Q Q showpage %%Trailer end %%EOF simrisc-14.05.00/documentation/manual/latex/outer.eps0000644000175000017500000004604314034554241021521 0ustar frankfrank%!PS-Adobe-3.0 EPSF-3.0 %%Creator: cairo 1.16.0 (https://cairographics.org) %%CreationDate: Thu Sep 3 16:44:10 2020 %%Pages: 1 %%DocumentData: Clean7Bit %%LanguageLevel: 2 %%BoundingBox: 3 4 238 215 %%EndComments %%BeginProlog 50 dict begin /q { gsave } bind def /Q { grestore } bind def /cm { 6 array astore concat } bind def /w { setlinewidth } bind def /J { setlinecap } bind def /j { setlinejoin } bind def /M { setmiterlimit } bind def /d { setdash } bind def /m { moveto } bind def /l { lineto } bind def /c { curveto } bind def /h { closepath } bind def /re { exch dup neg 3 1 roll 5 3 roll moveto 0 rlineto 0 exch rlineto 0 rlineto closepath } bind def /S { stroke } bind def /f { fill } bind def /f* { eofill } bind def /n { newpath } bind def /W { clip } bind def /W* { eoclip } bind def /BT { } bind def /ET { } bind def /BDC { mark 3 1 roll /BDC pdfmark } bind def /EMC { mark /EMC pdfmark } bind def /cairo_store_point { /cairo_point_y exch def /cairo_point_x exch def } def /Tj { show currentpoint cairo_store_point } bind def /TJ { { dup type /stringtype eq { show } { -0.001 mul 0 cairo_font_matrix dtransform rmoveto } ifelse } forall currentpoint cairo_store_point } bind def /cairo_selectfont { cairo_font_matrix aload pop pop pop 0 0 6 array astore cairo_font exch selectfont cairo_point_x cairo_point_y moveto } bind def /Tf { pop /cairo_font exch def /cairo_font_matrix where { pop cairo_selectfont } if } bind def /Td { matrix translate cairo_font_matrix matrix concatmatrix dup /cairo_font_matrix exch def dup 4 get exch 5 get cairo_store_point /cairo_font where { pop cairo_selectfont } if } bind def /Tm { 2 copy 8 2 roll 6 array astore /cairo_font_matrix exch def cairo_store_point /cairo_font where { pop cairo_selectfont } if } bind def /g { setgray } bind def /rg { setrgbcolor } bind def /d1 { setcachedevice } bind def /cairo_data_source { CairoDataIndex CairoData length lt { CairoData CairoDataIndex get /CairoDataIndex CairoDataIndex 1 add def } { () } ifelse } def /cairo_flush_ascii85_file { cairo_ascii85_file status { cairo_ascii85_file flushfile } if } def /cairo_image { image cairo_flush_ascii85_file } def /cairo_imagemask { imagemask cairo_flush_ascii85_file } def %%EndProlog %%BeginSetup %%BeginResource: font DejaVuSans 11 dict begin /FontType 42 def /FontName /DejaVuSans def /PaintType 0 def /FontMatrix [ 1 0 0 1 0 0 ] def /FontBBox [ 0 0 0 0 ] def /Encoding 256 array def 0 1 255 { Encoding exch /.notdef put } for Encoding 32 /space put Encoding 46 /period put Encoding 65 /A put Encoding 68 /D put Encoding 76 /L put Encoding 79 /O put Encoding 80 /P put Encoding 83 /S put Encoding 97 /a put Encoding 101 /e put Encoding 103 /g put Encoding 105 /i put Encoding 108 /l put Encoding 109 /m put Encoding 110 /n put Encoding 111 /o put Encoding 112 /p put Encoding 114 /r put Encoding 115 /s put Encoding 116 /t put Encoding 117 /u put Encoding 121 /y put /CharStrings 23 dict dup begin /.notdef 0 def /L 1 def /o 2 def /p 3 def /m 4 def /a 5 def /i 6 def /n 7 def /A 8 def /l 9 def /y 10 def /s 11 def /S 12 def /u 13 def /t 14 def /r 15 def /O 16 def /e 17 def /space 18 def /P 19 def /g 20 def /D 21 def /period 22 def end readonly def /sfnts [ <0001000000090080000300106376742000691d3900000f3c000001fe6670676d7134766a0000 113c000000ab676c79668f9ee3770000009c00000ea0686561641b3ee6ec000011e800000036 686865610d9f07840000122000000024686d747868c20c6f000012440000005c6c6f63610000 b63c000012a0000000606d617870048406710000130000000020707265703b07f10000001320 0000056800020066fe96046605a400030007001a400c04fb0006fb0108057f0204002fc4d4ec 310010d4ecd4ec301311211125211121660400fc73031bfce5fe96070ef8f2720629000100c9 0000046a05d500050025400c0295008104011c033a00040610fcecec31002fe4ec3040093007 50078003800404015d133311211521c9ca02d7fc5f05d5fad5aa00020071ffe30475047b000b 0017004a401306b91200b90cb8128c1809120f51031215451810fcecf4ec310010e4f4ec10ee 3040233f197b007b067f077f087f097f0a7f0b7b0c7f0d7f0e7f0f7f107f117b12a019f01911 015d012206151416333236353426273200111000232200111000027394acab9593acac93f001 12feeef0f1feef011103dfe7c9c9e7e8c8c7e99cfec8feecfeedfec701390113011401380000 000200bafe5604a4047b0010001c003e401b1ab9000e14b90508b80e8c01bd03bc1d11120b47 1704000802461d10fcec3232f4ec310010e4e4e4f4c4ec10c4ee304009601e801ea01ee01e04 015d2511231133153e013332001110022322260134262322061514163332360173b9b93ab17b cc00ffffcc7bb10238a79292a7a79292a7a8fdae060aaa6461febcfef8fef8febc6101ebcbe7 e7cbcbe7e7000000000100ba0000071d047b0022005a4026061209180f00061d07150c871d20 03b81bbc19100700110f0808065011080f501c18081a462310fcec32fcfcfcec11123931002f 3c3ce4f43cc4ec32111217393040133024502470249024a024a024bf24df24ff2409015d013e 013332161511231134262322061511231134262322061511231133153e01333216042945c082 afbeb972758fa6b972778da6b9b93fb0797aab03897c76f5e2fd5c029ea19cbea4fd87029ea2 9bbfa3fd870460ae67627c0000000002007bffe3042d047b000a002500bc4027191f0b17090e 00a91706b90e1120861fba1cb923b8118c170c001703180d09080b1f030814452610fcecccd4 ec323211393931002fc4e4f4fcf4ec10c6ee10ee11391139123930406e301d301e301f302030 2130223f27401d401e401f402040214022501d501e501f50205021502250277027851d871e87 1f8720872185229027a027f0271e301e301f30203021401e401f40204021501e501f50205021 601e601f60206021701e701f70207021801e801f80208021185d015d0122061514163332363d 01371123350e01232226353436332135342623220607353e0133321602bedfac816f99b9b8b8 3fbc88accbfdfb0102a79760b65465be5af3f00233667b6273d9b4294cfd81aa6661c1a2bdc0 127f8b2e2eaa2727fc00000200c100000179061400030007002b400e06be04b100bc02050108 0400460810fc3cec3231002fe4fcec30400b1009400950096009700905015d13331123113315 23c1b8b8b8b80460fba00614e900000100ba00000464047b001300364019030900030e010687 0e11b80cbc0a010208004e0d09080b461410fcec32f4ec31002f3ce4f4c4ec1112173930b460 15cf1502015d0111231134262322061511231133153e013332160464b87c7c95acb9b942b375 c1c602a4fd5c029e9f9ebea4fd870460ae6564ef000200100000056805d50002000a00c24041 00110100040504021105050401110a030a0011020003030a0711050406110505040911030a08 110a030a4200030795010381090509080706040302010009050a0b10d4c4173931002f3ce4d4 ec1239304b5358071005ed0705ed071005ed0705ed071008ed071005ed071005ed071008ed59 22b2200c01015d40420f010f020f070f080f005800760070008c000907010802060309041601 190256015802500c67016802780176027c0372047707780887018802800c980299039604175d 005d090121013301230321032302bcfeee0225fe7be50239d288fd5f88d5050efd1903aefa2b 017ffe810000000100c100000179061400030022b7009702010800460410fcec31002fec3040 0d10054005500560057005f00506015d13331123c1b8b80614f9ec000001003dfe56047f0460 000f018b40430708020911000f0a110b0a00000f0e110f000f0d110c0d00000f0d110e0d0a0b 0a0c110b0b0a420d0b0910000b058703bd0e0bbc100e0d0c0a09060300080f040f0b1010d44b b00a544bb008545b58b9000b004038594bb0145458b9000bffc03859c4c4111739310010e432 f4ec113911391239304b5358071005ed071008ed071008ed071005ed071008ed0705ed173259 220140f0060005080609030d160a170d100d230d350d490a4f0a4e0d5a095a0a6a0a870d800d 930d120a000a09060b050c0b0e0b0f1701150210041005170a140b140c1a0e1a0f2700240124 022004200529082809250a240b240c270d2a0e2a0f201137003501350230043005380a360b36 0c380d390e390f30114100400140024003400440054006400740084209450a470d490e490f40 115400510151025503500450055606550756085709570a550b550c590e590f50116601660268 0a690e690f60117b08780e780f89008a09850b850c890d890e890f9909950b950c9a0e9a0fa4 0ba40cab0eab0fb011cf11df11ff11655d005d050e012b01353332363f01013309013302934e 947c936c4c543321fe3bc3015e015ec368c87a9a488654044efc94036c0000000001006fffe3 03c7047b002700e7403c0d0c020e0b531f1e080902070a531f1f1e420a0b1e1f041500860189 041486158918b91104b925b8118c281e0a0b1f1b0700521b080e07081422452810fcc4ecd4ec e4111239393939310010e4f4ec10fef5ee10f5ee121739304b535807100eed111739070eed11 17395922b2002701015d406d1c0a1c0b1c0c2e092c0a2c0b2c0c3b093b0a3b0b3b0c0b200020 012402280a280b2a132f142f152a16281e281f292029212427860a860b860c860d1200000001 0202060a060b030c030d030e030f03100319031a031b031c041d09272f293f295f297f298029 9029a029f029185d005d7101152e012322061514161f011e0115140623222627351e01333236 3534262f012e01353436333216038b4ea85a898962943fc4a5f7d85ac36c66c661828c65ab40 ab98e0ce66b4043fae282854544049210e2a99899cb62323be353559514b50250f2495829eac 1e00000000010087ffe304a205f00027007e403c0d0c020e0b021e1f1e080902070a021f1f1e 420a0b1e1f0415010015a11494189511049500942591118c281e0a0b1f1b0700221b190e2d07 1914222810dcc4ecfcece4111239393939310010e4f4e4ec10eef6ee10c6111739304b535807 100eed11173907100eed1117395922b20f2901015db61f292f294f29035d01152e0123220615 14161f011e0115140421222627351e013332363534262f012e01353424333216044873cc5fa5 b377a67ae2d7feddfee76aef807bec72adbc879a7be2ca0117f569da05a4c53736807663651f 192bd9b6d9e0302fd04546887e6e7c1f182dc0abc6e42600000200aeffe30458047b00130014 003b401c030900030e0106870e118c0a01bc14b80c0d0908140b4e020800461510fcecf439ec 3231002fe4e432f4c4ec1112173930b46f15c01502015d131133111416333236351133112335 0e0123222601aeb87c7c95adb8b843b175c1c801cf01ba02a6fd619f9fbea4027bfba0ac6663 f003a80000010037000002f2059e0013003840190e05080f03a9001101bc08870a0b08090204 000810120e461410fc3cc4fc3cc432393931002fecf43cc4ec3211393930b2af1501015d0111 2115211114163b01152322263511233533110177017bfe854b73bdbdd5a28787059efec28ffd a0894e9a9fd202608f013e000000000100ba0000034a047b001100304014060b0700110b0387 0eb809bc070a06080008461210fcc4ec3231002fe4f4ecc4d4cc11123930b450139f1302015d 012e012322061511231133153e0133321617034a1f492c9ca7b9b93aba85132e1c03b41211cb befdb20460ae66630505000000020073ffe305d905f0000b00170023401306951200950c9112 8c1809190f33031915101810fcecfcec310010e4f4ec10ee3001220011100033320011100027 20001110002120001110000327dcfefd0103dcdc0101feffdc013a0178fe88fec6fec5fe8701 79054cfeb8fee5fee6feb80148011a011b0148a4fe5bfe9efe9ffe5b01a40162016201a50000 00020071ffe3047f047b0014001b00704024001501098608880515a90105b90c01bb18b912b8 0c8c1c1b1502081508004b02120f451c10fcecf4ecc4111239310010e4f4ece410ee10ee10f4 ee1112393040293f1d701da01dd01df01d053f003f013f023f153f1b052c072f082f092c0a6f 006f016f026f156f1b095d71015d0115211e0133323637150e01232000111000333200072e01 23220607047ffcb20ccdb76ac76263d06bfef4fec70129fce20107b802a5889ab90e025e5abe c73434ae2a2c0138010a01130143feddc497b4ae9e00000200c90000048d05d500080013003a 40180195100095098112100a0802040005190d3f11001c09041410fcec32fcec11173931002f f4ecd4ec30400b0f151f153f155f15af1505015d011133323635342623252132041514042b01 11230193fe8d9a9a8dfe3801c8fb0101fefffbfeca052ffdcf92878692a6e3dbdde2fda80002 0071fe56045a047b000b0028004a4023190c1d0912861316b90f03b92623b827bc09b90fbd1a 1d261900080c4706121220452910fcc4ecf4ec323231002fc4e4ece4f4c4ec10fed5ee111239 3930b6602a802aa02a03015d01342623220615141633323617100221222627351e013332363d 010e0123220211101233321617353303a2a59594a5a59495a5b8fefefa61ac51519e52b5b439 b27ccefcfcce7cb239b8023dc8dcdcc8c7dcdcebfee2fee91d1eb32c2abdbf5b6362013a0103 0104013a6263aa00000200c9000005b005d500080011002e4015009509810195100802100a00 05190d32001c09041210fcecf4ec113939393931002fecf4ec30b2601301015d011133200011 1000212521200011100029010193f40135011ffee1fecbfe42019f01b20196fe68fe50fe6105 2ffb770118012e012c0117a6fe97fe80fe7efe960000000100db000001ae00fe00030011b700 8302011900180410fcec31002fec3037331523dbd3d3fefe013500b800cb00cb00c100aa009c 01a600b800660000007100cb00a002b20085007500b800c301cb0189022d00cb00a600f000d3 00aa008700cb03aa0400014a003300cb000000d9050200f4015400b4009c0139011401390706 0400044e04b4045204b804e704cd0037047304cd04600473013303a2055605a60556053903c5 021200c9001f00b801df007300ba03e9033303bc0444040e00df03cd03aa00e503aa04040000 00cb008f00a4007b00b80014016f007f027b0252008f00c705cd009a009a006f00cb00cd019e 01d300f000ba018300d5009803040248009e01d500c100cb00f600830354027f000003330266 00d300c700a400cd008f009a0073040005d5010a00fe022b00a400b4009c00000062009c0000 001d032d05d505d505d505f0007f007b005400a406b80614072301d300b800cb00a601c301ec 069300a000d3035c037103db0185042304a80448008f0139011401390360008f05d5019a0614 072306660179046004600460047b009c00000277046001aa00e904600762007b00c5007f027b 000000b4025205cd006600bc00660077061000cd013b01850389008f007b0000001d00cd074a 042f009c009c0000077d006f0000006f0335006a006f007b00ae00b2002d0396008f027b00f6 00830354063705f6008f009c04e10266008f018d02f600cd03440029006604ee007300001400 00960000b707060504030201002c2010b002254964b040515820c859212d2cb002254964b040 515820c859212d2c20100720b00050b00d7920b8ffff5058041b0559b0051cb0032508b00425 23e120b00050b00d7920b8ffff5058041b0559b0051cb0032508e12d2c4b505820b0fd454459 212d2cb002254560442d2c4b5358b00225b0022545445921212d2c45442d2cb00225b0022549 b00525b005254960b0206368208a108a233a8a10653a2d000001000000025eb857fef6665f0f 3cf5001f080000000000daed9e8700000000daed9e87f7d6fc4c0e5909dc0000000800020001 0000000000010000076dfe1d00000efef7d6fa510e5900010000000000000000000000000000 001704cd0066047500c904e50071051400ba07cb00ba04e7007b023900c1051200ba05790010 023900c104bc003d042b006f05140087051200ae03230037034a00ba064c007304ec0071028b 000004d300c905140071062900c9028b00db0000000000000044000000880000012c000001cc 00000290000003bc0000040c0000048400000580000005bc00000788000008e8000009e00000 0a6400000ae000000b5000000bdc00000cb000000cb000000d3000000df800000e7800000ea0 0001000000170354002b0068000c000200100099000800000415021600080004b8028040fffb fe03fa1403f92503f83203f79603f60e03f5fe03f4fe03f32503f20e03f19603f02503ef8a41 05effe03ee9603ed9603ecfa03ebfa03eafe03e93a03e84203e7fe03e63203e5e45305e59603 e48a4105e45303e3e22f05e3fa03e22f03e1fe03e0fe03df3203de1403dd9603dcfe03db1203 da7d03d9bb03d8fe03d68a4105d67d03d5d44705d57d03d44703d3d21b05d3fe03d21b03d1fe 03d0fe03cffe03cefe03cd9603cccb1e05ccfe03cb1e03ca3203c9fe03c6851105c61c03c516 03c4fe03c3fe03c2fe03c1fe03c0fe03bffe03befe03bdfe03bcfe03bbfe03ba1103b9862505 b9fe03b8b7bb05b8fe03b7b65d05b7bb03b78004b6b52505b65d40ff03b64004b52503b4fe03 b39603b2fe03b1fe03b0fe03affe03ae6403ad0e03acab2505ac6403abaa1205ab2503aa1203 a98a4105a9fa03a8fe03a7fe03a6fe03a51203a4fe03a3a20e05a33203a20e03a16403a08a41 05a096039ffe039e9d0c059efe039d0c039c9b19059c64039b9a10059b19039a1003990a0398 fe0397960d0597fe03960d03958a410595960394930e05942803930e0392fa039190bb0591fe 03908f5d0590bb039080048f8e25058f5d038f40048e25038dfe038c8b2e058cfe038b2e038a 8625058a410389880b05891403880b03878625058764038685110586250385110384fe038382 110583fe0382110381fe0380fe037ffe0340ff7e7d7d057efe037d7d037c64037b5415057b25 037afe0379fe03780e03770c03760a0375fe0374fa0373fa0372fa0371fa0370fe036ffe036e fe036c21036bfe036a1142056a530369fe03687d036711420566fe0365fe0364fe0363fe0362 fe03613a0360fa035e0c035dfe035bfe035afe0359580a0559fa03580a035716190557320356 fe035554150555420354150353011005531803521403514a130551fe03500b034ffe034e4d10 054efe034d10034cfe034b4a13054bfe034a4910054a1303491d0d05491003480d0347fe0346 960345960344fe0343022d0543fa0342bb03414b0340fe033ffe033e3d12053e14033d3c0f05 3d12033c3b0d053c40ff0f033b0d033afe0339fe033837140538fa033736100537140336350b 05361003350b03341e03330d0332310b0532fe03310b03302f0b05300d032f0b032e2d09052e 10032d09032c32032b2a25052b64032a2912052a25032912032827250528410327250326250b 05260f03250b0324fe0323fe03220f03210110052112032064031ffa031e1d0d051e64031d0d 031c1142051cfe031bfa031a42031911420519fe031864031716190517fe0316011005161903 15fe0314fe0313fe031211420512fe0311022d05114203107d030f64030efe030d0c16050dfe 030c0110050c16030bfe030a100309fe0308022d0508fe030714030664030401100504fe0340 1503022d0503fe0302011005022d0301100300fe0301b80164858d012b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b002b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b 2b2b2b2b2b2b2b2b2b1d00> ] def /f-0-0 currentdict end definefont pop %%EndResource %%EndSetup %%Page: 1 1 %%BeginPageSetup %%PageBoundingBox: 3 4 238 215 %%EndPageSetup q 3 4 235 211 rectclip 1 0 0 -1 0 218 cm q 0.85098 0.819608 0.905882 rg 34.789 73.637 59.742 22.578 re f 0.188235 0.109804 0.109804 rg 1.01661 w 0 J 0 j [] 0.0 d 4 M q 1 0 0 1 0 0 cm 34.789 73.637 59.742 22.578 re S Q 0.85098 0.819608 0.905882 rg 34.824 119.883 59.742 27.727 re f 0.188235 0.109804 0.109804 rg 1.126575 w q 1 0 0 1 0 0 cm 34.824 119.883 59.742 27.727 re S Q 0.85098 0.819608 0.905882 rg 34.434 31.398 59.633 18.531 re f 0.188235 0.109804 0.109804 rg 0.920205 w q 1 0 0 -1 0 0 cm 34.434 -31.398 59.633 -18.531 re S Q 0 g BT 8.992397 0 0 -9.941295 52.211139 43.172501 Tm /f-0-0 1 Tf [(L)18(oop)]TJ ET 0.501961 0.898039 1 rg 35.41 172.781 59.887 28.668 re f 0.188235 0.109804 0.109804 rg 1.14693 w q 1 0 0 1 0 0 cm 35.41 172.781 59.887 28.668 re S Q 0 g BT 9 0 0 -9 55.66138 190.012871 Tm /f-0-0 1 Tf (main)Tj 8.992397 0 0 -9.941295 44.681685 86.268398 Tm (Analysis)Tj -0.348586 -4.916168 Td (Simulator)Tj 9.999975 0 0 -9.999975 9.253023 15.36996 Tm [(Outer P)18(r)22(ogram Design)]TJ ET 2.978018 w q 1 0 0 1 0 0 cm 5.238 5.238 230.672 206.816 re S Q 0.75 w q 1 0 0 1 0 0 cm 64.555 73.637 m 64.336 49.93 l S Q 61.082 57.977 m 64.312 48.934 l 67.711 57.918 l 65.742 56.496 63.062 56.527 61.082 57.977 c h 61.082 57.977 m f* 0.515603 w 1 j q 0.00927118 1 -1 0.00927118 0 0 cm 58.538 -60.539 m 49.526 -63.853 l 58.541 -67.168 l 57.101 -65.213 57.107 -62.533 58.538 -60.539 c h 58.538 -60.539 m S Q 0.75 w 0 j q 1 0 0 1 0 0 cm 64.688 119.883 m 64.668 96.215 l S Q 61.348 104.234 m 64.656 95.219 l 67.977 104.23 l 66.02 102.793 63.34 102.801 61.348 104.234 c h 61.348 104.234 m f* 0.515625 w 1 j q 0.00074619 1 -1 0.00074619 0 0 cm 104.28 -61.27 m 95.267 -64.585 l 104.281 -67.899 l 102.842 -65.943 102.848 -63.263 104.28 -61.27 c h 104.28 -61.27 m S Q 0.75 w 0 j q 1 0 0 1 0 0 cm 65.176 172.781 m 64.867 147.609 l S Q 61.637 155.668 m 64.844 146.613 l 68.266 155.586 l 66.293 154.172 63.617 154.211 61.637 155.668 c h 61.637 155.668 m f* 0.515586 w 1 j q 0.0122919 1 -1 0.0122919 0 0 cm 156.402 -59.714 m 147.388 -63.032 l 156.401 -66.343 l 154.963 -64.388 154.97 -61.712 156.402 -59.714 c h 156.402 -59.714 m S Q 0.92549 g 140.312 73.219 59.742 22.578 re f 0.188235 0.109804 0.109804 rg 1.01661 w 0 j q 1 0 0 1 0 0 cm 140.312 73.219 59.742 22.578 re S Q 0.92549 g 139.957 30.98 59.633 18.531 re f 0.188235 0.109804 0.109804 rg 0.920205 w q 1 0 0 -1 0 0 cm 139.957 -30.98 59.633 -18.531 re S Q 0 g BT 8.992397 0 0 -9.941295 157.735322 42.754535 Tm /f-0-0 1 Tf [(L)18(oop)]TJ -0.837313 -4.335038 Td (Analysis)Tj ET 0.75 w q 1 0 0 1 0 0 cm 170.082 73.219 m 169.859 49.512 l S Q 166.605 57.559 m 169.84 48.516 l 173.234 57.5 l 171.266 56.078 168.59 56.109 166.605 57.559 c h 166.605 57.559 m f* 0.515603 w 1 j q 0.00927141 1 -1 0.00927141 0 0 cm 59.098 -166.058 m 50.086 -169.375 l 59.101 -172.686 l 57.661 -170.731 57.667 -168.055 59.098 -166.058 c h 59.098 -166.058 m S Q 0.75 w 0 j q 1 0 0 1 0 0 cm 94.398 119.883 m 146 95.797 l S Q 137.328 96.172 m 146.898 95.363 l 140.133 102.18 l 140.609 99.797 139.469 97.375 137.328 96.172 c h 137.328 96.172 m f* 0.467232 w 1 j q -1 0.46677 -0.46677 -1 0 0 cm -75.901 -131.6 m -84.069 -134.604 l -75.901 -137.608 l -77.206 -135.834 -77.198 -133.409 -75.901 -131.6 c h -75.901 -131.6 m S Q BT 20.000025 0 0 -20.000025 108.03122 65.824362 Tm /f-0-0 1 Tf (...)Tj ET Q Q showpage %%Trailer end %%EOF simrisc-14.05.00/documentation/manual/simrisc.css0000644000175000017500000000101114034554241020702 0ustar frankfrank#title, #author, #date, #affiliation { text-align: center; } .lcell { text-align: left; } .rcell { text-align: right; } .vcell { vertical-align: top; } .vlcell { vertical-align: top; text-align: left; } .vrcell { vertical-align: top; text-align: right; } body { max-width: 800px; padding: 0 1em; margin: 0 auto; /* line-height: 1.5; font-size: 120%; */ } pre { background-color: #f3f3f3; padding: 1em 1ex; overflow-x: auto; } code { white-space: nowrap; } simrisc-14.05.00/documentation/manual/densities/0000755000175000017500000000000014034554241020515 5ustar frankfranksimrisc-14.05.00/documentation/manual/densities/densities.yo0000644000175000017500000000426514034554241023064 0ustar frankfrankThe tt(Densities) object provides access to information about the breast densities (cf. url(bi-rads info) (https://radiologyassistant.nl/breast/bi-rads/bi-rads-for-mammography-and-ultrasound-2013)). The American College of Radiology (ACR) distinguishes four breast densitiy categories: itemization( it() a: the breasts are almost entirely fatty it() b: there are scattered areas of fibroglandular density it() c: the breasts are heterogeneously dense, which may obscure small masses it() d: the breasts are extremely dense, which lowers the sensitivity of mammograph ) (see also url(the ACR reference card) (https://www.acr.org/-/media/ACR/Files/RADS/BI-RADS/BIRADS-Reference-Card.pdf)) In the s() configuration file the distributions of probabilities of these four categories by age groups are provided by the tt(breastDensities:) specifications, e.g., verb( bi-rad classification ---------------------------- agegroup a b c d breastDensities: 0 - 40 0.05 0.30 0.48 0.17 ... breastDensities: 70 - * 0.18 0.54 0.26 0.02 ) Age groups consist of an initial age and an upper limit. The upper limit is not considered part of the age range, but becomes the initial age of the next range. The final age range may use age specification tt(*), indicating the maximum possible age of simulated cases. Specifications following a specification using ending age tt(*) are ignored. S() checks whether the bi-rad probabilities per age group add to 1.00, and whether the ending age of an age group is equal to the initial age of the next age group. At the initialization phase of tt(Loop::genCases) (cf. section ref(GENCASES) breast densitiy indices (0..3) corresponding to bi-rad classifications a..d are determined for the simulated case's screening ages. The member tt(Densities::indices) generates a random value from the uniform random distribution and uses that probability to determine the bi-rad classification for the various screening ages, returning a vector containing the bi-rad classifications (0..3) for each screening round. simrisc-14.05.00/documentation/manual/densities/density.yo0000644000175000017500000000042214034554241022543 0ustar frankfrankObjects of the class tt(Density) contain the information about a single density age-group. It contains the density's age-group, bi-rad values and a vector of cumulative bi-rad values allowing fast lookups of a bi-rad category given a (randomly determined) proportion value. simrisc-14.05.00/documentation/manual/densities/src0000777000175000017500000000000014034554241023777 2../../../densitiesustar frankfranksimrisc-14.05.00/documentation/manual/generic/0000755000175000017500000000000014034554241020142 5ustar frankfranksimrisc-14.05.00/documentation/manual/generic/options.yo0000644000175000017500000000236514034554241022214 0ustar frankfrankS(), like many other programs, expects arguments when it is activated. As described in the bf(simrisc)(1) man-page s()'s only argument is tt(analyses), describing the analyses s() performs. Other than that s() expects options. Options come as boolean options (like tt(--help, --one-analysis,) and tt(--verbose) and as options requiring arguments (like tt(--nCases), specifying the number of cases to simulate). The class tt(Options) inspects all options and stores their values. Since tt(Arg), the class receiving the program arguments and options is a singleton it is only natural for tt(Options) to be a singleton class as well, allowing all program components to access the options without having to pass an tt(Options) object as argument. Most members simply return their option values (like tt(string const &base()), returning the base directory where by default the results are written). But some members (like tt(fixedNaturalDeathAge)) (conditionally) assign values to their parameters instead of returning a value. Hier is an overview of tt(Options') public members. All members are tt(const) members except tt(alter), which is used to modify option values as found in the configuration file: verbinsert(-s4 //members ../../../options/options.h) simrisc-14.05.00/documentation/manual/generic/distribution.yo0000644000175000017500000000000514034554241023225 0ustar frankfrankTODO simrisc-14.05.00/documentation/manual/generic/err.yo0000644000175000017500000000264414034554241021311 0ustar frankfrankError messages are handled by the class tt(Err). This class defines the content of various error messages, some of which are plain messages, and some require a onfiguration line information (tt(LineInfo), cf. section ref(TYPEDEFS)). The messages are selected using symbolic names defined in the tt(enum Msg), nested under the class tt(Err). The following symbolic names are defined: verbinsert(//msg ../../../err/err.h) All members of tt(Err) are static. They are: itemization( itt(char const *src(ParamsSrc type))nl() returns the name of the parameter specification source tt(type) (cf. section ref(ENUMS)); itt(std::ostream &msg(Msg err))nl() merely inserts the error message into the error stream, returning a reference to that stream; itt(std::ostream &msg(Msg err, LineInfo const &lineInfo))nl() inserts confguration source, line nr, and the error message into the error stream, ending in `tt(: )'. A reference to the stream is returned; itt(void specification(LineInfo const &line))nl() shorthand for using tt(msg(SPEC_ERROR, line)). itt(void multiplySpecified(LineInfoVect const &lines, std::string const §ionList))nl() shorthand for using tt(MULTIPLY_SPECIFIED) in specification tt(sectionList), listing the info about the multiple specifications provided in tt(lines). ) simrisc-14.05.00/documentation/manual/generic/enums.yo0000644000175000017500000000162014034554241021641 0ustar frankfrankConstants used throughout the program are defined in enumerations in the tt(enums/enums.h) file. These enumerations are: itemization( itt(Constants), defining the number of bi-rad categories (tt(N_BIRADS = 4)) and the ending and maximum ages for simulated cases (tt(END_AGE = 101, MAX_AGE = END_AGE - 1)); itt(DistType), defining the types of the distributions used when generating random values. All classes using distributions (like tt(Distribution) and tt(Random)) use this enumeration when referring to statistical distributions. itt(GeneratorType), defining the diffent ways the random number generators can be initialized (cf. the tt(generator:) parameter in the configuration file); itt(ParamsSrc), specifying whether parameters are defined in a configuration file or in an tt(analysis:) specification section. ) simrisc-14.05.00/documentation/manual/generic/globals.yo0000644000175000017500000000240714034554241022141 0ustar frankfrankThe class tt(Globals) merely provides functions. These functions are all static member functions. They are: itemization( itt(double findAge(DoubleVect const &cumProb, double prob))nl() finds the last series of elements that are smaller than tt(prob) in tt(cumProb), using the index of the first of that series of elements as the begin index, and finds the first element in tt(cumProb) exceeding tt(prob) using that element's index as the end-index. It then interpolates tt(prob) in the half-open range tt([cumProb[begin], cumProb[end]CHAR(41)) C(]) returning the corresponding the (floating point) index; itt(bool isZero(double value))nl() returns true if tt(value's) absolute value is smaller than tt(1e-8); itt(bool isPositiveZero(double value))nl() returns true if tt(value) is not negative and smaller than tt(1e-8); itt(ostream &setPrecision(ostream &out, uint16_t nDigits))nl() sets tt(out's) precision when inserting tt(double) values to tt(nDigits) behind the decimal point; itt(int weakCompare(double lhs, double rhs))nl() using tolerance tt(1e-3) returns -1 if tt(lhs < rhs), 0 if tt(lhs == rhs), and 1 if tt(lhs > rhs). ) simrisc-14.05.00/documentation/manual/generic/agegroup.yo0000644000175000017500000000164514034554241022332 0ustar frankfrankThe class tt(AgeGroup) extracts age group specifications from the configuration file. Age group specifications look like this: verb( 0 - 40 40 - 50 50 - 60 60 - 70 70 - * ) which are half-open age ranges: tt([begin, end+CHAR41). The star specifies the maximum possible age (tt(MAX_AGE) as defined in tt(enums.h)). tt(AgeGroup) objects have two accessors: tt(beginAge), returning the begin age, and tt(endAge) returning the ending age of the half open range. When age groups are read then their ranges must connect. This is checked by the member verb( bool nextRange(std::vector const &vect, LineInfo const &lineInfo) const; ) returning tt(true) if the begin age read from tt(lineInfo) equals the end age in tt(vect.back()). This is used, e.g., when reading the age ranges of the various breast densities (cf. tt(densities/add.cc)). simrisc-14.05.00/documentation/manual/generic/typedefs.yo0000644000175000017500000000113014034554241022331 0ustar frankfrankThe file tt(typedefs/typedefs.h) contains type definitions of container types that are used throughout the program. Because of the types that are defined in tt(typedefs.h) source files may assume that the headers tt(cstdint, vector, string, unordered_set) and tt(enums.h) are also included. When parameter specifications are retrieved these specifications are stored in a dedicated tt(struct LineInfo): verbinsert(-s4 //struct ../../../typedefs/typedefs.h) In addition the following type definitions of various containers are defined: verbinsert(-s4 //types ../../../typedefs/typedefs.h) simrisc-14.05.00/documentation/manual/generic/vsd.yo0000644000175000017500000000215514034554241021312 0ustar frankfrankThe class tt(VSD) (Value, Standard deviation, Distribution) stores the value, standard deviation and distribution type of parameter values. Such parameters are usually specified in the configuration file like this: verb( # value spread distr. parameterName: 72.9 .552 Normal ) The parameter values are retrieved by accessor members. If the tt(Scenario's spread) parameter was configured as tt(true) then the member tt(refresh) applies a random variation to the value parameter, which is then returned by the tt(value) accessor. If tt(D) represents a random value from the used distribution and tt(orgValue) is the value that was originally read from the configuration file then tt(refresh) modifies tt(value) as verb( value = orgValue + spread * D() ) which value is thereupon returned by its tt(value) accessor. Note: if the tt(VSD spread) parameter is not specified then the default value 0 is used. In those cases the tt(VSD value) data member is not modified when tt(Scenario spread) is specified as tt(true). simrisc-14.05.00/documentation/manual/modalities/0000755000175000017500000000000014034554241020660 5ustar frankfranksimrisc-14.05.00/documentation/manual/modalities/modalities.yo0000644000175000017500000000613114034554241023364 0ustar frankfrankScreening modalities are accessed via the tt(Modalities) object. The modalities object provides the interface to modalities that are defined for screening rounds. All modalities that are thus accessible are derived from a base class tt(ModBase). tt(ModBase) defines the interface that must be offered by classes derived from tt(ModBase). This allows reuse of existing components of s() that use modalities, irrespective of what actual modalities are configured for the various screening rounds. The structure of this design is illustrated in Figure ref(MODFIG). figure(modalities/modalities)(The Modalities design)(MODFIG) Figure ref(MODFIG) shows the tt(Modality) object in blue. It communicates with tt(ModBase) objects. tt(ModBase) is a polymorphic base clase completely defining the interface modalities must provide. What modalities there are or will be at some poiny in the future is irrelevant, as long as these future modalities implement the interface required by tt(ModBase). Currently three modalities are available: an MRI modality, a Mammo modality and a Tomo modality. The arrows pointing down from tt(ModBase) suggest time: MammoTomo was originally implemented. At some later point in time MRI was added. At some point in the future another, as yet unknown, modality may be added. At that point only the new modality must be implemented, but the program using the new modality can be reused, not requiring additional modifications. The tt(Modality) constructor receives the tt(modality) parameter specifications from the configuration file. Modality parameters specify the name of the modality; the costs of using the modality; optionally specifications of radiation doses for the treatment of the four bi-rads categories; the modality's sensitivity (optionally differently specified for the four bi-rads categories, and the modality's specificity, optionally using age groups, like the age groups that were used when specifying breast density parameters. E.g., verb( # bi-rads bi-rads (agegroups: values) # modalities id cost dose sensitivity specificity # 1..4 1..4 modality: Mammo 64 3 3 3 3 0.87 0.84 0.73 0.65 0-40: 0.961 40-*: 0.965 modality: MRI 64 0.00 0.00 ) The constructor uses the specification ID to create the matching modality-handling object. Modality handlers are derived from the (polymorphic) modality base class tt(ModBase) (see the next section). When a screening is performed for a specific screening age (cf. section ref(SCREEN)) then all modalities that were specified for that screening age are visited in turn. Screening round specifications define the modalities that are used for those rounds (cf. section ref(SCREENINGCLASS)). The tt(Screening) class provides, per screening round, the names (IDs) of the modalities that are used for those rounds, The member tt(Modality::use) receives these IDs and returns pointers to the modalities that are associated with those IDs. Those modalities are then applied in turn to the current case. simrisc-14.05.00/documentation/manual/modalities/modbase.yo0000644000175000017500000000331214034554241022642 0ustar frankfrankThe class tt(ModBase) defines the interface for modalities that is available to other parts of s(), in particular to members of the class tt(Loop) (cf. section ref(LOOP)). The interface provides the following members: itemization( itt(double sensitivity(size_t idx)): the modality's sensitivity given a bi-rad category tt(idx). For modalities that are independent of bi-rad categories the tt(idx) argument is ignored; itt(double specificity(double age)): the modality's specificity given an age. For modalities that are independent of age the tt(age) argument is ignored; itt(uint16_t cost()): returns the costs associated with using the modality; itt(uint16_t nr() const): returns an identifying order-number of the modality; The order number is used, e.g., when updating the number of false negative decisions during screening loops; itt(void resetCounters(size_t nRounds)): clears the vector counting the number of times modalities are used by the screening rounds and resets the number of encountered false positives to 0; itt(void count(size_t round)): increments the usage count for the specified screening round; itt(void falsePositive()): increments the number of false positive decisions; itt(std::string const &id()): returns the name (e.g., MRI, Mammo) of the modality; itt(double const *dose()): returns the array of radiation doses associated with the modality or 0 if there are no associated radiation doses; itt(double dose(uint16_t idx)): returns the radiation dose of a specified bi-rad category or 0 if there are no associated radiation doses. ) simrisc-14.05.00/documentation/manual/modalities/mammo.yo0000644000175000017500000000164014034554241022340 0ustar frankfrankThe class tt(Mammo) is derived from tt(ModBase). tt(Mammo's) base class extracts the tt(costs) parameter from the configuration file. Its sensitivity is computed by its tt(vSensitivity) member. The sensitivity of the tt(Mammo) modality depends on the tumor's diameter and the configured tt(beta) parameters. As a reference, here is the member implementing tt(Mammo's) sensitivity computation: verbinsert(-s4 //code ../../../mammo/vsensitivity.cc) This function also uses the systematic error which is also configured in the configuration file (tt(Mammo: systematicError:)). The modality's specificity is obtained by finding the case's actual age in the vector tt(d_specVect) (as configured in the configuration file) and returning the associated specificity value. Likewise, the radiation doses are returned by the tt(vDose) members, where the bi-rad category can be used as index (0 for 'a' through 3 for 'd'). simrisc-14.05.00/documentation/manual/modalities/mri.yo0000644000175000017500000000050614034554241022021 0ustar frankfrankThe class tt(MRI) is derived from tt(ModBase). tt(MRI's) base class extracts the tt(costs) parameter from the configuration file. Its sensitivity (tt(vSensitivity)) and specificity tt(vSpecificity)) values are constants, and there are no radiation doses associated with this modality (the tt(vDose) members return zeroes). simrisc-14.05.00/documentation/manual/modalities/tomo.yo0000644000175000017500000000076514034554241022217 0ustar frankfrankThe class tt(Tomo) is derived from tt(ModBase). tt(Tomo's) base class extracts the tt(costs) parameter from the configuration file. The modality's specificity is obtained by finding the case's actual age in the vector tt(d_specVect) (as configured in the configuration file) and returning the associated specificity value. Likewise, the radiation doses and sensitivity values are returned by the tt(vDose) and tt(vSensitivity) members, using bi-rad category as index (0 for 'a' through 3 for 'd'). simrisc-14.05.00/documentation/manual/intro/0000755000175000017500000000000014034554241017661 5ustar frankfranksimrisc-14.05.00/documentation/manual/intro/intro.yo0000644000175000017500000000440714034554241021372 0ustar frankfrankThis manual is primarily a technical manual. Currently the user-information is covered by s()'s man-pages This manual covers the design and organization of s()'s software. Each section (except for section tt(main)) covers a class as encountered when reading the sources starting at the tt(main) function. In total almost 30 classes were defined. Starting from tt(main) only tt(Simulator) is required. At the other side of the spectrum there are several classes or comparable elements which are used by many classes. These elements are defined in separate header files: itemization( itt(enums/enums.h), containing enumeration values for errors and constant values; itt(typedefs/typedefs.h), defining short names for frequently used vectors (like tt(SizeVect) for tt(std::vector)) itt(globals/globals.h), a struct defining several static functions handling frquently encountered small computations (like tt(isZero) to determine whether a tt(double) value has a value that's closer to zero than a (compile time configurable) tolerance). ) These files are not further covered in this manual: they contain definitions and trivial support functions, and the reader should refer for these files themselves for further details. figure(outer) (The Outer Program Design) (OUTER) The outline of the organization of the outer levels of the program is shown in Figure ref(OUTER). tt(main) uses a tt(Simulator), and for each separate analysis the tt(Simulator) creates an tt(Analysis) object, which in turn creates a tt(Loop) object, doing all the hard work (hence the ellipsis in Figure ref(OUTER)). The configuration file defines elements that can be used in the analyses. Such elements are, e.g., tt(Screening), containing screening parameters, tt(Densities), containing parameters of breast densities, and tt(Incidence), containing tumor incidence parameters. Objects of those classes are used by tt(Loop). It is quite possible that future versions of s() also supports different types of simulations. It's likely that tt(Loop) itself then becomes a em(scenario) as defined by Gamma et al. (1995), and that analysis specification files also select the requested scenario(s) by specifying the requested simulation type(s). simrisc-14.05.00/documentation/manual/analysis/0000755000175000017500000000000014034554241020351 5ustar frankfranksimrisc-14.05.00/documentation/manual/analysis/run.yo0000644000175000017500000000112314034554241021523 0ustar frankfrankThe tt(run) member may immediately end if errors were encountered in the specifications of the tt(Scanario) and/or tt(ConfigFile) parameters. One of the options defines the base directory into which the output is written. The member tt(requireBase) checks whether the base directory exists, and if not creates it. If that fails the program ends, showing the message verb( Cannot create base directory ... ) where tt(...) is replaced by the name of the base directory provided by the tt(Options) object. If all's well, the actual simulation is then performed by a tt(Loop) object. simrisc-14.05.00/documentation/manual/analysis/analysis.yo0000644000175000017500000000315514034554241022551 0ustar frankfranktt(Analysis) class objects handle one simulation analysis. Since multiple analyses are performed independently from each other, each tt(Analysis) object initializes its own error count (class tt(Error)) and option handling (class tt(Options)). As options may specify the name of the file containing the analysis-parameters tt(Analysis) objects also define a configuration file object (ConfFile). In s()'s scientific context simulation parameters are also known as `scenarios'. Scenarios contain information like the number of iterations to perform and the number of cases to simulate. The analysis's tt(Scenario) object is initialized by tt(Analysis)'s constructor, and is used by its tt(run) member. Figure ref(ANADATA) provides an overview of tt(Analysis)'s data members. figure(analysis/data) (The Analysis data members) (ANADATA) verbinsert(-s4 //data src/analysis.h) The class tt(Analysis) uses the classes tt(Scenario, Loop, ConfFile, Options) and tt(Error), which are covered in separate sections of this technical manual. When the tt(Analysis) object is constructed it constructs its own tt(Scenario) object. That object receives the modifications that are specific for the current analysis (e.g., that were specified following an tt(analysis:) line in an analysis-specification file). When the tt(Scenario) object (cf. section tt(SCENARIO)) is returning specifications (e.g., using its tt(lines) members, then it returns the modified specifications if available. Modified specification must be complete, as they replace the corresponding specifications in the used (standard) configuration file. simrisc-14.05.00/documentation/manual/analysis/src0000777000175000017500000000000014034554241023467 2../../../analysisustar frankfranksimrisc-14.05.00/documentation/manual/random/0000755000175000017500000000000014034554241020006 5ustar frankfranksimrisc-14.05.00/documentation/manual/random/random.yo0000644000175000017500000000412014034554241021634 0ustar frankfrankObjects of the class tt(Random) generate random numbers. Mercenne twisters (defined in bf(C++)'s STL as the tt(std::mt19937) type) generate random values. Its public members returning random values are: verbinsert(//members src/random.h) Each of these member returns random values drawn from the corresponding statistical distribution. Each distribution uses its own mercenne twister to obtain its next random value. The members tt(uniform, uniformCase) return random values drawn from the uniform random distribution. and tt(logNormal) from the standard log-normal distribution. The other members are only used and are only available when tt(spread: true) is specified. In that case at least tt(N = 2) cases must be simulated as the chi+sups(2) distribution uses tt(N - 1) degrees of freedom. If tt(spread: true) is specified the following members are available and are used for random variations of various configured parameters: itemization( it() the member tt(binomial) draws from the binomial distribution, and its argument specifies the distribution's probability; it() the member tt(chi2) draws from the chi+sups(2) distribution having tt(N - 1) degrees of freedom; it() the member tt(normal) draws from the standard normal distribution, ) COMMENT( and tt(exponential) generate random numbers conforming their distribution type. ) At each new analysis tt(Scenario's seed) value is assigned to the tt(Random) object's tt(seed) value. Then, at each tt(Loop) iteration the tt(Random) object is re-initialized: itemization( it() the tt(Scenario) object is used to set its tt(d_spread) and tt(d_nCases) data members; it() if tt(generator: random) was specified, tt(d_seed) is initialized with a random seed. it() when tt(generator: increasing) was specified tt(d_seed) is incremented. ) Next the generators and distributions are reset by the member tt(reset). The member tt(reset) resets the mercenne twisters by assigning new tt(mt19937) objects, initialized with tt(d_seed). Next the various distributions are reset. simrisc-14.05.00/documentation/manual/random/src0000777000175000017500000000000014034554241022561 2../../../randomustar frankfranksimrisc-14.05.00/documentation/manual/screening/0000755000175000017500000000000014034554241020503 5ustar frankfranksimrisc-14.05.00/documentation/manual/screening/screening.yo0000644000175000017500000000002614034554241023027 0ustar frankfrankincludefile(intro.yo) simrisc-14.05.00/documentation/manual/screening/intro.yo0000644000175000017500000000247614034554241022220 0ustar frankfrankThe class tt(Screening) handles the screening parameters. Screening parameters are obtained from the tt(Scenario) object (cf. section ref(SCENARIO)). At construction time the following parameters are obtained: itemization( it() the probability that a case attends a screening: probability and distribution are specified like this: verb( # value distribution: attendanceRate: 0.8 Normal ) it() the screening rounds specify the screening ages and the modalities that are used for those rounds. Currently the modalities tt(MRI, Mammo) (mammography) and tt(Tomo) (tomosynthesis) are available. Screening rounds use specifications like this: verb( screeningRound: 58 Mammo MRI ) Information about these rounds is stored in its tt(d_roundVect) vector, containing tt(Round) objects. Each tt(Round) object contains the round's age, the indices of the specified modalities and the names (IDs) of the specified modalities. ) Its member tt(radiationRisk) returns a vector of tt(double) values for each (integral) age. It uses the bi-rad indices which are recomputed for each new case (cf. section ref(GENCASES)) and consequently it is called by tt(Loop::genCases) for each similated case. simrisc-14.05.00/documentation/manual/spread/0000755000175000017500000000000014034554241020004 5ustar frankfranksimrisc-14.05.00/documentation/manual/spread/stddevs.yo0000644000175000017500000000401714034554241022033 0ustar frankfrankExpected values and variances of chi+sups(2) distributions are directly related (cf. url(this link) (https://en.wikipedia.org/wiki/Variance#Distribution_of_the_sample_variance)): Their expected values are equal to the population variance (= tt(var)), and their variances are equal to verb( 2 * sqr(var) / (N - 1) ) where tt(N) represents the sample size. In tt(simrisc) the used chi+sups(2) distribution is computed from the population variance as specified in the configuration file (like 21.1 for the tt(Normal) carrier's standard deviation) and the number of simulated cases (like 100,000). In that case the variance of the variances of such samples equals verb( 2 * sqr(21.1) / (100,000 - 1) = 0.0089 ) (and std. dev. 0.0944) Using tt(sd) to represent the standard deviation drawn from a distribution of standard deviations using samples of size tt(N) and population standard deviation tt(sigma), then verb( (N - 1) * sqr(sd) / sqr(sigma) ) follows a chi+sups(2) distribution with tt(N - 1) degrees of freedom. Using tt(chi^2[df]) to represent such a distribution, we get verb( (N - 1) * sqr(sd) / sqr(sigma): distributed as chi^2[N - 1] ) From sigma, N and a random value drawn from tt(chi^2[N - 1]) a corresponding tt(sd) value can now be computed: verb( sd = sqrt( sqr(sigma) * chi^2[N - 1] / (N - 1) ) ) The following table illustrates what these tt(sd) values might look like when computed 10 times: (using N = 100,000) en sigma = 21.2): verb( ---------------------- chi^2 sd ---------------------- 1: 100805.0 -> 21.285 1: 99499.8 -> 21.147 2: 99867.1 -> 21.186 3: 99873.8 -> 21.187 4: 100076.0 -> 21.208 5: 99895.8 -> 21.189 6: 99952.9 -> 21.195 7: 100558.0 -> 21.259 8: 100126.0 -> 21.213 10: 99289.8 -> 21.125 ---------------------- ) The procedure described here is used to compute spread variations for standard deviations. simrisc-14.05.00/documentation/manual/spread/spread.yo0000644000175000017500000000547514034554241021646 0ustar frankfrankAs described in section ref(SCENARIO) the Scenario parameter tt(spread) may be set to tt(true) resulting in random variations of several parameters. Handling spreading is illlustrated in figure ref(SPREADFIG). figure(spread/spread) (Spread used by Simrisc components) (SPREADFIG) When an analysis starts tt(Loop::initialize) passes tt(Scenario::spread) on to the member tt(Loop::spread). Various components support random fluctuations of their parameters, and if tt(Scenario::spread) is true these random fluctiations are applied to these components. Figure ref(SPREADFIG) illustrates where random fluctuations may be applied: itemization( it() the tt(Mammo) modality's tt(systematicError); it() the tt(Screening's attendanceRate); it() various tt(Tumor) components: itemization( it() tt(Survival); it() tt(Growth); it() tt(TumorInfo): itemization( it() tt(Beir7); it() tt(Incidence's) carrier specifications. ) ) ) Random fluctuations can be applied to means, standard deviations and proportions. For means the normal distribution is used by default. For example, the specification of the tt(meanAge) distribution, specifified for carrier tt(Normal) in the tt(Incidence) component of the tt(Tumor) specification may look like this: verb( # value spread distr. meanAge: 72.9 .552 Normal ) 95% of the mean-values which are randomly drawn from this distribution are located in the interval 71.8 to 74.0. When spreading is used, thus computed mean values are used as mean values of the tt(Normal) carrier during the actual simulations. For standard deviations the chi+sups(2) distribution is used, ensuring that the standard deviation that is used for the simulations exceeds 0 (see the next section for a description of the theory and implementation in tt(simrisc)). For example, the standard deviations of the tt(Normal) carrier distribution may look like this: verb( # value spread distr. stdDev: 21.1 .048 Normal ) The number of degrees of freedom of the chi+sups(2) distribution to use tt(N - 1), where tt(N) is the number of cases that are used in a simulation. COMMENT( For proportions the binomial distrubution is used, ensuring that randomly selected proportions lie within the interval 0..1 (see section ref(BINOMIAL) for a description of the theory and implementation in tt(simrisc)). For example, the tt(Screening attendanceRate) specification may be specified as: verb( attendanceRate: .8 ) Likewise, the tt(systematicError) (Modality, Mammo) and risks (e.g., tt(Normal Incidence Tomor) carrier are proportions). ) simrisc-14.05.00/documentation/manual/loop/0000755000175000017500000000000014034554241017477 5ustar frankfranksimrisc-14.05.00/documentation/manual/loop/gencases.yo0000644000175000017500000000640214034554241021642 0ustar frankfrankThe member tt(genCases) performs one complete iteration over all screening rounds for all simulated cases. The option tt(nCases) may be used to simulate a specific number of cases. When tt(nCases) is specified only the data of the final case are written to file. By default as many cases as specified at the `nWomen' parameter (stored in the tt(Scenario) object) are simulated, and the data of all those simulated cases are written to file. Analyses up to a specific number of cases, or a single simulation using a preset death-age (see option tt(--death-age) in the bf(simrisc)(1) man-page) can also be performed. The number of cases to simulate is determined in the tt(nCases) member. For each simulated case: itemization( it() the simulation data are initialized: itemization( it() the costs of the case (tt((d)_caseCost)), the tumor-caused death age (tt(d_deathAge)), the screening round in which a tumor is detected (d_roundDetected), and the indicator indicating whether the tumor has been self-detected (d_selfDetected); it() breast density indices are determined (uses random numbers, and thus they are recomputed at each new simulated case) (cf. section ref(DENSITIES)). These indices are stored in tt(d_indices) for the different screening ages (the index computed for the first screening age is stored at the first element). For each age a randomly determined proportion is located in the cumulative proportions of the bi-rads categories of its age group. The thus determined bi-rad category is stored in tt(d_indices). E.g., for age 54 these bi-rads proportions could be used: verb( agegroup bi-rads1 bi-rads2 bi-rads3 bi-rads4 breastDensities: 50 - 60 0.08 0.50 0.37 0.05 ) resulting in category 3 if the randomly selected proportion is 70; it() cumulative total tumor risks are determined (uses breast density indices, and must therefore be recomputed at each simulated case) (cf. section ref(TUMORINFO)); it() the case's natural death age is determined as a random age <= MAX_AGE, which is a compiled constant (100). it() the status of the simulated case is intialized to tt(PRESENT). The case's state changes during the simulation and the case's simulation may end during the pre-screening phase, the screening phase, or the post-screening phase, because of the case's natural death, because of self-detection of a tumor or because of a tumor that's detected during a screening cycle; it() the parameters of the tumor-simulating object are reset (cf. section ref(TUMORRESET)). ) it() following the initialization three simulation phases are simulated: itemization( it() pre-screening (cf. section ref(PRESCREEN)) it() screening (cf. section ref(SCREENING)) it() postscreening (cf. section ref(POSTSCREEN)) ) it() Once a case's simulation ends the case's death age and computed costs are accumulated and the simulated data are written to the data file containing all case-specific values (or, when the option tt(--nCases) or tt(--death-age) was specified: only the data of the requested single simulated case). ) simrisc-14.05.00/documentation/manual/loop/iterate.yo0000644000175000017500000000304414034554241021506 0ustar frankfrankThe tt(iterate) member performs the number of iterations (scenario: iterations). At each iteration itemization( it() the random number generator is reset; it() the tt(TumorInfo) (cf. section ref(TUMORINFO)) parameters may be refreshed; it() The following tt(Loop)'s counters are reset: itemization( itt(d_totalCost), the sum of all simulated costs over all screening rounds; itt(d_sumDeathAge), the sum of all simulated dying ages over all screening rounds; itt(d_nIntervals), the vector storing the number of simulated interval cancers per screening round; itt(d_nRoundFP), the vector storing the number of false positive diagnoses per screening round; itt(d_nRoundFN), the vector storing the number of false negative diagnoses per screening round; itt(d_nDetections), the vector storing the number of self-detected cancers per screening round; itt(d_roundCost), the vector storing the total costs per screening round; itt(d_modalities), the counters maintained by the used tt(Modalities) are reset. ) it() The actual simulation is performed over `scenario nWomen' cases by tt(genCases); it() At each iteration summarizing and actual simulation data are (optionally) written to files (sensitivity, parameters, and rounds info, while actually produced simulation data are written to file by the tt(genCases) member itself). ) simrisc-14.05.00/documentation/manual/loop/loop.yo0000644000175000017500000000143214034554241021021 0ustar frankfrankincludefile(intro.yo) subsect(iterations) includefile(iterate.yo) lsubsect(GENCASES)(Simulate Cases) includefile(gencases.yo) lsubsect(PRESCREEN)(Pre-screening) includefile(prescreen.yo) subsubsect(Performing a pre-screening) includefile(prescreening.yo) lsubsect(CHARACTERISTICS) (Self-detected tumors during the pre- and post-screen phases) includefile(characteristics) lsubsect(SCREENING)(Screening) includefile(screening.yo) subsubsect(Leaving screening rounds) includefile(leaving.yo) lsubsubsect(SCREEN)(Performing a screening) includefile(screen.yo) lsubsect(POSTSCREEN)(Post-screening) C(<<<<<<<<<<<<<) includefile(postscreen.yo) simrisc-14.05.00/documentation/manual/loop/prescreening.yo0000644000175000017500000000142314034554241022534 0ustar frankfrankIf a pre-screening phase is used then the following happens: itemization( it() If there's no tumor but the case's natural death occurs before the tumor-induced death, then (tt(loop/pretumordeath.cc)) the case's simulation ends, setting its status to tt(LEFT_PRE). If at this point there also happens to be an existing tumor then the tumor's characteristics are determined as well (by tt(Tumor::characteristics), cf. section ref(TUMOR)). it() On the other hand, if the complement of the above condition holds true (i.e., there is a tumor and the tumor's self-dectected age is before the case's natural death) the characteristics of the tumor are determined (see the next section) resulting in the case leaving the simulation because the tumor was self detected. ) simrisc-14.05.00/documentation/manual/loop/characteristics.yo0000644000175000017500000000151614034554241023226 0ustar frankfrankThe function tt(Loop:characteristics) may be called during the pre-screening phase and during the post-screening phase. In both phases the tumor is self-detected, the tumor characteristics are determined (tt(Tumor::characteristics, Tumor::setDeathAge), cf. sections ref(TUMORCHARACT) and ref(TUMORDEATHAGE)), and the treatment costs are determined using the tumor's induced death age and the tumor's diameter (tt(Costs::treatment), cf. section ref(COSTS)). If the case's natural death occurs before the tumor would have caused the case's death then the case leaves the pre-screening or post-screening simulation with status (respectively) tt(LEFT_PRE) and tt(LEFT_POST). Otherwise death was caused by the tumor and the the case leaves the pre-screening or post-screening simulation with status (respectively) tt(TUMOR_PRE) and tt(TUMOR_POST). simrisc-14.05.00/documentation/manual/loop/postscreen.yo0000644000175000017500000000122314034554241022233 0ustar frankfrankPost screening is skipped if the case has left the simulation process during the pre-screening or screening phases. If there is a tumor and the tumor's self-detection age is before the case's natural death then the tumor characteristics and treatment costs are determined (cf. section ref(CHARACTERISTICS)). On the other hand, if there is no tumor or if the tumor's self-detection age would have been after the case's natural death then the case leaves the simulation at the case's natural death age. In this latter case (athough there is a tumor, it hasn't caused death) the tumor's characteristics are determined as well (cf. section ref(TUMORCHARACT)). simrisc-14.05.00/documentation/manual/loop/prescreen.yo0000644000175000017500000000351314034554241022040 0ustar frankfrankThe original program uses the following condition to determine whether prescreening must be performed: verb( if (Nscr > 0 && (naturalDeathAge < 1st screening age || (tumor present && tumor.selfDetectAge() < 1st screening age))) ) This results in a needlessly complex implementation of the pre-screening phase. It's much simpler to use the complement of this expression, skipping the pre-screening phase if the complementary condition is true. The pre-screening phase is therefore skipped if the following condition holds true: verb( not (Nscr > 0 && (naturalDeathAge < 1st screening age || (tumor present && tumor.selfDetectAge() < 1st screening age))) ) The expression can be simplified using De Morgan's rule tt(a && b == !a || !b): verb( not (Nscr > 0) or not ( naturalDeathAge < 1st screening age or (tumor present and tumor.selfDetectAge() < 1st screening age) ) ) Consequently, pre-screening is skipped if there are no screening rounds (not (Nscr > 0)) and also if the following condition holds true: verb( not ( naturalDeathAge < 1st screening age or (tumor present and tumor.selfDetectAge() < 1st screening age) ) ) Distributing the not-operator over the terms of the above condition, and applying De Morgan's rule tt(!(a || b) == !a && !b) we get: verb( naturalDeathAge >= 1st screening age and not ( tumor present and tumor.selfDetectAge() < 1st screening age ) ) Applying De Morgan's rule once more this finally results in: verb( naturalDeathAge >= 1st screening age and ( not tumor present or tumor.selfDetectAge() >= 1st screening age ) ) Thus, pre-screening is skipped if the above condition holds true. simrisc-14.05.00/documentation/manual/loop/screening.yo0000644000175000017500000000216714034554241022033 0ustar frankfrankFollowing the pre-screening phase the screening phase itself starts. However, when a case's simulation has already ended during the pre-screening phase the screening phase is skipped. Other than that, a case's simulation may also end during the screening phase itself, ending the screening phase. As long as the case simulation has not ended (i.e., the case's state is tt(PRESENT)) a screening is performed for each of the screening rounds defined by the tt(Screening) object (cf. section ref(SCREENINGCLASS)), initialized in tt(Loop's) constructor. At each screening round two actions are performend: itemization( it() given the round's screening age it is determined whether the case leaves the simulation at that particular screening round. If so then the case's state is no longer tt(PRESENT) and the screening phase ends for that case (see the next section for details); it() if the case is still present, then a screening is performed, which may also result in changing the case's state, which then also ends the screening phase for that case (cf. section ref(SCREEN)). ) simrisc-14.05.00/documentation/manual/loop/intro.yo0000644000175000017500000000310314034554241021200 0ustar frankfrankThe class tt(Loop) is the `workhorse' class. It performs the simulation as specified by the tt(Scenario) object which is passed to its objects when they are constructed. The class tt(Loop) uses many other classes, most of which encapsulate parameters specified in the configuration file. Those classes read configuration file parameters and prepare these parameters for their use by tt(Loop). The constructor of a tt(Loop) object defines the following objects: itemization( itt(d_costs): a tt(Costs) object providing various costs parameters (cf. section ref(COSTS)). This object does not provide the costs associated with various modalities. Those costs are directly stored at the modalities themselves; itt(d_densities): a tt(Densities) object providing the breast-densities parameters (cf. section ref(DENSITIES)); itt(d_modalities): a tt(Modalities) object providing the details about which screening modalities are used in a specific simulation (cf. section ref(MODALITIES)); itt(d_screening): a tt(Screening) object providing screening parameters (cf. section ref(SCREENING)); itt(d_tumor): a tt(Tumor) object handling the simulation related to the occurrence of tumors (cf. section ref(TUMOR)); itt(d_tumorInfo): a tt(TumorInfo) object providing tumor-related configuration parameters (like incidence, growth and survival parameters. Cf. section ref(TUMORINFO)); ) It also defines a tt(Random) object (tt(d_random)), generating random numbers (cf. section ref(RANDOM)). simrisc-14.05.00/documentation/manual/loop/leaving.yo0000644000175000017500000000252614034554241021502 0ustar frankfrankWhether the case leaves the simulation before an actual screening at the current screening age is determined by the member tt(Loop::leaving). In the original program this is determined as follows: itemization( it() the case's natural death occurs before the screening round's age, it() or there is a tumor and the tumor's self-detection age is before the screening round's age ) Converting this condition, then the case leaves the simulation if itemization( it() the screening round's age is at most equal to the case's natural death age, and it() there is no tumor or the screening round's age is at most equal to the tumor's self-detection age. ) If at this point the case hasn't left the simulation, then itemization( it() if there is a tumor and the tumor's self-detection age is at most equal to the case's natural death age then an interval cancer has occurred (handled by tt(Loop::intervalCancer)); it() otherwise, the case's state is set to tt(LEFT_DURING) as the case's natural death age has caused the case to leave the simulation. However, a tumor might still have developed at that point, and if so the tumor's characteristics are determined at the case's natural death age (cf. tt(Tumor::characteristics), section ref(TUMOR)). ) simrisc-14.05.00/documentation/manual/loop/screen.yo0000644000175000017500000000730414034554241021333 0ustar frankfrankIf the case has not yet left the simulation, then the member tt(Loop::screen) simulates a screening at a given screening age. At this point the modalities are considered. Each of the modalities configured for the current screening age is considered in turn. They are considered in their order of specification in the configuration file. E.g., when specifying verb( screeningRound: 50 Mammo MRI screeningRound: 52 MRI Mammo ) then Mammo is considered before MRI at screening age 50, and MRI is considered before Mammo at screening age 52. Modalities are made available by the tt(Modalities) member (tt(d_modalities), cf. section ref(MODALITIES)). The tt(use) member of this member returns the information of all modalities that have been configured for the current screening round. Whether a configured modality is actually going to be used at a particular screening round is determined by chance. In the configuration file the parameter tt(attendanceRate) defines the probability that a case attends a screening round. If the next random value drawn from the uniform random distribution exceeds the configured attendance rate then the screening round for that modality is skipped for the current case. If a case attends a screening round then the screening round's costs are determined (cf. section ref(COSTS)) and are added to the costs so far (cf. tt(Loop::addCost)): the costs are added to the case's accumulated cost and to the accumulated costs of the current screening round. In addition, if a tumor exists at a screening round then the tumor's characteristics are determined for the current screening age. Two factors determine whether a tumor may be detected or whether its detection may be a false positive. One factor (factor-1) is the (apparent) presence of a tumor, the other factor (factor-2) is whether the screening round's age is at least equal to the age that the tumor can be detected. If both factors are true, then the tumor may be detected. Otherwise there may be a false positive tumor detection. em(Maybe detecting the tumor (maybe a false negative conclusion):) The member tt(maybeDetect) (cf. tt(Loop::maybeDetect)) is used to decide whether a tumor may be found during the screening. A false negative screening result is obtained if a random value exceeds the current modality's sensitivity. The sensitivities of the various modalities are returned by the tt(ModBase::sensitivity) member (which in turn call their derived class's members tt(vSensitivity) returning the return values of the actually used modality's overridden tt(vSensitivity) members. If a false negative result isn't obtained then a tumor was detected: its treatment costs are added to the accumulated costs and the dying age because of the tumor is set to the age of the current screening round. If the natural dying age is earlier than the dying age caused by the cancer, then the case leaves the simulation (using status tt(LEFT_DURING)). Otherwise the case leaves the simulation using status tt(TUMOR_DURING). em(Maybe incorrectly detecting the tumor (maybe a false positive conclusion):) Once a tumor has apparently been observed it may in fact not exist, in which case a false positive observation was made. The memebr tt(maybeFalsePositive) handles this situation. The specificity of the used modality, given the current screening age is compared to a random value from the uniform random distribution. If the generated random value exceeds the modality's specificity then the simulation has encountered a false positive tumor detection. The numbers of false positive decisions for the modality and for the screening round are incremented and tt(addCoist) is called with argument the biopsy costs at the current screening age. simrisc-14.05.00/documentation/manual/loop/src0000777000175000017500000000000014034554241021743 2../../../loopustar frankfranksimrisc-14.05.00/documentation/manual/main/0000755000175000017500000000000014034554241017452 5ustar frankfranksimrisc-14.05.00/documentation/manual/main/main.yo0000644000175000017500000000071614034554241020753 0ustar frankfrankThe tt(main) function defines the long options in its global tt(g_longOpts) array. The tt(g_longOpts) and tt(g_longEnd) global variables are not declared for general use in a header file but are declared in class specific headers when needed. Currently that's only tt(scenario/scenario.ih). verbinsert(-s4 //main src/main.cc) The simulations themselves are controlled by a tt(Simulator), having only one public member: tt(run), performing the simulations. simrisc-14.05.00/documentation/manual/main/src0000777000175000017500000000000014034554241020745 2../../..ustar frankfranksimrisc-14.05.00/documentation/manual/abstract.yo0000644000175000017500000000157714034554241020714 0ustar frankfrankabstract( WIP describing spreading nl() WIP updating section Random (ref(RANDOM)) nl() Jan. 06: added subsection AgeGroup (ref(AGEGROUP)) nl() old: nl() Jan. 04: added subsection Distribution (ref(DISTRIBUTION)) nl() Jan. 04: added subsection VSD (ref(VSD)) nl() Jan. 04: added subsection Beir7 (ref(BEIR)) nl() Dec. 31: added the section about Generic Support Classes (ref(GENERIC)) nl() Dec. 31: added the section TumorInfo (ref(TUMORINFO)) nl() Dec. 30: completed subsection Density (ref(DENSITY)) nl() Dec. 29: completed section Modalities (ref(MODALITIES)) nl() Oct. 18: completed section Densities ref(DENSITIES) nl() Oct. 17: completed section Costs ref(COSTS) nl() Oct. 16: completed section Loop ref(LOOP) nl() ) simrisc-14.05.00/documentation/manual/tumorinfo/0000755000175000017500000000000014034554241020550 5ustar frankfranksimrisc-14.05.00/documentation/manual/tumorinfo/beir7.yo0000644000175000017500000000031014034554241022123 0ustar frankfrankThe class tt(Beir7) stores the tt(Tumor Beir7's beta, eta, spread) and the spread-distribution configuration parameters. It's a wrapper class for these parameters, offering accessors to each of them. simrisc-14.05.00/documentation/manual/tumorinfo/tumorinfo.yo0000644000175000017500000000114714034554241023146 0ustar frankfrankObjects of the class tt(TumorInfo) provide access to the following paramters: tt(Beir7, Growth, Incidence) and tt(Survival), which are covered in the following sections. In addition its member tt(cumTotalRisk) computes the cumulative total risk, given the radiationrisk as determined in tt(Loop::caseInit). For each case the (Incidence) carrier is randomly determined given the probabilites of the various carriers. The cumulative total risks over all ages are computed by subsequently adding the products of the risk of getting a tumor (given the selected carrier) times the radiation risk (for the used age). simrisc-14.05.00/documentation/translations.txt0000644000175000017500000000675114034554241020544 0ustar frankfrankTranslations of symbols used in the original sources to currently used symbols ============================================================================== mammoCosts, MRICosts, TomoCosts = mammotomo.h, mri.h biopsyCosts, treatmentCosts[3] = costs.h fpctrl - input/control.txt oid fpin - not used fpout - not used fpcosts - input/costs.txt fpdeath - test3/data-?.txt fpsensitivity - test3/sensitivity.txt fpdist - test3/dist-?.txt fp = test3/rounds-?.txt Nmam = loop.d_nMam Ntomo = loop.d_nTomo NfalseP = loop.d_nRoundFP NfalseN = loop.d_nRoundFN Ndect = loop.d_nDetections screeningRoundCosts = loop.d_roundCost naturalDeathAge = loop.d_naturalDeathAge deathStatus = loop.d_status deathAge = loop.d_deathAge AgeOfDetection = loop.d_detectionAge Nscr - scenario.rounds().size() scr[].age = scenario.age(idx) src[].T0 = scenario.round(idx).mammo() src[].T1 = scenario.round(idx).tomo() fpdist, distFileName: options::d_cumTotalRiskFile calcTotalRisk = tumorinfo/cumtotalrisk cumTotRisk = tumorinfo/d_cumRisk tumorinfo: DoubleVect const &cumTotalRisk() const beir = tumorInfo.induction() dose = modalities.mammoParams().dose() tomodose = modalities.tomoParams().dose() [a][b]: a = type (xray) b = id(Mammo, Tomo) specMam[?] = - d_modality.mammoParams()[?].value() - d_modality[XRAY][MAMMO][?].value() specTomo[?] = - d_modality.tomoParams[?].value() - d_modality[XRAY][TOMO][?].value() tumorSurvival[0..4] = Survival tumorRisk_f = incidence.risk().value() params(): vector of nCarriers values tumorRisk_m = incidence.mean().value() tumorRisk_s = incidence.stdDev().value() tumorRisk = incidence tumor.selfDetectAge() - d_tumor.age() tumor.deathAge(...) - d_tumor.deathAge() - wrt tumor.age() d_tumor.deathAge(x) - wrt age x (e.g. tumor.selfDetect() tumorConfig.startDiameter = growth.start() (VSD's) tumorConfig.selfDetectDiameterMu = growth.selfMu() tumorConfig.selfDetectDiameterSigma = growth.selfSigma() tumorConfig.doublingTimeMu[ageGroupIndex] - growth.group[idx].mean() tumorConfig.doublingTimeSigma[ageGroupIndex] - growth.group[idx].stdDev() RoundVect rounds() - vector of screening rounds: uint16_t age(), mammo() tomo() womenYears - Loop:d_sumDeathAge womenCosts - Loop:d_caseCost (was: Loop:d_totalCost) Ninterval - Loop:d_nIntervals (vector) womencost - Loop:d_roundCost (vector) screeningRoundCosts - Loop:d_screeningCost (vector) attendanceRate - Screening:d_attentanceRate densities - d_densities.indices() -> Loop:d_indices Breast density index at screening rounds int density[Nscr] - Loop:d_indices Ndect - Loop:d_nDetected; filenames: scenarioName is, e.g. 'noscreening', defined in control.txt iter is the string converted iteration index all filenames end in scenarioName + -i + iter + .txt (not used below) settingsFileName = "output/settings- writeSettings(settingsFileName); outputFileName = "output/summary- deathFileName = "./output/women- sensitivityFileName = ./output/sensitivity- resetRandomNumberGenerator - d_random.reset simrisc-14.05.00/enums/0000755000175000017500000000000014034554241013527 5ustar frankfranksimrisc-14.05.00/enums/enums.ih0000644000175000017500000000005314034554241015176 0ustar frankfrank#include "enums.h" using namespace std; simrisc-14.05.00/enums/enums.h0000644000175000017500000000152314034554241015030 0ustar frankfrank#ifndef INCLUDED_ENUMS_ #define INCLUDED_ENUMS_ static unsigned const END_AGE = 101; static unsigned const MAX_AGE = END_AGE - 1; enum VaryType { VARY_MEAN, // every value is OK VARY_NONNEG, // varied values must be >= 0 VARY_PROB // varied values must be probabilities }; enum DistType // update Random::Sizes, Dostribution::s_name { // when modified UNIFORM, // always used distributions UNIFORM_CASE, LOGNORMAL, N_STD_DISTRIBUTIONS, NORMAL_VARY = N_STD_DISTRIBUTIONS, UNIFORM_VARY, LOGNORMAL_VARY, N_DISTRIBUTIONS }; enum GeneratorType { FIXED_SEED, INCREASING_SEED, RANDOM_SEED, }; enum ParamsSrc { CONFIGFILE, ANALYSIS, NONE, }; #endif simrisc-14.05.00/enums/frame0000644000175000017500000000006014034554241014540 0ustar frankfrank//#define XERR #include "enums.ih" Enums:: { } simrisc-14.05.00/err/0000755000175000017500000000000014051665273013177 5ustar frankfranksimrisc-14.05.00/err/negative.cc0000644000175000017500000000020214034554241015273 0ustar frankfrank//#define XERR #include "err.ih" // static void Err::negative() { msg(NEGATIVE) << '`' << s_lineInfo->txt << '\'' << endl; } simrisc-14.05.00/err/data.cc0000644000175000017500000000533314034554241014414 0ustar frankfrank//#define XERR #include "err.ih" ///Err Err::s_err; // the singleton object LineInfo const *Err::s_lineInfo; // last set LineInfo bool Err::s_handle = true; // handle a context message char const *Err::s_src[] { "config file", "analysis specification", "" }; char const *Err::s_plain[] // plain msg: no line context { "probabilities don't sum to 1" , // CUMPROB "Incidence carrier probabilites must sum to 1" , // INCIDENCE_SUM_PROB "specification(s) missing for" , // MISSING_SPEC "multiply specified: " , // MULTIPLY_SPECIFIED "undefined specification" , // UNDEFINED_SPEC }; char const *Err::s_context[] // line context available { "parameter value too small" , // AT_LEAST "invalid Survival type" , // INVALID_TYPE "invalid value" , // INVALID_VALUE "modality repeatedly specified" , // MODALITY_REPEATED "parameter cannot be negative" , // NEGATIVE "age ranges not consecutive" , // NOT_CONSECUTIVE "proportions must sum to 1" , // PROB_SUM, "parameter(s) must lie within 0..1" , // RANGE_0_1 "screening round ages don't increment" , // ROUND_AGES_DONT_INC "`round: none' conflicts with " "`round: age' specifications" , // ROUND_NONE "specification error" , // SPEC_ERROR "undefined distribution" , // UNDEFINED_DIST "undefined modality" , // UNDEFINED_MODALITY "VSD specification missing. Require " , // VSD_MISSING }; // "integral number not found (parameter `" , // MISSING_NR, // "`tumorIncidence' probabilities must add up to 1" , // INVALID_PROBSUM, // string{"max. number of carrier specifications (" + // N_CARRIERS, // to_string(END_CARRIERS) + " exceeded"}.c_str() , // "`tumorGrowth:' startDiameter, Mu and Sigma not specified" , // TUMORGROWTH_STARTDIAM, // "`tumorGrowth:' no `agegroups' defined" , // TUMORGROWTH_AGEGROUPS, // "at least one `tumorIncidence:' parameter line is required" , // TUMORINCIDENCE_SIZE, // "missing `tumorSurvival' types (a, b, c and d are required)\n" , // TUMORSURVIVAL_TYPES, // string{"max. number of carrier specifications (" + // N_CARRIERS, // to_string(END_CARRIERS) + " exceeded"}.c_str() , // "age ranges not consecutive " , // NOT_CONSECUTIVE, simrisc-14.05.00/err/reset.cc0000644000175000017500000000025614034554241014624 0ustar frankfrank#define XERR #include "err.ih" // static LineInfo const * Err::reset(LineInfo const &lineInfo) { s_lineInfo = &lineInfo; s_handle = true; return s_lineInfo; } simrisc-14.05.00/err/specification.cc0000644000175000017500000000021114034554241016311 0ustar frankfrank//#define XERR #include "err.ih" // static void Err::specification() { msg(SPEC_ERROR) << '`' << s_lineInfo->txt << '\'' << endl; } simrisc-14.05.00/err/range.cc0000644000175000017500000000020014034554241014563 0ustar frankfrank//#define XERR #include "err.ih" // static void Err::range() { msg(RANGE_0_1) << '`' << s_lineInfo->txt << '\'' << endl; } simrisc-14.05.00/err/err.h0000644000175000017500000000522414034554241014134 0ustar frankfrank#ifndef INCLUDED_ERR_ #define INCLUDED_ERR_ #include #include #include "../typedefs/typedefs.h" // err messages to cerr, messages may end in '\n' class Err { static char const *s_plain[]; static char const *s_context[]; static char const *s_src[]; static LineInfo const *s_lineInfo; // last set LineInfo static bool s_handle; // handle a context message public: enum Plain // plain errors, { // no line context CUMPROB, INCIDENCE_SUM_PROB, MISSING_SPEC, MULTIPLY_SPECIFIED, UNDEFINED_SPEC, }; enum Context { AT_LEAST, INVALID_TYPE, INVALID_VALUE, MODALITY_REPEATED, NEGATIVE, NOT_CONSECUTIVE, PROB_SUM, RANGE_0_1, ROUND_AGES_DONT_INC, ROUND_NONE, SPEC_ERROR, UNDEFINED_DIST, UNDEFINED_MODALITY, VSD_MISSING, }; static char const *src(ParamsSrc type); // merely the error message: static std::ostream &msg(Plain err); // 1. // error msg + src and line nr, ending in ": " static std::ostream &msg(Context err); // 2. static void msgTxt(Context err); // also inserts line txt // msg(RANGE_0_1 using line) static void range(); // msg(NEGATIVE using line) static void negative(); // msg(AT_LEAST using line) static void atLeast(double minimum); // msg(SPEC_ERROR using line static void specification(); // msg(MULTIPLY_SPECIFIED) static void multiplySpecified(LineInfoVect::const_iterator begin, LineInfoVect::const_iterator end, std::string const §ionList); static LineInfo const *reset(LineInfo const &lineInfo); static std::string const &txt(); // status of all operations since the static bool valid(); // last reset }; inline bool Err::valid() { return s_handle; } inline char const *Err::src(ParamsSrc type) { return s_src[type]; } inline void Err::msgTxt(Context err) { msg(err) << '`' << s_lineInfo->txt << '\'' << std::endl; } inline std::string const &Err::txt() { return s_lineInfo->txt; } #endif simrisc-14.05.00/err/msg2.cc0000644000175000017500000000057614034554241014357 0ustar frankfrank//#define XERR #include "err.ih" // line context available ostream &Err::msg(Context err) { if (not s_handle) return imsg; // switched 'off' s_handle = false; return emsg << s_src[s_lineInfo->src] << " [" << s_lineInfo->lineNr << "]: " << s_context[err] << ": "; } simrisc-14.05.00/err/msg1.cc0000644000175000017500000000021014034554241014337 0ustar frankfrank//#define XERR #include "err.ih" ostream &Err::msg(Plain plain) // no line context { return emsg << s_plain[plain]; } simrisc-14.05.00/err/icmconf0000644000175000017500000000007214034554241014530 0ustar frankfrank#define LIBRARY "err" #include "../icmconf.lib" simrisc-14.05.00/err/atleast.cc0000644000175000017500000000027614034554241015141 0ustar frankfrank//#define XERR #include "err.ih" // static void Err::atLeast(double minimum) { msg(AT_LEAST) << '`' << s_lineInfo->txt << "': parameter must be >= " << minimum << endl; } simrisc-14.05.00/err/err.ih0000644000175000017500000000012214034554241014275 0ustar frankfrank#include "err.h" //#include using namespace std; using namespace FBB; simrisc-14.05.00/err/frame0000644000175000017500000000005414034554241014204 0ustar frankfrank//#define XERR #include "err.ih" Err:: { } simrisc-14.05.00/err/multiplyspecified.cc0000644000175000017500000000064114034554241017233 0ustar frankfrank//#define XERR #include "err.ih" // static void Err::multiplySpecified(LineInfoVect::const_iterator begin, LineInfoVect::const_iterator end, string const §ionList) { msg(MULTIPLY_SPECIFIED) << sectionList << ". Lines:"; for (; begin != end; ++begin) // list the line nrs emsg << ' ' << begin->lineNr << ','; emsg << endl; } simrisc-14.05.00/extractable/0000755000175000017500000000000014034554241014676 5ustar frankfranksimrisc-14.05.00/extractable/extractable.h0000644000175000017500000000051014034554241017341 0ustar frankfrank#ifndef INCLUDED_EXTRACTABLE_ #define INCLUDED_EXTRACTABLE_ // concept used by Parser's extract templates to ensure that // the arguments to extract can actually be extracted template concept Extractable = requires(std::istream in, Type value) { in >> value; }; #endif simrisc-14.05.00/flexc++scanner/0000755000175000017500000000000014034554241015201 5ustar frankfranksimrisc-14.05.00/flexc++scanner/scanner.ih0000644000175000017500000000021414034554241017151 0ustar frankfrank// Generated by Flexc++ V2.07.09 on Mon, 23 Mar 2020 12:52:39 +0100 // $insert class_h #include "scanner.h" #include "../parser/tokens.h" simrisc-14.05.00/flexc++scanner/scanner.h0000644000175000017500000000242314034554241017004 0ustar frankfrank// Generated by Flexc++ V2.07.11 on Sat, 07 Nov 2020 16:28:03 +0100 #ifndef Scanner_H_INCLUDED_ #define Scanner_H_INCLUDED_ // $insert baseclass_h #include "scannerbase.h" // $insert classHead class Scanner: public ScannerBase { public: Scanner(std::string const &infile, std::string const &outfile); // $insert lexFunctionDecl int lex(); private: int lex_(); int executeAction_(size_t ruleNr); void print(); void preCode(); // re-implement this function for code that must // be exec'ed before the patternmatching starts void postCode(PostEnum_ type); // re-implement this function for code that must // be exec'ed after the rules's actions. }; inline Scanner::Scanner(std::string const &infile, std::string const &outfile) : ScannerBase(infile, outfile) {} // $insert inlineLexFunction inline int Scanner::lex() { return lex_(); } inline void Scanner::preCode() { // optionally replace by your own code } inline void Scanner::postCode([[maybe_unused]] PostEnum_ type) { // optionally replace by your own code } inline void Scanner::print() { print_(); } #endif // Scanner_H_INCLUDED_ simrisc-14.05.00/flexc++scanner/lexer0000644000175000017500000000560414034554241016250 0ustar frankfrank%filenames scanner // %interactive //%debug %% [ \t\n]+ // skip ws #.* // skip comment true | false return Tokens::BOOL; random | fixed | increasing return Tokens::GENTYPE; ageGroup:? return Tokens::AGEGROUP; BreastDensities:? return Tokens::BREASTDENSITIES; Costs:? return Tokens::COSTS; Discount:? return Tokens::DISCOUNT; Scenario:? return Tokens::SCENARIO; age:? return Tokens::AGE; biop:? return Tokens::BIOP; cases:? return Tokens::CASES; diameters:? return Tokens::DIAMETERS; generator:? return Tokens::GENERATOR; iterations:? return Tokens::ITERATIONS; prop:? return Tokens::PROP; seed:? return Tokens::SEED; spread:? return Tokens::SPREAD; Modalities:? return Tokens::MODALITIES; Mammo:? return Tokens::MAMMO; Tomo:? return Tokens::TOMO; MRI:? return Tokens::MRI; costs:? return Tokens::COST; dose:? return Tokens::DOSE; sensitivity:? return Tokens::SENSITIVITY; specificity:? return Tokens::SPECIFICITY; beta:? return Tokens::BETA; systematicError:? return Tokens::SYSERR; Normal:? return Tokens::NORMAL; Screening:? return Tokens::SCREENING; round:? return Tokens::ROUND; attendanceRate:? return Tokens::ATTENDANCERATE; Tumor:? return Tokens::TUMOR; Beir7:? return Tokens::BEIR7; eta:? return Tokens::ETA; Incidence:? return Tokens::INCIDENCE; prob:? return Tokens::PROB; lifetimeRisk:? return Tokens::LIFETIMERISK; meanAge:? return Tokens::MEANAGE; stdDev:? return Tokens::STDDEV; BRCA1:? return Tokens::BRCA1; BRCA2:? return Tokens::BRCA2; Growth:? return Tokens::GROWTH; start:? return Tokens::START; selfDetectMu:? return Tokens::SELFDETECTMU; selfDetectSigma:? return Tokens::SELFDETECTSIGMA; DoublingTime:? return Tokens::DOUBLINGTIME; Survival:? return Tokens::SURVIVAL; type:?[ \t]+. return Tokens::TYPE; [0-9]+ return Tokens::NR; -?[0-9]*\.[0-9]+ | -?[0-9]+\.[0-9]* return Tokens::REAL; . return matched()[0]; simrisc-14.05.00/frame0000644000175000017500000000007114034554241013413 0ustar frankfrank//#define XERR #include "incidence.ih" void Incidence:: simrisc-14.05.00/globals/0000755000175000017500000000000014051665273014032 5ustar frankfranksimrisc-14.05.00/globals/setprecision.cc0000644000175000017500000000031214034554241017035 0ustar frankfrank//#define XERR #include "globals.ih" // static ostream &Globals::setPrecision(ostream &out, uint16_t nDigits) { out.setf(ios::fixed, ios::floatfield); out.precision(nDigits); return out; } simrisc-14.05.00/globals/weakcompare.cc0000644000175000017500000000035414034554241016632 0ustar frankfrank//#define XERR #include "globals.ih" // static int Globals::weakCompare(double lhs, double rhs) { lhs -= rhs; return lhs < -WEAK_TOLERANCE ? -1 : lhs > WEAK_TOLERANCE ? 1 : 0; } simrisc-14.05.00/globals/data.cc0000644000175000017500000000016714034554241015247 0ustar frankfrank//#define XERR #include "globals.ih" double const Globals::s_sqrt2PI = sqrt(2 * M_PI); unsigned Globals::s_width = 0; simrisc-14.05.00/globals/globals.ih0000644000175000017500000000027514034554241015774 0ustar frankfrank#include "globals.h" #include "../xerr/xerr.ih" #include #include #include #include "../enums/enums.h" using namespace std; using namespace FBB; simrisc-14.05.00/globals/iszero.cc0000644000175000017500000000017514034554241015650 0ustar frankfrank//#define XERR #include "globals.ih" // static bool Globals::isZero(double value) { return fabs(value) <= TOLERANCE; } simrisc-14.05.00/globals/icmconf0000644000175000017500000000007614034554241015367 0ustar frankfrank#define LIBRARY "globals" #include "../icmconf.lib" simrisc-14.05.00/globals/setwidthprec.cc0000644000175000017500000000044414034554241017041 0ustar frankfrank//#define XERR #include "globals.ih" // static ostream &Globals::setWidthPrec(ostream &out, unsigned width, unsigned precision) { if (width != 0) { out.width(width); setPrecision(out, precision); } return out; } simrisc-14.05.00/globals/frame0000644000175000017500000000006414034554241015040 0ustar frankfrank//#define XERR #include "globals.ih" Globals:: { } simrisc-14.05.00/globals/globals.h0000644000175000017500000000264314034554241015624 0ustar frankfrank#ifndef INCLUDED_GLOBALS_ #define INCLUDED_GLOBALS_ #include #include #include #include "../typedefs/typedefs.h" class Globals { static unsigned s_width; public: static constexpr double TOLERANCE = 1e-8; static constexpr double WEAK_TOLERANCE = 1e-3; static constexpr double NO_TUMOR = -1; // tumor/ static double const s_sqrt2PI; static bool proportion(double const &value); static double findAge(DoubleVect const &cumProb, double prob); static bool isZero(double value); static bool isPositiveZero(double value); // -1: lhs < rhs // 0: lhs == rhs // 1: lhs > rhs static int weakCompare(double lhs, double rhs); // uses WEAK_TOLERANCE static std::ostream &setPrecision(std::ostream &out, uint16_t nDigits); static std::ostream &setWidthPrec(std::ostream &out, unsigned width, unsigned precision); }; // static inline bool Globals::isPositiveZero(double value) { return 0 <= value and value <= TOLERANCE; } // static inline bool Globals::proportion(double const &value) { return 0 <= value and value <= 1; } #endif simrisc-14.05.00/globals/findage.cc0000644000175000017500000000110214034554241015721 0ustar frankfrank//#define XERR #include "globals.ih" // static double Globals::findAge(DoubleVect const &cumProb, double prob) { auto begin = cumProb.begin(); auto last = upper_bound(begin, cumProb.end(), prob); auto first = lower_bound(begin, last, *(last - 1)); return (first - begin) + ( // interpolate 'prob' in the range of (last - first) * // categories containing 'prob' (prob - *first) / ((last == cumProb.end() ? 1.0 : *last) - *first) ); } simrisc-14.05.00/globals/driver/0000755000175000017500000000000014034554241015316 5ustar frankfranksimrisc-14.05.00/globals/driver/main.cc0000644000175000017500000000106214034554241016550 0ustar frankfrank#include #include #include "../globals.h" using namespace std; int main() { DoubleVect dv{.1, .1, .5, .5, .5, .7, .8, .9, 1}; while (true) { cout << "prob? "; double prob; cin >> prob; cin.ignore(100, '\n'); auto begin = dv.begin(); auto last = upper_bound(begin, dv.end(), prob); auto first = lower_bound(begin, last, *(last - 1)); cout << (first - begin) << ", " << (last - begin) << '\n' << Globals::findAge(dv, prob) << '\n'; } } simrisc-14.05.00/globals/driver/compile0000755000175000017500000000004714034554241016675 0ustar frankfrankg++ -Wall main.cc -L ../tmp/ -lglobals simrisc-14.05.00/growth/0000755000175000017500000000000014051665273013721 5ustar frankfranksimrisc-14.05.00/growth/growth1.cc0000644000175000017500000000030114034554241015606 0ustar frankfrank#define XERR #include "growth.ih" Growth::Growth() : d_base{ "Tumor:", "Growth:", "" }, d_selfMean(VARY_NONNEG) { setStart(); setSelfDetect(); setDoublingTime(); } simrisc-14.05.00/growth/vary.cc0000644000175000017500000000041414034554241015201 0ustar frankfrank//#define XERR #include "growth.ih" void Growth::vary(ostream &out) { d_selfMean.vary(); out << " Growth:\n" " selfDetect: "; d_selfMean.showVary(out); out.put('\n'); AgeGroupVSD::vary(out, 4, "DoublingTime", d_doublingTime); } simrisc-14.05.00/growth/growth.ih0000644000175000017500000000017114034554241015545 0ustar frankfrank#include "growth.h" #include "../xerr/xerr.ih" #include #include "../parser/parser.h" using namespace std; simrisc-14.05.00/growth/nextrange.cc0000644000175000017500000000031714034554241016215 0ustar frankfrank//#define XERR #include "growth.ih" bool Growth::nextRange(AgeGroupVSD const &next) const { return d_doublingTime.empty() or next.beginAge() == d_doublingTime.back().endAge(); } simrisc-14.05.00/growth/setdoublingtime.cc0000644000175000017500000000144614034554241017424 0ustar frankfrank#define XERR #include "growth.ih" void Growth::setDoublingTime() { d_base.back() = "DoublingTime:"; d_base.push_back("ageGroup:"); auto lines = Parser::any(d_base); d_base.pop_back(); // remove the pushed value // (for other analyses) bool push = true; while (true) { LineInfo const *line = lines.get(); if (line == 0) break; AgeGroupVSD spec{ VARY_NONNEG, true }; if (not Parser::extract(*line, spec)) push = false; if (not push) continue; if (not spec.ageGroup().nextRange(d_doublingTime)) { push = false; continue; } d_doublingTime.push_back(spec); } } simrisc-14.05.00/growth/icmconf0000644000175000017500000000007514034554241015255 0ustar frankfrank#define LIBRARY "growth" #include "../icmconf.lib" simrisc-14.05.00/growth/growth.h0000644000175000017500000000334414034554241015401 0ustar frankfrank#ifndef INCLUDED_GROWTH_ #define INCLUDED_GROWTH_ //Tumor: // Growth: # value spread dist. // start: 5 // selfDetectMu: 2.92 .084 Normal // selfDetectSigma: .70 // // DoublingTime: // # mean spread dist. stdev // ageGroup: 1 - 50: 4.38 .43 Normal .61 // ageGroup: 50 - 70: 5.06 .17 Normal .26 // ageGroup: 70 - * : 5.24 .23 Normal .45 #include "../agegroupvsd/agegroupvsd.h" class VSD; class Growth { StringVect d_base; double d_start; double d_selfSD; VSD d_selfMean; AgeGroupVSDvect d_doublingTime; public: Growth(); AgeGroupVSD const &ageGroupVSD(uint16_t idx) const; void vary(std::ostream &out); double start() const; VSD const &selfMu() const; double selfSigma() const; void writeParameters(std::ostream &out) const; private: void setStart(); void setSelfDetect(); void setDoublingTime(); bool nextRange(AgeGroupVSD const &next) const; static void writeDiameter(std::ostream &out, char const *name, VSD const &vsd); // static void writeDT(std::ostream &out, char const *name, // size_t idx, double value); }; inline AgeGroupVSD const &Growth::ageGroupVSD(uint16_t idx) const { return d_doublingTime[idx]; } inline double Growth::start() const { return d_start; } inline VSD const &Growth::selfMu() const { return d_selfMean; } inline double Growth::selfSigma() const { return d_selfSD; } #endif simrisc-14.05.00/growth/writeparameters.cc0000644000175000017500000000130414034554241017435 0ustar frankfrank//#define XERR #include "growth.ih" void Growth::writeParameters(ostream &out) const { VSD::fmt(1, 2, 0, 3); // used at selfDetect out << " Growth:\n" " diameters:\n" << setw(6) << ' ' << "start: " << setw(4) << d_start << '\n' << setw(6) << ' ' << "self-detect std.dev.: " << setw(4) << d_selfSD << '\n' << setw(6) << ' ' << "self-detect mean: " << d_selfMean << '\n'; AgeGroupVSD::fmt(8, 1, 2, 0, 2); out << setw(6) << ' ' << "DoublingTime:\n" << d_doublingTime; } simrisc-14.05.00/growth/setselfdetect.cc0000644000175000017500000000045314034554241017061 0ustar frankfrank//#define XERR #include "growth.ih" void Growth::setSelfDetect() { d_base.back() = "selfDetect:"; Parser::extract(Parser::one(d_base), d_selfSD, d_selfMean); // Parser::one(d_base, d_selfSD, d_selfMean); if (0 <= d_selfSD) return; Err::negative(); d_selfSD = 0; } simrisc-14.05.00/growth/setstart.cc0000644000175000017500000000021114034554241016064 0ustar frankfrank//#define XERR #include "growth.ih" void Growth::setStart() { d_base.back() = "start:"; Parser::nonNegative(d_base, d_start); } simrisc-14.05.00/growth/frame0000644000175000017500000000006214034554241014725 0ustar frankfrank//#define XERR #include "growth.ih" Growth:: { } simrisc-14.05.00/hasagegroup/0000755000175000017500000000000014034554241014705 5ustar frankfranksimrisc-14.05.00/hasagegroup/hasagegroup.h0000644000175000017500000000061614034554241017366 0ustar frankfrank#ifndef INCLUDED_HASAGEGROUP_ #define INCLUDED_HASAGEGROUP_ // concept used by AgeGroup to ensure that // Type has a member ageGroup() returning a const & to an AgeGroup class AgeGroup; template concept HasAgeGroup = requires(std::vector const &object) { { object.back().ageGroup() } -> std::same_as; }; #endif simrisc-14.05.00/hierarchy.odp0000644000175000017500000004673214034554241015076 0ustar frankfrankPKKˆR3&¬¨//mimetypeapplication/vnd.oasis.opendocument.presentationPKKˆRConfigurations2/toolbar/PKKˆRConfigurations2/floater/PKKˆRConfigurations2/menubar/PKKˆRConfigurations2/popupmenu/PKKˆRConfigurations2/toolpanel/PKKˆRConfigurations2/progressbar/PKKˆRConfigurations2/statusbar/PKKˆRConfigurations2/images/Bitmaps/PKKˆRConfigurations2/accelerator/PKKˆR styles.xmlí]Kã6¾ï¯0$7ÉzúÑ™ž Ù`³ L'ÁÌ$ÀžY¢medQäv÷œöìaûÿö—,Ÿe=LÙòs42c±HV},‹Å¢ôæ»—u0xqâÃðq¨«ÚpBz~¸|þöñoÊtøÝÛ¿¼‹…›5S%I_ På0y …ÂÇá*M£‡ÑF ¤OU/G†¦ÍFô÷ÕqBý8ÜÄát?y5HR÷WåÝ<ä´NŠ| üчÉÚdÀ´Š ×je±™( "$ÍË6'ÖÛr“ÄL3 ¶Û­º5‰üßp™’‚—tÄ©ã(mÀËÅ ‚qÊ©=7#Ž6q@È/k`õbg+Û ¦Eê&VÇ@ÉVÇ´b]¤‡n°ÖÈu7ë±´¸˜x§«mcWÛØOAÌÉ× udû´bW/~ªÒ-}6›H)']@ÙN^’@YÀš!lžÏÖÎ|¦¿d;f椠0¦'¯0¦WÐg.?ˆ„X¬nÖsK÷í¤NYò‚£zF6Q‘&æš/3ûº€›Ð£ö…¶^"û¸È Hµ‡B %4öcB$NÖÆ º6Â4œ~{^P¥‹¨is„ìÂHyöÁö+^#€ˆÉ”Dh¡ 0p]Â>B xÆv1›>¸~eÒUv ¡²N?DóFBm±s´­j&ãtô„ ÉÿžÞåS2–^í0mÁ»±I[CJ]°«t]9ZÔràÒá€"8æð-_õ­ø ÇŠÜ yû†N€ìñ€þÆl=ßùh6‘1|pB4h‘à¤h~}~ãD0ùv‡Ž> Mcze B4<ȤÇpí„ŠÈO]4ÏNì}ɳ†š\Hñ† ÏÁÜÏ0…͈eç`ç?MÒ8ëÁïŠfÆ*h%XL^“¬áñGð§óû¦™7æ,<ý- †!¡èXFu3“=§îùÛ7Øj#síx>²ò‹±éð†ôs‚œ8{†ÜBä-_-ÈV„lNVà’?…:Øt†‰Ÿ"‰uMûZ¨T]â„KÜ»©y`ÉÍaìá%ÑŒö ñ‡¡ýñC°¬®ç'Qà¼*"É@(ß/ìĘ-Ü*aMÛ6Ƴ‹ ûÒ£°IZ‘@BÜÉÜÛâêÆdl÷}¦§•Â¾o¥ÆcoìU©ñÌÐupqQÿ ‚n›¤-PÈì{V!ðÜšL5ëBX9HŠBÄÀMQ‹› “Ä}yÚYoî«ø«(eÁ‰RÌÖQR6 ¹vâO Eü>Žñ0á5;Â?@$Œ6І605ú¹£O:z(:~¸2´ÏYƒh9…ŸQw’UQSB€õäGô¼vV„`P(æ5`šèHJñ§€p‰Z}6ù:o ÞÕ‘‡ÙÊç…³ Xˆ¯Tl‘Cã­|wÈiÙo%BÞ4ˆS$Dx&`fY­±ípu\ U/ã|Ø¢¦ÑHMü;g*rb‡tVèŠáâlR˜D–Æ÷¤¤N­¾ØF›ÐM7Äí#m£ÅØ_Gx›DËñqd#/{zͨ*ûÍJWþnÏYÑ?~æCV˜|¬Ä¹BaÆsËsboØ~ 6µßŠ³jë{x&kîz¸w²QÓ¥PãÈ+ª®Z.wÞs­-` Z_åŠÊxªgÔO~R‚µÝA³OYÁØÿ ñnÍ_‰†þÏM’ú‹W¢ƒ‘ãáൂ¦fE7lÌŒP0‡iŠcUeX¤D€Ý‚Ø_®„:+Ç#ñ?ßór‹‰)PÒ½˜’LÂxíy+iŒ¶Åôˆ2„!Bº6@Z„›smö„""MºŠáf¹RXlJìµL”¾F;45Á ²¹ßÕ Ó6îh›>eaúŒKV„šïKoÐHÆ46$b›۲áçí±) R´¥VÐ;$Ñ$:4-/LpFÕþԌ׬;¹âå9n5Q  XHæ)+-J.€Ò@PŒ5¿Iq3âZ‘3Šz¡3’±³òzÁkHˆ>u´r¨b–fN ,*”>Wé`³¹]â_{â^pþ'pÓ­Ÿ®•ÀឺË:q–q¨”ÂÍ12_"bHó÷ á‡Ù1øïâÿã¶ðߨëü!ƒ3Z ÄÓf¸A¸öUÅÿ+@h¤£w0Ñ€w›¬<³ÙäOýWZ„\Šêå óT 9H¿·Ú;†vzÞì«•¼.øi@Nžr ŠÚN‡È‡ê´RhIù,«|ó6IÈH®IF£•ŒX‘‡•ŸKº/fºhÓE»Uš.5fÓåzdœM—º!$Óå<ÒÉqüS±ë¶köžE˜åRÈ/ÂW¶3“†‘g§´ןZúF%÷Œ§ÊˆèógJ7Y£e‰;R¾…œÃÀ“Gƒ' ¶Eƒq*§t’3>ZòçVMáBr`[C2VË’ñÖ4š»™L;a :–!ØJą̂о…åª,Òcô>Ÿvõ‰Ÿ÷t"ž[iyîc&E’3ÃÂ:?2¿Ð ëéŒóþ #U›ê5YFùsDü‹×lÃ9ÕV<ðe¾"Í—jž4ÞÉPï±ÝZïÑ`‰â2hðœòÎШµ’ÙÉ‘`yä2Hð”óÎh2‡H<$#,õ\#ž¥~Fïßgpçë>Ú’dr<Äïj£Í„dðî À2hŸœb"h–ßÞ&…„^e½šÌÑd·Ê&ôSv¬Õ-ž_W‘¢kĸfà,~yödÙÃsÇý´ŒñÙ]þÄ×P= éÓÊóÅ#$¡G?¥ÉØJ ™4àó¥çžÀ¦e v -Ëk YTµ™ …ÄE2ߣÏM8iÌЮ$7ÕÉÍA>jHljfo7{B,’ãÞ³jľÛìn“™ÑOh–ÙÄM 4_¶Y Xñ 2‘Íò‚AKV±~Â…‹Ì‡j¾LRíL—Jv/S4¦1Ï®,{ðÈë&ÿúÏ!Wìë@hr­×MŒæ$Ýé­êPõu“Ctèj½;Ö¡î®›ÜX󮛌ïô:EwN&wzY » '³»Ä§»ë&ºv-†úzï›èúm™ê+¸p¢Ž «ùÒI½äÊB8VÂ9uÇ4¾ÈNØ_JÇh áÔU„KNd¬­Ù¬kcMÆ´wG^ h–î%­’*wÀ2»ÁÜ8ææÄ<楀iÍ‹ª0o•ð¿V)™þ0ÌÍÓanXÓÓ`n4êyå€܇bnwƒ¹u:ÌuãDz~1ÌÇÝ`n÷˜Ëc>éóq¹<æÓn0Ÿô˜Ëc>ëói¹æÉfžâ{r'?bÍRŠžqM7O(ZûžÈ›fìöïâëßÅ׿‹ïJGûwñâp´_ÿ.¾þ]|ý»øúwñ]ùÙèe±\æh”Î\~ú–òþô@éAUÚöG ÝÞR|¥®ôÁ•>¸ÒW®¡>¸ÒWúàJ\éƒ+×P\é ¸R1éƒ#— ŽØv9qpÄ*eg~Á‘±ï$8"F;”ð3p^‘)Ä ¾§}4pvšHýh5XÁMA¡€¾çæq¸rùÚ`ðž—8FÕì)_~‘•:±Lþ›­º¦Úö˜?äwþM5L“.(Çñ £UK·.ÌÄ.ÈaÕKq &v@<åoT¼‡11jžO-ç›þQk=Ýx4S~²¦:ËÇœKeª¶69Y!c­nx§æTŠÝT Y`Gp±ð]f×ïÆ~â7‡¬¹«ðîÔUƒþë“6¬ ©>W“ùpU‹#8ÒDWí™øœcbLÔÕSˆŒ;Œ}ŽÊã0‚1ò4|1Ù°JkÐÛ jÓ=wsÁÖªkˆ_±?yQéE68r¿|ŒÈP–Ž¯®ës{ø,õà"¾J·³ZñU˜¥ü €+àx ÛIT’, L÷®ÂÍz.|Óº’ÐsR´™ð±<í^ÿö´ŒK£r¶ÏÕ`Ïk‰°v#ÕÎì˜jÎ&âF¸rKI‹¶±ŸâQ\CñÄJ:o…VIW®­Ú0j-®Ó¨¬-3ÞË/¼½Ô¦ã3axì ÓëÅð|zxìÑscx«3þ×ò„ç]5_Ziì\Ø¡×^0Ñ+ï¾òoC6_ŒÕ[]Œ}úµ<#!ilQâÛQ_ɹ}¨ÊONv¢Ä ñ^¾/}N¹yøÊWŸÒžyS²—¯ _PunÁ¥U³6¼ŸMéiOïÎö¢Ô8cì“Òú¤´>)íjê“Òú¤´>)­OJ»,B}RZŸ”&Ÿ”Öìl½³Ý;Û½³Ý;ÛׇPïl÷Îvïl÷Îvïl_7B½³-Ü©Ídk'IÉÇ]éSr$8¯øn1ÿMO+¨›NóÍ0CÕå·M%hø}-©‹pˆaÐ@±N²ÁYåø»­§]9(à,3V¡BÓ¹êÒ/•B†x–ˆ°[Ž“+y^Ák–@ÜÓ‹=ª !Y`YNA!¹dç¢T&fšÎTs<+%šªæ,Ëë}aɈ,]•ü»€‚8Iò8¤)tœsÂ×¾°9±™R`4;$A(¬ ø¨ï¦ûÒ>2¥Æõø¿#>‚yÏ£Ãcð´:ÇS7TÃÁ4Ël«ÙÖ¬›S k\JS±jÓìî*hi:çiÕ•öqfPO¯®ÍÀ I°k-­žwðö› ý–þó›eú-ÇV 8zÒFºB„Ž´@ÔV§“RæþDÕ¬‰€¨¡Nt]D4Ïåº@ﺦZ–}¹î§ª53ÏÖ½nªš6¾ø¥îÏŒ~¹þQ•ÏÃ=!æöaö X–NÙäçèÕ~Ž^ôs ÖD$Ýy5‘<"¦­Îf%ûfªÆt**¤¸«“±QgÚXÿu€²/ê¬Ë¨Þ²ï8ÿ¢ð±2ã¢fЖjOí:¡ç›æ–wå-èU ›=©Á@Ÿ¨3Z£3G¬½ÃЙ#v Äã6#·`<Ù‹1²7ã©4Îí½2ûB^Ù·õÎ$”xÚà›÷Î B…h$“ÆýuõšÚýJƒVQöýÄÂX¡µ}Rp¥UkZp¥ùÇêÆ*ó $W ‚H+Æ'ª1ÑKŒªûÄiÓ홨e&¯VÅ9ãâ,+ÆÅö—w 9×>"Ò Âf¹¸}„äÈ5xT^„³½£°KÌvN øcº›uv;/yûPK .§/zÎPKKˆR content.xmlí][“£Æ’~ß_AèÄÙ'ƒ¨ ·^Ïœ°=k‡#fÎ:<½ûr‚–Jjl @}ñŸØÇýûK6‹›ªˆÔ¸{ŽæafDõå¥2³²Šoÿö´ µ–¤A½[ Ã\h,ZÅë Ú¾[üçíº»øÛûù6Þl‚»YÇ«ÃŽE™¾Š£ þÕàî(½)Zã8~·¸Ï²ýÍrïYT\5âd»Ä¦é-‹ß‹ò? vï‡$º‰ý4Ho"ÇÒ›luÃo­Þssìëg@áMN`q1Ý¡êx_ y·‡§Ü…L|Ì>a)t̯ú8ññY«4%YÁãã£ñHòñßþºämzÆž²eÕ{›¬×a[o@‹,·ËµŸùúCÀÿRÝñtŸíZï@žç-óÖªë&NvOåxj^”ƒbO{–|<~xÇpƒ¯7z,MâýÍñâØžÒ ƒV´ü¯O?¯îÙ·g¤™¹œì³32a-¶“¬ê½^Õ÷‡$Ì»­WK2NlºDªÑ[ÝûI¦Ê°¼³$<[eÙyØvˆÎ:ñUŸÂû‚N‰·saP½÷ï][–.W~¸ª›=‡Ly¸¼óÉ«Ͼê1 @pªî;–ùªïâ}% ƒè÷nùæ­GùV}ÉS꛸ƒ…çm=±YÅ/Õ—:' Y« YKÒâß©31ï,Þvw,Q~7Xž¦lÔ÷áZQA’žlëId¢uaC[ì¿íFzB¾ 'ï$*ëÙ¹ä}ªþa<‚è’åÂ$öÇ»NÊ0{àV®–ð€…k5 ë»ôÔ|ó»eû½î·ßµûÙ}‡ºËOИÿõé£8Û¨JÇéÄ’®’`¯l‹ÞÒÀøÓŽ±áeѼÐJüW‡,ÞW~MñÔtY_Ø€£oüÓ×l¦ï¿-Ô¡¾¬¿9¥ïЭ\&´Ï~ï‚)£ê ŽÇó»Å¿úû8ý·“~ÅÅ…&=š÷×·,ö‚OâI=öA¶Ö<øIK÷R4xäF‰6ÞqâþgñyÄêsó}¥YÂüö 8OXK_Óç4c»)4~`¿ù_çiúÌBÓ c MS)XvifyÝ?d1VzþœZeó¿%z×{T¿¬¤³ôÎô½¿e‹êNñ¢¾ÓÊ’,`©&yÿwþê÷mÂ'pÕÓ Ÿ£³äÓNW·øî7¶ÊÒ³Ý×Aºýgð[âŒOÛgºäÔUÓûÆÓ®Ž0k1= vÕ9¦Dçð—ë¢æžùëž‘½ŠÁo“†°l¬ªË{?áqþC/nâ1ÐÚOÖ54å-"*-x_ÿ7DqÄ õ)®€·Æ0¤¿˜ùŸEÑ{„aÕ·¾PwÝäÊ/]¾~'Á1÷t? ¶0ñ…l“•½¸Îè –ÀŽ`{ŸUXŸ4>kî”ønâ›]Õw˜†ë­võå²/6<ÁåÚtJ~Ž‚ˆAÑÄã.7»x P„‰žÝ áOC8¯üéç5,:È•?ÃùcÎÃzåÍpÞòìyøc]ù3†?®Gçá}åÏpþX†i;óðǹòç<rEùsæ÷Ê›1ºCèLswåÏ(ßyóð™W |:ÓäƒFdŠäÐcÝLJŒ£ØË©ŸüÎEëw‹ï@eqz½¶ëáx´s¬æËøêÈ•]°^‡Ã&#"òAãnÇÍÆ4k{…\ƒà³ºŠ d¢¶ÙΚk¶C×Px”;2ƒ®±ð¨é‘¹t †{lœéµªš+[®áð² <›Çx‰ÇÙ¸¹Ö2Ð?UP\2á,‡ÊWg:4§Á¬n(A¼O‚èwÞ}*–7³Pi ¥ ™Iïð5”åüÍäYàëü(öxÞL©(|]ƒ·ïÍ¥A×üCƒì!àÛ\*tÍ?Œá6lbÍÄ¡kb ‡fZMÄ#²Óí›Ò8 Ö ñš¾öSíAÄþÍ|€_¬êñúòÑøš 7P<“8_3} r¬¶éÀòÈLú§J\L…ˆaÍÕ“kT?Î¥š+M®qý8‘™l¹Æõ%æ‰Ëþ¸ž;ƒ®qý;3…õäÖ`2lw.÷BQ}_Rwt×Äü·Cš›gÅ0°g5§±*mµ9ÒŽášåšš2’/´þÿvtM·E–©éP(¯áù9«aØl³Žáx3%Ɉø|j#¡¶åÓW›S"/¿!ýÏ·µœJ%ÌqÔ¦ÿ´3r=‡Srg emðÇöí›ÛœÅ}ÔgXømüC×wY…¬×þt.Óp 4OÃÍâì››‹¢7Ò Á0Ï’šü¥)'Õ›`˜Å‘7C†9࢑+±x “Q£PsŸ \“݃×;Q¾ðh1ˆÁ ñ6ÂÇ79^Mè{ˆÖ, ƒˆêX/Õ´v)M4W²Žåxòwæÿn#ôîyœârâZ1~ÔÑÏ[€#ûë˺Ÿ~ÔÕÈÏ ÙSÙ¬ŽT#ºyHzô™ñÞ_Ù3wMÌ¿.¦šF¨òpé vRÆIsÈX#¨˜Ób¼2}kD¯‹y¦žy€oî+ýÚ4úòåõxÞjß6æH.^Âq¿m8î^5tÊ»mxÍÃ_Ö?㨓Óð3GS_­(Hv~¨2/V7>–‘¨|çñ™•N´´·žéP< Ö›îGœvQÇ°á÷a8Þµº ¨½ M†¤áð«×ãUÝ6<ÔˆŠœ`¿4¸(·®ç#ò§ŠmÃoÉíËe~n{¤¥“Hýˆb‡=°°´uw‡0d™V4òë`QÅÏ¢Iç'Ú¿[üßÿþO=4á!Âó{xª0ôï ¥^6t¡RAø9ó“ÏÏ»»¸æÕ!å®R´Žõ£#$$'Å™ÜúkŽË¹‘ÀOÀ!ÝóscïØ&NXÂׇ¹BÈÀ_%Bô‚¹_%BÖÅÂý*²/†ù*ñq.‡ÏWj§Ý‹!D¿R;í]¡¯ÓNódÝ… ²Þ–¡šK_{Ùù%€²á.^?×?Ä…ü÷ßæY2~š|‘/+—ÿá7ªwy=׋ûùÊj›4cIy ½¸ðr ½ø£èúÏñ!+oúî#º5%›®É·‹/Ï+5êò©èà—ªÎÄ/ÞQÔxU¥¯Õ®ðüb£¢"¿ú”ŸÇ…qõû9ð7‰®Uè§é»E]ú!·Ë=Kü(åŸ`aë’Ûå0sêïâ§RØ÷å¿ “Q)ÂÈnëP)­%ƒ÷¬þw/Ožº<‚)Ûàæö  ÅGŒn =XWÝä_ÝXc{¤µ¨4¶ {Ò–i˜ùŽÖQ0áÅûq¼¿8BøB}"gØí8†ëŠ0·¬ÑY¼ÿ¼b‘ŸñÅ¡  à;ì((2_Šâ4K/ŽUS,)Š´ ÓéÌvD„Àÿ ¨Ìía'ÈRÈ”2U B¨"Û°]#Ì+ºGÛ¢Ÿ’ø1»ŸW”dã‹f:°(¸Ïú"Ãηê(9t JŸâõ÷~Ê.“­•P¢½ Qƒx½¢¾A" ~ÈžR®o?G›ËgG &"KQ‘&Ššn“q¼ö”a:ôD˜Ü)SØ!yüðâ(¹¦0j˜–Û#1®a“ ]¼ÿ9Zk­.¯VÞ¤ÉÜé©,Ѽ»iP€L|ςĹ¼lvâ@$½‘ÕFEkhŸë‡<Ãò$Ç)÷OŽ¶Áþn7Ú´¬â(b«,NZqêŽ:lmÑûyÏ«'‚j¿ÍI€ ºØx• žÑçÅ=†eÏ8ßèq7G Q6qïóÇ#’âò6<0}ßfW¶ð]!uw,\;ãâuÀâOØ5˺B×Â:¢¶i=ø§©¿…¦fj¼•h¼Õ®Bµý²¸un‘AŽÂÆA®…k,Èäò # Q#Ðê.õŽ©í¶@ mXƒ6o*ÀÝÑÜP€OÀC‚s ly"ÀØ·ÃëB˜CØêGa R# ‰­#7?÷^âhÐâöƒÛmFYdIv´þynÖEžÕ4¤ÄB+É›¥Hôù!”Dù… Þ¬<Ã÷5˜Sèc ‘5\¡ÌEôBöÔjOѱë¡6c šðYTŒÏmImIÄ´7¬¢0ï#QmÃ4é¤lNÂXDÛË»>Šaº#áäôâÄ?€Ù¢±rÖ ì Y!jxÞ”ðóWþ…Ù7 «¢"A>j]¥¦áJªŠlêܦªö0UuTThÔÀ1iˆ(¶\{®íµ)+´z´:æ}UŒð‘,ˆ¨_‰áÑ–¤#¡bìJˆá"1h#®œ)¢øE餩£*Å(ß“òL›cõ™6‚ ,«¬k˜¹¤ŽM>þG›`û4ä:é‘r%¤\ãæô"E Ó’b_~Î÷oä?IÙè<í\ÖðOëJžH=ðÚºAûhïróæ\á.óæ3o^¿y#ˆÔ° „…–§#‡´u6X7‡(tÝØa±$³v²¸¦´ºFÛÒ/È=ÛÀÄÕµòǪë—Ï.¿ºÖ~±%ä¥Ô¿T`½9pð9LWJ×ñÅàÑΚµxÿÝ–ý”ćý¨æRVÏ“â×zôÇ°Á8KŠ_óƒFºÓ0æ0m­‡s.‚µL ƒ«ÞˆIl['6i ÑÑ qJì€UÄå| êO‚Ýsû‚Ø2L)Œ ´Üð!H³$¸;ð¢„ËëîÙ¥q+y!©¬„b»/¿LøLŒdûfÒÑ fšÿØs˜^}¼2ƒ"Á;7ËB¼ï¢.Åõê­Bn@A5äeºg¶j¬æ™“”µ;餥’–j ˜DÅØÂyÏ’óGgèÁ¸Ç'è»èÎxH®–ãÜ*ô<‡ÒqR(Q² Çm¶¤ŸÂøÎ/àì’ɋɨCEœaã^œxôOEóîÖho`ú÷äeBÜwHÝ Ùƒ@Ç)휓a¶Õ™$G×!jîKy@àiˆ"Û|ЉÕa­ a’¹êÞûÓàÈðÚÜYY¾@[éÉz¢gŽ. ûôëÏ/3v»ƒ%ŒwZšëÜÿQÄ %/tyéΩՙQUSI€ S£H ;]Ü"d”‡.y¹uÄ¡ðÊÙH$$jG+°syý¥àeðt$PÆWk©tJòS9›‹µ”'7 q¦hrwrIžGäìêO/Ãl-œ=N.O¹w‡¤2q­çN•±|žÛõ*Œ0NǵEi¬sµG×ú˜’4út/u G·_‰djÄÒBÝqtl¶Î(Ž«Aˤ)E5Ç$;~H%#l’ÖÓ‰ãG¤ ñ\ú÷¸J ¼I4%¿¦ÖÁãê?Ì1¶dÁt ¶ âÀT'RÉuZ@%÷[¨vÑ&ÔYD¨mæVËÔxë+š}T’TCaš£R€YÌQab;ºMݶ: hs5hS¨´˜ aW\Õ~FB¹ôa™ ¸8öÀî4©x(ĦÄ.©aHIÆ È¦­n:1†6³:Æà~ÚÄ;ÁØ¡Ó0X¢¡‚1ˆ'ñc -Ôm›Úº…Ü6Œ¡ÍÑ m2Æ— À¡7‘\ŽÅåXŠ4OÖ§ ŒM¯ÓTÔ NEŒU<¨äo¦ê”Ú®Ž¸‰n‹¨ ©å …¥õ¹@>©g+ãûc½Ë†Z #ìòª 1²]›› ÚfŽ¡Ñá¶Âz9ˆ;<­³á¬u*ÇÖ$„ÑÀˆ!˜µ¸[È ‘éyĘòÄL˪ Ÿy+àç’îeBnØ„ §¼.ƒÕ µ{+–dÀóç”Ägüšmf_j,Œì]™±<û;•‰hÅ®5ÿzswžEÍpq[ç+ÞíôÉêr¸Ê.+â¦ñYÑ¡K8 Yä;/oGnèxž§dµMU®išAö”"0Ò˹yÜŸ›‡I«-¥rš:5å;†‹G×6Š³è°{ƒúm û¸r1¤u\Q yM]ç:"ºG@97o;Ô uìºHÇ ‹m³¹ëB€²8¥f§ZyK¦\:Œûk‡ÿ„ ñî mˆ'ÝÎŽ#$—úãþ5b¯mƒ]cIÖëš,l Ñ ñ”Sä‡ÏipùÕFrvyZJ®kÅ*u­Ž£²v-&K( Ú>©ÏÁîúÙ l'Ý Ø2TrB«Ôk"ëšw,ÎáPÙ†MGlT;?]p3›õon)Uéhþå.pÅBU½ÕþŒæ°úÎŒ,pð<§už&áõ¸w-ÀVªwY^õÔéßáËXasX‰,ÒÀu6ÝÖõ2ˆà\…µ²?ÛJWÏakÓK˜yÇJ›(rly¦ °ENkl¬AƒBX¼:¤Y¼+Þßj=»ËZ¨´ $»-¨ßmq b¶’àJË‘ÍPSZŽ,3ÂÀJ¸îýhÅ3ïX–<·¦dÌòoIÀöõ—ÉêGí}Nç'ßü±¼]zŒvü×Ôþ[ûûⳫ*ÒÝ•1Ò²ë£PÝs5mÅò-õT:)¨N¾]è]$q"|9®þÚ›Ø\}/Nnœ•IÝ^Ĥ\ôF @n‰ž‚i,: æ„ .oñþ~ŠKµÿüvwÈ´u¬Eq¦ÝûLËâo´CÊ4? µUٱݧP|[ÂüÕ½2íîYÛÅA´ÕûG?éØ7§øØï€>²‹²T "mHöüñÌPŸ¿ŸM{P^>ßçŸ~Lµùù@²û8­^êGkhfüåëiÁë*êóÈ/Ï¿š"¾zÒ˾|þp£}ñaBùFû¼´Ößh—¨à~Mû†n)º(®°£@ܤ;ȵu‚ì¶õhsx^kòòÀwm4O(O;®$6OuÀ€¹Ýéý CX%oX:@±ÇS²iÃ|¼"`Uvæž”ò½ºØ y9x+²×]’Ë~Ü›«“º:±ZëÜ ~¨”¹Í&»ýYïF-?±»Ls`Ϋ”rsÞºå‘v¿ÝâB=¡lK-ÍX¯züœvà$`ì™b^~“)‡,þ Óm¼{‘ɉtZŽ8Ç!’å¬Æ=RúÈÀ*éÃ(ͺB‡èØ´ZW®‰Ca³¦Ð âÛÐîjÈ资¡Ú­¼¢ea¡…«ÃDÕ–O‚6Oƒ¶É9¥Ë7¤rÊËI LqÅþ8AÕõ0Šç¼ Lˆ«£®‚Chõ4t‚Ã3ûUì°_E6$8?”Õt.¶_…¨Tj÷«„:xàš­+ßÐ.¬ù’‹ß€X’íŽ(Á2º·­…S®*@\šÁ‡%ighxM6¢¿v褑_qϺXCM„Bü%AðåÚ­6B/hQA·/g×]#/åìjëvòóLʈ%ÓX°ÄÒî£ü4"Õ…‰o0?:W¨ÀÑjTÌÊ¡ÂÀ‚Yò³ˆ•¼`Ö5ClQª[µc˜' í|0&}A Š³ê ¦"’ë=®üôü[ ÙýawùAØÆÚ0 ×°q3b0ÁS³Fu¥"Hp+Šo@!ü%¨ýC ¼Ïb)Fg¾óÐmŽGAŽæªHÇñ䞧| Ò!=–·µÑŸóãôÓ¡¿b÷q¸æ„´}àayð,›,®zp|ND eÿm*¿tóï‰<ipÇ¿ÁXdáù‹Z?î±”¾ÿQýZÇ«O×ê }üûþÿPK0k> ÑPKKˆR settings.xmlÝZmsÚ8þ~¿¢ÃÜÍôæ&Å— L“Žy1Ð^ÍKü¥#,jdÉ'ÉòëO2$M‰ISwn.ØÒóì®V»«µ?~Z{äÝ q½Ê>¹wˆº bº¸Êlëä2÷éú·l>Ç.*Cæ¢òD )ÕñNM§¢¼½Í»Ê-¥ôËù<óÝ^ýÀø"_4ŒR~û;·›(ö®r§ee <$ÊÒ-ë©DåocT"–# ·…‡É[ôØ—y¾B™ôÆçH¨ü[ážÏyŽå2:Ç‹·¢lG?Ÿ¿&˜Þ?Ù0 Ãáid¿B©TÊGw‡¾nì³=co½U°ÝjG‚í¾?s‘ÓÜõ£?<ºÁõÇ.Û,‘§}äÝî²&»Ê)‘Ë+ŒÂ'ïÉÅÍû~Î ½`&GÀf~îñ¦Üøê&¦2w}Z0Jó/q~ »æ2ü¤p~y™}‚¡\ÆÁŸF15|áÅ2Vü³Óâù›sâÿSˆÖîs¡0~±¢9Êqøæ-£°÷Ä’+OÈ]k¿($³DƒcØ;{ìÁÏ#ÐÜõÒà[œÑ}½%†ø6Ó,Â÷ÀݾÀTb‘,u*h]¥EBO;êÜÊdüø–ùFRSÇë¨æˆ§Ix‚ûŽãîW(r—"-zš¦Nu=“ÅAF£gPO:Œy]“e!³I]•&Ô‰°»B|NXØF ànÅ\|~ú>t{w  |{ëf{!àQ²ý™Žéûd3ˆ×€ÇÏÒ,•¢¶v¼Ñ } ¿ðûûWç-]ñœü™KÀQÞD©þ8­üþ>Pþ¹ /¤ 8ü Ø,™Tª6á@Up¼Ê<Ý.ÔÝ3[‰tÔb.*™3ÓÜM&T ˆef2Á„2¡9ˆTb e|u”<ÄÖ½‚¦À€]Ž}i±WŽ¤)ÎØšF;Aëì‰^ÅN#ð¶ !¿ÀX]…#êr¸Ej1>Ã"ú´ïÓ7LÛêtÄœÿv›ѤA#ÐüPGÄe6àjì—z;Ô7ô*h©n&F¨Søêü´ ôGü  V`™Å¾E²•Ñ}FHÑd?¨­Èñ÷[H7» ¿LZ—Þ N£ÈÜ ¨+ƒWÛéú¹º•Waì^)“9A¸÷YôTžs¼ú¸#5‰*³é>mÑ9µÇe%½…eF†ÁnÇfH¥*­D&j"Ž“‡ÑÓ«Ð $yíH ­ÓÉê1SÄ`c‚²u$g"¿N³*Ûfï“ŠÅ ™ªû2Ð:rˆ@–\{ˆï#&…æ`Á¿ž—U–Š<¢‚å¾yÒ4ž#XÄ[ªLÒo’¨¨ 6/£×£Wž¨ã0#V3eÌî|diö¾t£WT>#ù¥ÇÙ—Ë¿ éôë_-j~^M§·öÓЉiÞšçߦ¶LË©ÏûYß4‡^ –q74×UZـɹáL[¥¡U™ÛEÇ“zccZ¨lf…˳ÎC=¬z%5n@5LJAo\Y¹t°¹›£êuVnƒ÷ÁXëï³Æz £’ãYÂ-ŽnfkãIà4¬à´cÌ4NÍÛ5SÜVÃp;§´qã6¥Û¯ý·ÙÎÔ!35NÉxïxõÙÑø¢–µg›7#«RïKJ¾ñY¤[ßïßM É…cû·ÊNZGs89át`«ùF—ŒC·1Þ˜õAÁm¬ ªùu8­(ÞewVf“ÏÂQöª/*5Û(ôûãÁ|`ûv}|75 ½A}4zš[/¬œÆè¢{¿^Í**çKã°÷z²= G»´£è%t4Üá¼ãRf!‰KcJ©C¾Ä:¡Ãð{E©‹ŽŒJƒÊ™Hk©c?«FC 5 ÓðšÒJÇè ´Ç(y)»ÛûZÅ°¼ û”}ì o}3jS-^eå`ѽæFî’írªØÁ¹Œ¸ ô”ñ©lt#.\hF[`Š •I…‰ÂŒLpŒµ‡&· ŠŽš*G‘$Ÿ3dc’âÏ€)™P`­©#|ŸèRC<‡ãp]†#º9wÜúă„ C.(v.AéÀ cÂG·üs&íGL"ŽmW%;Eu…`úÏ?ù-k í1/Çöû߃îäT©ÂO+‡>íZï<ùdïÞÍeúÍÚêS¦Ö4\èfÁØ ÂÑI¶À»åHÈ´ûJ˜Ú£°æûU7œØÑžî´lž ZøŸWŠž¹=÷ Ö<Õß­”=ÃBm †§B5 çƒ;£ŒµJ´w'@uç¿ÆíËqÔõm½£¦3eÕí6˜TñÓ£°>XST=¿ ½ ÃjYã(ôojtS2< ºsa°twzLT_Öµ oþ]Õ ÒÝ9XÜ'ÕbüèÀÐV®[LwÛ'Br*#®¤‚?åe‹­S7¿*v1u\G¹”J Æú)U±ÀaÓH¹Mâx»m°¸Oª8"DÄ"Š"%#”ó ¦ƒ‹°Cy)%Ú‚l»`q¿jqÁ^î2SDEßY+J/á²­ýð‡Cjà—ß7‘2©e?BõãðËFØámíl#Ð .݃PÆ\­ßãî»ÞÖqˆp˜C :•õ/£ i—i‘Ž„¶SêÅ!¨’#~ìm—W{†?÷™înãWœªùDÄâíÓð@TËö§»Paƒ÷.A.v‹¦6|ˆ*XÞY§¥ÄŒ ÇÅŒ0Î üÝðñ@-pô’M‚’×+—¾ƒÜ‡È¼kÈTðÍ'~ÊÕŒÒuaŤDjžzG@en‹û6×\ÒugŒ|ù\Ûì—j˜ ŠS£Ûn7¬ £å»mª`ó·; >|ìýS¸½ðæH¨&9¬pQïÛzâI÷PT½Ußû”9”®ŸB™†«3MÑJËŽ”µ'ª©l©`Sí—*ÿɽÇ×´/XuS=?]ªIŒ Æ1DOLÒ’2 ˆÊÌSóaP\J)cÚsT¤’ÒŽ»J)!éHíys°8°°äÛ*syü6É›PÄ5µb¿TEŸ<ñ?nRäpåì‘a.ÜLEUÐôCha£Í_s/Sýü¥®©öIæÄ L×]…Hg”’Ç°bÛn‡*Èê@ðR›ìV*æùËP$¬Ÿ<ï*å&WõÁ¯6°ÏSÝŽFµ4Õ¤`üé—ªq¤á ë×9öGå¿èC‘~W¶¸ŸŸ‹Ü{:ÕÓ]Rè/ikÃÛm¿ž:¦Ú•ç¯s*ÕNO’„mJoÚ¥ênh&Aq˜;ïùÅåÒuLU“Š'%GB1³ucDvOe¥Ž±£â©Àvx×6•ã"·Ó!¹´#;ÄÅŠ0Zr Ò¤âw>«Ý«jRiɉË¥ðQ—(¤äezR%ï»ïÿË¿2QG¯m*Ûú^k`‡£®6Ûé71ÿñoÿU#ܯZtõ¹B¤XÊ=»÷¼~ÒöÆÛ5±ß7Õäõ]…^]:=÷—Dú³z½joTO½Àô6'áS¿€è>­×öÉûš¦Ú•oc‹xsû-E>¶D+¯÷Çö¯W¯Wí‹Ê •=c°H¶Æžç=ä_Ï)„Ê_ÖKn7¶˜îÓ ˜hÙþ¬bŒëAí‡*)Ïài}÷~ð¼?ü_é«Þ²‡yµ´bOT~*–&7¢¤Û”&[/\P…ÓR-„jY² {ÅDÏ’­Ùkwê×k€{¡òWŽaäìs&µè®ëTæEÛw?éâÝÞL•*¯N–SóŸèþ9_‡(’Êþ8ÝÃêôª½P-?ü1•aüƒ]Ÿl3®ËRõF¤zD Röç?”•ˆÛuV8ÆuLµ*Åe.ìÓÚ@#—ly+ßgJÕ¡oŒu°/ÙÑÚ@c%ÙzXuË^SÕ§Z6»ÙÀûùσ¬(¬ 4zÅ¢¾ÔŽÇÇCS-ìªYh¤gÓ^çÓ“ß™RÏË¡Ðkþ2ªÒ!ïÇùúóÁ¨Àý>펊Æ{›“­ñ}²wªÄÁβ…½‚)ÚÃò°g9ðº ë><7@eÃœu¿üéôÎû½7ßæO{ÿ¹¼36ù@£,Ùòf…­Ók€ªÚ{†“AÌ´©òaa;²5x(ÂGµªß2Ñi>y%ÂÚUßpÂu¤URñÖB­4ƒ¿±NΡôïÓ8Ž•‰u²Z©‹’mr‰„¥­v`'ìRûŸ KºW×ež}üЄ­q;(N*±‘]Vat‰ÝK†:€!1²‹%bŒ;óJ?V.ÇL]—¼RÙ%r1v\Œ‹;¬àsþö¿¥žÝk‚JRn×HNÆb®8a”Q%å,1 #<â‚H:; Ô‰€Àµ—Jx¡’T0N ¶3YQýý¹?ük™'óšhu¶YÕ~u]4²µHì©®KË/ÏEÉ–_û›mƒjöë’Ý¢¾-¾$öÞÞ©Öú`ï§õ/{ÏU¾¢¥¨¯$[¾iŒjÃöëÙ6{{f}ù%“l½Ö`v×ö©[íÝß@•Ùz5ܬß2ÕvŸWh«çô{¼žá—®Áx-Syõ÷¾.îLé>¶³¶·BÕ/õ|²•™\±sf/öþÜd“Šå™tª6î/·ÿùS?µýÔ/ÞšÊDòך\ôíÛaµB†Ÿy~fæ¿O}¹ ¿³ôƒÔ¯×X~•Ãò ù{f‘?ád])* ¨2gM¤ž¯5G•ë[}CH#׌™½<ıar˜djM¿¤Wõí5ÚæŽÖú T«Xžá›bÉ gD&³ƒ¸¤±á;”’>š¬÷öìE;0cv€Âe”bK†d©‘Œe?ðX®´àv¡Î~“þÕ¶µ.¯DáyNpì8wP’™*„"Ç%¿»60‰íÕJì•ÝµU¶ÎPE†_vYY¹¢ð¿r&8ç‘`D {önL%çö"Ô S™iúœªûÕ¹2×__æÌx‹›_µmhÔ,ÕúÓѯK½ðêÊGFµv%Ÿ¯jXq½°gv{µsú½óß SͳÈâm<¨’Ø—oãÿÚrÄ”Ï"· ªx‚‹·-Ô>k·¥Xeó *®\ñuûñƒ}V¤Ë–“*³U%S=ÝáHö»~àÝ6T•V®´9~U5‹\”Îv6Õ}«cøÕ°."GÆA¤ˆE…Ä~U'æ¨ÌM:‚¸;ã âÁÑæÄ>kâ¯3sT&H *!™b6pOîèíL5¾Þù ö?*çW;#ûfÓ9ö5Nh`¬±ÖÆÕCKk¢Ê/ŠðC^î6-‡p]çT¹fÆ…Wsþ»ßæ»ßz×{=3GG5½Úѯ7ÕÀ«yÍŒáçÖòYƒ\oãTù,2L­]©sW×Û•-±Ò#qûu½ 2£›Uª}»ÞCP-Ó­§aS®÷ T ¬Ñ¢,3蛳 šE.Æâp½¢J’ãI¢ÞØœ •3h©Ô‰CPA9í6åzGeÂa÷¡oÎÊ¿˜3£²éâÌœÑ\ðó¢Â¢—ÈAçE¥ ÃÂág§‹ÞufT“Og§6üá©LøFu TñòO|FT:9ÿ—Á?zFTØÅŒ¸ØÄž s.TQ¬")‰¤ç¦ñ¹©Eâ…?¾yá“iÁYRglñt^TŠ©äV˜èŒ¨"p¾ˆ0J‡÷|l…8·§§"ÄŠ®#|â¹ð9ªE÷©†ÎÒVo¹ðÕa©¦gG+¿*>/*‰1u ¡çE¥¥âT(y~ýêù`ýôum7ó ¹&æ÷ÕàÅ~±LÙhY‘;ã˜ç~0Ü"ŽH€‡'Ú‘˜ÞJâ“MLÒ,Ã9º@äœÑš8ÝB£„Æ8Lï2‚³(%9ZdSUà ðN»\Å·¡ÞCœ>Å›ïs™3É{’½±L‘Ü~ÏñI\„Vºx Ï®{tâ0 £›G!»ãþgºÙoo%Ø·ZýfÆ7_:Qó š‹üË7å?m«7ÍXÁ<W‡‘«“vëg©Š½ó]Ú÷â/PKÛv\Ã-PKKˆRMETA-INF/manifest.xml­“MjÃ0…÷9…ÑÞR6EÄɢФPí‘#FB?Á¾}%Ç.%Cv3Ìè½OiŒ®.àƒ²ØWúB*ÀÖv û†|Ÿ¾êr<ìöF ’"Ÿ‹*ŸÃpk’øtNæ…ÒŹ¤û;&ʈX™or1Ńè{öï;~PKµºâ&ÉPKKˆR3&¬¨//mimetypePKKˆRUConfigurations2/toolbar/PKKˆR‹Configurations2/floater/PKKˆRÁConfigurations2/menubar/PKKˆR÷Configurations2/popupmenu/PKKˆR/Configurations2/toolpanel/PKKˆRgConfigurations2/progressbar/PKKˆR¡Configurations2/statusbar/PKKˆRÙConfigurations2/images/Bitmaps/PKKˆRConfigurations2/accelerator/PKKˆR .§/zÎ Pstyles.xmlPKKˆR0k> Ñ ·content.xmlPKKˆRôKI[÷ô) ô*settings.xmlPKKˆRc½;ÜÜ%2Thumbnails/thumbnail.pngPKKˆRÛv\Ã-7Fmeta.xmlPKKˆRµºâ&É0HMETA-INF/manifest.xmlPK+™Isimrisc-14.05.00/icmake/0000755000175000017500000000000014034554241013631 5ustar frankfranksimrisc-14.05.00/icmake/pspdf0000644000175000017500000000063414034554241014673 0ustar frankfrankvoid pspdf(string basename) { string pdfname; string psname; string papersizeoption = "a4"; psname = basename + ".ps"; if (basename + ".dvi" younger psname) system("dvips -t " + papersizeoption + " -o" + psname + " " + basename); pdfname = basename + ".pdf"; system("ps2pdf -sPAPERSIZE=" + papersizeoption + " " + psname + " " + pdfname); chdir(g_cwd); } simrisc-14.05.00/icmake/setopt0000644000175000017500000000034114034554241015070 0ustar frankfrankstring setOpt(string install_im, string envvar) { list optvar; string ret; optvar = getenv(envvar); if (optvar[0] == "1") ret = optvar[1]; else ret = install_im; return ret; } simrisc-14.05.00/icmake/installer0000755000175000017500000000050714034554241015556 0ustar frankfrank#!/bin/bash if [ $# -eq 0 ] ; then echo destination path, ending in /, must be provided exit 0 fi for src in `find -mindepth 1 -type d` # create missing target dirs do [ ! -e $1$src ] && mkdir -p $1$src done for file in `find -type f -or -type l` do cp -d --preserve=timestamps $file $1$file done simrisc-14.05.00/icmake/manpage0000644000175000017500000000070414034554241015165 0ustar frankfrankvoid _manpage(string dest, string manpage, string source) { run("yodl2man -o " + dest + manpage + " " + source); run("yodl2html " "-o ../../tmp/manhtml/" + manpage + ".html " + source); } void manpage() { md("tmp/man tmp/manhtml"); chdir("documentation/man"); _manpage("../../tmp/man/", PROGRAM ".1", PROGRAM ".yo"); _manpage("../../tmp/man/", PROGRAM "params.7", PROGRAM "params.yo"); exit(0); } simrisc-14.05.00/icmake/findall0000644000175000017500000000107414034554241015167 0ustar frankfrank// assuming we're in g_cwd, all entries of type 'type' matching source/pattern // are returned w/o final \n list findAll(string type, string source, string pattern) { string cmd; list entries; list ret; int idx; chdir(source); cmd = "find ./ -mindepth 1 -maxdepth 1 -type " + type; if (pattern != "") pattern = "-name '" + pattern + "'"; entries = backtick(cmd + " " + pattern + " -printf \"%f\\n\""); for (idx = listlen(entries); idx--; ) ret += (list)cutEoln(entries[idx]); chdir(g_cwd); return ret; } simrisc-14.05.00/icmake/log0000755000175000017500000000063214034554241014341 0ustar frankfrank#!/bin/bash find tmp/install -type f -exec md5sum "{}" \; | sed 's|tmp/install|'$1'|' > $2 find tmp/install -type l -exec printf "link %s\n" "{}" \; | sed 's|tmp/install|'$1'|' >> $2 find tmp/install -type d -exec printf "dir %s\n" "{}" \; | sed 's|tmp/install|'$1'|' >> $2 simrisc-14.05.00/icmake/pathfile0000644000175000017500000000055214034554241015352 0ustar frankfranklist path_file(string path) { list ret; int len; int idx; for (len = strlen(path), idx = len; idx--; ) { if (path[idx] == "/") { ret = (list)substr(path, 0, idx) + (list)substr(path, idx + 1, len); return ret; } } ret = (list)"" + (list)path; return ret; } simrisc-14.05.00/icmake/clean0000644000175000017500000000043614034554241014641 0ustar frankfrankvoid clean(int dist) { run("rm -rf " "build-stamp configure-stamp " "options/SKEL " "tmp/*.o tmp/*-stamp " + "o */o release.yo tmp/lib*.a " ); if (dist) run("rm -rf tmp *.ih.gch */*.ih.gch"); exit(0); } simrisc-14.05.00/icmake/uninstall0000644000175000017500000000045614034554241015572 0ustar frankfrankvoid uninstall(string logfile) { int idx; list entry; string dir; list line; if (!exists(logfile)) { printf("installation log file " + logfile + " not found\n"); exit(0); } run("icmake/remove " + logfile + " " + (string)g_echo); exit(0); } simrisc-14.05.00/icmake/cuteoln0000644000175000017500000000023314034554241015223 0ustar frankfrankstring cutEoln(string text) { int len; len = strlen(text) - 1; if (text[len] == "\n") text = substr(text, 0, len); return text; } simrisc-14.05.00/icmake/run0000644000175000017500000000033014034554241014354 0ustar frankfrankint g_dryrun = setOpt("", "DRYRUN") != ""; void runP(int testValue, string cmd) { if (g_dryrun) printf(cmd, "\n"); else system(testValue, cmd); } void run(string cmd) { runP(0, cmd); } simrisc-14.05.00/icmake/md0000644000175000017500000000074014034554241014155 0ustar frankfrank// md: target should be a series of blank-delimited directories to be created // If an element is a whildcard, the directory will always be created, // using mkdir -p. // // uses: run() void md(string target) { int idx; list paths; string dir; if (!exists(target)) run("mkdir -p " + target); else if (((int)stat(target)[0] & S_IFDIR) == 0) { printf(target + " exists, but is not a directory\n"); exit(1); } } simrisc-14.05.00/icmake/gitlab0000644000175000017500000000025614034554241015021 0ustar frankfrankvoid gitlab() { run("cp -r tmp/manhtml/*.html ../../wip/manhtml/"); run("cp changelog ../../wip/changelog.txt"); run("cp release.yo ../../wip/"); exit(0); } simrisc-14.05.00/icmake/remove0000755000175000017500000000117014034554241015053 0ustar frankfrank#!/bin/bash g_echo=$2 rm_f() { [ $g_echo -ne 0 ] && echo rm $1 rm -f $1 } rm_dir() { [ $g_echo -ne 0 ] && echo rmdir $1 rmdir --ignore-fail-on-non-empty -p $1 } IFS=" " for line in `cat $1` do field1=`echo $line | awk '{printf $1}'` field2=`echo $line | awk '{printf $2}'` if [ $field1 == "link" ] ; then rm_f $field2 elif [ $field1 == "dir" ] ; then rm_dir $field2 elif [ -e "$field2" ] ; then if [ "$field1" != "`md5sum $field2 | awk '{printf $1}'`" ] ; then echo $field2 changed, not removed else rm_f $field2 fi fi done rm_f $1 simrisc-14.05.00/icmake/backtick0000644000175000017500000000016014034554241015324 0ustar frankfranklist backtick(string arg) { list ret; echo(OFF); ret = `arg`; echo(g_echo); return ret; } simrisc-14.05.00/icmake/manual0000644000175000017500000000067214034554241015036 0ustar frankfrankvoid manual() { list files; string file; string cwd; int idx; cwd = chdir("."); md("tmp/manual"); chdir("documentation"); run("cp -r manual/html ../tmp/manual"); chdir("manual"); run("yodl2html -l3 " PROGRAM ".yo"); run("mv *.html ../../tmp/manual/html"); run("cp simrisc.css ../../tmp/manual/html"); // run("cp -r images/*.jpg ../../tmp/manual/images"); exit(0); } simrisc-14.05.00/icmake/latexdoc0000644000175000017500000000127114034554241015360 0ustar frankfrankvoid latexdoc() { string basename; string latexname; string yodldefine; md("tmp/latex"); // cp necessary files for LaTeX if (!exists("tmp/latex/cplusplus.sty")) system("cp -r documentation/manual/latex tmp"); // assign file name variables basename = "simrisc"; latexname = basename + ".latex"; chdir("documentation/manual"); system("yodl2latex --no-warnings -l3 " "-o ../../tmp/latex/simrisc.latex simrisc.yo"); chdir("../../tmp/latex"); system("latex " + latexname); system("latex " + latexname); system("latex " + latexname); } simrisc-14.05.00/icmake/install0000644000175000017500000000444014034554241015224 0ustar frankfrank void install(string request, string dest) { string target; int components = 0; list pathsplit; string localInstall = "tmp/install/"; // this is the LOCAL tmp/install dir md(localInstall); if (request == "x") components = 63; else { if (strfind(request, "b") != -1) components |= 2; if (strfind(request, "d") != -1) components |= 4; if (strfind(request, "m") != -1) components |= 8; } if (components & 2) { target = localInstall + BINARY; pathsplit = path_file(target); printf(" installing the executable `", target, "'\n"); logFile("tmp/bin", "binary", pathsplit[0], pathsplit[1]); } if (components & (4 | 8)) { target = localInstall + DOC "/"; if (components & 4) { printf(" installing the changelog at `", target, "\n"); logZip("", "changelog", target); printf(" installing stdconfig/simrisc at `", target, "\n"); logZip("stdconfig", "simrisc", target); printf(" installing the pdf-manual at `", target, "\n"); logInstall("tmp/pdf", "simrisc.pdf", target); printf(" installing the html-manual at `", target, "\n"); logInstall("tmp/manual/html", "", target + "manual"); logInstall("tmp/manual/html/analysis", "", target + "manual/analysis"); } if (components & 8) { printf(" installing the html man pages at `", target, "\n"); logInstall("tmp/manhtml", "", target); } } if (components & 8) { target = localInstall + MAN; printf(" installing the man pages below `", target, "'\n"); logZip("tmp/man", "simrisc.1", target + "/man1/"); logZip("tmp/man", "simriscparams.7", target + "/man7/"); } chdir(g_cwd); if (dest == "") dest = "/"; else md(dest); dest = cutEoln(backtick("readlink -f " + dest)[0]); if (g_logPath != "") backtick("icmake/log " + dest + " " + g_logPath); chdir(localInstall); run("../../icmake/installer " + dest + "/"); printf("\n Installation completed\n"); exit(0); } simrisc-14.05.00/icmake/logfile0000644000175000017500000000025714034554241015201 0ustar frankfrankvoid logFile(string srcdir, string src, string destdir, string dest) { chdir(g_cwd); md(destdir); run("cp " + srcdir + "/" + src + " " + destdir + "/" + dest); } simrisc-14.05.00/icmake/loginstall0000644000175000017500000000130014034554241015716 0ustar frankfrank// source and dest, absolute or reachable from g_cwd, should exist. // files and links in source matching dest (if empty: all) are copied to dest // and are logged in g_log // Before they are logged, dest is created void logInstall(string src, string pattern, string dest) { list entries; int idx; chdir(g_cwd); md(dest); src += "/"; dest += "/"; if (listlen(makelist(O_DIR, src)) == 0) { printf("Warning: ", src, " not found: can't install ", src, pattern, " at ", dest, "\n"); return; } entries = findAll("f", src, pattern); for (idx = listlen(entries); idx--; ) run("cp " + src + entries[idx] + " " + dest); } simrisc-14.05.00/icmake/pdf0000644000175000017500000000034214034554241014324 0ustar frankfrankvoid pdf() { md("tmp/pdf"); latexdoc(); // now in tmp/latex system("dvips simrisc"); system("ps2pdf simrisc.ps ../pdf/simrisc.pdf"); printf("the log files are in tmp/latex\n"); exit(0); } simrisc-14.05.00/icmake/special0000644000175000017500000000072314034554241015176 0ustar frankfrankvoid special() { if (! exists("release.yo") || "VERSION" newer "release.yo") { system("touch version.cc"); // using FORTIFY is weird, but Nilesh // Patra noticed some complaints when // omitted. run("gcc -D_FORTIFY_SOURCE=2 -E VERSION.h | grep -v '#' | " "sed 's/\\\"//g' > release.yo"); } } simrisc-14.05.00/icmake/logzip0000644000175000017500000000165614034554241015070 0ustar frankfrank// names may be a series of files in src, not a wildcard. // if it's empty then all files in src are used. // the files are gzipped and logged in dest. // src and dest do not have to end in / void logZip(string src, string names, string dest) { list files; int idx; string file; chdir(g_cwd); md(dest); dest += "/"; if (src != "") { if (listlen(makelist(O_DIR, src)) == 0) { printf("Warning: ", src, " not found: can't install ", src, names, " at ", dest, "\n"); return; } chdir(src); } if (names == "") files = makelist("*"); else files = strtok(names, " "); for (idx = listlen(files); idx--; ) { file = files[idx]; run("gzip -n -9 < " + file + " > " + file + ".gz"); } run("tar cf - *.gz | (cd " + g_cwd + "; cd " + dest + "; tar xf -)"); run("rm *.gz"); } simrisc-14.05.00/icmconf0000644000175000017500000000112014034554241013733 0ustar frankfrank#define PRECOMP "-x c++-header" #include "INSTALL.im" // #undef CXXFLAGS // #define CXXFLAGS "-Wall -O2 -pthread" #define MAIN "main.cc" #define ADD_LIBRARIES "bobcat" #define ADD_LIBRARY_PATHS "" #define REFRESH #define LIBRARY "modules" #define IH ".ih" #define SHAREDREQ "" #define USE_ALL "a" #define SOURCES "*.cc" #define USE_ECHO ON #define TMP_DIR "tmp" #define OBJ_EXT ".o" #define USE_VERSION #define DEFCOM "program" simrisc-14.05.00/icmconf.lib0000644000175000017500000000073414034554241014512 0ustar frankfrank#define PRECOMP "-x c++-header" #define CLS #define SOURCES "*.cc" #define OBJ_EXT ".o" #define TMP_DIR "tmp" #define USE_ECHO ON #define IH ".ih" #define CXX "g++" #define CXXFLAGS " --std=c++2a -Wall -O2 " \ " -fdiagnostics-color=never " #define ADD_LIBRARIES "bobcat" #define ADD_LIBRARY_PATHS "" #define DEFCOM "library" simrisc-14.05.00/incidence/0000755000175000017500000000000014051665273014330 5ustar frankfranksimrisc-14.05.00/incidence/sumprobs.cc0000644000175000017500000000036414034554241016505 0ustar frankfrank//#define XERR #include "incidence.ih" double Incidence::sumProbs() { double sumProb = 0; for (Params const ¶ms: d_params) { sumProb += params.prob(); d_cumProb.push_back(sumProb); } return sumProb; } simrisc-14.05.00/incidence/lifetimerisk.cc0000644000175000017500000000026414034554241017321 0ustar frankfrank#define XERR #include "incidence.ih" //static bool Incidence::lifetimeRisk(StringVect &base, VSD &vsd) { base.back() = "lifetimeRisk:"; return Parser::one(base, vsd ); } simrisc-14.05.00/incidence/paramsvary.cc0000644000175000017500000000047614034554241017024 0ustar frankfrank//#define XERR #include "incidence.ih" void Incidence::Params::vary(ostream &out) { for (auto &vsd: d_vsd) vsd.vary(); out << " " << s_carrier[d_idx] << "\n" " lifetimeRisk: "; d_vsd[0].showVary(out); out << " meanAge: "; d_vsd[1].showVary(out); } simrisc-14.05.00/incidence/vary.cc0000644000175000017500000000064214034554241015613 0ustar frankfrank//#define XERR #include "incidence.ih" void Incidence::vary(ostream &out) { out << " Incidence:\n"; for (Params ¶ms: d_params) { if (params.d_prob >= Globals::TOLERANCE) // if this carrier is used { params.vary(out); // vary the distribution's out.put('\n'); // value } } cptTumorRisk(); } simrisc-14.05.00/incidence/data.cc0000644000175000017500000000015314034554241015540 0ustar frankfrank//#define XERR #include "incidence.ih" StringVect Incidence::s_carrier{ "Normal:", "BRCA1:", "BRCA2:" }; simrisc-14.05.00/incidence/incidence.h0000644000175000017500000000674514034554241016427 0ustar frankfrank#ifndef INCLUDED_INCIDENCE_ #define INCLUDED_INCIDENCE_ // Incidence: // Normal: // prob: 1 // # value spread distr. // lifetimeRisk: .226 .0053 Normal // meanAge: 72.9 .552 Normal // stdDev: 21.1 // // BRCA1: // prob: 0 // # value spread distr. // lifetimeRisk: .96 // meanAge: 53.9 // stdDev: 16.51 // // BRCA2: // prob: 0 // # value spread distr. // lifetimeRisk: .96 // meanAge: 53.9 // stdDev: 16.51 // as in the original sources: with 0 probabilities the specified values // are set to 0 #include #include #include "../vsd/vsd.h" struct Incidence { class Params { friend class Incidence; unsigned d_idx; double d_prob = 0; double d_stdDev = 0; VSD d_vsd[2] = { VSD{ VARY_PROB }, // lifetimeRisk VSD{ VARY_NONNEG } }; // meanAge public: Params(unsigned idx); void vary(std::ostream &out); double prob() const; VSD const &risk() const; // lifeTimeRisk VSD const &mean() const; double stdDev() const; }; private: std::vector d_params; DoubleVect d_cumProb; DoubleVect2 d_tumorRisk; static StringVect s_carrier; public: Incidence(); void vary(std::ostream &out); // vary d_vsd's values std::vector const ¶ms() const; uint16_t carrier() const; // randomly selected carrier // index DoubleVect2 const &tumorRisk() const; DoubleVect const &tumorRisk(size_t idx) const; void writeParameters(std::ostream &out) const; private: void setCarrier(size_t idx); // sets d_params bool carrierProb(StringVect const &base, Params ¶ms); static bool lifetimeRisk(StringVect &base, VSD &vsd); static bool meanAge(StringVect &base, VSD &vsd); static bool stdDev(StringVect &base, double &sd); double sumProbs(); void cptTumorRisk(); // assign values to d_tumorRisk 1 void cptTumorRisk(DoubleVect &ageValues, // 2 Params const ¶ms); static void writeCarrier(std::ostream &out, size_t idx, char type, double value); static bool valid(double sumProb); }; inline std::vector const &Incidence::params() const { return d_params; } inline Incidence::Params::Params(unsigned idx) : d_idx(idx) {} inline double Incidence::Params::prob() const { return d_prob; } inline VSD const &Incidence::Params::risk() const { return d_vsd[0]; } inline VSD const &Incidence::Params::mean() const { return d_vsd[1]; } inline double Incidence::Params::stdDev() const { return d_stdDev; } inline DoubleVect2 const &Incidence::tumorRisk() const { return d_tumorRisk; } inline DoubleVect const &Incidence::tumorRisk(size_t idx) const { return d_tumorRisk[idx]; } #endif simrisc-14.05.00/incidence/cpttumorrisk1.cc0000644000175000017500000000040314034554241017454 0ustar frankfrank//#define XERR #include "incidence.ih" void Incidence::cptTumorRisk() { auto iter = d_params.cbegin(); // access the incidence parameters for (auto &vect: d_tumorRisk) // resize for all ages cptTumorRisk(vect, *iter++); } simrisc-14.05.00/incidence/incidence.ih0000644000175000017500000000052014034554241016561 0ustar frankfrank#include "incidence.h" #include "../xerr/xerr.ih" #include "../globals/globals.h" #include "../parser/parser.h" #include "../random/random.h" using namespace std; // static inline bool Incidence::valid(double sumProb) { return 1 - Globals::TOLERANCE <= sumProb and sumProb <= 1 + Globals::TOLERANCE; } simrisc-14.05.00/incidence/incidence1.cc0000644000175000017500000000140614034554241016633 0ustar frankfrank#define XERR #include "incidence.ih" Incidence::Incidence() { for (size_t idx = 0; idx != s_carrier.size(); ++idx) setCarrier(idx); if (d_params.size() != s_carrier.size()) // some specs are unavailable return; if (not valid(sumProbs())) // probs must sum to 1 { Err::msg(Err::INCIDENCE_SUM_PROB) << endl; return; } // compute the tumor risks per category for END_AGE elements // room for the age-risks per d_tumorRisk.resize(d_params.size()); // carrier category for (auto &vect: d_tumorRisk) // resize for all ages vect.resize(END_AGE); cptTumorRisk(); // then set the tumor risks } simrisc-14.05.00/incidence/meanage.cc0000644000175000017500000000026514034554241016230 0ustar frankfrank//#define XERR #include "incidence.ih" // static bool Incidence::meanAge(StringVect &base, VSD &vsd) { base.back() = "meanAge:"; return Parser::one(base, vsd ); } simrisc-14.05.00/incidence/stddev.cc0000644000175000017500000000027414034554241016124 0ustar frankfrank//#define XERR #include "incidence.ih" // static bool Incidence::stdDev(StringVect &base, double &sd) { base.back() = "stdDev:"; return Parser::nonNegative(base, sd); } simrisc-14.05.00/incidence/carrier.cc0000644000175000017500000000052214034554241016256 0ustar frankfrank//#define XERR #include "incidence.ih" uint16_t Incidence::carrier() const { double value = Random::instance().uniform(); return find_if(d_cumProb.begin(), d_cumProb.end(), [&](double cumProb) { return value <= cumProb; } ) - d_cumProb.begin(); } simrisc-14.05.00/incidence/icmconf0000644000175000017500000000010014034554241015651 0ustar frankfrank#define LIBRARY "incidence" #include "../icmconf.lib" simrisc-14.05.00/incidence/writecarrier.cc0000644000175000017500000000041314034554241017330 0ustar frankfrank//#define XERR #include "incidence.ih" // static void Incidence::writeCarrier(ostream &out, size_t idx, char type, double value) { out << " " << type << "_carrier_" << idx << ":\t" << setw(8) << value << '\n'; } simrisc-14.05.00/incidence/writeparameters.cc0000644000175000017500000000173514034554241020054 0ustar frankfrank//#define XERR #include "incidence.ih" void Incidence::writeParameters(ostream &out) const { out << " Incidence:\n"; for (size_t idx = 0; idx != s_carrier.size(); ++idx) { auto ¶m = d_params[idx]; Globals::setPrecision(out, 1) << setw(6) << ' ' << s_carrier[idx] << '\n' << setw(8) << ' ' << "probability: " << param.prob() << ( Globals::isZero(param.prob()) ? " (carrier ignored)\n" : "\n" ); Globals::setPrecision(out, 2) << setw(8) << ' ' << "std. dev.: " << param.stdDev() << '\n'; VSD::fmt(2, 3, 0, 4); out << setw(8) << ' ' << "lifetimeRisk: " << param.risk() << '\n'; VSD::fmt(2, 1, 3, 3); out << setw(8) << ' ' << "mean age: " << param.mean() << '\n'; } } simrisc-14.05.00/incidence/carrierprob.cc0000644000175000017500000000114214034554241017140 0ustar frankfrank//#define XERR #include "incidence.ih" bool Incidence::carrierProb(StringVect const &base, Params ¶ms) { // read the 'probability:' value if (not Parser::proportion(base, params.d_prob)) return false; // not found -> done here if (Globals::isZero(params.d_prob)) // 0-prob carriers -> all { // VSD values are 0 d_params.push_back(params); return false; // false because params already pushed } return true; } simrisc-14.05.00/incidence/setcarrier.cc0000644000175000017500000000106114034554241016771 0ustar frankfrank//#define XERR #include "incidence.ih" void Incidence::setCarrier(size_t idx) { StringVect base{ "Tumor:", "Incidence:", s_carrier[idx], "probability:" }; Params params( idx ); bool ok = Parser::proportion(base, params.d_prob); base.back() = "stdDev:"; ok = Parser::positive(base, params.d_stdDev) and ok; base.back() = "lifetimeRisk:"; ok = Parser::one(base, params.d_vsd[0]) and ok; base.back() = "meanAge:"; ok = Parser::one(base, params.d_vsd[1]) and ok; if (ok) d_params.push_back(params); } simrisc-14.05.00/incidence/cpttumorrisk2.cc0000644000175000017500000000103714034554241017461 0ustar frankfrank//#define XERR #include "incidence.ih" // see calcTumorRisk in SimRisc.cpp void Incidence::cptTumorRisk(DoubleVect &ageValues, Params const ¶ms) { size_t age = 0; double mean = params.mean().value(); double factor1 = params.risk().value() / (params.stdDev() * Globals::s_sqrt2PI); for (double &value: ageValues) // compute the risks per age value { double factor2 = (age++ - mean) / params.stdDev(); value = factor1 * exp(-(factor2 * factor2 / 2)); } } simrisc-14.05.00/incidence/frame0000644000175000017500000000007014034554241015333 0ustar frankfrank//#define XERR #include "incidence.ih" Incidence:: { } simrisc-14.05.00/INSTALL0000644000175000017500000001023014034554241013425 0ustar frankfrankSee also the KICKSTART chapter in the manual: doc/manual/index.html, click the kickstart chapter. =========================================================================== To install simrisc by hand instead of using a binary distribution perform the following steps: 0. simrisc and its construction depends, in addition to the normally standard available system software on specific software and versions which is documented in the file `required'. (If you compile the bobcat library yourself, note that simrisc does not use the SSL, Milter and Xpointer classes; they may --as far as simrisc is concerned-- be left out of the library by running './build light') 1. It is expected you use icmake for the package construction. For this a top-level script (build) and support scripts in the ./icmake/ directory are available. By default, the 'build' script echoes the commands it executes to the standard output stream. By specifying the option -q (e.g., ./build -q ...) this is prevented, significantly reducing the output generated by 'build'. 2. Inspect the values of the variables in the file INSTALL.im Modify these when necessary. 3. Run ./build program [strip] to compile simrisc. The argument `strip' is optional and strips symbolic information from the final executable. 4. If you installed Yodl then you can create the documentation: ./build man builds the man-page, and ./build manual builds the manual. 5. Before installing the components of simrisc, consider defining the environment variable SIMRISC, defining its value as the (preferably absolute) filename of a file on which installed files and directories are logged. Defining the SIMRISC environment variable as ~/.simrisc usually works well. 6. Run (probably as root) ./build install 'what' 'base' to install. Here, 'what' specifies what you want to install. Specify: x, to install all components, or specify a combination of: a (additional documentation), b (binary program), d (standard documentation), m (man-pages) u (user guide) E.g., use ./build install bm 'base' if you only want to be able to run simrisc, and want its man-page to be installed below 'base'. ./build install's last argument 'base' is optional: the base directory below which the requested files are installed. This base directory is prepended to the paths #defined in the INSTALL.im file. If 'base' is not specified, then INSTALL.im's #defined paths are used as-is. When requesting non-existing elements (e.g., './build install x' was requested, but the man-pages weren't constructed) then these non-existing elements are silently ignored by the installation process. If the environment variable SIMRISC was defined when issuing the `./build install ...' command then a log of all installed files is written to the file indicated by the SIMRISC environment variable (see also the next item). Defining the SIMRISC environment variable as ~./simrisc usually works well. 7. Uninstalling previously installed components of simrisc is easy if the environment variable SIMRISC was defined before issuing the `./build install ...' command. In that case, run the command ./build uninstall logfile where 'logfile' is the file that was written by ./build install. Modified files and non-empty directories are not removed, but the logfile itself is removed following the uninstallation. 8. Following the installation nothing in the directory tree which contains this file (i.e., INSTALL) is required for the proper functioning of simrisc, so consider removing it. If you only want to remove left-over files from the build-process, just run ./build distclean simrisc-14.05.00/INSTALL.im0000644000175000017500000000263414034554241014042 0ustar frankfrank // Specify the name of the project: #define PROGRAM "simrisc" // Compiler to use: #define CXX "g++" // The compiler options to use: #define CXXFLAGS "--std=c++2a -Wall -O2 -fdiagnostics-color=never" // #define CXXFLAGS "--std=c++2a -Wall -O2 -pthread -fdiagnostics-color=never" // Flags passed to the linker: //#define LDFLAGS "-lpthread" #define LDFLAGS "" #define CPOPTS // COMPONENTS TO INSTALL // ===================== // For an operational non-Debian installation, you probably must be // `root'. // If necessary, adapt DOC, HDR, LIB and MAN (below) to your situation. // The provided locations are used by Debian Linux. // With 'build install' you can dynamically specify a location to prepend // to the locations configured here, and select which components you want // to install // ONLY USE ABSOLUTE DIRECTORY NAMES: // the directory where the additional documentation is stored #define ADD "/usr/share/doc/"${PROGRAM}"-doc" // the final program #define BINARY "/usr/bin/"${PROGRAM} // the directory where the standard documentation is stored #define DOC "/usr/share/doc/"${PROGRAM} // the directory whre the manual page is stored #define MAN "/usr/share/man" // the directory whre the user guide is stored #define UGUIDE "/usr/share/doc/"${PROGRAM}"-doc/manual" simrisc-14.05.00/legacy/0000755000175000017500000000000014034554241013644 5ustar frankfranksimrisc-14.05.00/legacy/changelog.txt0000644000175000017500000001050514034554241016335 0ustar frankfrank// Changes compared to SiMRiSc version 11a (by Chris) // // * New tumor growth model (Tumor.cpp) now calculating preclinical period from 'self-detect-diameter'. See thesis report for details. // // * Survival chance now taken from continuous formula (see thesis report) // * New parameters a, b, c and d in input file // * Alternatively, the old way (loading from CumTumorDeathProb.txt) can be used by setting config parameter cumDeathProbFromFile to 1 // // * Changed how breast density is assigned. A women will now progress 'naturally' through her life instead of being assigned a completely random density each screening round. // // * Rewritten the way tumor chance and induced tumors from radiation is calculated // * The code-flow was severly bugged; // The tumor probability of a women was depending on the -previous- women in the simulation! // The first women in the simulation had no chance on a tumor, because the array was pointing to a random place in memory (wasn't initialized at that point in code) // Execution time is now reduced from >1 minute to 4 seconds for 10000 women with 16 screening rounds each // // * Rewritten and fixed MamDens function // The input parameter age was integer, but the age in the rest of the code is floating point, generating compiler warnings and unpredictable behaviour. // No more 'if else else if if else if then' code... // // * CumDeathProb (mortality rate because of natural causes) loaded from CumDeathProb.txt instead of being hardcoded // // * Fixed a bug where if the women dies because of natural cause before the first screening, the death age is later on rewritten by 1 // * Fixed a bug in the interval cancer detection: // If a the screening interval is not 2 years, a women that // dies within 2 years after the screening moment was still recorded as interval cancer. // // * Fixed dangling pointer bug in arrays r6, r7 and r8 which could cause SiMRiSc to crash when running multiple iterations // // * Renamed the executable to SiMRiSc.exe // // * Removed all console input (make it possible to run from batch process) // * The control file is now a command line argument: // Starting SiMRiSc can now be done by 'SiMRiSc.exe control.txt' making it possible to run from batch file // If no command line argument is given, 'control.txt' is assumed for the control file by default // // * The number of scenarios executed is now taken from the number of lines of the control file instead of requiring a seperate parameter // // * Introduced variable deathStatus (replacing previous 'death' variable) to give more insight into when and why a women died. // This enum can have the following values: // 0 DEATHSTATUS_NOTDEAD, // 1 DEATHSTATUS_NATURAL_PRESCREENING, // 2 DEATHSTATUS_NATURAL_DURINGSCREENING, // 3 DEATHSTATUS_NATURAL_POSTSCREENING, // 4 DEATHSTATUS_TUMOR_PRESCREENING, // 5 DEATHSTATUS_TUMOR_DURINGSCREENING, // 6 DEATHSTATUS_TUMOR_POSTSCREENING // This variable is also recorded to the output, making it clear what the exact cause of death per women is // // * Replaced quasi-boolean variables (using constants 'TRUE' and 'FALSE') by real boolean type // This drastic measure saves 15 bits of memory per variable \O/ // // * Moved all output generating code after the simulation loops // // // * Made the implementation of the random number generator abstract (random.cpp) // * Implemented the random number engine provided by the C++ STL (in addition to the existing 3rd party library). Functionality between the 2 random number generator engines is exactly the same. Switching can be done in random.cpp. // * Random number generator can now also generate exponential distribution // // * Removed all console output // * Introduced progress bar to console, showing the progress of the current iteration and of the total execution // * Introduced execution time benchmark // // // * General code cleanups and comments // * Changed variable name 'j' to 'iteration'. // Will change all variables like 'i','k','l','q' by sensible variable names in the future // * Removed weird hardcoded stuff like // if (preclin_age1>3.1 && tumor_age<50) // preclin_age1=3.1; // * All variable names and comments now in English // * Marked code that is dirty, unclear or both by 'TODO' comment so it can be reviewed in the future simrisc-14.05.00/legacy/2017-11-30 change.txt0000644000175000017500000000064214034554241016645 0ustar frankfrankchange modality"MRI" to "Tomo" simirisc.h: add new variable "tomodose[4]" sensTomo[4];specTomo[2] simrisc.cpp: add tumor induction part of Tomo line873 &line906 line 921 choose modality for different BIRADS line 271 add configuration of tomo in input config line 754-767 &line 813-822 add number of tomo in output files"summary-" line60,119,281£¬442£¬454 cost cpp: change MRIcost to tomocost simrisc-14.05.00/legacy/20200414 change.txt0000644000175000017500000000014614034554241016510 0ustar frankfrankJ.Wang Incorperate attendance rate to radiation induced tumor New added line 35 Modified line 988 simrisc-14.05.00/legacy/20190729 change.txt0000644000175000017500000000012614034554241016527 0ustar frankfrankJ.Wang Incorperate attendance rate New added line 34,48,163,759 Modified line 277 simrisc-14.05.00/LICENSE0000644000175000017500000010451314052262454013413 0ustar frankfrank GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . simrisc-14.05.00/loop/0000755000175000017500000000000014051665273013360 5ustar frankfranksimrisc-14.05.00/loop/maybedetect.cc0000644000175000017500000000440714034554241016153 0ustar frankfrank#define XERR #include "loop.ih" void Loop::maybeDetect(ModBase *modBase, double screeningAge) { // see also: Marcel: Tue, 9 Jun 2020 13:01:00 +0000 // Marcel: Thu, 11 Jun 2020 10:35:44 +0000 (MRI, Mammo, Tomo are // all used // the check for tumor.diameter() >= 1 is omitted, since // all tumors have at least 1 mm diameter // (see Marcel: Tue, 30 Jun 2020 10:46:05 +0000) // modified using Jing Wang's email (Tue, 20 Oct 2020 16:04:42 +0000) if (Random::instance().uniform() > sensitivity(modBase)) { ++d_nRoundFN[d_round]; d_roundInfo[d_round] = FALSE_NEGATIVE; return; } // Found a tumor during the screening -> no need to call // diameterCheck() d_tumor.detected(); ++d_nDetections[d_round]; addCost(d_costs.treatment(screeningAge, d_tumor.diameter())); d_tumor.setDeathAge(screeningAge); d_roundDetected = d_round; // if this condition is true then a tumor was found, but the case // dies naturally (i.e., not caused by the cancer). // Otherwise death is caused by the cancer if (d_naturalDeathAge < d_tumor.deathAge()) setStatus(LEFT_DURING, d_naturalDeathAge); else setStatus(TUMOR_DURING, d_tumor.deathAge()); } ///////////////////////////////////////////////////////////////////////// // if (betaFunction(modBase->nr())) // { // // Found a tumor during the screening -> no need to call // // diameterCheck() // d_tumor.detected(); // ++d_nDetections[d_round]; // // addCost(d_costs.treatment(screeningAge, d_tumor.diameter())); // d_tumor.setDeathAge(screeningAge); // // d_roundDetected = d_round; // // // if this condition is true then a tumor was found, but the case // // dies naturally (i.e., not caused by the cancer). // // Otherwise death is caused by the cancer // if (d_naturalDeathAge < d_tumor.deathAge()) // setStatus(LEFT_DURING, d_naturalDeathAge); // else // setStatus(TUMOR_DURING, d_tumor.deathAge()); // } // // if (d_random.uniform() > sensitivity(modBase)) // ++d_nRoundFN[d_round]; // simrisc-14.05.00/loop/fillzeroes.cc0000644000175000017500000000023514034554241016036 0ustar frankfrank//#define XERR #include "loop.ih" // static void Loop::fillZeroes(ostream &out, size_t idx) { for ( ; idx < N_RESULTS; ++idx) out << "0\t"; } simrisc-14.05.00/loop/intervalcancer.cc0000644000175000017500000000137014034554241016661 0ustar frankfrank//#define XERR #include "loop.ih" void Loop::intervalCancer() { // a self-detected tumor before the next screening: an interval cancer. d_tumor.intervalCancer(); ++d_nIntervals[d_round]; d_selfDetected = true; d_tumor.characteristics(); // treat the tumor and determine the death-age of the women // since the tumor is present, no need to call diameterCheck() addCost(d_costs.treatment(d_tumor.age(), d_tumor.diameter())); d_tumor.setDeathAge(); if (d_naturalDeathAge < d_tumor.deathAge()) // natural death setStatus(LEFT_DURING, d_naturalDeathAge); else // death by tumor setStatus(TUMOR_DURING, d_tumor.deathAge()); } simrisc-14.05.00/loop/headerdata.cc0000644000175000017500000000714014034554241015744 0ustar frankfrank//#define XERR #include "loop.ih" // woman, death cause, death age, tumor present, tumor detected, tumor is // interval, tumor diameter, tumor self-detect age, tumor death age, tumor // doubling time, tumor onset age, tumor preclinical period, natural death age, // death status, cdsts, self detected, round detected, CSVTable Loop::headerData(size_t iter) const { CSVTable tab{ outStream(Options::instance().dataFile(), iter), " " }; if (not tab.stream()) return tab; labels(tab.stream()); tab.fmt() << right(7) << // 1 "Natural" << right("100.12", 2) << // 2 - 3 "natural" << "status" << // 4 - 5 "present" << "detected" << "interval" << // 6 - 8 "diameter" << "doubling" << "preclinical" << // 9 - 11 // death: "onset" << "self-detect" << "100.00" << // 12 - 14 "costs" << "self" << "round" << // 15 - 17 right(d_nRounds > 10 ? d_nRounds : 10); // 18 tab << hline(); // 6 - 14 + hline tab.row(5) << join(9, FMT::CENTER) << "tumor"; tab.row(5) << hline(9); tab.row(1) << // 1 join(4, FMT::CENTER) << "death" << // 2 - 5 join(6, FMT::RIGHT) << ' ' << // 4 - 9 ' ' << // 10 join(2, FMT::CENTER) << "age" << // 11 - 12 ' ' << // 15 join(2, FMT::CENTER) << "detected"; // 16 - 17 tab.row(1) << // 1 hline(4) << // 2 - 5 join(4, FMT::RIGHT) << ' ' << // 6 - 9 "doubling" << "preclinical" << ' ' << // 10 - 12 hline(2) << // 13 - 14 ' ' << // 15 hline(2) << "screening"; // 16 - 18 tab << "case" << // 1 "cause" << "age" << // 2 - 3 "natural" << "status" << // 4 - 5 "present" << "detected" << "interval" << // 6 - 8 "diameter" << "days" << "period" << // 9 - 11 "onset" << "self-detect" << "death" << // 12 - 14 "costs" << // 15 "self" << "round" << "rounds"; // 16 - 18 tab << hline(); tab.sep(", "); return tab; } // out << // 1 " woman, " // 2 "death cause, " // 3 "death age, " // 4 "tumor present, " // 5 "tumor detected, " // 6 "tumor is interval, " // 7 "tumor diameter, " // 8 11 "tumor self-detect age, " // 9 12 "tumor death age, " // 10 8 "tumor doubling time, " // 11 10 "tumor onset age, " // 12 9 "tumor preclinical period, " // 13 "natural death age, " // 14 "death status, " // 15 "costs, " // 16 "self detected, " // 17 "round detected, " // "\n"; // } simrisc-14.05.00/loop/data.cc0000644000175000017500000000245414034554241014576 0ustar frankfrank//#define XERR #include "loop.ih" unordered_set Loop::s_availableFiles; // from original input/CumDeathProb.txt DoubleVect Loop::s_cumDeathProb = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00014, 0.00028, 0.00042, 0.00056, 0.0007, 0.00106, 0.00142, 0.00178, 0.00214, 0.0025, 0.00382, 0.00514, 0.00646, 0.00778, 0.0091, 0.01118, 0.01326, 0.01534, 0.01742, 0.0195, 0.02312, 0.02674, 0.03036, 0.03398, 0.0376, 0.04414, 0.05068, 0.05722, 0.06376, 0.0703, 0.07776, 0.08522, 0.09268, 0.10014, 0.1076, 0.11564, 0.12368, 0.13172, 0.13976, 0.1478, 0.15718, 0.16656, 0.17594, 0.18532, 0.1947, 0.20658, 0.21846, 0.23034, 0.24222, 0.2541, 0.2756, 0.2971, 0.3186, 0.3401, 0.3616, 0.39368, 0.42576, 0.45784, 0.48992, 0.522, 0.5624, 0.6028, 0.6432, 0.6836, 0.724, 0.75826, 0.79252, 0.82678, 0.86104, 0.8953, 0.90962, 0.92394, 0.93826, 0.95258, 0.9669, 0.97104, 0.97518, 0.97932, 0.98346, 0.9876, }; simrisc-14.05.00/loop/postscreen.cc0000644000175000017500000000173614034554241016054 0ustar frankfrank//#define XERR #include "loop.ih" void Loop::postScreen() { xerr("status: " << d_status); if (d_status != PRESENT) // the woman has died: no further actions return; xerr("treatment cost entry: " << d_caseCost); // there is a tumor, detected before the // woman's natural death if (d_tumor and d_tumor.age() < d_naturalDeathAge) treatmentDeath(); // this results in a tumor caused death. // (the contition check in the original // sources is superfluous) else // or a naturally caused death { setStatus(LEFT_POST, d_naturalDeathAge); // although the woman has died, still if (d_tumor) // determine the tumor's characteristics d_tumor.characteristics(d_deathAge); } } simrisc-14.05.00/loop/prescreen.cc0000644000175000017500000000132714034554241015651 0ustar frankfrank//#define XERR #include "loop.ih" void Loop::preScreen() { // see prescreen.txt if (d_nRounds == 0) // no scenario rounds, no pre-screening return; // using the complement of the prescreen if ( // in the original code d_naturalDeathAge >= d_screening.age(0) and (not d_tumor or d_tumor.age() >= d_screening.age(0)) ) return; // pre-screening is performed: if (not d_tumor or (d_tumor and d_naturalDeathAge < d_tumor.age())) preTumorDeath(); // natural death: no tumor or not self-detected else selfDetected(); // self detected the tumor before the screening } simrisc-14.05.00/loop/headerrounds.cc0000644000175000017500000000317314034554241016347 0ustar frankfrank//#define XERR #include "loop.ih" CSVTable Loop::headerRounds(size_t iteration) const { CSVTable tab{ outStream( d_nRounds == 0 ? "" : Options::instance().roundsFile(), iteration), " " }; // false number of number of // --------- ---------------- screening -------------- // round pos. neg. tumors interval costs Mammo Tomo MRI // ------------------------------------------------------------- if (not tab.stream() or d_nRounds == 0) return tab; labels(tab.stream()); tab.fmt() << "round" << // 1: round "pos." << "neg." << // 2-3 "tumors" << "interval" << // 4-5 "screening"; // 6 // E.g., "Mammo" << "Tomo" << "MRI"; // 7-9 d_modalities.roundFmt(tab); tab << hline(); tab.row(1) << join(2, FMT::CENTER) << "false" << // 2-3 join(2, FMT::CENTER) << "number of" << // 4-5 ' ' << // 6 join(tab.size() - 6, FMT::CENTER) << "number of"; tab.row(1) << hline(2) << hline(2) << "screening" << hline(tab.size() - 6); tab.more() << "round" << "pos." << "neg." << // 1-3 "tumors" << "interval" << // 4-5 "costs"; // 6 d_modalities.roundHeaders(tab); tab.row(); tab << hline(); tab.sep(", "); return tab; } // "# Women with a tumor present\t" // not computed in org. prog. // (see rounds2.cc) simrisc-14.05.00/loop/naturaldeathage.cc0000644000175000017500000000055014034554241017011 0ustar frankfrank//#define XERR #include "loop.ih" // static unsigned idx = 0; double Loop::naturalDeathAge() { // double rnd; double ret = findAge(s_cumDeathProb, // rnd = Random::instance().uniformCase()); xerr(idx++ << ": nat.death: " << ret << ", rnd: " << rnd); return ret >= MAX_AGE ? MAX_AGE : ret; } simrisc-14.05.00/loop/loop.h0000644000175000017500000001300114034554241014466 0ustar frankfrank#ifndef INCLUDED_LOOP_ #define INCLUDED_LOOP_ #include #include #include "../globals/globals.h" #include "../scenario/scenario.h" #include "../screening/screening.h" #include "../densities/densities.h" #include "../modalities/modalities.h" #include "../tumorinfo/tumorinfo.h" #include "../tumor/tumor.h" #include "../costs/costs.h" class Scenario; namespace FBB { class CSVTable; } class Loop: public Globals { enum Status { PRESENT, LEFT_PRE, // left the pre, during, post screening LEFT_DURING, LEFT_POST, TUMOR_PRE, TUMOR_DURING, TUMOR_POST, }; enum // round info (per case) { ATTENDED = '1', FALSE_NEGATIVE = '2', FALSE_POSITIVE = '3' }; enum { N_RESULTS = 13 // weird... used in results() }; Status d_status = PRESENT; StringVect const &d_labels; Scenario d_scenario; Costs d_costs; Densities d_densities; TumorInfo d_tumorInfo; Tumor d_tumor; Modalities d_modalities; Screening d_screening; bool d_selfDetected; uint16_t d_roundDetected; // Analysis &d_analysis; // Beir7 const &d_beir7; // Incidence const &d_incidence; double d_sumDeathAge = 0; double d_naturalDeathAge = 0; // dying age w/o tumor double d_deathAge = 0; // actual dying age //FBBunused: // double d_detectionAge = 0; // age at which the tumor is detected uint16_t d_nRounds; uint16_t d_round = 0; // currently used screening round std::string d_roundInfo; SizeVect d_nIntervals; // SizeVect d_nMam; // # rounds // SizeVect d_nTomo; SizeVect d_nRoundFP; // # of false-positives per round SizeVect d_nRoundFN; // # of false-negatives per round // SizeVect d_nModalityFP; // # of false-positives per modality // -> Modalities SizeVect d_nDetections; double d_caseCost; double d_totalCost; // DoubleVect d_screeningCost; SizeVect d_roundCost; // sum of costs over all scr. rounds // (org: screeningRoundCosts) // randomly determined bi-rad indices for // the ages of the screening rounds Uint16Vect d_biRadIndices; // ('densities' in the original sources) std::string d_timestamp; static DoubleVect s_cumDeathProb; static std::unordered_set s_availableFiles; // sensitivity output file? loop.cpp line 40 public: Loop(StringVect const &labels); void iterate(); private: bool betaFunction(uint16_t modalityNr); // ORG void setBeir7dose(); void genCases(size_t iter, size_t nCases); void caseInit(); void resetCounters(); // void checkSeed(); // reset the random generator unless // // using RANDOM_SEED void preScreen(); void preTumorDeath(); // early natural death void selfDetected(); // self detected the tumor // i.h void screening(); bool leaving(double screeningAge); void intervalCancer(); void screen(double screeningAge); void maybeDetect(ModBase *modBase, double screeningAge); void maybeFalsePositive(ModBase *modBase, double screeningAge); void postScreen(); void treatmentDeath(); // .ih void characteristics(Status natural, Status tumor); size_t cases() const; // #cases in womenLoop double naturalDeathAge(); // NOTE: in the orig. source density NRs are used: 1..4 // here density INDICES are usd: 0..3 // but when writing the data file (e.g., data-0.txt, original // name e.g., women-test-i0.txt) a + 1 correction is // currently applied bool use(ModBase *modBase); // use this modality // add to totalCost, screeningCose void addCost(double cost); //+ and womenCost // returns the sensitivity for the double sensitivity(ModBase *modBase) const; // current round 1.cc void setStatus(Status status, double age); void labels(std::ostream &out) const; FBB::CSVTable headerData(size_t iter) const; FBB::CSVTable headerRounds(size_t iter) const; FBB::CSVTable headerSensitivity() const; void writeParameters(size_t iter) const; // also opens the file void writeSensitivity(FBB::CSVTable &sensTable, size_t iter) const; void writeData(FBB::CSVTable &dataTable, size_t idx) const; void writeRounds(FBB::CSVTable &roundTable) const; static void fillZeroes(std::ostream &out, size_t idx); static std::ofstream outStream(std::string const &fname, size_t idx); static std::string replaceDollar(std::string const &settingsFile, size_t idx); static std::ofstream open(std::string const &fname); }; #endif simrisc-14.05.00/loop/sensitivity1.cc0000644000175000017500000000124714034554241016337 0ustar frankfrank#define XERR #include "loop.ih" double Loop::sensitivity(ModBase *modBase) const { // NOTE: d_indices uses indices (0..4) instead of numbers // (as used in the original code) return modBase->sensitivity(d_biRadIndices[d_round]); } ////Calculate sensitivity for the modality and breastdensity (possibility to make function of age and tumorsize in the future but not used for now) //float calcSens(float age, float tumorsize, int modality, int density ) { // switch (modality) { // case 0: //Mammography // return sensMam[density-1]; // case 1: //Tomo // return sensTomo[density-1]; // } //} // simrisc-14.05.00/loop/leaving.cc0000644000175000017500000000234314034554241015307 0ustar frankfrank//#define XERR #include "loop.ih" bool Loop::leaving(double screeningAge) { xerr("natural: " << d_naturalDeathAge << ", screen age: " << screeningAge); if ( // see below screeningAge <= d_naturalDeathAge and (not d_tumor or screeningAge <= d_tumor.age()) ) return false; // no natural Death // determine whether the woman died between the previous and current // screening rounds if (d_tumor and d_tumor.age() <= d_naturalDeathAge) intervalCancer(); else { setStatus(LEFT_DURING, d_naturalDeathAge); if (d_tumor) // a tumor was developed d_tumor.characteristics(d_deathAge); // d_deathAge now equal // to d_naturalDeathAge } return true; } // negating the original condition to return false if the woman hasn't died: // return false if death didn't occur: // not ( // d_naturalDeathAge < screeningAge // or // (d_tumor and d_tumor.age() < screeningAge) // ) // if (d_tumor) // xerr("self detect age: " << d_tumor.age()); simrisc-14.05.00/loop/open.cc0000644000175000017500000000104114034554241014615 0ustar frankfrank//#define XERR #include "loop.ih" // static ofstream Loop::open(string const &fname) { // already saw fname if (s_availableFiles.find(fname) != s_availableFiles.end()) { ofstream out{ Exception::factory(fname, ios::in | ios::out | ios::ate) }; out << setfill('-') << setw(40) << '-' << setfill(' ') << "\n\n"; return out; } s_availableFiles.insert(fname); return Exception::factory(fname); } simrisc-14.05.00/loop/writesensitivity.cc0000644000175000017500000000041114034554241017321 0ustar frankfrank//#define XERR #include "loop.ih" void Loop::writeSensitivity(CSVTable &tab, size_t iter) const { if (tab.stream()) tab << iter << static_cast(round(d_sumDeathAge)) << static_cast(round(d_totalCost)); } simrisc-14.05.00/loop/loop.ih0000644000175000017500000000100414034554241014637 0ustar frankfrank#include "loop.h" #include "../xerr/xerr.ih" #include #include #include #include #include #include "../random/random.h" #include "../options/options.h" #include "../modbase/modbase.h" using namespace std; using namespace FBB; namespace Icmake { extern char version[]; } inline void Loop::selfDetected() { characteristics(LEFT_PRE, TUMOR_PRE); } inline void Loop::treatmentDeath() { characteristics(LEFT_POST, TUMOR_POST); } simrisc-14.05.00/loop/screening.cc0000644000175000017500000000050514034554241015635 0ustar frankfrank//#define XERR #include "loop.ih" void Loop::screening() { for (d_round = 0; d_status == PRESENT and d_round != d_nRounds; ++d_round) { double screeningAge = d_screening.age(d_round); if (leaving(screeningAge)) return; xerr("round: " << d_round); screen(screeningAge); } } simrisc-14.05.00/loop/labels.cc0000644000175000017500000000042314034554241015121 0ustar frankfrank//#define XERR #include "loop.ih" void Loop::labels(ostream &out) const { out << "Analysis " << d_timestamp << " (SimRisc V. " << Icmake::version << ")\n"; for (auto const &line: d_labels) out << line << '\n'; out.put('\n'); } simrisc-14.05.00/loop/replacedollar.cc0000644000175000017500000000071014034554241016467 0ustar frankfrank//#define XERR #include "loop.ih" // static string Loop::replaceDollar(string const &settingsFile, size_t idx) { string ret{ settingsFile }; string nr{ to_string(idx) }; idx = 0; while (true) { idx = ret.find('$', idx); // find the next $ if (idx == string::npos) // no more return ret; ret.replace(idx, 1, nr); // replace the $ by nr } } simrisc-14.05.00/loop/outstream.cc0000644000175000017500000000040314034554241015700 0ustar frankfrank//#define XERR #include "loop.ih" // static ofstream Loop::outStream(string const &fname, size_t idx) { ofstream ret; if (fname.empty()) ret.setstate(ios::failbit); else ret = open(replaceDollar(fname, idx)); return ret; } simrisc-14.05.00/loop/headersensitivity.cc0000644000175000017500000000112014034554241017415 0ustar frankfrank#define XERR #include "loop.ih" // ----------------------------------- // iteration women years total costs // ----------------------------------- // 0, 795, 13478 // ----------------------------------- CSVTable Loop::headerSensitivity() const { CSVTable tab{ outStream(Options::instance().sensitivityFile(), 0), " " }; if (not tab.stream()) return tab; labels(tab.stream()); tab.fmt("iteration, women years, total costs"); tab << hline(); tab("iteration, women years, total costs"); tab << hline(); return tab; } simrisc-14.05.00/loop/icmconf0000644000175000017500000000007314034554241014712 0ustar frankfrank#define LIBRARY "loop" #include "../icmconf.lib" simrisc-14.05.00/loop/addcost.cc0000644000175000017500000000027414034554241015304 0ustar frankfrank//#define XERR #include "loop.ih" void Loop::addCost(double cost) { xerr("costs: " << cost); d_caseCost += cost; d_roundCost[d_round] += round(cost); // round(): cmath } simrisc-14.05.00/loop/maybefalsepositive.cc0000644000175000017500000000103014034554241017545 0ustar frankfrank//#define XERR #include "loop.ih" // d_pool->falsePositives(d_round * (modality + 1)) > // d_modalities[XRAY][modality == MAMMOGRAPHY ? MAMMO : TOMO] // [screeningAge >= 40].value() void Loop::maybeFalsePositive(ModBase *modBase, double screeningAge) { if (Random::instance().uniform() > modBase->specificity(screeningAge)) { modBase->falsePositive(); ++d_nRoundFP[d_round]; d_roundInfo[d_round] = FALSE_POSITIVE; addCost(d_costs.biopsy(screeningAge)); } } simrisc-14.05.00/loop/prescreen.txt0000644000175000017500000000311314034554241016076 0ustar frankfrankIn the original code's prescreen handling the following condition is used: if (Nscr > 0 && (naturalDeathAge < scr[0].age || (tumor.isTumor() && tumor.selfDetectAge() < scr[0].age))) Following this a lot of code is provided to be executed when the condition is true. It's more elegant to put this code in a function, returning when the condition isn't true. So: if ( not (Nscr > 0 && (naturalDeathAge < scr[0].age || (tumor.isTumor() && tumor.selfDetectAge() < scr[0].age))) ) return; But this isn't too readabile. However, the condition can be rewritten using De Morgan's rules. First the condition is simplified by using symbols: not (Nscr > 0 && (naturalDeathAge < scr[0].age || (tumor.isTumor() --> not ( A and ( B or ( C && tumor.selfDetectAge() < scr[0].age))) --> and D ))) And thus: not ( A and ( B or ( C and D ) ) ) Now distribute the 'not' using De Morgan: not A or not ( B or ( C and D ) ) The 2nd 'not' is next: not A or not B and not( C and D ) And maybe also the 3rd 'not': not A or not B and (not C or not D ) Now substitute the original expressions: // if (not A) -> if (Nscr == 0) // (Nscr is never negative) return; // if (not B and (not C or not D )) -> if ( naturalDeathAge >= scr[0].age // not B and (not tumor.isTumor() or tumor.selfDetectAge() >= scr[0].age) // not C or not D ) return; simrisc-14.05.00/loop/writeparameters.cc0000644000175000017500000000104714034554241017100 0ustar frankfrank//#define XERR #include "loop.ih" void Loop::writeParameters(size_t iteration) const { ofstream out{ outStream(Options::instance().parametersFile(), iteration) }; if (not out) return; labels(out); // timestamp and scenatio explanatory labels setPrecision(out, 3); d_scenario.writeParameters(out, iteration + 1); d_costs.writeParameters(out); d_densities.writeParameters(out); d_modalities.writeParameters(out); d_screening.writeParameters(out); d_tumorInfo.writeParameters(out); } simrisc-14.05.00/loop/gencases.cc0000644000175000017500000000204314051175670015453 0ustar frankfrank#define XERR #include "loop.ih" // -> ORG/womanloop.cpp void Loop::genCases(size_t iter, size_t nCases) { CSVTable dataTable = headerData(iter); auto const &options = Options::instance(); bool showAll = not options.specificAges() and options.lastCase() == 0; // perform 'nCases' simulations for (size_t caseIdx = 0; caseIdx != nCases; ++caseIdx) { caseInit(); preScreen(); // no action unless screening rounds are specified screening(); // same postScreen(); d_sumDeathAge += d_deathAge; d_totalCost += d_caseCost; if (dataTable.stream() and (showAll or caseIdx + 1 == nCases)) writeData(dataTable, caseIdx); } dataTable << hline(); } // In the original womanloop function a test is performed whether the // woman has died or not. This test is superfluous because if the woman enters // postScreen with status PRESENT then in postScreen the status either changes // to LEFT_POST or TUMOR_POST. simrisc-14.05.00/loop/writerounds.cc0000644000175000017500000000074714034554241016255 0ustar frankfrank//#define XERR #include "loop.ih" void Loop::writeRounds(CSVTable &tab) const { if (not tab.stream() or d_nRounds == 0) return; for (size_t rnd = 0; rnd != d_nRounds; ++rnd) { tab.more() << rnd << d_nRoundFP[rnd] << d_nRoundFN[rnd] << d_nDetections[rnd] << d_nIntervals[rnd] << d_roundCost[rnd]; d_modalities.writeRounds(tab, rnd); tab.row(); } tab << hline(); } simrisc-14.05.00/loop/cases.cc0000644000175000017500000000100114034554241014746 0ustar frankfrank//#define XERR #include "loop.ih" // if last case (--nCases) was specified, use that number of cases // if death-age (--death-age) was specified simulate one case having // the specified death age. Otherwise use nWomen cases size_t Loop::cases() const { auto const &options = Options::instance(); return options.lastCase() != 0 ? options.lastCase() : options.specificAges() ? 1 : d_scenario.nCases(); } simrisc-14.05.00/loop/screen.cc0000644000175000017500000000236214034554241015142 0ustar frankfrank//#define XERR #include "loop.ih" // perform a screening void Loop::screen(double screeningAge) { // visit all modalities: for (ModBase *...) or comparable // org/screen: 4, screen.txt: 1 for (ModBase *modBase: d_modalities.use( d_screening.round(d_round).modalityIndices()) ) { if (not use(modBase)) continue; addCost(d_costs.screening(screeningAge, modBase->cost())); if (d_tumor) d_tumor.characteristics(screeningAge); // test2 (see below) if (d_tumor and screeningAge >= d_tumor.detectableAge()) maybeDetect(modBase, screeningAge); else maybeFalsePositive(modBase, screeningAge); } } // tumor test2 maybedetect maybefalsepos // 1 1 1 0 // 1 0 0 1 // 0 1 0 1 // 0 0 0 1 // // -> calling maybeFalsePositive may not be called when just 'not d_tumor' // is true. //xerr(""); //for (auto const &id: d_screening.round(d_round).modalityIDs()) //cerr<<" id: " << id <<'\n'; //xerr("use " << modBase->id()); //xerr("cpt costs"); simrisc-14.05.00/loop/caseinit.cc0000644000175000017500000000231514051175670015464 0ustar frankfrank#define XERR #include "loop.ih" void Loop::caseInit() { d_caseCost = 0; // org: womenCosts d_deathAge = 0; // org: tumorDeathAge d_roundDetected = 0; // org: roundDetected d_selfDetected = false; // org: selfDetected d_roundInfo.assign(d_nRounds, '0'); // attendance info per round per // case at [idx] the info of round // idx is stored // Breast bi-rad indices to use for the // ages of the screening rounds d_biRadIndices = d_densities.biRadIndices(d_screening.ages()); d_tumorInfo.cumTotalRisk( d_screening.radiationRisk( d_modalities, d_biRadIndices, d_tumorInfo.beir7().beta(), d_tumorInfo.beir7().eta() ) ); Options::instance().fixedNaturalDeathAge( d_naturalDeathAge = naturalDeathAge()); d_status = PRESENT; d_tumor.reset(); } simrisc-14.05.00/loop/loop1.cc0000644000175000017500000000042714034554241014715 0ustar frankfrank#define XERR #include "loop.ih" Loop::Loop(StringVect const &labels) : d_labels(labels), d_tumor(d_tumorInfo), d_modalities(d_tumor), d_screening(d_modalities), d_nRounds(d_screening.nRounds()), d_timestamp(DateTime{ DateTime::LOCALTIME }.rfc2822()) {} simrisc-14.05.00/loop/resetcounters.cc0000644000175000017500000000077314034554241016574 0ustar frankfrank//#define XERR #include "loop.ih" void Loop::resetCounters() { d_totalCost = 0; // org: womenCosts d_sumDeathAge = 0; // org: womenYears d_nIntervals = SizeVect(d_nRounds); d_nRoundFP = SizeVect(d_nRounds); // # of false-positives per round d_nRoundFN = SizeVect(d_nRounds); // # of false-positives per round d_nDetections = SizeVect(d_nRounds); d_roundCost = SizeVect(d_nRounds); d_modalities.resetCounters(d_nRounds); } simrisc-14.05.00/loop/frame0000644000175000017500000000005614034554241014367 0ustar frankfrank//#define XERR #include "loop.ih" Loop:: { } simrisc-14.05.00/loop/writedata.cc0000644000175000017500000000106614034554241015647 0ustar frankfrank#define XERR #include "loop.ih" void Loop::writeData(CSVTable &tab, size_t idx) const { tab.more() << idx << // 1 (d_status >= TUMOR_PRE ? "Tumor" : "Natural") << // 2 d_deathAge << d_naturalDeathAge << d_status; // 3 - 5 d_tumor.writeData(tab); // 6 - 14 tab << static_cast(round(d_caseCost)) << // 15 d_selfDetected << d_roundDetected << d_roundInfo; // 16 - 18 } simrisc-14.05.00/loop/setstatus.cc0000644000175000017500000000020214034554241015711 0ustar frankfrank#define XERR #include "loop.ih" void Loop::setStatus(Status status, double age) { d_status = status; d_deathAge = age; } simrisc-14.05.00/loop/characteristics.cc0000644000175000017500000000170614034554241017037 0ustar frankfrank//#define XERR #include "loop.ih" void Loop::characteristics(Status natural, Status tumor) { // the tumor was self-detected: determine d_tumor.characteristics(); // its characteristics d_selfDetected = true; // treat the tumor: add the treatment cost and compute the age of // tumor-caused death. There is a tumor: no need to call // diameterCheck() d_caseCost += d_costs.treatment(d_tumor.age(), d_tumor.diameter()); d_tumor.setDeathAge(); if (d_naturalDeathAge < d_tumor.deathAge()) // naturally caused death setStatus(natural, d_naturalDeathAge); else // or tumor caused death setStatus(tumor, d_tumor.deathAge()); } // double cost = d_costs.treatment(d_tumor.age(), d_tumor.diameter()); // xerr("costs: " << cost << ", age: " << d_tumor.age() << ", dia: " <<[bsl] // d_tumor.diameter()); // d_caseCost += cost; simrisc-14.05.00/loop/use.cc0000644000175000017500000000366614034554241014467 0ustar frankfrank//#define XERR #include "loop.ih" // true: this modality is used bool Loop::use(ModBase *modBase) { if (d_screening.rate() < Random::instance().uniform()) return false; xerr("round " << d_round << ", count " << d_round); d_roundInfo[d_round] = ATTENDED; modBase->count(d_round); // screen around line 22 -> return true; } // ---------------------------------------------------------------------- // //// screen: line 26: densities not used anymore // // // uint16_t density = d_indices[d_round]; // // // NOTE: in the orig. source density NRs are used: 1..4 // // here density INDICES are usd: 0..3 // // if ( use Modalities member: // modality == MAMMOGRAPHY and d_screening.round(d_round).mammo() //// and (density == 0 or density == 1) // // ) // { // ++d_nMam[d_round]; // return true; // } // // if ( // modality == TOMOSYNTHESIS and d_screening.round(d_round).tomo() //// and (density == 2 or density == 3) // ) // { // ++d_nTomo[d_round]; // return true; // } // // return false; // return RandomPool::instance().attendance(d_round * (modality + 1) // <= d_screening.rate().value() // and // ... // ( // rndPoolAttendance[ screeningRound * (modality + 1) ] // <= // attendanceRate // ) // && // ( // ( // ( modality == 0) && // (scr[screeningRound].T0) && // ( // (density[screeningRound] == 1) // || // (density[screeningRound] == 2) // ) // ) // || // ( // ( modality == 1) && // (scr[screeningRound].T1) && // ( // (density[screeningRound] == 3) || // (density[screeningRound] == 4) // ) // ) // ) simrisc-14.05.00/loop/pretumordeath.cc0000644000175000017500000000057314034554241016550 0ustar frankfrank//#define XERR #include "loop.ih" // Woman dies because of natural cause before screening and // does not have tumor or dies before self-detecting the tumor void Loop::preTumorDeath() { setStatus(LEFT_PRE, d_naturalDeathAge); if (d_tumor) // would have developed a tumor. Compute the tumor's d_tumor.characteristics(d_deathAge); // characteristics } simrisc-14.05.00/loop/iterate.cc0000644000175000017500000000251114034554241015314 0ustar frankfrank#define XERR #include "loop.ih" // -> ORG/niterationsloop.cpp void Loop::iterate() { CSVTable sensTable = headerSensitivity(); // table to collect // sensitivity values Random::instance().setSeed(d_scenario.seed()); for (size_t idx = 0, end = d_scenario.nIterations(); idx != end; ++idx) { ofstream spreadStream; size_t nCases = cases(); Random::instance().reinit(nCases, d_scenario.vary(), d_scenario.generatorType()); if (d_scenario.vary()) // maybe vary the parameters { spreadStream = outStream(Options::instance().spreadFile(), idx); labels(spreadStream); d_modalities.vary(spreadStream); // vary the used modalities d_tumorInfo.vary(spreadStream); // vary Beir7, Growth, // Incidence, and Survival } writeParameters(idx); // write the actual parameter values, CSVTable rounds = headerRounds(idx); resetCounters(); genCases(idx, nCases); writeRounds(rounds); // -> ORG/loopendout.cpp writeSensitivity(sensTable, idx); } if (sensTable.stream()) sensTable << hline(); } simrisc-14.05.00/main.cc0000644000175000017500000000303614050457455013644 0ustar frankfrank//#define XERR #include "main.ih" // update Options::alter, Options::inspect and // Options::Options if g_longOpts is modified Arg::LongOption g_longOpts[] = { Arg::LongOption{"base", 'B'}, Arg::LongOption{"config", 'C'}, Arg::LongOption{"data", 'D'}, Arg::LongOption{"death-age", 'a'}, Arg::LongOption{"err", 'e'}, Arg::LongOption{"help", 'h'}, Arg::LongOption{"last-case", 'l'}, Arg::LongOption{"one-analysis", 'o'}, Arg::LongOption{"parameters", 'P'}, Arg::LongOption{"rounds", 'R'}, Arg::LongOption{"sensitivity", 'S'}, Arg::LongOption{"spread", 's'}, Arg::LongOption{"tumor-age", 't'}, Arg::LongOption{"verbose", 'V'}, Arg::LongOption{"version", 'v'}, }; auto const *g_longEnd = g_longOpts + size(g_longOpts); //main int main(int argc, char **argv) try { Arg const &arg = Arg::initialize("a:B:el:C:D:hoP:R:S:s:t:vV", g_longOpts, g_longEnd, argc, argv); arg.versionHelp(usage, Icmake::version, arg.option('o') ? 0 : 1); Options::instance(); // construct the Options object Simulator simulator; // construct the simulator simulator.run(); // and run it. } //= catch(int x) { return Arg::instance().option("hv") ? 0 : x; } catch (exception const &exc) { cerr << exc.what() << '\n'; return 1; } catch (...) { cerr << "unexpected exception\n"; return 1; } simrisc-14.05.00/main.ih0000644000175000017500000000054114034554241013646 0ustar frankfrank#include #include #include #include #include "xerr/xerr.ih" #include "simulator/simulator.h" #include "options/options.h" namespace Icmake { extern char version[]; extern char years[]; extern char author[]; }; using namespace std; using namespace FBB; void usage(string const &progname); simrisc-14.05.00/mammo/0000755000175000017500000000000014051665273013515 5ustar frankfranksimrisc-14.05.00/mammo/vspecificity.cc0000644000175000017500000000113014034554241016511 0ustar frankfrank//#define XERR #include "mammo.ih" // E.g., age groups: // 0-40 // 40-100 // then by searching from the last to the first: find the agegroup // where the begin-age is < specified age. // Examples: age 50: the last group, // age 40: the first group // 'age' may not be negative double Mammo::vSpecificity(double age) const { return find_if(d_specVect.rbegin(), d_specVect.rend(), [&](AgeGroupVSD const &spec) { return spec.beginAge() < age; } )->value(); } simrisc-14.05.00/mammo/vdose1.cc0000644000175000017500000000014014034554241015211 0ustar frankfrank//#define XERR #include "mammo.ih" VSDvect const *Mammo::vDose() const { return &d_dose; } simrisc-14.05.00/mammo/mammo.ih0000644000175000017500000000022614034554241015136 0ustar frankfrank#include "mammo.h" #include #include "../xerr/xerr.ih" #include "../tumor/tumor.h" #include "../parser/parser.h" using namespace std; simrisc-14.05.00/mammo/setsystematicerror.cc0000644000175000017500000000023314034554241017766 0ustar frankfrank//#define XERR #include "mammo.ih" void Mammo::setSystematicError() { d_base.back() = "systematicError:"; Parser::proportion(d_base, d_sysErr); } simrisc-14.05.00/mammo/mammo.h0000644000175000017500000000450214034554241014766 0ustar frankfrank#ifndef INCLUDED_MAMMO_ #define INCLUDED_MAMMO_ #include "../enums/enums.h" #include "../modbase/modbase.h" #include "../agegroupvsd/agegroupvsd.h" //Mammo: // costs: 64 // // systematicError: 0.1 // // Dose: // # mean spread dist // bi-rad: a 3 1 Normal // bi-rad: b 3 1 Normal // bi-rad: c 3 1 Normal // bi-rad: d 3 1 Normal // // M: // # proportion spread dist // bi-rad: a .061 .021 Normal // bi-rad: b .163 .045 Normal // bi-rad: c .400 .106 Normal // bi-rad: d .826 .088 Normal // // Beta: // # mean spread dist // nr: 1 -4.38 .002 Normal // nr: 2 .49 .0005 Normal // nr: 3 -1.34 .0074 Normal // nr: 4 -7.18 .0340 Normal // // Specificity: // # range proporion spread dist // ageGroup: 0 - 40 .961 .005 Normal // ageGroup: 40 - * .965 .005 Normal class Tumor; class Mammo: public ModBase { Tumor const &d_tumor; double d_sysErr; StringVect d_base; VSDvect d_dose; VSDvect d_m; VSDvect d_beta; AgeGroupVSDvect d_specVect; public: Mammo(Tumor const &tumor); ~Mammo() override; private: void setSystematicError(); void setBeta(); void setM(); VSDvect const *vDose() const override; // 1 double vDose(uint16_t) const override; // 2 void vInsert(std::ostream &out) const override; double vSensitivity(size_t idx) const override; double vSpecificity(double age) const override; void vVary(std::ostream &out) override; }; //Modalities: // // Mammo: // costs: 64 // // # bi-rad: a b c d // dose: 3 3 3 3 // m: .136 .136 .136 .136 // // # ageGroup // specificity: 0 - 40: .961 40 - *: .965 // // # 1 2 3 4 // beta: -4.38 .49 -1.34 -7.18 // // systematicError: 0.1 #endif simrisc-14.05.00/mammo/vdose2.cc0000644000175000017500000000016014034554241015214 0ustar frankfrank//#define XERR #include "mammo.ih" double Mammo::vDose(uint16_t idx) const { return d_dose[idx].value(); } simrisc-14.05.00/mammo/icmconf0000644000175000017500000000007414034554241015050 0ustar frankfrank#define LIBRARY "mammo" #include "../icmconf.lib" simrisc-14.05.00/mammo/mammo1.cc0000644000175000017500000000374414034554241015214 0ustar frankfrank#define XERR #include "mammo.ih" //Mammo: // costs: 64 // // # default: // systematicError: 0.1 // // Dose: // # mean spread dist // bi-rad: a 3 1 Normal // bi-rad: b 3 1 Normal // bi-rad: c 3 1 Normal // bi-rad: d 3 1 Normal // // M: // # proportion spread dist // bi-rad: a .061 .021 Normal // bi-rad: b .163 .045 Normal // bi-rad: c .400 .106 Normal // bi-rad: d .826 .088 Normal // // Beta: // # mean spread dist // nr: 1 -4.38 .002 Normal // nr: 2 .49 .0005 Normal // nr: 3 -1.34 .0074 Normal // nr: 4 -7.18 .0340 Normal // // Specificity: // # range proporion spread dist // ageGroup: 0 - 40 .961 .005 Normal // ageGroup: 40 - * .965 .005 Normal Mammo::Mammo(Tumor const &tumor) : ModBase("Mammo"), d_tumor(tumor), d_base{ "Modalities:", "Mammo:", "" } { costBase(d_base); // ModBase members setSystematicError(); // must be before doseBase d_base.resize(4); doseBase(d_dose, d_base); // ModBase members specificityBase(d_specVect, d_base); setM(); setBeta(); } //Modalities: // // Mammo: // costs: 64 // // # bi-rad: a b c d // dose: 3 3 3 3 // m: .136 .136 .136 .136 // // # ageGroup // specificity: 0 - 40: .961 40 - *: .965 // // # 1 2 3 4 // beta: -4.38 .49 -1.34 -7.18 // // # default: // # systematicError: 0.1 simrisc-14.05.00/mammo/destructor.cc0000644000175000017500000000006714034554241016216 0ustar frankfrank//#define XERR #include "mammo.ih" Mammo::~Mammo() {} simrisc-14.05.00/mammo/setm.cc0000644000175000017500000000027114034554241014765 0ustar frankfrank//#define XERR #include "mammo.ih" void Mammo::setM() { d_base[2] = "M:"; d_base[3] = "bi-rad:"; d_m = Parser::VSDparameters(VARY_PROB, d_base, { 'a', 'b', 'c', 'd' }); } simrisc-14.05.00/mammo/setbeta.cc0000644000175000017500000000027714034554241015452 0ustar frankfrank#define XERR #include "mammo.ih" void Mammo::setBeta() { d_base[2] = "Beta:"; d_base[3] = "nr:"; d_beta = Parser::VSDparameters(VARY_MEAN, d_base, { '1', '2', '3', '4' }); } simrisc-14.05.00/mammo/vinsert.cc0000644000175000017500000000114414034554241015507 0ustar frankfrank#define XERR #include "mammo.ih" void Mammo::vInsert(ostream &out) const { Globals::setPrecision(out, 2) << setw(4) << ' ' << "systematicError: " << d_sysErr << '\n'; VSD::fmt(6, "bi-rad:", 'a', 1, 0, 1, 0); out << setw(4) << ' ' << "Dose:\n" << d_dose; VSD::fmt(6, "bi-rad:", 'a', 0, 3, 0, 3); out << setw(4) << ' ' << "M:\n" << d_m; VSD::fmt(6, "nr:", 0, 3, 2, 0, 4); out << setw(4) << ' ' << "Beta:\n" << d_beta; AgeGroupVSD::fmt(6, 0, 3, 0, 3); out << setw(4) << ' ' << "Specificity:\n" << d_specVect; } simrisc-14.05.00/mammo/frame0000644000175000017500000000006014034554241014517 0ustar frankfrank//#define XERR #include "mammo.ih" Mammo:: { } simrisc-14.05.00/mammo/vsensitivity.cc0000644000175000017500000000121214034554241016571 0ustar frankfrank#define XERR #include "mammo.ih" //code // cf. Isheden, G., & Humphreys, K. (2017). Modelling breast cancer tumour // growth for a stable disease population. Statistical Methods in Medical // Research, 28(3), 681-702. double Mammo::vSensitivity(size_t idx) const { double diameter = d_tumor.diameter(); double mValue = d_m[idx].value(); double expBeta = exp( d_beta[0].value() + d_beta[1].value() * diameter + d_beta[2].value() * mValue + d_beta[3].value() * mValue / (diameter * diameter) ); return (1 - d_sysErr) * expBeta / (1 + expBeta); } //= simrisc-14.05.00/mammo/vvary.cc0000644000175000017500000000047014034554241015165 0ustar frankfrank//#define XERR #include "mammo.ih" void Mammo::vVary(ostream &out) { out << " Mammo:\n"; VSD::vary(out, 4, "Dose", "bi-rad", 'a', d_dose); VSD::vary(out, 4, "M" , "bi-rad", 'a', d_m); VSD::vary(out, 4, "Beta", "nr", '1', d_beta); AgeGroupVSD::vary(out, 4, "Specificity", d_specVect); } simrisc-14.05.00/modalities/0000755000175000017500000000000014051665273014541 5ustar frankfranksimrisc-14.05.00/modalities/find.cc0000644000175000017500000000066714034554241015772 0ustar frankfrank//#define XERR #include "modalities.ih" uint16_t Modalities::find(std::string const &modality) const { auto iter = std::find_if(d_modalityIDs.begin(), d_modalityIDs.end(), [&](string const &available) { return modality == available; } ); return iter != d_modalityIDs.end() ? iter - d_modalityIDs.begin() : ~0U; } simrisc-14.05.00/modalities/vary.cc0000644000175000017500000000030714034554241016022 0ustar frankfrank//#define XERR #include "modalities.ih" void Modalities::vary(ostream &out) { out << "Modalities\n"; for (ModBase *modBase: d_modBaseVect) modBase->vary(out); out.put('\n'); } simrisc-14.05.00/modalities/addmod.cc0000644000175000017500000000025114034554241016267 0ustar frankfrank//#define XERR #include "modalities.ih" void Modalities::addMod(ModBase *modBase) { d_modBaseVect.push_back(modBase); d_modalityIDs.push_back(modBase->id()); } simrisc-14.05.00/modalities/modalities.ih0000644000175000017500000000033714034554241017211 0ustar frankfrank#include "modalities.h" #include "../xerr/xerr.ih" #include #include "../tomo/tomo.h" #include "../mammo/mammo.h" #include "../mri/mri.h" #include using namespace std; using namespace FBB; simrisc-14.05.00/modalities/icmconf0000644000175000017500000000010114034554241016063 0ustar frankfrank#define LIBRARY "modalities" #include "../icmconf.lib" simrisc-14.05.00/modalities/writeparameters.cc0000644000175000017500000000032414034554241020256 0ustar frankfrank//#define XERR #include "modalities.ih" void Modalities::writeParameters(ostream &out) const { out << "Modalities:\n" "\n"; for (auto modBasePtr: d_modBaseVect) out << *modBasePtr; } simrisc-14.05.00/modalities/destructor.cc0000644000175000017500000000021314034554241017233 0ustar frankfrank//#define XERR #include "modalities.ih" Modalities::~Modalities() { for (auto modBasePtr: d_modBaseVect) delete modBasePtr; } simrisc-14.05.00/modalities/modalities1.cc0000644000175000017500000000027614034554241017261 0ustar frankfrank#define XERR #include "modalities.ih" Modalities::Modalities(Tumor const &tumor) : d_tumor(tumor) { addMod(new Mammo{ d_tumor }); addMod(new Tomo); addMod(new MRI); } simrisc-14.05.00/modalities/roundheaders.cc0000644000175000017500000000032214034554241017521 0ustar frankfrank//#define XERR #include "modalities.ih" void Modalities::roundHeaders(CSVTable &tab) const { for (auto modBasePtr: d_modBaseVect) // insert the IDs tab.more() << modBasePtr->id(); } simrisc-14.05.00/modalities/writerounds.cc0000644000175000017500000000030214034554241017421 0ustar frankfrank//#define XERR #include "modalities.ih" void Modalities::writeRounds(CSVTable &tab, size_t round) const { for (auto modBasePtr: d_modBaseVect) tab.more() << (*modBasePtr)[round]; } simrisc-14.05.00/modalities/modalities.comment0000644000175000017500000000527514034554241020261 0ustar frankfrank //////////////////////////////////////////////////////////////////// // // 1st dimension is the type index, // // 2nd dimension is the id dimension // ParamsVect2 d_modality; // // static Map s_type; // static Map s_id; // // class Params // { // friend class Modalities; // // double d_dose[N_DOSES]; // double d_sens[N_SENS]; // sensitivities // SpecVect d_spec; // specificities // // public: // double const *dose() const; // double const *sens() const; // // double dose(size_t idx) const; // double sens(size_t idx) const; // Specificity const &operator[](size_t idx) const; // }; // // typedef std::vector ParamsVect; // typedef std::vector ParamsVect2; // // // // ParamsVect const &operator[](size_t idx) const; // // Params const &mammoParams() const; // Params const &tomoParams() const; // // void writeParameters(std::ostream &out) const; // 1 // // private: // void params(std::ostream &out, char const *label, Constants type) // const; // void birads(std::ostream &out, char const *label, // double const *value, Constants count) const; // // // void makeRoom(uint16_t typeIdx, uint16_t idIdx); // // static bool readSpecificities(std::istream &in, Params ¶ms); // inline Modalities::ParamsVect const &Modalities::operator[](size_t idx) const // { // return d_modality[idx]; // } // // inline Modalities::Params const &Modalities::mammoParams() const // { // return d_modality[XRAY][MAMMO]; // } // // inline Modalities::Params const &Modalities::tomoParams() const // { // return d_modality[XRAY][TOMO]; // } // // inline uint16_t Modalities::Specificity::beginAge() const // { // return d_beginAge; // } // // inline uint16_t Modalities::Specificity::endAge() const // { // return d_endAge; // } // // inline double Modalities::Specificity::value() const // { // return d_value; // } // // inline double Modalities::Params::dose(size_t idx) const // { // return d_dose[idx]; // } // // inline double const *Modalities::Params::dose() const // { // return d_dose; // } // // inline double Modalities::Params::sens(size_t idx) const // { // return d_sens[idx]; // } // // inline double const *Modalities::Params::sens() const // { // return d_sens; // } // // inline Modalities::Specificity // const &Modalities::Params::operator[](size_t idx) const // { // return d_spec[idx]; // } simrisc-14.05.00/modalities/roundfmt.cc0000644000175000017500000000224014034554241016675 0ustar frankfrank//#define XERR #include "modalities.ih" void Modalities::roundFmt(CSVTable &tab) const { StringVect ids; unsigned totalWidth = 0; // store modality IDs and // compute their total table for (auto modBasePtr: d_modBaseVect) // width { string const &id = modBasePtr->id(); ids.push_back(id); unsigned IDwidth = id.length(); tab.fmt(tab.size()) << right(IDwidth); // add this column totalWidth += IDwidth; } // table width of all totalWidth += ids.size() * tab.sep().length(); // Modalities IDs // to allow for the header: if (totalWidth < size("number of")) // an extra column is needed { totalWidth = size("number of") - totalWidth - tab.sep().length(); // at least 1 char wide tab.fmt(tab.size()) << (static_cast(totalWidth) < 1 ? 1 : totalWidth); } } simrisc-14.05.00/modalities/resetcounters.cc0000644000175000017500000000026114034554241017745 0ustar frankfrank//#define XERR #include "modalities.ih" void Modalities::resetCounters(size_t nRounds) { for (auto modBasePtr: d_modBaseVect) modBasePtr->resetCounters(nRounds); } simrisc-14.05.00/modalities/frame0000644000175000017500000000007214034554241015546 0ustar frankfrank//#define XERR #include "modalities.ih" Modalities:: { } simrisc-14.05.00/modalities/modalities.h0000644000175000017500000000337214034554241017042 0ustar frankfrank#ifndef INCLUDED_MODALITIES_ #define INCLUDED_MODALITIES_ // See README #include #include #include "../typedefs/typedefs.h" #include "../enums/enums.h" class ModBase; class Tumor; namespace FBB { class CSVTable; } class Modalities { Tumor const &d_tumor; // used by Mammo std::vector d_modBaseVect; // defined modalities StringVect d_modalityIDs; // and their IDs public: Modalities(Tumor const &tumor); ~Modalities(); // visit all modalities and initialize // their data, see loop/initialize // see also Loop::d_nModalityFP: modality specific, to become // a size_t variables in each used modality void resetCounters(size_t nRounds); // returns ~0U if 'modality' is unknown uint16_t find(std::string const &modality) const; // double specificity(age) const: age may not be negative // return a vector of ModBase ptrs matching the names specified // in 'active' std::vector use(Uint16Vect const &active) const; StringVect const &modalityIDs() const; void vary(std::ostream &out); // currently not used // double const *hasDose(StringVect const &ids) const; void writeParameters(std::ostream &out) const; void roundFmt(FBB::CSVTable &tab) const; void roundHeaders(FBB::CSVTable &tab) const; void writeRounds(FBB::CSVTable &tmp, size_t round) const; private: void addMod(ModBase *modBase); }; inline StringVect const &Modalities::modalityIDs() const { return d_modalityIDs; } #endif simrisc-14.05.00/modalities/use.cc0000644000175000017500000000061014034554241015632 0ustar frankfrank//#define XERR #include "modalities.ih" vector Modalities::use(Uint16Vect const &active) const { vectorret; for (uint16_t idx: active) ret.push_back(d_modBaseVect[idx]); // store the Modality ptr // return ptrs to the return ret; // requested Modality handlers } simrisc-14.05.00/modbase/0000755000175000017500000000000014051665273014021 5ustar frankfranksimrisc-14.05.00/modbase/modbase1.cc0000644000175000017500000000016714034554241016020 0ustar frankfrank//#define XERR #include "modbase.ih" ModBase::ModBase(std::string const &id) : d_id(id) //, // d_nr(++s_nr) {} simrisc-14.05.00/modbase/costbase.cc0000644000175000017500000000024214034554241016122 0ustar frankfrank//#define XERR #include "modbase.ih" void ModBase::costBase(StringVect &keywords) { keywords.back() = "costs:"; Parser::nonNegative(keywords, d_cost); } simrisc-14.05.00/modbase/opinsert.cc0000644000175000017500000000041314034554241016162 0ustar frankfrank//#define XERR #include "modbase.ih" std::ostream &operator<<(std::ostream &out, ModBase const &modBase) { out << " " << modBase.id() << ":\n" << " costs: " << modBase.d_cost << '\n'; modBase.vInsert(out); return out.put('\n'); } simrisc-14.05.00/modbase/icmconf0000644000175000017500000000007614034554241015356 0ustar frankfrank#define LIBRARY "modbase" #include "../icmconf.lib" simrisc-14.05.00/modbase/destructor.cc0000644000175000017500000000007514034554241016521 0ustar frankfrank//#define XERR #include "modbase.ih" ModBase::~ModBase() {} simrisc-14.05.00/modbase/specificitybase.cc0000644000175000017500000000202014034554241017461 0ustar frankfrank#define XERR #include "modbase.ih" void ModBase::specificityBase(AgeGroupVSDvect &dest, StringVect &keywords) { keywords[2] = "Specificity:"; keywords[3] = "ageGroup:"; auto lines = Parser::any(keywords); if (not lines) // keywords not found return; unsigned count = 0; unsigned success = 0; while (auto line = lines.get()) // get all lines { AgeGroupVSD spec{ VARY_PROB, false }; // agegroupvsd w/o sd. istringstream in{ line->tail }; // prepare for extraction if (in >> spec) // extract the next specification { ++count; // got a specification if (not spec.ageGroup().nextRange(dest)) // check increasing break; // age ranges dest.push_back(spec); // OK ++success; } } if (success == 0 or count != success) Err::specification(); } simrisc-14.05.00/modbase/outspec.cc0000644000175000017500000000071514034554241016006 0ustar frankfrank//#define XERR #include "modbase.ih" // static void ModBase::outSpec(ostream &out, char const *prefix, unsigned fill, AgeGroupVSD const &spec) { out << prefix << setw(fill) << ' ' << setw(2) << spec.beginAge() << " - " << setw(2); if (Globals::isZero(spec.endAge() - END_AGE)) out << '*'; else out << spec.endAge(); out << ':' << setw(6) << spec.value() << ";\n"; } simrisc-14.05.00/modbase/dosebase.cc0000644000175000017500000000035614034554241016112 0ustar frankfrank#define XERR #include "modbase.ih" void ModBase::doseBase(VSDvect &dose, StringVect &keywords) { keywords[2] = "Dose:"; keywords[3] = "bi-rad:"; dose = Parser::VSDparameters(VARY_NONNEG, keywords, { 'a', 'b', 'c', 'd' }); } simrisc-14.05.00/modbase/modbase.ih0000644000175000017500000000020714034554241015745 0ustar frankfrank#include "modbase.h" #include "../xerr/xerr.ih" #include "../globals/globals.h" #include "../parser/parser.h" using namespace std; simrisc-14.05.00/modbase/resetcounters.cc0000644000175000017500000000022214034554241017222 0ustar frankfrank//#define XERR #include "modbase.ih" void ModBase::resetCounters(size_t nRounds) { d_count = SizeVect(nRounds); d_falsePositives = 0; } simrisc-14.05.00/modbase/modbase.h0000644000175000017500000000566114034554241015605 0ustar frankfrank#ifndef INCLUDED_MODBASE_ #define INCLUDED_MODBASE_ // see ../modalities/README #include #include #include "../err/err.h" #include "../typedefs/typedefs.h" #include "../agegroupvsd/agegroupvsd.h" class ModBase { friend std::ostream &operator<<(std::ostream &, ModBase const &); std::string const d_id; uint16_t d_cost = 0; SizeVect d_count; uint16_t d_falsePositives; public: ModBase(std::string const &id); virtual ~ModBase(); void vary(std::ostream &out); // see Growth::vary() double sensitivity(size_t idx) const; double specificity(double age) const; uint16_t cost() const; void resetCounters(size_t nRounds); void count(size_t round); void falsePositive(); std::string const &id() const; VSDvect const *dose() const; double dose(uint16_t idx) const; // void roundHeader(std::ostream &out) const; // void count(std::ostream &out, size_t round) const; size_t operator[](size_t round) const; protected: void costBase(StringVect &keywords); // sets "costs:" // ageGroup and specificity // sets keywords: [2]: Specificity // [3]: ageGroup void specificityBase(AgeGroupVSDvect &dest, StringVect &keywords); void doseBase(VSDvect &dose, StringVect &keywords); private: virtual VSDvect const *vDose() const = 0; virtual double vDose(uint16_t idx) const = 0; virtual void vInsert(std::ostream &out) const = 0; virtual double vSensitivity(size_t idx) const = 0; virtual double vSpecificity(double age) const = 0; virtual void vVary(std::ostream &out) = 0; static void outSpec(std::ostream &out, char const *prefix, unsigned fill, AgeGroupVSD const &spec); }; inline void ModBase::count(size_t round) { ++d_count[round]; } inline size_t ModBase::operator[](size_t idx) const { return d_count[idx]; } //inline void ModBase::count(std::ostream &out, size_t round) const //{ // out << ',' << std::setw(7) << d_count[round]; //} inline uint16_t ModBase::cost() const { return d_cost; } inline void ModBase::falsePositive() { ++d_falsePositives; } inline std::string const &ModBase::id() const { return d_id; } inline VSDvect const *ModBase::dose() const { return vDose(); } inline double ModBase::dose(uint16_t idx) const { return vDose(idx); } inline double ModBase::sensitivity(size_t idx) const { return vSensitivity(idx); } inline double ModBase::specificity(double age) const { return vSpecificity(age); } inline void ModBase::vary(std::ostream &out) { return vVary(out); } //inline void ModBase::roundHeader(std::ostream &out) const //{ // out << ", #" << d_id; //} #endif simrisc-14.05.00/modbase/frame0000644000175000017500000000006414034554241015027 0ustar frankfrank//#define XERR #include "modbase.ih" ModBase:: { } simrisc-14.05.00/modifications0000644000175000017500000000317214034554241015156 0ustar frankfrank3: cumDeathProbs are not read from file, but are hard-coded in Loop::s_cumDeathProb. 4. The costs are not read from file anymore, but are specified in the configuration file at 'costs:', reading values for, resp.: cost_XM cost_Tomo cost_<2 cost_2-5 cost_>5 cost_biop discount (all ints, except for the last, a double. 5. Cf calculateSize: when computing _volume = _startVolume * //Exponential growth of tumorvolume pow(2.0, ((womenAge - _preclinAge) / _doublingTimeYear)); using floats, then for values, resp. 65.4499, 40, 26.1368 and 0.109376 _volume is 'inf' when using floats, but in fact (using doubles) it is 9.34711e+39. -> the new version uses doubles, and avoids floats. 6. loop/loop.h: // NOTE: in the orig. source density NRs are used: 1..4 // here density INDICES are usd: 0..3 // but when writing the data file (e.g., data-0.txt, original // name e.g., women-test-i0.txt) a + 1 correction is // currently applied bool use(size_t modality); //+ use this modality See also loop/sensitivity1.cc loop/results.cc and densities/biradsidx.cc 7: the 'no tumor' age is computed as -1, not as 0 as reported in the original program. See tumor/results.cc. Also see tumor/reset: when there is no tumor all ages are reported as -1, and start volume and self-detect (diameter) are set to 0 8. To synchronize the output of the current and original program, tumor diameters exceeding 1000 mm. are reported as 1001 mm (used to be 'inf') (tumor/results.cc) simrisc-14.05.00/mri/0000755000175000017500000000000014051665273013176 5ustar frankfranksimrisc-14.05.00/mri/vspecificity.cc0000644000175000017500000000016314034554241016177 0ustar frankfrank//#define XERR #include "mri.ih" double MRI::vSpecificity(double age) const { return d_specificity.value(); } simrisc-14.05.00/mri/vdose1.cc0000644000175000017500000000012614034554241014676 0ustar frankfrank//#define XERR #include "mri.ih" VSDvect const *MRI::vDose() const { return 0; } simrisc-14.05.00/mri/setspecificity.cc0000644000175000017500000000015514034554241016526 0ustar frankfrank//#define XERR #include "mri.ih" void MRI::setSpecificity() { extract("specificity:", d_specificity); } simrisc-14.05.00/mri/setsensitivity.cc0000644000175000017500000000015614034554241016606 0ustar frankfrank//#define XERR #include "mri.ih" void MRI::setSensitivity() { extract("sensitivity:", d_sensitivity); } simrisc-14.05.00/mri/vdose2.cc0000644000175000017500000000015314034554241014677 0ustar frankfrank//#define XERR #include "mri.ih" double MRI::vDose([[maybe_unused]] uint16_t idx) const { return 0; } simrisc-14.05.00/mri/icmconf0000644000175000017500000000007214034554241014527 0ustar frankfrank#define LIBRARY "mri" #include "../icmconf.lib" simrisc-14.05.00/mri/extract.cc0000644000175000017500000000043614034554241015153 0ustar frankfrank//#define XERR #include "mri.ih" void MRI::extract(char const *keyword, VSD &dest) { d_base.back() = keyword; auto lines = Parser::one(d_base); // get one line LineInfo const *line = lines.get(); if (line != 0) Parser::extract(*line, dest); } simrisc-14.05.00/mri/mri.h0000644000175000017500000000172614034554241014135 0ustar frankfrank#ifndef INCLUDED_MRI_ #define INCLUDED_MRI_ #include #include "../vsd/vsd.h" #include "../modbase/modbase.h" // MRI: // costs: 280 // # value spread distr. // sensitivity: .94 0.005 Normal // specificity: .95 0.005 Normal class MRI: public ModBase { VSD d_sensitivity; VSD d_specificity; StringVect d_base; public: MRI(); ~MRI() override; private: void setSensitivity(); void setSpecificity(); VSDvect const *vDose() const override; // 1 double vDose(uint16_t idx) const override; // 2 void vInsert(std::ostream &out) const override; double vSensitivity(size_t idx) const override; double vSpecificity(double age) const override; void vVary(std::ostream &out) override; void extract(char const *keyword, VSD &dest); }; #endif simrisc-14.05.00/mri/destructor.cc0000644000175000017500000000006114034554241015671 0ustar frankfrank//#define XERR #include "mri.ih" MRI::~MRI() {} simrisc-14.05.00/mri/vinsert.cc0000644000175000017500000000036714034554241015176 0ustar frankfrank//#define XERR #include "mri.ih" void MRI::vInsert(ostream &out) const { VSD::fmt(0, 2, 0, 3); out << setw(4) << ' ' << "sensitivity: " << d_sensitivity << '\n'; out << setw(4) << ' ' << "specificity: " << d_specificity << '\n'; } simrisc-14.05.00/mri/mri.ih0000644000175000017500000000022714034554241014301 0ustar frankfrank#include "mri.h" #include #include "../xerr/xerr.ih" #include "../globals/globals.h" #include "../parser/parser.h" using namespace std; simrisc-14.05.00/mri/mri1.cc0000644000175000017500000000065014034554241014347 0ustar frankfrank//#define XERR #include "mri.ih" // configfile lines: // MRI cost: 280 // sensitivity: .94 0.005 Normal // specificity: .95 0.005 Normal MRI::MRI() : ModBase("MRI"), d_sensitivity(VARY_PROB), d_specificity(VARY_PROB), d_base{ "Modalities:", "MRI:", "" } { costBase(d_base); setSpecificity(); setSensitivity(); } simrisc-14.05.00/mri/frame0000644000175000017500000000005414034554241014203 0ustar frankfrank//#define XERR #include "mri.ih" MRI:: { } simrisc-14.05.00/mri/vsensitivity.cc0000644000175000017500000000016314034554241016256 0ustar frankfrank//#define XERR #include "mri.ih" double MRI::vSensitivity(size_t idx) const { return d_sensitivity.value(); } simrisc-14.05.00/mri/vvary.cc0000644000175000017500000000044014034554241014643 0ustar frankfrank//#define XERR #include "mri.ih" // override void MRI::vVary(ostream &out) { d_sensitivity.vary(); d_specificity.vary(); out << " MRI:\n" " sensitivity: "; d_sensitivity.showVary(out); out << " specificity: "; d_specificity.showVary(out); } simrisc-14.05.00/options/0000755000175000017500000000000014051665273014102 5ustar frankfranksimrisc-14.05.00/options/instance.cc0000644000175000017500000000031514034554241016205 0ustar frankfrank//#define XERR #include "options.ih" // static Options &Options::instance() { if (s_options == 0) s_options = new Options; // Note: not deleted at end of program return *s_options; } simrisc-14.05.00/options/data.cc0000644000175000017500000000065714034554241015323 0ustar frankfrank//#define XERR #include "options.ih" Options *Options::s_options; char const Options::s_base[] = "./"; char const Options::s_config[] = "~/.config/simrisc"; unordered_map Options::s_fileName { { 'D', "+data-$.txt" }, { 'P', "" }, { 'R', "+rounds-$.txt" }, { 'S', "+sensitivity.txt" }, { 's', "+spread-$.txt" }, // { 'T', "" }, }; simrisc-14.05.00/options/replaceplus.cc0000644000175000017500000000031214034554241016715 0ustar frankfrank//#define XERR #include "options.ih" void Options::replacePlus(string &fname) { if (not fname.empty() and fname.front() == '+') fname.replace(0, 1 + (fname[1] == '/'), d_base[ANALYSIS]); } simrisc-14.05.00/options/options1.cc0000644000175000017500000000137114034554241016160 0ustar frankfrank//#define XERR #include "options.ih" Options::Options() : d_arg(Arg::instance()) { imsg.off(); if (char *cp = getenv("HOME"); cp) d_home = cp; if (d_arg.option('V')) { d_specified[STARTUP] += 'V'; imsg.on(); } configOption(); // set d_config[STARTUP] baseOption(); fileOption(d_dataFile, 'D'); fileOption(d_roundsFile, 'R'); fileOption(d_sensitivityFile, 'S'); fileOption(d_spreadFile, 's'); fileOption(d_parametersFile, 'P'); string value; if (d_arg.option(&value, 'a')) deathAgeOption(value); if (d_arg.option(&value, 't')) tumorAgeOption(value); if (d_arg.option(&value, 'l')) lastCaseOption(value); } simrisc-14.05.00/options/lastcaseoption.cc0000644000175000017500000000022314034554241017427 0ustar frankfrank//#define XERR #include "options.ih" void Options::lastCaseOption(string const &value) { d_specified[STARTUP] += 'l'; lastCase(value); } simrisc-14.05.00/options/tumorageoption.cc0000644000175000017500000000021514034554241017454 0ustar frankfrank//#define XERR #include "options.ih" void Options::tumorAgeOption(string const &value) { d_specified[0] += 't'; tumorAge(value); } simrisc-14.05.00/options/activate.cc0000644000175000017500000000101214034554241016174 0ustar frankfrank//#define XERR #include "options.ih" void Options::activate() { d_specified[ANALYSIS] = d_specified[STARTUP]; d_config[ANALYSIS] = d_config[STARTUP]; d_base[ANALYSIS] = d_base[STARTUP]; d_dataFile[ANALYSIS] = d_dataFile[STARTUP]; d_parametersFile[ANALYSIS] = d_parametersFile[STARTUP]; d_roundsFile[ANALYSIS] = d_roundsFile[STARTUP]; d_sensitivityFile[ANALYSIS] = d_sensitivityFile[STARTUP]; d_spreadFile[ANALYSIS] = d_spreadFile[STARTUP]; } simrisc-14.05.00/options/tumorage.cc0000644000175000017500000000022014034554241016217 0ustar frankfrank//#define XERR #include "options.ih" void Options::tumorAge(string const &value) { d_specificAges = true; d_tumorAge = stod(value); } simrisc-14.05.00/options/alter.cc0000644000175000017500000000320414034554241015510 0ustar frankfrank//#define XERR #include "options.ih" bool Options::alter(int optChar, std::string const &value) { // if a command-line option was specified, then do not alter // options in 'Analysis: specifications // if (d_specified[ANALYSIS].find(optChar) != string::npos) return false; d_specified[ANALYSIS] += optChar; switch (optChar) // these options can be altered { // they set the [1] parameters case 'a': deathAge(value); break; case 'B': d_base[ANALYSIS] = value; break; case 'C': d_config[ANALYSIS] = value; break; case 'D': d_dataFile[ANALYSIS] = value; break; case 'l': lastCase(value); break; case 'o': throw Exception{} << "`one-scenario' cannot be used in scenario specifications"; break; case 'P': d_parametersFile[ANALYSIS] = value; break; case 'R': d_roundsFile[ANALYSIS] = value; break; case 'S': d_sensitivityFile[ANALYSIS] = value; break; case 's': d_spreadFile[ANALYSIS] = value; break; // case 'T': // setFile(d_cumTotalriskFile = value, 'T'); // break; case 't': tumorAge(value); break; case 'V': d_specified[ANALYSIS] += 'V'; imsg.on(); break; } return true; } simrisc-14.05.00/options/actualize.cc0000644000175000017500000000074214034554241016366 0ustar frankfrank//#define XERR #include "options.ih" void Options::actualize() { d_specificAges = d_specified[STARTUP].find("at") != string::npos; replaceHome(d_config[ANALYSIS]); setBase(); replacePlus(d_dataFile[ANALYSIS]); replacePlus(d_parametersFile[ANALYSIS]); replacePlus(d_roundsFile[ANALYSIS]); replacePlus(d_sensitivityFile[ANALYSIS]); replacePlus(d_spreadFile[ANALYSIS]); conflictCheck(); // prevent conflicting options } simrisc-14.05.00/options/configoption.cc0000644000175000017500000000044614034554241017104 0ustar frankfrank//#define XERR #include "options.ih" void Options::configOption() { string value; if (d_arg.option(&value, 'C')) d_specified[STARTUP] += 'C'; else value = s_config; d_config[STARTUP] = value; imsg << "using configuration file `" << value << "'\n"; } simrisc-14.05.00/options/fixednaturaldeathage.cc0000644000175000017500000000030414034554241020550 0ustar frankfrank//#define XERR #include "options.ih" void Options::fixedNaturalDeathAge(double &deathAge) const { if (d_specified[ANALYSIS].find('a') != string::npos) deathAge = d_naturalDeathAge; } simrisc-14.05.00/options/deathageoption.cc0000644000175000017500000000022314034554241017372 0ustar frankfrank//#define XERR #include "options.ih" void Options::deathAgeOption(string const &value) { d_specified[STARTUP] += 'a'; deathAge(value); } simrisc-14.05.00/options/lastcase.cc0000644000175000017500000000016614034554241016204 0ustar frankfrank//#define XERR #include "options.ih" void Options::lastCase(string const &value) { d_lastCase = stoul(value); } simrisc-14.05.00/options/icmconf0000644000175000017500000000007614034554241015437 0ustar frankfrank#define LIBRARY "options" #include "../icmconf.lib" simrisc-14.05.00/options/options.h0000644000175000017500000001104214034554241015735 0ustar frankfrank#ifndef INCLUDED_OPTIONS_ #define INCLUDED_OPTIONS_ #include #include #include #include "../enums/enums.h" namespace FBB { class Arg; } class Options { enum Specified { STARTUP, ANALYSIS }; FBB::Arg const &d_arg; std::string d_home; // current 'HOME' directory std::string d_specified[2]; // specified options: // [0]: command-line, [1]: analysis bool d_specificAges = false; double d_naturalDeathAge; // single run, subject age double d_tumorAge; // single run, tumor self-detect age size_t d_lastCase; // compute until d_lastCase, report // d_lastCase's results std::string d_base[2]; // guaranteed to end in '/' // [0]: as specified, [1]: as used // in Analysis: sections std::string d_config[2]; // [0]: as specified, [1]: as used // in Analysis: sections std::string d_dataFile[2]; // [0]: as specified, [1]: as used // after replacing + by base std::string d_parametersFile[2]; std::string d_roundsFile[2]; std::string d_sensitivityFile[2]; std::string d_spreadFile[2]; static char const s_base[]; static char const s_config[]; static std::unordered_map s_fileName; static Options *s_options; public: static Options &instance(); Options(Options const &other) = delete; void reset(); // reset options to the // default/command-line values std::string const &base() const; // .h std::string const &configFile() const; // .h std::string const ¶metersFile() const; // .h std::string const &dataFile() const; // .h std::string const &roundsFile() const; // .h std::string const &sensitivityFile() const; // .h std::string const &spreadFile() const; // .h bool specificAges() const; // .h void fixedNaturalDeathAge(double &deathAge) const; void fixedTumorAge(double &tumorAge) const; size_t lastCase() const; // .h void activate(); // [ANALYSIS] = [STARTUP] // try to change this option's // value in this analysis bool alter(int optChar, std::string const &value); void actualize(); // transform ~ and + private: Options(); void configOption(); void baseOption(); void fileOption(std::string *dest, int option); void deathAgeOption(std::string const &value); void tumorAgeOption(std::string const &value); void lastCaseOption(std::string const &value); void deathAge(std::string const &value); void lastCase(std::string const &value); void tumorAge(std::string const &value); void replaceHome(std::string &path); void setBase(); // dest[0]: as specified, dest[1]: as used // void setFile(std::string *dest, std::string const &newValue, // 2 // int option); // fname[0]: as specified, fname[1]: as used void replacePlus(std::string &fname); void conflictCheck() const; }; inline std::string const &Options::base() const { return d_base[ANALYSIS]; } inline std::string const &Options::configFile() const { return d_config[ANALYSIS]; } inline std::string const &Options::parametersFile() const { return d_parametersFile[ANALYSIS]; } inline std::string const &Options::dataFile() const { return d_dataFile[ANALYSIS]; } inline std::string const &Options::roundsFile() const { return d_roundsFile[ANALYSIS]; } inline std::string const &Options::sensitivityFile() const { return d_sensitivityFile[ANALYSIS]; } inline std::string const &Options::spreadFile() const { return d_spreadFile[ANALYSIS]; } inline bool Options::specificAges() const { return d_specificAges; } inline size_t Options::lastCase() const { return d_lastCase; } #endif simrisc-14.05.00/options/replacehome.cc0000644000175000017500000000051414034554241016666 0ustar frankfrank//#define XERR #include "options.ih" void Options::replaceHome(string &path) { static bool warned = false; if (not path.empty() and path.front() == '~') path.replace(0, 1, d_home); if (d_home.empty() and not warned) { warned = true; wmsg << "No HOME environment variable found\n"; } } simrisc-14.05.00/options/options.ih0000644000175000017500000000027514034554241016114 0ustar frankfrank#include "options.h" #include "../xerr/xerr.ih" #include #include #include #include using namespace std; using namespace FBB; simrisc-14.05.00/options/setbase.cc0000644000175000017500000000025714034554241016034 0ustar frankfrank//#define XERR #include "options.ih" void Options::setBase() { replaceHome(d_base[ANALYSIS]); if (d_base[ANALYSIS].back() != '/') d_base[ANALYSIS] += '/'; } simrisc-14.05.00/options/baseoption.cc0000644000175000017500000000054514034554241016551 0ustar frankfrank//#define XERR #include "options.ih" void Options::baseOption() { string value; if (d_arg.option(&value, 'B')) // get the option's value d_specified[STARTUP] += 'B'; else value = s_base; // or use the default d_base[STARTUP] = value; imsg << "using base directory `" << value << "'\n"; } simrisc-14.05.00/options/deathage.cc0000644000175000017500000000022714034554241016145 0ustar frankfrank//#define XERR #include "options.ih" void Options::deathAge(string const &value) { d_specificAges = true; d_naturalDeathAge = stod(value); } simrisc-14.05.00/options/conflictcheck.cc0000644000175000017500000000076614034554241017212 0ustar frankfrank//#define XERR #include "options.ih" void Options::conflictCheck() const { size_t count = (d_specified[ANALYSIS].find('a') != string::npos) + (d_specified[ANALYSIS].find('t') != string::npos); if (count == 1) throw Exception{} << "Options --death-age and --tumor-age " "must both be specified"; if (count != 0 and d_specified[ANALYSIS].find('c') != string::npos) throw Exception{} << "--case and --death_age are mutually exclusive"; } simrisc-14.05.00/options/frame0000644000175000017500000000006414034554241015110 0ustar frankfrank//#define XERR #include "options.ih" Options:: { } simrisc-14.05.00/options/fixedtumorage.cc0000644000175000017500000000026714034554241017252 0ustar frankfrank//#define XERR #include "options.ih" void Options::fixedTumorAge(double &tumorAge) const { if (d_specified[ANALYSIS].find('t') != string::npos) tumorAge = d_tumorAge; } simrisc-14.05.00/options/fileoption.cc0000644000175000017500000000067514034554241016562 0ustar frankfrank//#define XERR #include "options.ih" // dest[0]: as specified, dest[1]: as used void Options::fileOption(string *dest, int option) { if (not d_arg.option(&dest[STARTUP], option)) dest[STARTUP] = s_fileName[option]; // use the default if not spec'd else { d_specified[STARTUP] += option; if (dest[STARTUP] == "!") // specified as `!': do not use dest[STARTUP].clear(); } } simrisc-14.05.00/oxref/0000755000175000017500000000000014034554241013523 5ustar frankfranksimrisc-14.05.00/oxref/replace0000644000175000017500000000234214034554241015062 0ustar frankfrank// replace objdump's idea of what a string is by ours: #std::__cxx11::basic_string, std::allocator >#std::string# #__gnu_cxx::__normal_iterator > >#Scenario::const_iterator# #, std::allocator > > const&, Scenario::Range&, char const*, std::vector > const*## #, std::hash, std::equal_to, std::allocator > ## #__gnu_cxx::__normal_iterator >#Next::ConstIter # #std::set const*> >#std::set# #[abi:cxx11]## #, std::hash## #, std::equal_to## #, std::allocator## #, std::allocator## #, std::allocator## #, std::allocator## #, std::allocator >## #, std::allocator ## #, std::allocator > ## #, std::allocator*> ## simrisc-14.05.00/parser/0000755000175000017500000000000014051665273013703 5ustar frankfranksimrisc-14.05.00/parser/parser.h0000644000175000017500000001466314034554241015353 0ustar frankfrank#ifndef INCLUDED_PARSER_ #define INCLUDED_PARSER_ #include #include #include #include #include #include "../extractable/extractable.h" //#include "../unsignedcastable/unsignedcastable.h" #include "../typedefs/typedefs.h" #include "../err/err.h" #include "../globals/globals.h" #include "../vsd/vsd.h" class ConfigLines; struct Parser { struct OptionInfo { std::string name; std::string value; uint16_t lineNr; }; typedef std::vector OptionsVect; private: typedef std::unordered_map Map; // vectors of LineInfoVects // each element holds the specs std::vector d_lines; // of one series of keywords Map d_map; static Map s_map; public: class Lines { friend class Parser; unsigned d_size; // initial size LineInfoVect::const_iterator d_iter; // first and last elements LineInfoVect::const_iterator d_end; // of a selected vector public: LineInfo const *get(); // by repeated calls get all // lines, from the first to // the last until 0 is // returned unsigned size() const; operator bool() const; private: Lines(LineInfoVect const &lines); // no lines found 1.f (ih) // >= 1 line found 2.f (ih) Lines(LineInfoVect::const_iterator const &begin, LineInfoVect::const_iterator const &end); Lines(Lines const &other) = default; LineInfoVect::const_iterator begin() const; // .f (ih) LineInfoVect::const_iterator end() const; // .f (ih) }; typedef Map::value_type MapValue; Parser() = default; Parser(Map &&tmp); // analysis file 1. void load(std::istream &in, uint16_t startLineNr, StringVect &labels, OptionsVect &options); void load(std::string const &fname); // continuration file 2. static VSDvect VSDparameters( VaryType varyType, StringVect const &keywords, std::initializer_list const &required); // any number (>= 1) lines is OK static Lines any(StringVect const &keywords); // exactly 1 configuration line is required static Lines one(StringVect const &keywords); // extract exactly one value associated with keywords template // .f static bool one(StringVect const &keywords, Type &dest); // exactly 1 line is required. // 1.f static bool nonNegative(StringVect const &keywords, double &dest); static bool positive(StringVect const &keywords, double &dest); // .f template // 2.f static bool nonNegative(StringVect const &keywords, Type &dest); // exactly 1 line is required static bool proportion(StringVect const &keywords, double &dest); // extract 'dest' variables from lines.get()->tail // returns 'good' if ok, else if no lines then // eof() else fail() + error msg template // 1.f static std::istringstream extract(Lines &&ines, Types &...dest); // same as 1.f, but LineInfo is already available // extracts from line.tail template // 2.f static std::istringstream extract(LineInfo const &line, Types &...dest); // extract 'size' 'dest' elements from lines.get()->tail // return values as with extract1.f template // 3.f static std::istringstream extract(Lines &&lines, Type *dest, size_t size); private: static Lines lines(StringVect const &keywords); static std::string sectionList(StringVect const &keywords); static bool atLeast(double minimum, StringVect const &keywords, double &dest); template // 4.f static bool extract(std::istream &in, Type &first, Types &...more); static bool extract(std::istream &in); // used in 4.f static std::vector const &keywordsLines( StringVect const &keywords); static void setLabels(ConfigLines &parser, StringVect &labels); static void setOptions(ConfigLines &parser, OptionsVect &options); // deepest nesting level in the map static bool endPoint(Map::value_type const &mapValue); // add the next parser line to the // appropriate map-section static void addConfigLine(std::vector &mapPtrVect, ConfigLines &lines, ParamsSrc src); static void locateError(std::vector &mapPtrVect, ConfigLines &lines, ParamsSrc src); // add (empty) LineInfoVects // at s_map's deepest nesting static void addLineInfoVectors(Map &map); // levels }; #include "extract1.f" #include "extract2.f" #include "extract3.f" #include "extract4.f" #include "one.f" #include "nonnegative1.f" #include "nonnegative2.f" #include "positive.f" #include "linessize.f" #include "linesopbool.f" #endif simrisc-14.05.00/parser/parser1.cc0000644000175000017500000000013114034554241015553 0ustar frankfrank//#define XERR #include "parser.ih" Parser::Parser(Map &&tmp) : d_map(move(tmp)) {} simrisc-14.05.00/parser/addlineinfovectors.cc0000644000175000017500000000117114034554241020065 0ustar frankfrank#define XERR #include "parser.ih" // static void Parser::addLineInfoVectors(Map &map) { // element.first: the key // element.second: Parser * for (auto &element: map) // all elements of 'map' { if (not endPoint(element)) // there's a deeper link: addLineInfoVectors(element.second->d_map); // continue there else // no map is used here { auto &vect = element.second->d_lines; // add a LineInfo vector vect.resize(vect.size() + 1); // of lines } } } simrisc-14.05.00/parser/linesend.f0000644000175000017500000000013114034554241015637 0ustar frankfrankinline LineInfoVect::const_iterator Parser::Lines::end() const { return d_end; } simrisc-14.05.00/parser/one.cc0000644000175000017500000000045314034554241014766 0ustar frankfrank//#define XERR #include "parser.ih" // static Parser::Lines Parser::one(StringVect const &keywords) { Lines lines = any(keywords); if (lines.size() > 1) Err::multiplySpecified(lines.begin(), lines.end(), sectionList(keywords)); return lines; } simrisc-14.05.00/parser/data.cc0000644000175000017500000001601514034554241015117 0ustar frankfrank//#define XERR #include "parser.ih" // In the configuration file specifications are just lines. Each keyword // must therefore be searched via a unique path. So searching for // e.g., { 'costs:' } returns multiple hits, but searching for // { 'Scenario:', 'costs:' } returns only one hit // Named MapValues must be used only once. E.g., for Mammo 'Dose' is // specified by mdose, for Tomo it is specified by tdose. // final "named" keys are always unique and can be specified at MapValue // specifications. // see also the description at the end of this file namespace { Parser::MapValue scenario { "Scenario:", new Parser { { // map {"spread:", new Parser }, {"iterations:", new Parser }, {"generator:", new Parser }, {"seed:", new Parser }, {"cases:", new Parser }, } } }; Parser::MapValue screening { "Screening:", new Parser { { // map {"round:", new Parser }, {"attendanceRate:", new Parser }, } } }; Parser::MapValue breastDensities { "BreastDensities:", new Parser { { // map {"ageGroup:", new Parser}, } } }; Parser::MapValue mamDose { "Dose:", new Parser { { {"bi-rad:", new Parser }, } } }; Parser::MapValue mamM { "M:", new Parser { { {"bi-rad:", new Parser }, } } }; Parser::MapValue mamBeta { "Beta:", new Parser { { {"nr:", new Parser }, } } }; Parser::MapValue mamSpecificity { "Specificity:", new Parser { { {"ageGroup:", new Parser }, } } }; Parser::MapValue mammo { "Mammo:", new Parser { { {"costs:", new Parser }, {"systematicError:", new Parser }, mamDose, mamM, mamBeta, mamSpecificity, } } }; Parser::MapValue tomDose { "Dose:", new Parser { { {"bi-rad:", new Parser }, } } }; Parser::MapValue tomSensitivity { "Sensitivity:", new Parser { { {"bi-rad:", new Parser }, } } }; Parser::MapValue tomSpecificity { "Specificity:", new Parser { { {"ageGroup:", new Parser }, } } }; Parser::MapValue tomo { "Tomo:", new Parser { { {"costs:", new Parser }, tomDose, tomSpecificity, tomSensitivity, } } }; Parser::MapValue mri { "MRI:", new Parser { { {"costs:", new Parser }, {"sensitivity:", new Parser }, {"specificity:", new Parser }, } } }; Parser::MapValue modalities { "Modalities:", new Parser { { // map mammo, tomo, mri } } }; Parser::MapValue incNormal { "Normal:", new Parser { { {"probability:", new Parser }, {"lifetimeRisk:", new Parser }, {"meanAge:", new Parser }, {"stdDev:", new Parser }, } } }; Parser::MapValue incBrca1 { "BRCA1:", new Parser { { {"probability:", new Parser }, {"lifetimeRisk:", new Parser }, {"meanAge:", new Parser }, {"stdDev:", new Parser }, } } }; Parser::MapValue incBrca2 { "BRCA2:", new Parser { { {"probability:", new Parser }, {"lifetimeRisk:", new Parser }, {"meanAge:", new Parser }, {"stdDev:", new Parser }, } } }; Parser::MapValue tumIncidence { "Incidence:", new Parser { { incNormal, incBrca1, incBrca2, } } }; Parser::MapValue groDoublingTime { "DoublingTime:", new Parser { { {"ageGroup:", new Parser}, } } }; Parser::MapValue tumGrowth { "Growth:", new Parser { { {"start:", new Parser }, {"selfDetect:", new Parser }, groDoublingTime, } } }; Parser::MapValue tumSurvival { "Survival:", new Parser { { {"type:", new Parser }, } } }; Parser::MapValue tumor { "Tumor:", new Parser { { // map tumIncidence, tumGrowth, { "beir7:", new Parser }, tumSurvival, } } }; Parser::MapValue cosDiscount { "Discount:", new Parser { { // map {"age:", new Parser }, {"proportion:", new Parser }, } } }; Parser::MapValue costs { "Costs:", new Parser { { {"biop:", new Parser }, {"diameters:", new Parser }, cosDiscount, } } }; } // namespace Parser::Map Parser::s_map { scenario, costs, screening, breastDensities, modalities, tumor, }; // By convention, keywords of lines mererly containing the keyword // start with capitals, and those followed by actual parameter values // start with lower-case letters // // MapValue definitions ending in 'new Parser' match one or more // configuration lines which are handled by the objects for which // the configuration line is intended. // // Parser specifications merely consisting of identifiers refer to // separately defined specifications // // E.g., // // Parser::MapValue modalities // { // "Modalities:", // new Parser // { // { // mammo, // tomo, // mri // } // } // }; // // specifies Modalities: as a keyword, followed by the definitions of mammo, // tomo, and mri. The 'tomo' MapValue is // // Parser::MapValue tomo // { // "Tomo:", // new Parser // { // { // {"costs:", new Parser }, // dose, // ... // } // } // }; // // and so 'costs:' is followed by >= 1 parameter values, but 'dose' is // specified separately: // // Parser::MapValue dose // { // "Dose:", // new Parser // { // { // {"bi-rad:", new Parser }, // } // } // }; // // The keyword 'Dose:' is on a line by itself, followed by lines starting // with 'bi-rad:' containing parameter specifications. // // What the parameter specifications are is determined by the objects parsing // the configuration lines. E.g., ageGroup: is specified as // ageGroup: 0 - 40: .961 .005 Normal // but also as: // ageGroup: 0 - 40: .05 .30 .48 .17 simrisc-14.05.00/parser/load2.cc0000644000175000017500000000077714034554241015217 0ustar frankfrank//#define XERR #include "parser.ih" void Parser::load(string const &fname) { ConfigLines lines{ fname }; addLineInfoVectors(s_map); // add (empty) LineInfoVects at // the map's deepest nesting // levels vector mapPtrVect{ &s_map }; // start loading at the top while (lines.get()) // add the parser lines addConfigLine(mapPtrVect, lines, CONFIGFILE); } simrisc-14.05.00/parser/linesbegin.f0000644000175000017500000000013414034554241016160 0ustar frankfrankinline LineInfoVect::const_iterator Parser::Lines::begin() const { return d_iter; } simrisc-14.05.00/parser/sectionlist.cc0000644000175000017500000000057314034554241016550 0ustar frankfrank//#define XERR #include "parser.ih" // for keywords A, B, C // where is set to: C, in section B, in section A // static string Parser::sectionList(StringVect const &keywords) { string where = " `" + keywords.back() + '\''; for (auto iter = keywords.rbegin() + 1; iter != keywords.rend(); ++iter) where += ", in section " + *iter; return where; } simrisc-14.05.00/parser/linessize.f0000644000175000017500000000010314034554241016042 0ustar frankfrankinline unsigned Parser::Lines::size() const { return d_size; } simrisc-14.05.00/parser/vsdparameters.cc0000644000175000017500000000240614034554241017065 0ustar frankfrank#define XERR #include "parser.ih" // static VSDvect Parser::VSDparameters(VaryType varyType, StringVect const &keywords, initializer_list const &required) { VSDvect vsdVect(required.size(), VSD{ varyType }); auto lines = any(keywords); // all config lines of 'keywords' unsigned count = 0; while (true) { auto const *line = lines.get(); // get the next line if (not line) break; VSD vsd{ varyType }; char type; if (not Parser::extract(*line, type, vsd)) // get the next VSD continue; // check whether the // type (a..x) is OK auto idIter = find(required.begin(), required.end(), type); if (idIter == required.end()) { Err::msg(Err::INVALID_TYPE) << '`' << type << '\'' << endl; continue; } ++count; // found a VSD specification vsdVect[idIter - required.begin()] = vsd; // store the extracted VSD } if (count != required.size()) Err::msg(Err::VSD_MISSING) << count << " specifications\n"; return vsdVect; } simrisc-14.05.00/parser/extract2.f0000644000175000017500000000051114034554241015574 0ustar frankfrank// static template std::istringstream Parser::extract(LineInfo const &line, Types &...dest) { std::istringstream in{ line.tail }; if (not extract(in, std::forward(dest) ...)) { in.setstate(std::ios::failbit); Err::specification(); } return in; } simrisc-14.05.00/parser/proportion.cc0000644000175000017500000000041514034554241016416 0ustar frankfrank//#define XERR #include "parser.ih" bool Parser::proportion(StringVect const &base, double &dest) { if (extract(one(base), dest)) { if (Globals::proportion(dest)) return true; Err::range(); } dest = 0; return false; } simrisc-14.05.00/parser/one.f0000644000175000017500000000024014034554241014620 0ustar frankfrank// static template bool Parser::one(StringVect const &base, Type &dest) { return static_cast(extract(one(base), dest)); } simrisc-14.05.00/parser/setlabels.cc0000644000175000017500000000043214034554241016160 0ustar frankfrank//#define XERR #include "parser.ih" // static void Parser::setLabels(ConfigLines &parser, StringVect &labels) { while (parser.get() and parser.key() == "label:") labels.push_back(parser.tail()); parser.redo(); // redo the line not containing a label } simrisc-14.05.00/parser/parser.ih0000644000175000017500000000041614034554241015513 0ustar frankfrank#include "parser.h" #include "../xerr/xerr.ih" #include #include #include #include "../configlines/configlines.h" using namespace std; using namespace FBB; #include "lines1.f" #include "linesbegin.f" #include "linesend.f" simrisc-14.05.00/parser/keywordslines.cc0000644000175000017500000000147714034554241017116 0ustar frankfrank//#define XERR #include "parser.ih" // static std::vector const &Parser::keywordsLines( StringVect const &keywords) { Map const *mapPtr = &s_map; Map::const_iterator mapIter; for (auto const &keyword: keywords) // visit the range of keywords { mapIter = mapPtr->find(keyword); // ptr to Map::value_type if (mapIter == mapPtr->end()) // internal error: throw exception throw Exception{} << "Internal error: keyword `" << keyword << "' not configured"; mapPtr = &mapIter->second->d_map; // use the next keyword } // return the first used return mapIter->second->d_lines; // LineInfoVect } simrisc-14.05.00/parser/locateerror.cc0000644000175000017500000000166514034554241016534 0ustar frankfrank#define XERR #include "parser.ih" // static void Parser::locateError(vector &mapPtrVect, ConfigLines &lines, ParamsSrc src) { string key = lines.key(); // look for this key for (size_t idx = mapPtrVect.size(); idx--; ) // upwards from the most { // nested level Map &map = *mapPtrVect[idx]; // found the key at an earlier if (map.find(key) != map.end()) // level { mapPtrVect.resize(idx + 1); // remove nested pointers lines.redo(); // reprocess this line return; } } // the key at the current line was not found in this section emsg << Err::src(src) << " [" << lines.lineNr() << "]: "; Err::msg(Err::UNDEFINED_SPEC) << " `" << lines.line() << '\'' << endl; } simrisc-14.05.00/parser/test/0000755000175000017500000000000014034554241014653 5ustar frankfranksimrisc-14.05.00/parser/test/simrisc0000644000175000017500000000773014034554241016256 0ustar frankfrank# supported distribution names are: Normal, LogNormal, Uniform, Exponential Scenario: # uncomment to use variable spreading #variableSpread: true (or (default if not specified: false)) spread: false iterations: 1 # random generator random, fixed, increasing (default: random) generator: random # with fixed, increasing generators: initial seed (default 1) seed: 1 # nWomen -> nCases nCases: 100000 # discount: pairs of (increasing) begin-diam: cost # age proportion biop (first diameter must be 0) Costs: 50 .0 176 0: 6438 20: 7128 50: 7701 Screening: # round: age (space separated) type(s). # Types are Mammo, Tomo, MRI, see below at Modalities. round: 50 Mammo round: 52 Mammo round: 54 Mammo round: 56 Mammo round: 58 Mammo round: 60 Mammo round: 62 Mammo round: 64 Mammo round: 66 Mammo round: 68 Mammo round: 70 Mammo round: 72 Mammo round: 74 Mammo # value distribution: systematicError: 0 Normal attendanceRate: .8 Normal BreastDensities: # bi-rad classification # ---------------------------- # a b c d ageGroup: 0 - 40 .05 .30 .48 .17 ageGroup: 40 - 50 .06 .34 .47 .13 ageGroup: 50 - 60 .08 .50 .37 .05 ageGroup: 60 - 70 .15 .53 .29 .03 ageGroup: 70 - * .18 .54 .26 .02 Modalities: Mammo: costs: 64 # bi-rad cat: a b c d dose: 3 3 3 3 # agegroup specificity: 0 - 40: .961 40 - *: .965 # 1 2 3 4 m beta: -4.38 Normal .49 Normal -1.34 Normal -7.18 Normal .136 Normal Tomo: costs: 64 # bi-rad cat: a b c d dose: 3 3 3 3 sensitivity: .87 .84 .73 .65 # agegroup specificity: 0 - 40: .961 40 - *: .965 MRI: costs: 280 sensitivity: .94 specificity: .95 Tumor: Incidence: Normal: prob: 1 # value spread dist. lifetimeRisk: .226 .0053 Normal meanAge: 72.9 .552 Normal standardDev: 21.1 .048 Normal BRCA1: prob: 0 lifetimeRisk: .96 meanAge: 53.90 standardDev: 16.51 BRCA2: prob: 0 lifetimeRisk: .96 meanAge: 53.90 standardDev: 16.51 Growth: # value spread dist. start: 5 0 Normal selfDetectMu: 2.92 .084 Normal selfDetectSigma: .70 0 Normal DoublingTime: # mean spread dist. stdev spread dist. ageGroup: 1 - 50: 4.38 .43 Normal .61 0 Normal ageGroup: 50 - 70: 5.06 .17 Normal .26 0 Normal ageGroup: 70 - * : 5.24 .23 Normal .45 0 Normal # b e spread dist. Beir7: .51 -2.0 .32 Normal Survival: # value spread dist: type: a .00004475 .000004392 Normal type: b 1.85867 .0420 Normal type: c - .271 .0101 Normal type: d 2.0167 .0366 Normal simrisc-14.05.00/parser/test/icmconf0000644000175000017500000000105114034554241016211 0ustar frankfrank#define CLS #define MAIN "main.cc" #define SOURCES "*.cc" #define OBJ_EXT ".o" #define TMP_DIR "tmp" #define USE_ECHO ON #define IH ".ih" #define CXX "g++" #define CXXFLAGS " --std=c++2a -Wall -O2 " \ " -fdiagnostics-color=never " #define REFRESH #define LDFLAGS "-s" #define ADD_LIBRARIES "parser configlines err bobcat" #define ADD_LIBRARY_PATHS "../../lib" #define DEFCOM "program" simrisc-14.05.00/parser/test/analysis0000644000175000017500000000017114034554241016420 0ustar frankfranklabel: first line label: second line simple this that next: what Scenario: nCases: 1000 simrisc-14.05.00/parser/test/main.cc0000644000175000017500000000357014034554241016113 0ustar frankfrank//#define XERR #include "main.ih" // needs parser, parserlines and error int main(int argc, char **argv) try { if (argc == 1) throw Exception{} << "arg1: simrisc conf., arg2: one analysis spec\n"; Parser parser; StringVect labels; Parser::OptionsVect options; ifstream in{ argv[2] }; parser.load(in, 1, labels, options); parser.load(argv[1]); cout << "Labels:\n"; for (string const &label: labels) cout << " Label: " << label << '\n'; cout << "Options:\n"; for (auto const &option: options) cout << " Option: `" << option.name << "': " << option.value << '\n'; cout << "Spread:\n"; for (auto element: parser.select({"Scenario:", "spread:"})) cout << "src: " << element.src << ", nr: " << element.lineNr << ", tail: " << element.tail << '\n'; cout << "nCases:\n"; for (auto element: parser.select({"Scenario:", "nCases:"})) cout << "src: " << element.src << ", nr: " << element.lineNr << ", tail: " << element.tail << '\n'; { cout << "Costs:\n"; LineInfoVect const &lines = Parser::select({ "Costs:" }); if (lines.front().tail.empty()) Err::msg(Err::UNDEFINED_SPEC) << ": Costs" << endl; else { double refAge; double prop; uint16_t biop; std::istringstream in{ Parser::extract( lines[0], refAge, prop, biop ) }; if (in) cout << refAge << ", " << biop << '\n'; } } } catch(int x) { return x; } catch (exception const &exc) { cerr << exc.what() << '\n'; } catch (...) { cerr << "unexpected exception\n"; return 1; } simrisc-14.05.00/parser/test/main.ih0000644000175000017500000000025514034554241016123 0ustar frankfrank#include #include #include #include #include #include "../parser.h" using namespace std; using namespace FBB; simrisc-14.05.00/parser/positive.f0000644000175000017500000000021214034554241015700 0ustar frankfrank// static inline bool Parser::positive(StringVect const &base, double &dest) { return atLeast(Globals::WEAK_TOLERANCE, base, dest); } simrisc-14.05.00/parser/lines.cc0000644000175000017500000000115514034554241015317 0ustar frankfrank//#define XERR #include "parser.ih" // static Parser::Lines Parser::lines(StringVect const &keywords) { // Map is unordered_map auto const &vectors = keywordsLines(keywords); for (auto const &vect: vectors) // multiple vectors are possible { // because of respecifications in if (vect.size() != 0) // extra analysis-specs. Return { xerr(" line[0]: " << vect.front().txt); return Lines{ vect.begin(), vect.end() }; } } return Lines{ vectors.front() }; // initializes to empty: no lines } simrisc-14.05.00/parser/nonnegative1.f0000644000175000017500000000015514034554241016442 0ustar frankfrankinline bool Parser::nonNegative(StringVect const &base, double &dest) { return atLeast(0, base, dest); } simrisc-14.05.00/parser/extract3.f0000644000175000017500000000102114034554241015572 0ustar frankfrank// static template std::istringstream Parser::extract(Lines &&lines, Type *dest, size_t size) { std::istringstream in; if (not lines) { in.setstate(std::ios::eofbit); return in; } in.str(lines.get()->tail); for (; size--; ++dest) // fill 'size' elements starting at dest { if (not (in >> *dest)) { in.setstate(std::ios::failbit); Err::specification(); break; } } return in; } simrisc-14.05.00/parser/endpoint.cc0000644000175000017500000000026514034554241016026 0ustar frankfrank//#define XERR #include "parser.ih" // static bool Parser::endPoint(Map::value_type const &value) { return value.second->d_map.empty(); // the next Parser has an empty map } simrisc-14.05.00/parser/lib/0000755000175000017500000000000014034554241014442 5ustar frankfranksimrisc-14.05.00/parser/lib/libparser.a0000777000175000017500000000000014034554241021724 2../tmp/libparser.austar frankfranksimrisc-14.05.00/parser/lib/libconfiglines.a0000777000175000017500000000000014034554241026447 2../../configlines/tmp/libconfiglines.austar frankfranksimrisc-14.05.00/parser/lines1.f0000644000175000017500000000017314034554241015237 0ustar frankfrankinline Parser::Lines::Lines(LineInfoVect const &lines) : d_size(0), d_iter(lines.end()), d_end(lines.end()) {} simrisc-14.05.00/parser/icmconf0000644000175000017500000000007514034554241015237 0ustar frankfrank#define LIBRARY "parser" #include "../icmconf.lib" simrisc-14.05.00/parser/extract1.f0000644000175000017500000000044114034554241015575 0ustar frankfrank// static template std::istringstream Parser::extract(Lines &&lines, Types &...dest) { if (lines) return extract(*lines.get(), std::forward(dest) ...); std::istringstream in; in.setstate(std::ios::eofbit); return in; } simrisc-14.05.00/parser/lines2.cc0000644000175000017500000000040414034554241015375 0ustar frankfrank//#define XERR #include "parser.ih" Parser::Lines::Lines(LineInfoVect::const_iterator const &begin, LineInfoVect::const_iterator const &end) : d_size(end - begin), d_iter(begin), d_end(end) { Err::reset(*d_iter); } simrisc-14.05.00/parser/atleast.cc0000644000175000017500000000045114034554241015640 0ustar frankfrank//#define XERR #include "parser.ih" // static bool Parser::atLeast(double minimum, StringVect const &base, double &dest) { if (extract(one(base), dest)) { if (minimum <= dest) return true; Err::atLeast(minimum); } dest = minimum; return false; } simrisc-14.05.00/parser/linesget.cc0000644000175000017500000000061414034554241016016 0ustar frankfrank#define XERR #include "parser.ih" LineInfo const *Parser::Lines::get() { return d_iter == d_end ? // no more lines 0 : Err::reset(*d_iter++); // allow new error messages, provide // Err with the current line and // return the current line's address } simrisc-14.05.00/parser/setoptions.cc0000644000175000017500000000144414034554241016415 0ustar frankfrank//#define XERR #include "parser.ih" // static void Parser::setOptions(ConfigLines &parser, OptionsVect &options) { while ( parser.get() // got a line and it's not and // a top-level parser s_map.find(parser.key()) == s_map.end() // parameter ) options.push_back( { parser.key().back() == ':' ? parser.key().substr(0, parser.key().length() - 1) : parser.key(), parser.value(), parser.lineNr(), } ); parser.redo(); // redo the line not containing a label } simrisc-14.05.00/parser/linesopbool.f0000644000175000017500000000011014034554241016360 0ustar frankfrankinline Parser::Lines::operator bool() const { return d_size != 0; } simrisc-14.05.00/parser/nonnegative2.f0000644000175000017500000000026714034554241016447 0ustar frankfranktemplate bool Parser::nonNegative(StringVect const &base, Type &dest) { double tmp; bool ret = nonNegative(base, tmp); dest = tmp; return ret; } simrisc-14.05.00/parser/frame0000644000175000017500000000006214034554241014707 0ustar frankfrank//#define XERR #include "parser.ih" Parser:: { } simrisc-14.05.00/parser/load1.cc0000644000175000017500000000131214034554241015200 0ustar frankfrank//#define XERR #include "parser.ih" void Parser::load(std::istream &in, uint16_t startLineNr, StringVect &labels, OptionsVect &options) { ConfigLines lines{ in, startLineNr }; // read the current stream setLabels(lines, labels); setOptions(lines, options); addLineInfoVectors(s_map); // add (empty) LineInfoVects at // the map's deepest nesting // levels vector mapPtrVect{ &s_map }; // start loading at the top while (lines.get()) // add the config lines addConfigLine(mapPtrVect, lines, ANALYSIS); } simrisc-14.05.00/parser/any.cc0000644000175000017500000000040114034554241014765 0ustar frankfrank//#define XERR #include "parser.ih" //static Parser::Lines Parser::any(StringVect const &keywords) { Lines lines = Parser::lines(keywords); if (not lines) Err::msg(Err::MISSING_SPEC) << sectionList(keywords) << endl; return lines; } simrisc-14.05.00/parser/extract4.f0000644000175000017500000000044414034554241015603 0ustar frankfrank// static template bool Parser::extract(std::istream &in, Type &first, Types &...more) { in >> first; return extract(in, std::forward(more)...); } inline bool Parser::extract(std::istream &in) { return static_cast(in); } simrisc-14.05.00/parser/addconfigline.cc0000644000175000017500000000152114034554241016770 0ustar frankfrank//#define XERR #include "parser.ih" // static void Parser::addConfigLine(vector &mapPtrVect, ConfigLines &lines, ParamsSrc src) { string key = lines.key(); Map &map = *mapPtrVect.back(); // look for the key in the current auto iter = map.find(key); // map section if (iter != map.end()) // key was found { if (endPoint(*iter)) // no deeper level: store the line iter->second->d_lines.back().push_back ( { src, lines.lineNr(), lines.line(), lines.tail() } ); else // key found, but not an endpoint: mapPtrVect.push_back(&iter->second->d_map); // go nesting return; } locateError(mapPtrVect, lines, src); } simrisc-14.05.00/random/0000755000175000017500000000000014051665273013667 5ustar frankfranksimrisc-14.05.00/random/reinit.cc0000644000175000017500000000073714034554241015470 0ustar frankfrank//#define XERR #include "random.ih" void Random::reinit(size_t nCases, bool vary, GeneratorType type) { d_vary = vary; if (d_vary and nCases == 1) throw Exception{} << "'spread: true' cannot be used with 'cases: 1'"; d_nCases = nCases; switch (type) { case INCREASING_SEED: ++d_seed; break; case FIXED_SEED: break; default: d_seed = time(0); break; } reset(); } simrisc-14.05.00/random/data.cc0000644000175000017500000000007714034554241015104 0ustar frankfrank//#define XERR #include "random.ih" Random Random::s_random; simrisc-14.05.00/random/lognormalvary.cc0000644000175000017500000000033114034554241017060 0ustar frankfrank//#define XERR #include "random.ih" double Random::logNormalVary(double mean, double stdDev) { d_logNormalVary->param(LogNormalParams{ mean, stdDev }); return (*d_logNormalVary)(d_engine[LOGNORMAL_VARY]); } simrisc-14.05.00/random/random.ih0000644000175000017500000000027414034554241015465 0ustar frankfrank#include "random.h" #include "../xerr/xerr.ih" #include #include #include #include "../globals/globals.h" using namespace std; using namespace FBB; simrisc-14.05.00/random/reset.cc0000644000175000017500000000155114034554241015313 0ustar frankfrank#define XERR #include "random.ih" void Random::reset() { size_t seed = d_seed; for (size_t idx = 0; idx != N_STD_DISTRIBUTIONS; ++idx) d_engine[idx] = mt19937{seed <<= 1}; d_uniform.reset(); d_uniformCase.reset(); d_logNormal.reset(); if (d_vary) { seed <<= 1; if (d_normalVary) { d_engine[NORMAL_VARY] = mt19937{seed}; d_normalVary->reset(); } seed <<= 1; if (d_uniformVary) { d_engine[UNIFORM_VARY] = mt19937{seed}; d_uniformVary->reset(); } seed <<= 1; if (d_logNormalVary) { d_engine[LOGNORMAL_VARY] = mt19937{seed}; d_logNormalVary->reset(); } } } // d_chi2->reset(); // d_binomial->reset(); // d_exponential.reset(exponential_distribution<>); simrisc-14.05.00/random/lognormal.cc0000644000175000017500000000030414034554241016156 0ustar frankfrank//#define XERR #include "random.ih" double Random::logNormal(double mean, double stdDev) { d_logNormal.param(LogNormalParams{ mean, stdDev }); return d_logNormal(d_engine[LOGNORMAL]); } simrisc-14.05.00/random/uniformvary.cc0000644000175000017500000000016414034554241016551 0ustar frankfrank//#define XERR #include "random.ih" double Random::uniformVary() { return d_uniform(d_engine[UNIFORM_VARY]); } simrisc-14.05.00/random/random.h0000644000175000017500000000425714034554241015321 0ustar frankfrank#ifndef INCLUDED_RANDOM_ #define INCLUDED_RANDOM_ #include #include // using the stl's mercenne twister #include #include #include "../enums/enums.h" class Random { typedef std::lognormal_distribution::param_type LogNormalParams; typedef std::vector EngineVect; bool d_vary; size_t d_seed; size_t d_nCases; EngineVect d_engine; // all distribution types are default: double std::uniform_real_distribution<> d_uniform; // default: 0, max std::uniform_real_distribution<> d_uniformCase; std::lognormal_distribution<> d_logNormal; // default: 0, 1 // these are used for varying: // default: 0, 1 std::unique_ptr> d_normalVary; std::unique_ptr> d_uniformVary; std::unique_ptr> d_logNormalVary; static Random s_random; public: Random(Random const &other) = delete; void setSeed(size_t seed); // called at each iteration void reinit(size_t nCases, bool vary, GeneratorType type); static Random &instance(); // when parsing the config file // specify which vary-specific // distributions are used void use(DistType distribution); double uniform(); // used for generating reproducible double uniformCase(); // case characteristics double logNormal(double mean, double stdDev); // only used when 'spread: true': double normalVary(); double uniformVary(); double logNormalVary(double mean, double stdDev); private: Random(); void reset(); }; inline void Random::setSeed(size_t seed) { d_seed = seed; } // static inline Random &Random::instance() { return s_random; } #endif simrisc-14.05.00/random/uniformcase.cc0000644000175000017500000000016614034554241016505 0ustar frankfrank#define XERR #include "random.ih" double Random::uniformCase() { return d_uniformCase(d_engine[UNIFORM_CASE]); } simrisc-14.05.00/random/normalvary.cc0000644000175000017500000000066714034554241016372 0ustar frankfrank//#define XERR #include "random.ih" double Random::normalVary() { return (*d_normalVary)(d_engine[NORMAL_VARY]); } //////////////////////////////////////////// // ?? // d_normal is the std. normal distribution. To obtain a value from the // std. normal distribution return d_normal(d_engine) // double x1 = uniform(); // double x2 = uniform(); // double y = sqrt( -2 * log(x1) ); // // return y * sin( 2 * M_PI * x2 ); simrisc-14.05.00/random/icmconf0000644000175000017500000000007514034554241015223 0ustar frankfrank#define LIBRARY "random" #include "../icmconf.lib" simrisc-14.05.00/random/random1.cc0000644000175000017500000000027014034554241015527 0ustar frankfrank//#define XERR #include "random.ih" Random::Random() : d_engine(N_DISTRIBUTIONS) {} // d_binomial(new binomial_distribution<>{}), // d_chi2(new chi_squared_distribution<>{}), simrisc-14.05.00/random/uniform.cc0000644000175000017500000000015314034554241015645 0ustar frankfrank//#define XERR #include "random.ih" double Random::uniform() { return d_uniform(d_engine[UNIFORM]); } simrisc-14.05.00/random/frame0000644000175000017500000000006214034554241014673 0ustar frankfrank//#define XERR #include "random.ih" Random:: { } simrisc-14.05.00/random/users.txt0000644000175000017500000000450214034554241015563 0ustar frankfrankdensities/indices.cc -- randomly determines the bi-rad category for every screening round age tumor/reset.cc -- resets the tumor's parameters like tumor age, p(survival), doublingtime, selfdetect age etc. Called from Loop:initialize, called from Loop::womenLoop for every simulated case tumor/tumorage.cc -- given the cumulative risk distribution for having a tumor, an age from that distribution is randomly drawn (used by Tumor::reset) incidence/carrier.cc -- determines which incidence carrier is used vary/refresh.cc -- if 'variableVary:' was specified, the values used for the Growth, Survival, and Incidence parameters like risk, mean and std. dev. are updated loop/maybedetect.cc -- determines whether, given a modality's sensitivity, a false negative occurred loop/naturaldeathage.cc -- from Loop::initialize in Loop::womenLoop: for each simulated case (woman): determines the case's natural death age loop/checkseed.cc -- at each new iteration: determines whether the random number generator is reset using the original seed or using the next seed value loop/maybefalsepositive.cc -- determines whether, given a modality's specificity, a false positive occurred loop/use.cc -- determines whether a modality is used by a screening round loop/loop1.cc -- resets the generators if variableVary was specified loop/iterate.cc -- initializes the generators ---------------------------------- Candidates for a separate random number generator: loop/naturaldeathage.cc simrisc-14.05.00/random/use.cc0000644000175000017500000000126614034554241014770 0ustar frankfrank#define XERR #include "random.ih" // when use() is called, reinit -> reset has defined the // vary-generators and vary-engines void Random::use(DistType distType) { switch (distType) { case NORMAL_VARY: if (not d_normalVary) d_normalVary.reset(new normal_distribution<>{}); break; case UNIFORM_VARY: if (not d_uniformVary) d_uniformVary.reset(new uniform_real_distribution<>{}); break; case LOGNORMAL_VARY: if (not d_logNormalVary) d_logNormalVary.reset(new lognormal_distribution<>{}); break; default: break; } } simrisc-14.05.00/round/0000755000175000017500000000000014051665273013536 5ustar frankfranksimrisc-14.05.00/round/round.h0000644000175000017500000000331114034554241015025 0ustar frankfrank#ifndef INCLUDED_ROUND_ #define INCLUDED_ROUND_ #include #include #include // contains a round specification from the config file #include "../typedefs/typedefs.h" #include "../globals/globals.h" class Round { friend std::istream &operator>>(std::istream &in, Round &round); friend std::ostream &operator<<(std::ostream &out, Round const &round); double d_age; Uint16Vect d_modalities; // modalities used in this screening round StringVect const &d_modalityIDs; public: Round(StringVect const &modalityIDs); bool add(uint16_t idx); bool none() const; // true: none was specified; double age() const; uint16_t rndAge() const; // rounded double age value // modality indices used by Uint16Vect const &modalityIndices() const; // this screening round // StringVect const &modalityIDs() const; // screening round private: std::ostream &insert(std::ostream &out) const; }; inline bool Round::none() const { return Globals::isZero(d_age - END_AGE); } inline Round::Round(StringVect const &modalityIDs) : d_modalityIDs(modalityIDs) {} inline Uint16Vect const &Round::modalityIndices() const { return d_modalities; } // inline StringVect const &Round::modalityIDs() const // { // return d_modalities; // } inline double Round::age() const { return d_age; } inline uint16_t Round::rndAge() const { return round(d_age); } inline std::ostream &operator<<(std::ostream &out, Round const &round) { return round.insert(out); } typedef std::vector RoundVect; #endif simrisc-14.05.00/round/insert.cc0000644000175000017500000000041514034554241015342 0ustar frankfrank//#define XERR #include "round.ih" std::ostream &Round::insert(std::ostream &out) const { out << "age: " << static_cast(round(d_age)); for (uint16_t modalityIdx: d_modalities) out << ", " << d_modalityIDs[modalityIdx]; return out; } simrisc-14.05.00/round/round.ih0000644000175000017500000000020114034554241015171 0ustar frankfrank#include "round.h" #include "../xerr/xerr.ih" #include #include #include using namespace std; simrisc-14.05.00/round/icmconf0000644000175000017500000000007414034554241015071 0ustar frankfrank#define LIBRARY "round" #include "../icmconf.lib" simrisc-14.05.00/round/extract.cc0000644000175000017500000000106414034554241015511 0ustar frankfrank////#define XERR //#include "round.ih" // //std::istream &Round::extract(istream &in) //{ // string modality; // // if (in >> d_age >> modality) // at least one modality must be // { // specified // do // { // d_idx = d_modalities.size(); // d_modalities.push_back(move(modality)); // 'modality' must be // // configured // } // while (in >> modality); // // in.clear(); // } // // return in; //} // simrisc-14.05.00/round/opextract.cc0000644000175000017500000000057014034554241016051 0ustar frankfrank//#define XERR #include "round.ih" std::istream &operator>>(std::istream &in, Round &round) { string specification; in >> specification; if (specification == "none") round.d_age = END_AGE; else { istringstream inStr{ specification }; if (not (inStr >> round.d_age)) in.setstate(ios::failbit); } return in; } simrisc-14.05.00/round/frame0000644000175000017500000000006014034554241014540 0ustar frankfrank//#define XERR #include "round.ih" Round:: { } simrisc-14.05.00/round/add.cc0000644000175000017500000000040714034554241014567 0ustar frankfrank//#define XERR #include "round.ih" bool Round::add(uint16_t idx) { if ( find(d_modalities.begin(), d_modalities.end(), idx) != d_modalities.end() ) return false; d_modalities.push_back(idx); return true; } simrisc-14.05.00/scenario/0000755000175000017500000000000014051665273014212 5ustar frankfranksimrisc-14.05.00/scenario/scenario.ih0000644000175000017500000000305214034554241016330 0ustar frankfrank#include "scenario.h" #include "../xerr/xerr.ih" #include #include using namespace std; // using namespace FBB; // template // Value const &setDefault(StringVect &base, char const *next, // Value const &fallback, // unordered_map const &map) // { // base.back() = next; // specify the required line // auto const &lines = Parser::select(base); // get the line(s) // base.pop_back(); // back to the orig. d_base // // return lines.empty() ? // not specified: use the default val. // fallback // : // extract 1 value // Parser::locateOne(map, lines.front()); // } // // template // Value setDefault(StringVect &base, char const *next, Value const &fallback) // { // base.push_back(next); // specify the required line // auto const &lines = Parser::select(base); // get the line(s) // base.pop_back(); // back to the orig. d_base // // if (lines.empty()) // not specified: use the default val. // return fallback; // // Value value; // Parser::extract(lines.front(), value); // return value; // } //////////////////////////////////////////////////////////// // #include // //#include // #include // #include // // #include // using namespace std; simrisc-14.05.00/scenario/find.cc0000644000175000017500000000046214034554241015434 0ustar frankfrank//#define XERR #include "scenario.ih" // static int Scenario::find(StringVect const &haystack, string const &needle) { auto iter = std::find(haystack.begin(), haystack.end(), needle); if (iter != haystack.end()) return iter - haystack.begin(); Err::specification(); return -1; } simrisc-14.05.00/scenario/setvary.cc0000644000175000017500000000042314034554241016206 0ustar frankfrank#define XERR #include "scenario.ih" void Scenario::setVary() { d_base.back() = "spread:"; string spread; if (Parser::one(d_base, spread)) { if (int idx = find(s_bool, spread); idx != -1) d_vary = static_cast(idx); } } simrisc-14.05.00/scenario/data.cc0000644000175000017500000000055314034554241015426 0ustar frankfrank//#define XERR #include "scenario.ih" StringVect Scenario::s_generatorType = { "fixed", // the SeedType ordering must "increasing", // correspond to the order of the "random", // GeneratorType enum's values }; StringVect Scenario::s_bool = { "false", "true" }; simrisc-14.05.00/scenario/setseed.cc0000644000175000017500000000035314034554241016147 0ustar frankfrank#define XERR #include "scenario.ih" void Scenario::setSeed() { if (d_generatorType == RANDOM_SEED) { d_seed = 0; return; } d_base.back() = "seed:"; Parser::nonNegative(d_base, d_seed); } simrisc-14.05.00/scenario/scenario1.cc0000644000175000017500000000036414034554241016401 0ustar frankfrank#define XERR #include "scenario.ih" Scenario::Scenario() : d_base{ "Scenario:", "" } // 2nd field set by set-members { setNiterations(); setNcases(); setGeneratorType(); setSeed(); setVary(); } simrisc-14.05.00/scenario/scenario.h0000644000175000017500000000411114034554241016154 0ustar frankfrank#ifndef INCLUDED_SCENARIO_ #define INCLUDED_SCENARIO_ // Scenario: // # default values are shown // // # use true for variable varying // spread: false // // iterations: 1 // // # random generator behavior: // # random, fixed, increasing // generator: random // // # initial seed unless using generator: random // seed: 1 // // # n cases to simulate // cases: 1000 #include "../parser/parser.h" class Scenario { StringVect d_base; bool d_vary; // true: apply variations to configuration // parameters GeneratorType d_generatorType; size_t d_nIterations; size_t d_nCases; size_t d_seed; static StringVect s_generatorType; static StringVect s_bool; public: Scenario(); bool vary() const; // true: vary to config. params size_t nIterations() const; size_t seed() const; GeneratorType generatorType() const; size_t nCases() const; void writeParameters(std::ostream &out, size_t iter) const; private: void setNiterations(); // set n iteratations void setNcases(); // set nCases void setSeed(); // set seed value void setGeneratorType(); // set the random generator type void setVary(); // set variableSpred static int find(StringVect const &haystack, std::string const &needle); }; inline bool Scenario::vary() const { return d_vary; } inline size_t Scenario::nIterations() const { return d_nIterations; } inline size_t Scenario::seed() const { return d_seed; } inline GeneratorType Scenario::generatorType() const { return d_generatorType; } inline size_t Scenario::nCases() const { return d_nCases; } #endif simrisc-14.05.00/scenario/icmconf0000644000175000017500000000007714034554241015550 0ustar frankfrank#define LIBRARY "scenario" #include "../icmconf.lib" simrisc-14.05.00/scenario/writeparameters.cc0000644000175000017500000000072214034554241017731 0ustar frankfrank//#define XERR #include "scenario.ih" void Scenario::writeParameters(ostream &out, size_t iter) const { out << "Scenario:\n" " iteration: " << iter << "\n" " generator: " << s_generatorType[d_generatorType] << "\n" " n iterations: " << d_nIterations << "\n" " n cases: " << d_nCases << "\n" " seed " << d_seed << "\n" " spread: " << s_bool[d_vary] << "\n" "\n"; } simrisc-14.05.00/scenario/setgeneratortype.cc0000644000175000017500000000045414034554241020121 0ustar frankfrank#define XERR #include "scenario.ih" void Scenario::setGeneratorType() { d_base.back() = "generator:"; string type; if (Parser::one(d_base, type)) { if (int idx = find(s_generatorType, type); idx != -1) d_generatorType = static_cast(idx); } } simrisc-14.05.00/scenario/setncases.cc0000644000175000017500000000023114034554241016476 0ustar frankfrank//#define XERR #include "scenario.ih" void Scenario::setNcases() { d_base.back() = "cases:"; Parser::nonNegative(d_base, d_nCases); } simrisc-14.05.00/scenario/setniterations.cc0000644000175000017500000000025014034554241017562 0ustar frankfrank//#define XERR #include "scenario.ih" void Scenario::setNiterations() { d_base.back() = "iterations:"; Parser::nonNegative(d_base, d_nIterations); } simrisc-14.05.00/scenario/frame0000644000175000017500000000006614034554241015222 0ustar frankfrank//#define XERR #include "scenario.ih" Scenario:: { } simrisc-14.05.00/screening/0000755000175000017500000000000014052262374014360 5ustar frankfranksimrisc-14.05.00/screening/ages.cc0000644000175000017500000000030214034554241015576 0ustar frankfrank//#define XERR #include "screening.ih" DoubleVect Screening::ages() const { DoubleVect ret; for (auto const &round: d_roundVect) ret.push_back(round.age()); return ret; } simrisc-14.05.00/screening/screening.h0000644000175000017500000001106014052262374016504 0ustar frankfrank#ifndef INCLUDED_SCREENING_ #define INCLUDED_SCREENING_ // Screening: // // # round: age space separated modalities. // round: 50 Mammo // round: 52 Mammo // round: 54 Mammo // round: 56 Mammo // round: 58 Mammo // round: 60 Mammo // round: 62 Mammo // round: 64 Mammo // round: 66 Mammo // round: 68 Mammo // round: 70 Mammo // round: 72 Mammo // round: 74 Mammo // alternatively: // round: none // // # screening value // attendanceRate: .8 // #include #include "../round/round.h" class Modalities; class Screening { Modalities const &d_modalities; StringVect d_base; RoundVect d_roundVect; double d_rate; // points to static members: // errRisk1404 or void (*d_errRiskVector)(DoubleVect &, // errRiskA1405 Modalities const &, Round const &, uint16_t, double, double); public: Screening(Modalities const &modalities); double rate() const; DoubleVect radiationRisk( Modalities const &modalities, Uint16Vect const &indices, double beta, double eta); // beir7 values DoubleVect ages() const; // vector of ages of the screening rounds uint16_t nRounds() const; double age(size_t idx) const; // roundIdx is, e.g. Round const &round(size_t roundIdx) const; // Loop::d_round void writeParameters(std::ostream &out) const; private: void setAttendanceRate(); void setRounds(); // false: round: none, noneLine // has the last noneLine bool addRound(LineInfo *noneLine, LineInfo const &line); bool increasingAge(Round const &round) const; static void errRisk1404(DoubleVect &riskVect, Modalities const &modalities, Round const &round, uint16_t biRadIdx, double beta, double eta); static void errRisk1405(DoubleVect &riskVect, Modalities const &modalities, Round const &round, uint16_t biRadIdx, double beta, double eta); // called by errRiskRelative static double beir7Err(Round const &round, uint16_t idx, double beta, double eta, Modalities const &modalities); // called by earRisk static double beir7Err(uint16_t age, Round const &round, uint16_t idx, double beta, double eta, Modalities const &modalities); }; inline double Screening::rate() const { return d_rate; } inline uint16_t Screening::nRounds() const { return d_roundVect.size(); } inline double Screening::age(size_t idx) const { return d_roundVect[idx].age(); } inline Round const &Screening::round(size_t idx) const { return d_roundVect[idx]; } // // void beir7dose(double const *dose); // .h // // // // // RoundVect const &rounds() const; // // // StringSet const &modalities() const; // double const *d_beir7dose; // set from Screening using // // beir7dose() // // RoundVect d_rounds; // StringSet d_modalities; // specified modalities // void set(Distribution *dest, // 1 // Scenario const &scenario, char const *id); // // 2 // static bool set(Distribution *dest, // Scenario::const_iterator const &iter); // // // inline StringSet const &Screening::modalities() const // { // return d_modalities; // } // // inline RoundVect const &Screening::rounds() const // { // return d_rounds; // } // // inline void Screening::beir7dose(double const *dose) // { // d_beir7dose = dose; // } //////////////////////////////////////////////////////////// // inline double Screening::Distribution::value() const // { // return d_value; // } // static char const s_errorID[]; // static char const s_attendanceID[]; // static char const s_roundID[]; #endif simrisc-14.05.00/screening/errrisk1404.cc0000644000175000017500000000115714052230324016653 0ustar frankfrank//#define XERR #include "screening.ih" // static void Screening::errRisk1404(DoubleVect &vect, Modalities const &modalities, Round const &round, uint16_t biRadIdx, double beta, double eta) { // compute beir7Err once, double error = beir7Err(round, biRadIdx, beta, eta, modalities); // then visit all subsequent ages for (uint16_t age = round.rndAge() + 1; age != END_AGE; ++age) vect[age] *= error; } simrisc-14.05.00/screening/setattendancerate.cc0000644000175000017500000000027214034554241020363 0ustar frankfrank//#define XERR #include "screening.ih" // attendanceRate: 0.8 void Screening::setAttendanceRate() { d_base.back() = "attendanceRate:"; Parser::proportion(d_base, d_rate); } simrisc-14.05.00/screening/addround.cc0000644000175000017500000000206514034554241016467 0ustar frankfrank//#define XERR #include "screening.ih" // false: round: none was specified // true: round: age modality/ties was specified bool Screening::addRound(LineInfo *noneLine, LineInfo const &lineInfo) { Round round(d_modalities.modalityIDs()); auto in = Parser::extract(lineInfo, round); // extracts the age if (round.none()) { *noneLine = lineInfo; // save the last round: none line return false; } if (not in) return true; if (not increasingAge(round)) { Err::msg(Err::ROUND_AGES_DONT_INC) << endl; return true; } string modality; while (in >> modality) { Err::Context context; if (uint16_t idx = d_modalities.find(modality); idx == ~0U) context = Err::UNDEFINED_MODALITY; else { if (round.add(idx)) continue; context = Err::MODALITY_REPEATED; } Err::msg(context) << endl; return true; } d_roundVect.push_back(move(round)); return true; } simrisc-14.05.00/screening/icmconf0000644000175000017500000000010014034554241015705 0ustar frankfrank#define LIBRARY "screening" #include "../icmconf.lib" simrisc-14.05.00/screening/radiationrisk.cc0000644000175000017500000000131714051665063017535 0ustar frankfrank#define XERR #include "screening.ih" // called from loop/initialize.cc DoubleVect Screening::radiationRisk( Modalities const &modalities, Uint16Vect const &biRadIndices, double beta, double eta) // beir7 values { DoubleVect vect = DoubleVect(END_AGE, 1); for (size_t rndIdx = 0, end = d_roundVect.size(); rndIdx != end; ++rndIdx) { if (Random::instance().uniform() <= d_rate) (*d_errRiskVector) ( vect, modalities, d_roundVect[rndIdx], biRadIndices[rndIdx], beta, eta ); } return vect; } simrisc-14.05.00/screening/writeparameters.cc0000644000175000017500000000060714034554241020105 0ustar frankfrank//#define XERR #include "screening.ih" void Screening::writeParameters(ostream &out) const { Globals::setPrecision(out, 1) << "Screening:\n" " attendanceRate: " << d_rate << "\n" " rounds: " << d_roundVect.size() << '\n'; for (auto const &round: d_roundVect) out << " " << round << '\n'; Globals::setPrecision(out, 3).put('\n'); } simrisc-14.05.00/screening/screening1.cc0000644000175000017500000000042414052230415016714 0ustar frankfrank#define XERR #include "screening.ih" Screening::Screening(Modalities const &modalities) : d_modalities(modalities), d_base{ "Screening:", "" }, d_errRiskVector(Arg::instance().option('e') ? errRisk1404 : errRisk1405) { setAttendanceRate(); setRounds(); } simrisc-14.05.00/screening/beir7err2.cc0000644000175000017500000000073114051175670016474 0ustar frankfrank//#define XERR #include "screening.ih" // static double Screening::beir7Err(uint16_t age, Round const &round, uint16_t biradIdx, double beta, double eta, Modalities const &modalities) { double risk = 1; double factor = beta * pow(age / 60.0, eta) / 1000; for (ModBase const *modBase: modalities.use(round.modalityIndices())) risk *= (1 + factor * modBase->dose(biradIdx)); return risk; } simrisc-14.05.00/screening/errrisk1405.cc0000644000175000017500000000107614052230333016654 0ustar frankfrank//#define XERR #include "screening.ih" // static void Screening::errRisk1405(DoubleVect &vect, Modalities const &modalities, Round const &round, uint16_t biRadIdx, double beta, double eta) { // visit all subsequent ages, and compute // beir7Err separately for each age for (uint16_t age = round.rndAge() + 1; age != END_AGE; ++age) vect[age] *= beir7Err(age, round, biRadIdx, beta, eta, modalities); } simrisc-14.05.00/screening/frame0000644000175000017500000000007014034554241015367 0ustar frankfrank//#define XERR #include "screening.ih" Screening:: { } simrisc-14.05.00/screening/beir7err1.cc0000644000175000017500000000067014034554241016471 0ustar frankfrank//#define XERR #include "screening.ih" // static double Screening::beir7Err(Round const &round, uint16_t biradIdx, double beta, double eta, Modalities const &modalities) { double risk = 1; double factor = beta * pow(round.age() / 60, eta) / 1000; for (ModBase const *modBase: modalities.use(round.modalityIndices())) risk *= (1 + factor * modBase->dose(biradIdx)); return risk; } simrisc-14.05.00/screening/increasingage.cc0000644000175000017500000000044314034554241017464 0ustar frankfrank//#define XERR #include "screening.ih" bool Screening::increasingAge(Round const &round) const { return d_roundVect.empty() or Globals::weakCompare(d_roundVect.back().age() + 1, round.age()) != 1; // new age must be at least last age + 1 ; } simrisc-14.05.00/screening/setrounds.cc0000644000175000017500000000102014034554241016703 0ustar frankfrank//#define XERR #include "screening.ih" void Screening::setRounds() { d_base.back() = "round:"; auto lines = Parser::any(d_base); bool useRounds = true; LineInfo noneLine; while (true) { LineInfo const *line = lines.get(); if (line == 0) break; useRounds = addRound(&noneLine, *line) and useRounds; } if (d_roundVect.size() and not useRounds) { Err::reset(noneLine); Err::msg(Err::ROUND_NONE) << noneLine.txt << endl; } } simrisc-14.05.00/screening/screening.ih0000644000175000017500000000043014050462564016655 0ustar frankfrank#include "screening.h" #include "../xerr/xerr.ih" #include #include "../random/random.h" #include "../modbase/modbase.h" #include "../globals/globals.h" #include "../modalities/modalities.h" #include "../parser/parser.h" using namespace std; using namespace FBB; simrisc-14.05.00/simulator/0000755000175000017500000000000014051665273014426 5ustar frankfranksimrisc-14.05.00/simulator/endofspecs.cc0000644000175000017500000000014014034554241017052 0ustar frankfrank//#define XERR #include "simulator.ih" string Simulator::endOfSpecs() { return string{}; } simrisc-14.05.00/simulator/run.cc0000644000175000017500000000065514034554241015540 0ustar frankfrank#define XERR #include "simulator.ih" //code void Simulator::run() { while (d_next) { uint16_t lineNr = d_lineNr; // read the next analysis specs string spec = (this->*d_nextSpecs)(); emsg.setCount(0); Analysis analysis{ istringstream{ spec }, lineNr }; analysis.run(); // run the simulation } } //= simrisc-14.05.00/simulator/fileanalysis.cc0000644000175000017500000000157714034554241017423 0ustar frankfrank//#define XERR #include "simulator.ih" string Simulator::fileAnalysis() { d_next = false; string specs; string line; while (getline(d_ifstream, line)) { ++d_lineNr; // process all lines until the next // analysis: specification is found if ( size_t pos = line.find_first_not_of(" \t\r"); pos != string::npos // found non-blanks and // and 'analysis:' as 1st word line.find("Analysis:", pos) == pos ) { d_next = true; break; // the next analysis is ready } specs += line + '\n'; // append the line to the } // specs return specs; } simrisc-14.05.00/simulator/setanalysissource.cc0000644000175000017500000000165114034554241020511 0ustar frankfrank//#define XERR #include "simulator.ih" void Simulator::setAnalysisSource() { Arg const &arg = Arg::instance(); if (arg.option('o')) // -o -> specs from { d_next = true; d_nextSpecs = &Simulator::cmdLineAnalysis; // cmd line args } else { // otherwise from file d_ifstream = Exception::factory(arg[0]); string line; while (getline(d_ifstream, line)) { ++d_lineNr; size_t pos = line.find_first_not_of(" \t\r"); if (pos == string::npos) continue; if (line.find("Analysis:", pos) == pos) // analysis up to EOF of { d_next = true; break; // the next analysis } } d_nextSpecs = &Simulator::fileAnalysis; } } simrisc-14.05.00/simulator/simulator.ih0000644000175000017500000000034714034554241016764 0ustar frankfrank#include "simulator.h" #include "../xerr/xerr.ih" #include #include #include #include #include "../analysis/analysis.h" using namespace std; using namespace FBB; simrisc-14.05.00/simulator/simulator1.cc0000644000175000017500000000024714034554241017031 0ustar frankfrank//#define XERR #include "simulator.ih" Simulator::Simulator() { imsg.off(); setAnalysisSource(); // maybe one analysis (-o) or more } simrisc-14.05.00/simulator/cmdlineanalysis.cc0000644000175000017500000000066214034554241020111 0ustar frankfrank//#define XERR #include "simulator.ih" string Simulator::cmdLineAnalysis() { string specs; Arg const &arg = Arg::instance(); for (size_t idx = 0, end = arg.nArgs(); idx != end; ++idx) { specs += arg[idx]; if (specs.back() == ',') // commas end specifications specs.back() = '\n'; else specs += ' '; } d_next = false; return specs; } simrisc-14.05.00/simulator/icmconf0000644000175000017500000000010014034554241015747 0ustar frankfrank#define LIBRARY "simulator" #include "../icmconf.lib" simrisc-14.05.00/simulator/simulator.h0000644000175000017500000000210314034554241016603 0ustar frankfrank#ifndef INCLUDED_SIMULATOR_ #define INCLUDED_SIMULATOR_ #include // analyses specfy different parameters, like screeningRound, iterations, // nWomen class Simulator { //data bool d_next = false; // true if 'run()' should run // an analysis uint16_t d_lineNr = 1; // updated by 'fileAnalysis' std::ifstream d_ifstream; // multiple analysis specs std::string (Simulator::*d_nextSpecs)(); // ptr to function handling // the (next) analysis spec. //= public: Simulator(); void run(); private: bool nextAnalysis(); void setAnalysisSource(); // extra specifications either on the // cmd line or the next 'analysis:' // specification from file std::string cmdLineAnalysis(); std::string fileAnalysis(); std::string endOfSpecs(); }; #endif simrisc-14.05.00/simulator/frame0000644000175000017500000000007014034554241015431 0ustar frankfrank//#define XERR #include "simulator.ih" Simulator:: { } simrisc-14.05.00/stdconfig/0000755000175000017500000000000014034554241014360 5ustar frankfranksimrisc-14.05.00/stdconfig/simrisc0000644000175000017500000001314114034554241015754 0ustar frankfrank# supported distribution names are: Normal, LogNormal, Uniform, Exponential # Modalities are: Mammo, Tomo, MRI Scenario: # use true for variable spreading # spread: true spread: false iterations: 1 # random generator behavior: # random, fixed, increasing generator: fixed # initial seed unless using generator: random seed: 1 # n cases to simulate cases: 1000 # discount: pairs of (increasing) 'begin-diam: cost' # ref.age proportion biop specs (first diameter must be 0) Costs: biop: 176 diameters: 0: 6438 20: 7128 50: 7701 Discount: age: 50 proportion: 0 BreastDensities: # bi-rad: a b c d ageGroup: 0 - 40 .05 .30 .48 .17 ageGroup: 40 - 50 .06 .34 .47 .13 ageGroup: 50 - 60 .08 .50 .37 .05 ageGroup: 60 - 70 .15 .53 .29 .03 ageGroup: 70 - * .18 .54 .26 .02 Modalities: Mammo: costs: 64 # default: systematicError: 0.1 Dose: # mean spread dist bi-rad: a 3 1 Normal bi-rad: b 3 1 Normal bi-rad: c 3 1 Normal bi-rad: d 3 1 Normal M: # proportion spread dist bi-rad: a .061 .021 Normal bi-rad: b .163 .045 Normal bi-rad: c .400 .106 Normal bi-rad: d .826 .088 Normal Beta: # mean spread dist nr: 1 -4.38 .002 Normal nr: 2 .49 .0005 Normal nr: 3 -1.34 .0074 Normal nr: 4 -7.18 .0340 Normal Specificity: # range proportion spread dist ageGroup: 0 - 40 .961 .005 Normal ageGroup: 40 - * .965 .005 Normal Tomo: costs: 64 Dose: # mean spread dist bi-rad: a 3 1 Normal bi-rad: b 3 1 Normal bi-rad: c 3 1 Normal bi-rad: d 3 1 Normal Sensitivity: # proportion spread dist bi-rad: a .87 .05 Normal bi-rad: b .84 .05 Normal bi-rad: c .73 .05 Normal bi-rad: d .65 .05 Normal Specificity: # range proportion spread dist ageGroup: 0 - 40 .961 .0025 Normal ageGroup: 40 - * .965 .0025 Normal MRI: costs: 280 # proportion spread dist sensitivity: .94 .005 Normal specificity: .95 .005 Normal Screening: # round: age space separated modalities. # subsequent ages must exceed the last age by at least 1 # instead of specifying screening rounds by age it's also # possible to use a single # round: none # specification, in which case no screening rounds are used. round: 50 Mammo round: 52 Mammo round: 54 Mammo round: 56 Mammo round: 58 Mammo round: 60 Mammo round: 62 Mammo round: 64 Mammo round: 66 Mammo round: 68 Mammo round: 70 Mammo round: 72 Mammo round: 74 Mammo # proportion: attendanceRate: .8 Tumor: # eta beta spread dist. beir7: -2.0 0.51 0.32 Normal Growth: start: 5 # stdev mean spread dist selfDetect: .70 2.92 .084 Normal DoublingTime: # stdev mean spread dist. ageGroup: 1 - 50 .61 4.38 .43 Normal ageGroup: 50 - 70 .26 5.06 .17 Normal ageGroup: 70 - * .45 5.24 .23 Normal Incidence: Normal: probability: 1 stdDev: 21.1 # value spread distr. lifetimeRisk: .226 .0053 Normal meanAge: 72.9 .552 Normal BRCA1: probability: 0 stdDev: 16.51 # value spread distr. lifetimeRisk: .96 meanAge: 53.9 BRCA2: probability: 0 stdDev: 16.51 # value spread distr. lifetimeRisk: .96 meanAge: 53.9 Survival: # value spread dist: type: a .00004475 .000004392 Normal type: b 1.85867 .0420 Normal type: c -.271 .0101 Normal type: d 2.0167 .0366 Normal simrisc-14.05.00/survival/0000755000175000017500000000000014051665273014262 5ustar frankfranksimrisc-14.05.00/survival/survival.ih0000644000175000017500000000023314034554241016446 0ustar frankfrank#include "survival.h" #include "../xerr/xerr.ih" #include #include "../globals/globals.h" #include "../parser/parser.h" using namespace std; simrisc-14.05.00/survival/vary.cc0000644000175000017500000000021014034554241015534 0ustar frankfrank//#define XERR #include "survival.ih" void Survival::vary(ostream &out) { VSD::vary(out, 2, "Survival", "type", 'a', d_vsdVect); } simrisc-14.05.00/survival/survival1.cc0000644000175000017500000000036114034554241016516 0ustar frankfrank#define XERR #include "survival.ih" Survival::Survival() : d_vsdVect( Parser::VSDparameters( VARY_MEAN, { "Tumor:", "Survival:", "type:" }, { 'a', 'b', 'c', 'd' } ) ) {} simrisc-14.05.00/survival/icmconf0000644000175000017500000000007714034554241015620 0ustar frankfrank#define LIBRARY "survival" #include "../icmconf.lib" simrisc-14.05.00/survival/writeparameters.cc0000644000175000017500000000030614034554241017777 0ustar frankfrank//#define XERR #include "survival.ih" void Survival::writeParameters(ostream &out) const { VSD::fmt(6, "type:", 'a', 2, 8, 0, 9); out << setw(4) << "Survival:\n" << d_vsdVect; } simrisc-14.05.00/survival/survival.h0000644000175000017500000000132614034554241016301 0ustar frankfrank#ifndef INCLUDED_SURVIVAL_ #define INCLUDED_SURVIVAL_ // Tumor: // Survival: // # value spread dist: // type: a .00004475 .000004392 Normal // type: b 1.85867 .0420 Normal // type: c - .271 .0101 Normal // type: d 2.0167 .0366 Normal #include "../vsd/vsd.h" class Survival { VSDvect d_vsdVect; public: Survival(); void vary(std::ostream &out); VSD const &operator[](size_t idx) const; void writeParameters(std::ostream &out) const; }; inline VSD const &Survival::operator[](size_t idx) const { return d_vsdVect[idx]; } #endif simrisc-14.05.00/survival/frame0000644000175000017500000000006614034554241015272 0ustar frankfrank//#define XERR #include "survival.ih" Survival:: { } simrisc-14.05.00/tomo/0000755000175000017500000000000014051665273013365 5ustar frankfranksimrisc-14.05.00/tomo/vspecificity.cc0000644000175000017500000000112614034554241016366 0ustar frankfrank//#define XERR #include "tomo.ih" // E.g., age groups: // 0-40 // 40-100 // then by searching from the last to the first: find the agegroup // where the begin-age is < specified age. // Examples: age 50: the last group, // age 40: the first group // 'age' may not be negative double Tomo::vSpecificity(double age) const { return find_if(d_specVect.rbegin(), d_specVect.rend(), [&](AgeGroupVSD const &spec) { return spec.beginAge() < age; } )->value(); } simrisc-14.05.00/tomo/vdose1.cc0000644000175000017500000000013614034554241015066 0ustar frankfrank//#define XERR #include "tomo.ih" VSDvect const *Tomo::vDose() const { return &d_dose; } simrisc-14.05.00/tomo/setsensitivity.cc0000644000175000017500000000026314034554241016774 0ustar frankfrank//#define XERR #include "tomo.ih" void Tomo::setSensitivity() { d_base[2] = "Sensitivity:"; d_sens = Parser::VSDparameters(VARY_PROB, d_base, { 'a', 'b', 'c', 'd' }); } simrisc-14.05.00/tomo/tomo.h0000644000175000017500000000356714034554241014520 0ustar frankfrank#ifndef INCLUDED_TOMO_ #define INCLUDED_TOMO_ #include "../enums/enums.h" #include "../modbase/modbase.h" #include "../agegroupvsd/agegroupvsd.h" // Tomo: // costs: 64 // // # bi-rad: a b c d // dose: 3 3 3 3 // sensitivity: .87 .84 .73 .65 // # ageGroup // specificity: 0 - 40: .961 40 - *: .965 // Tomo: // costs: 64 // // Dose: // # mean spread dist // bi-rad: a 3 1 Normal // bi-rad: b 3 1 Normal // bi-rad: c 3 1 Normal // bi-rad: d 3 1 Normal // // Sensitivity: // # proportion spread dist // bi-rad: a .87 .05 Normal // bi-rad: b .84 .05 Normal // bi-rad: c .73 .05 Normal // bi-rad: d .65 .05 Normal // // Specificity: // # range proportion spread dist // ageGroup: 0 - 40: .961 .0025 Normal // agegroup: 40 - * : .965 .0025 Normal class Tomo: public ModBase { StringVect d_base; VSDvect d_dose; VSDvect d_sens; AgeGroupVSDvect d_specVect; // was: d_specificity; public: Tomo(); ~Tomo() override; private: void setSensitivity(); VSDvect const *vDose() const override; // 1 double vDose(uint16_t) const override; // 2 void vInsert(std::ostream &out) const override; double vSensitivity(size_t idx) const override; double vSpecificity(double age) const override; void vVary(std::ostream &out) override; }; #endif simrisc-14.05.00/tomo/vdose2.cc0000644000175000017500000000015614034554241015071 0ustar frankfrank//#define XERR #include "tomo.ih" double Tomo::vDose(uint16_t idx) const { return d_dose[idx].value(); } simrisc-14.05.00/tomo/icmconf0000644000175000017500000000007314034554241014717 0ustar frankfrank#define LIBRARY "tomo" #include "../icmconf.lib" simrisc-14.05.00/tomo/destructor.cc0000644000175000017500000000006414034554241016063 0ustar frankfrank//#define XERR #include "tomo.ih" Tomo::~Tomo() {} simrisc-14.05.00/tomo/tomo.ih0000644000175000017500000000023114034554241014652 0ustar frankfrank#include "tomo.h" #include #include "../xerr/xerr.ih" #include "../globals/globals.h" #include "../parser/parser.h" using namespace std; simrisc-14.05.00/tomo/tomo1.cc0000644000175000017500000000271214034554241014726 0ustar frankfrank//#define XERR #include "tomo.ih" // Tomo cost: 64 // // # bi-rad cat: a b c d // Tomo dose: 3 3 3 3 // Tomo sensitivity: 0.87 0.84 0.73 0.65 // // # agegroup // Tomo specificity: 0 - 40: 0.961 40 - *: 0.965 // Tomo: // costs: 64 // // Dose: // # mean spread dist // bi-rad: a 3 1 Normal // bi-rad: b 3 1 Normal // bi-rad: c 3 1 Normal // bi-rad: d 3 1 Normal // // Sensitivity: // # proportion spread dist // bi-rad: a .87 .05 Normal // bi-rad: b .84 .05 Normal // bi-rad: c .73 .05 Normal // bi-rad: d .65 .05 Normal // // Specificity: // # range proportion spread dist // ageGroup: 0 - 40: .961 .0025 Normal // agegroup: 40 - * : .965 .0025 Normal Tomo::Tomo() : ModBase("Tomo"), d_base{ "Modalities:", "Tomo:", "" } { costBase(d_base); // ModBase handles the costs spec. d_base.resize(4); doseBase(d_dose, d_base); // using ModBase's members setSensitivity(); specificityBase(d_specVect, d_base); } simrisc-14.05.00/tomo/vinsert.cc0000644000175000017500000000063214034554241015360 0ustar frankfrank//#define XERR #include "tomo.ih" void Tomo::vInsert(ostream &out) const { VSD::fmt(6, "bi-rad:", 'a', 1, 0, 1, 0); out << setw(4) << ' ' << "Dose:\n" << d_dose; VSD::fmt(6, "bi-rad:", 'a', 0, 2, 0, 2); out << setw(4) << ' ' << "Sensitivity:\n" << d_sens; AgeGroupVSD::fmt(6, 0, 3, 0, 4); out << setw(4) << ' ' << "Specificity:\n" << d_specVect; } simrisc-14.05.00/tomo/frame0000644000175000017500000000005614034554241014374 0ustar frankfrank//#define XERR #include "tomo.ih" Tomo:: { } simrisc-14.05.00/tomo/vsensitivity.cc0000644000175000017500000000016314034554241016445 0ustar frankfrank//#define XERR #include "tomo.ih" double Tomo::vSensitivity(size_t idx) const { return d_sens[idx].value(); } simrisc-14.05.00/tomo/vvary.cc0000644000175000017500000000044014034554241015032 0ustar frankfrank//#define XERR #include "tomo.ih" // override void Tomo::vVary(ostream &out) { out << " Tomo:\n"; VSD::vary(out, 4, "Dose", "bi-rad", 'a', d_dose); VSD::vary(out, 4, "Sensitivity", "bi-rad", 'a', d_sens); AgeGroupVSD::vary(out, 4, "Specificity", d_specVect); } simrisc-14.05.00/tumor/0000755000175000017500000000000014051665273013555 5ustar frankfranksimrisc-14.05.00/tumor/data.cc0000644000175000017500000000013214034554241014762 0ustar frankfrank//#define XERR #include "tumor.ih" char const *Tumor::s_noYes[] { "No", "Yes" }; simrisc-14.05.00/tumor/check.cc0000644000175000017500000000035214034554241015132 0ustar frankfrank//#define XERR #include "tumor.ih" void Tumor::check(char const *type) const { if (d_age == NO_TUMOR) throw Exception{} << "cannot determine tumor " << type << " for a non-existing tumor"; } simrisc-14.05.00/tumor/functionf.cc0000644000175000017500000000034514034554241016052 0ustar frankfrank//#define XERR #include "tumor.ih" double Tumor::functionF(double years) const { return years <= 0 ? 1 : exp(-functionQ(years) * pow(d_diameter, functionZ(years))); } simrisc-14.05.00/tumor/tumor.h0000644000175000017500000000734314034554241015074 0ustar frankfrank#ifndef INCLUDED_TUMOR_ #define INCLUDED_TUMOR_ #include #include "../globals/globals.h" class TumorInfo; class Growth; class Survival; namespace FBB { class CSVTable; } class Tumor: public Globals { enum { // max iterations when determining N_ITER_AGE = 15, // deathAge }; static unsigned const N_YEARDAYS = 365; static constexpr double NO_TUMOR = -1; TumorInfo const &d_tumorInfo; Growth const &d_growth; Survival const &d_survival; bool d_detected; // tumor has been detected by screening bool d_interval; // an interval cancer bool d_present; // true: tumor is present double d_age; // the age the tumor willl go clinical or NO_TUMOR double d_deathAge; // death age because of the tumor double d_prePeriod; // _preclin... #years before d_age // the age where a tumor is potentially // detectable on mammographic screening. // From this age onward it'll grow. // (originally called _preclinAge) double d_detectableAge; // (d_age - d_prePeriod) double d_pSurvival; // p(Survival) after treatment double d_doublingDays; // doubling time in days double d_doublingYears; // doubling time in years double d_selfDetect; // self-detect diameter (mm.) double d_startVolume; double d_volume; // actual tumor volume double d_diameter; // actual diameter (mm.) static constexpr double s_log2YearInv = 1 / (365 * log(2)); static char const *s_noYes[]; public: Tumor(TumorInfo const &tumorInfo); void reset(); // reassign the modifiable members operator bool() const; // true: tumor is active .h double age() const; // self-detect age .h double deathAge() const; // .h double detectableAge() const; // .h double volume() const; double diameter() const; // cpt the tumor's characteristics void characteristics(double age); //+ at 'age' void characteristics(); // same, at d_age .h void intervalCancer(); // .h void detected(); // .h void setDeathAge(); // wrt d_age .h void setDeathAge(double refAge); // wrt reference age void writeData(FBB::CSVTable &tab) const; private: bool tumorAge(); // false: no tumor void check(char const *type) const; uint16_t ageGroup() const; // .ih double functionF(double years) const; double functionQ(double years) const; double functionZ(double years) const; static double volume(double diameter); static double diameter(double volume); }; inline double Tumor::age() const { return d_age; } inline double Tumor::detectableAge() const { return d_detectableAge; } inline Tumor::operator bool() const { return d_age != NO_TUMOR; } inline void Tumor::characteristics() { characteristics(d_age); } inline void Tumor::intervalCancer() { d_interval = true; } inline void Tumor::detected() { d_detected = true; } inline void Tumor::setDeathAge() { setDeathAge(d_age); } inline double Tumor::deathAge() const { return d_deathAge; } inline double Tumor::diameter() const { return d_diameter; } #endif simrisc-14.05.00/tumor/reset.cc0000644000175000017500000000241414034554241015200 0ustar frankfrank//#define XERR #include "tumor.ih" void Tumor::reset() { d_detected = false; d_interval = false; d_present = false; // see 'characteristics()' d_volume = 0; d_diameter = 0; d_deathAge = 0; if (not tumorAge()) // sets doublingTime { d_pSurvival = 1; d_startVolume = 0; // see modifications (7) d_doublingDays = NO_TUMOR; d_doublingYears = NO_TUMOR; d_selfDetect = 0; d_prePeriod = NO_TUMOR; d_detectableAge = NO_TUMOR; return; } uint16_t idx = ageGroup(); Random &random = Random::instance(); d_pSurvival = random.uniformCase(); d_startVolume = volume(d_growth.start()); AgeGroupVSD const &group = d_growth.ageGroupVSD(idx); d_doublingDays = random.logNormal(group.value(), group.stdDev()); d_doublingYears = d_doublingDays / N_YEARDAYS; d_selfDetect = random.logNormal(d_growth.selfMu().value(), d_growth.selfSigma()); d_prePeriod = d_doublingDays * log( volume(d_selfDetect) / volume(d_growth.start()) ) * s_log2YearInv; d_detectableAge = d_age - d_prePeriod; } simrisc-14.05.00/tumor/tumor1.cc0000644000175000017500000000026614034554241015310 0ustar frankfrank#define XERR #include "tumor.ih" Tumor::Tumor(TumorInfo const &tumorInfo) : d_tumorInfo(tumorInfo), d_growth(tumorInfo.growth()), d_survival(tumorInfo.survival()) {} simrisc-14.05.00/tumor/tumor.ih0000644000175000017500000000117314034554241015240 0ustar frankfrank#include "tumor.h" #include "../xerr/xerr.ih" #include #include #include #include "../options/options.h" #include "../tumorinfo/tumorinfo.h" #include "../growth/growth.h" #include "../random/random.h" using namespace std; using namespace FBB; inline uint16_t Tumor::ageGroup() const { return d_age < 50 ? 0 : d_age < 70 ? 1 : 2; } // static inline double Tumor::volume(double diameter) { return M_PI / 6 * pow(diameter, 3); } // static inline double Tumor::diameter(double volume) { return pow(6 / M_PI * volume, 1 / 3.); } simrisc-14.05.00/tumor/tumorage.cc0000644000175000017500000000146214034554241015703 0ustar frankfrank//#define XERR #include "tumor.ih" // if (0.120662 < rndTumor and rndTumor < 0.120664) // { // cerr.setf(ios::fixed, ios::floatfield); // // for (double value: d_tumorInfo.cumTotalRisk()) // cerr << setw(6) << value << '\n'; // } bool Tumor::tumorAge() { Random &random = Random::instance(); d_age = findAge(d_tumorInfo.cumTotalRisk(), random.uniformCase()); xerr("random tumor prob: " << rndTumor << ", age " << d_age); Options::instance().fixedTumorAge(d_age); if (d_age <= MAX_AGE) return true; d_age = NO_TUMOR; random.uniformCase(); // extra calls to synchronize the random.logNormal(0, 0); // random generator between random.logNormal(0, 0); // tumor and no tumor states return false; } simrisc-14.05.00/tumor/icmconf0000644000175000017500000000007414034554241015110 0ustar frankfrank#define LIBRARY "tumor" #include "../icmconf.lib" simrisc-14.05.00/tumor/functionq.cc0000644000175000017500000000023214034554241016060 0ustar frankfrank//#define XERR #include "tumor.ih" double Tumor::functionQ(double years) const { return d_survival[0].value() * pow(years, d_survival[1].value()); } simrisc-14.05.00/tumor/volume.cc0000644000175000017500000000016014034554241015361 0ustar frankfrank//#define XERR #include "tumor.ih" double Tumor::volume() const { check("volume"); return d_volume; } simrisc-14.05.00/tumor/setdeathage.cc0000644000175000017500000000220314034554241016330 0ustar frankfrank#define XERR #include "tumor.ih" // this function computes the estimated death age using the function // published in // Cancer. 2002 Aug 15;95(4):713-23. Predicting the survival of patients // with breast carcinoma using tumor size. Michaelson JS, Silverstein M, // Wyatt J, Weber G, Moore R, Halpern E, Kopans DB, Hughes K. void Tumor::setDeathAge(double detectionAge) { check("death age"); // interval halving: search between 0 and 100 double low = 0; double high = 100; double mid; for (size_t iter = 0; iter != N_ITER_AGE; ++iter) { mid = (low + high) / 2; switch (weakCompare(functionF(mid), d_pSurvival)) { case -1: // use the lhs half: low..mid high = mid; continue; case 1: // use the rhs half: mid::high low = mid; continue; default: // equal within WEAK_TOLERANCE break; } break; // convergence } d_deathAge = std::min(detectionAge + mid, 100.); } simrisc-14.05.00/tumor/frame0000644000175000017500000000006014034554241014557 0ustar frankfrank//#define XERR #include "tumor.ih" Tumor:: { } simrisc-14.05.00/tumor/functionz.cc0000644000175000017500000000026014034554241016072 0ustar frankfrank//#define XERR #include "tumor.ih" double Tumor::functionZ(double years) const { return d_survival[2].value() * log(years) + d_survival[3].value(); } simrisc-14.05.00/tumor/writedata.cc0000644000175000017500000000143014034554241016037 0ustar frankfrank//#define XERR #include "tumor.ih" void Tumor::writeData(CSVTable &tab) const { tab.more() << s_noYes[d_present] << // 4 s_noYes[d_detected] << // 5 s_noYes[d_interval]; // 6 // see modifications (8) if (d_diameter > 1000) // 7 tab.more() << "1001"; // was: 'inf' else tab.more() << d_diameter; // see also modifications (7) // //setw(6) << d_age == NO_TUMOR ? 0 : age << '\t' << tab.more() << d_doublingDays << d_prePeriod << // 8 - 9 d_detectableAge << d_age << d_deathAge; // 10 - 12 } simrisc-14.05.00/tumor/characteristics.cc0000644000175000017500000000077114034554241017235 0ustar frankfrank//#define XERR #include "tumor.ih" // (ORG: calculateSize) void Tumor::characteristics(double age) { check("size"); if ((d_present = (d_detectableAge <= age))) // there is a tumor { d_diameter = diameter( d_volume = d_startVolume * // exp. growth of volume pow(2, (age - d_detectableAge) / d_doublingYears) ); } else { d_volume = 0; d_diameter = 0; } } simrisc-14.05.00/tumorinfo/0000755000175000017500000000000014051665273014431 5ustar frankfranksimrisc-14.05.00/tumorinfo/tumorinfo.ih0000644000175000017500000000022414034554241016764 0ustar frankfrank#include "tumorinfo.h" #include "../xerr/xerr.ih" #include #include using namespace std; using namespace FBB; simrisc-14.05.00/tumorinfo/vary.cc0000644000175000017500000000033714034554241015715 0ustar frankfrank//#define XERR #include "tumorinfo.ih" void TumorInfo::vary(ostream &out) { out << "Tumor:\n"; d_beir7.vary(out); out.put('\n'); d_growth.vary(out); d_incidence.vary(out); d_survival.vary(out); } simrisc-14.05.00/tumorinfo/data.cc0000644000175000017500000000015114034554241015637 0ustar frankfrank////#define XERR //#include "tumorinfo.ih" // ////char const TumorInfo::s_id[] = "tumorInduction"; // // simrisc-14.05.00/tumorinfo/icmconf0000644000175000017500000000010014034554241015752 0ustar frankfrank#define LIBRARY "tumorinfo" #include "../icmconf.lib" simrisc-14.05.00/tumorinfo/cumtotalrisk.cc0000644000175000017500000000135114034554241017452 0ustar frankfrank#define XERR #include "tumorinfo.ih" // see void calcTotalRisk(int carrierIndex) void TumorInfo::cumTotalRisk(DoubleVect const &radiationRisk) { double sum = 0; d_cumRisk.clear(); uint16_t carrierIdx = d_incidence.carrier(); auto iter = radiationRisk.begin(); for (double risk: d_incidence.tumorRisk(carrierIdx)) d_cumRisk.push_back(sum += risk * *iter++); } //void calcTotalRisk(int carrierIndex) { // float totRisk; // for (int T = 0; T < 101; T++) { // totRisk = radRisk[T] * tumorRisk[carrierIndex][T]; <<------ !!! // if (T == 0) { // cumTotRisk[T] = totRisk; // } // else { // cumTotRisk[T] = cumTotRisk[T-1] + totRisk; // } // } // simrisc-14.05.00/tumorinfo/writeparameters.cc0000644000175000017500000000043614034554241020152 0ustar frankfrank//#define XERR #include "tumorinfo.ih" void TumorInfo::writeParameters(ostream &out) const { out << "Tumor:\n"; d_beir7.writeParameters(out); d_incidence.writeParameters(out); d_growth.writeParameters(out); out.put('\n'); d_survival.writeParameters(out); } simrisc-14.05.00/tumorinfo/tumorinfo.h0000644000175000017500000000262114034554241016616 0ustar frankfrank#ifndef INCLUDED_TUMORINFO_ #define INCLUDED_TUMORINFO_ #include #include "../globals/globals.h" #include "../incidence/incidence.h" #include "../beir7/beir7.h" #include "../growth/growth.h" #include "../survival/survival.h" class Scenario; class TumorInfo: public Globals { Incidence d_incidence; Beir7 d_beir7; Growth d_growth; Survival d_survival; DoubleVect d_cumRisk; public: void vary(std::ostream &out); // vary parameters Incidence const &incidence() const; uint16_t induction() const; // beir model to use Beir7 const &beir7() const; Growth const &growth() const; Survival const &survival() const; void cumTotalRisk(DoubleVect const &radiationRisk); DoubleVect const &cumTotalRisk() const; void writeParameters(std::ostream &out) const; private: void totalRiskFile() const; }; inline Incidence const &TumorInfo::incidence() const { return d_incidence; } inline Beir7 const &TumorInfo::beir7() const { return d_beir7; } inline Growth const &TumorInfo::growth() const { return d_growth; } inline Survival const &TumorInfo::survival() const { return d_survival; } inline DoubleVect const &TumorInfo::cumTotalRisk() const { return d_cumRisk; } #endif simrisc-14.05.00/tumorinfo/frame0000644000175000017500000000007014034554241015434 0ustar frankfrank//#define XERR #include "tumorinfo.ih" TumorInfo:: { } simrisc-14.05.00/typedefs/0000755000175000017500000000000014034554241014223 5ustar frankfranksimrisc-14.05.00/typedefs/typedefs.h0000644000175000017500000000124714034554241016223 0ustar frankfrank#ifndef INCLUDED_TYPEDEFS_ #define INCLUDED_TYPEDEFS_ #include #include #include #include #include "../enums/enums.h" //struct struct LineInfo { ParamsSrc src; uint16_t lineNr; std::string txt; std::string tail; }; //= //types typedef std::unordered_set StringSet; typedef std::vector LineInfoVect; typedef std::vector DoubleVect; typedef std::vector DoubleVect2; typedef std::vector SizeVect; typedef std::vector StringVect; typedef std::vector Uint16Vect; //= #endif simrisc-14.05.00/typedefs/typedefs.ih0000644000175000017500000000005614034554241016371 0ustar frankfrank#include "typedefs.h" using namespace std; simrisc-14.05.00/typedefs/frame0000644000175000017500000000006614034554241015242 0ustar frankfrank//#define XERR #include "typedefs.ih" typedefs:: { } simrisc-14.05.00/unsignedcastable/0000755000175000017500000000000014034554241015713 5ustar frankfranksimrisc-14.05.00/unsignedcastable/unsignedcastable.h0000644000175000017500000000053114034554241021376 0ustar frankfrank#ifndef INCLUDED_UNSIGNEDCASTABLE_ #define INCLUDED_UNSIGNEDCASTABLE_ // concept used by Parser's unsignedcast templates to ensure that // the arguments can be static_cast to an unsigned template concept UnsignedCastable = requires(Type value) { static_cast(value); }; #endif simrisc-14.05.00/usage.cc0000644000175000017500000000750614051664606014031 0ustar frankfrank// usage.cc #include "main.ih" // --totalrisk (-T) path - path name of the file containing the // cumulative total risk proportions (default: // '/totalrisk-$.txt', use ! to // suppress) // // --id-base (-i) nr - Use the IDPoool, starting with value 'nr' // (specify 0 to use the std. RandomPool, // 1 is used by default) namespace { char const info[] = R"_( [options] analyses Where: [options] - optional arguments (short options between parentheses): --base (-B) dirname - base directory (by default './', below referred to as '/') --config (-C) path - path name to the config file (by default '~/.config/simrisc') --data (-D) path - path name of the file containing the data generated by the simulation (default: '/data-$.txt', use ! to suppress) --death-age (-a) age - run one simulation using a specific natural death-age (also requires --tumor-age) --err (-e) - use the previously used Beir7 ERR function (excess relative risk) instead of the excess absolute risk function, using the cases' subsequent simulated ages; --help (-h) - provide this help --last-case (-l) nCases - perform simulations until 'nCases' have been analyzed and only write the data for the final case to the data file; --one-analysis (-o) - run a single scenario analysis. The program's arguments may be used to specify comma-separated configuration parameters --parameters (-P) path - path name of the parameters-file (default: not used) --rounds (-R) path - path name of the file containing the summary info of the simulation rounds (default: '/rounds-$.txt', use ! to suppress) --sensitivity (-S) path - path name of the sensitivity-file (default: '/sensitivity.txt', use ! to suppress) --spread (-s) path - path name of the file showing the actual 'spread' values when 'spread: true' is specified (default: ' #include #include #include "../err/err.h" #include "../globals/globals.h" using namespace std; simrisc-14.05.00/vsd/probcheck.cc0000644000175000017500000000026614034554241015447 0ustar frankfrank//#define XERR #include "vsd.ih" // static void VSD::probCheck(double &value) { if (not Globals::proportion(value)) { Err::range(); value = 0; } } simrisc-14.05.00/vsd/data.cc0000644000175000017500000000057014034554241014416 0ustar frankfrank//#define XERR #include "vsd.ih" // static void (*VSD::s_valueCheck[])(double &) = { &meanCheck, &posCheck, &probCheck, }; // static VaryType VSD::s_varyType[] = { VARY_MEAN, VARY_NONNEG, VARY_PROB }; unsigned VSD::s_indent = 0; char const *VSD::s_type = 0; char VSD::s_ch = 0; unsigned VSD::s_width = 0; unsigned VSD::s_prec = -1; simrisc-14.05.00/vsd/vsd1.cc0000644000175000017500000000020314034554241014353 0ustar frankfrank//#define XERR #include "vsd.ih" VSD::VSD(VaryType varyType) : d_dist(varyType), d_valueCheck(s_valueCheck[varyType]) {} simrisc-14.05.00/vsd/fmt2.cc0000644000175000017500000000050514034554241014353 0ustar frankfrank//#define XERR #include "vsd.ih" // static void VSD::fmt(unsigned indent, char const *type, char ch, unsigned valueWidth, unsigned valuePrec, unsigned distWidth, unsigned distPrec) { s_indent = indent; s_type = type; s_ch = ch; fmt(valueWidth, valuePrec, distWidth, distPrec); } simrisc-14.05.00/vsd/vsd.h0000644000175000017500000001031614034554241014142 0ustar frankfrank#ifndef INCLUDED_VSD_ #define INCLUDED_VSD_ #include #include #include "../distribution/distribution.h" class VSD { friend std::istream &operator>>(std::istream &in, VSD &vsd); friend std::ostream &operator<<(std::ostream &out, VSD const &vsd); friend std::ostream &operator<<(std::ostream &out, std::vector const &vect); double d_value = 0; double d_orgValue = 0; // initial config. value, // used by vary() Distribution d_dist; // distribution used for spreading // d_value. The distribution // receives the 'spread' and the // name of the distribution void (*d_valueCheck)(double &value); // mean, stddev, proportion // functions checking static void (*s_valueCheck[])(double &value); // d_value static VaryType s_varyType[]; static unsigned s_indent; static char const *s_type; static char s_ch; static unsigned s_width; static unsigned s_prec; public: VSD(VaryType varyType); void vary(); // was: refresh/spread void showVary(std::ostream &out) const; // the actually used and orig. // values double value() const; // mean or proportion double spread() const; // Distribution's value DistType distType() const; // was: dist std::string const &distName() const; // was: name Distribution const &distribution() const; static void fmt(unsigned valueIntWidth, unsigned valuePrec, // 1 unsigned distValueWdith, unsigned distPrec); static void fmt(unsigned indent, char const *type, char ch, // 2 unsigned valueIntWidth, unsigned valuePrec, unsigned distValueWidth, unsigned distPrec); static void vary(std::ostream &out, // 2 unsigned indent, char const *hdr, char const *type, char ch, std::vector &vect); private: std::ostream &insert(std::ostream &out) const; // 1 static std::ostream &insert(std::ostream &out, // 2 std::vector const &vect); std::istream &extract(std::istream &in); static void meanCheck(double &value); static void posCheck(double &value); static void probCheck(double &value); }; typedef std::vector VSDvect; inline Distribution const &VSD::distribution() const { return d_dist; } inline void VSD::vary() { d_value = d_dist.vary(d_orgValue); } inline double VSD::value() const { return d_value; } inline double VSD::spread() const { return d_dist.value(); } inline DistType VSD::distType() const { return d_dist.type(); } inline std::string const &VSD::distName() const { return Distribution::name(d_dist.type()); } inline std::ostream &operator<<(std::ostream &out, VSD const &vsd) { return vsd.insert(out); } inline std::ostream &operator<<(std::ostream &out, VSDvect const &vect) { return VSD::insert(out, vect); } inline std::istream &operator>>(std::istream &in, VSD &vsd) { return vsd.extract(in); } // // charShift != 0 then idx is converted to char // // indent: initial indentation // static std::ostream &insert(std::ostream &out, char const *label, // 1 // char const *type, // std::vector const &vect, // unsigned indent, unsigned mPrecision, // unsigned sdPrecision, char ch = 0); // // std::ostream &insert(std::ostream &out, // 2 // unsigned mPrec, unsigned sdPrec) const; // #endif simrisc-14.05.00/vsd/meancheck.cc0000644000175000017500000000023114034554241015415 0ustar frankfrank//#define XERR #include "vsd.ih" // static void VSD::meanCheck(double &value) { // the default Distribution setting is VARY_OK: OK for Mode::MEAN } simrisc-14.05.00/vsd/vary2.cc0000644000175000017500000000066314034554241014553 0ustar frankfrank//#define XERR #include "vsd.ih" // static void VSD::vary(ostream &out, unsigned indent, char const *hdr, char const *type, char ch, VSDvect &vect) { out << setw(indent) << ' ' << hdr << ":\n"; indent += 2; for (VSD &vsd: vect) { vsd.vary(); out << setw(indent) << ' ' << type << ": " << ch << " "; vsd.showVary(out); ++ch; } out.put('\n'); } simrisc-14.05.00/vsd/insert1.cc0000644000175000017500000000027214034554241015071 0ustar frankfrank//#define XERR #include "vsd.ih" std::ostream &VSD::insert(std::ostream &out) const { return Globals::setWidthPrec(out, s_width, s_prec) << d_value << ", " << d_dist; } simrisc-14.05.00/vsd/insert2.cc0000644000175000017500000000063014034554241015070 0ustar frankfrank//#define XERR #include "vsd.ih" // static ostream &VSD::insert(ostream &out, VSDvect const &vect) { for (unsigned idx = 0, end = vect.size(); idx != end; ++idx) { out << setw(s_indent) << ' ' << s_type << ' '; if (s_ch == 0) out << idx; else out << static_cast(s_ch + idx); out << " " << vect[idx] << '\n'; } return out; } simrisc-14.05.00/vsd/fmt1.cc0000644000175000017500000000043114034554241014350 0ustar frankfrank//#define XERR #include "vsd.ih" // static void VSD::fmt(unsigned valueWidth, unsigned valuePrec, unsigned distWidth, unsigned distPrec) { s_width = valueWidth + valuePrec + (valuePrec > 0); s_prec = valuePrec; Distribution::fmt(distWidth, distPrec); } simrisc-14.05.00/vsd/icmconf0000644000175000017500000000007214034554241014534 0ustar frankfrank#define LIBRARY "vsd" #include "../icmconf.lib" simrisc-14.05.00/vsd/extract.cc0000644000175000017500000000055314034554241015160 0ustar frankfrank#define XERR #include "vsd.ih" // value spread dist. // 21.1 0.048 Normal // 16.51 // implies spread = 0 istream &VSD::extract(istream &in) { string v1; string v2; in >> d_value >> d_dist; d_orgValue = d_value; (*d_valueCheck)(d_value); // check valid SD / Prob. values return in; } simrisc-14.05.00/vsd/frame0000644000175000017500000000005414034554241014210 0ustar frankfrank//#define XERR #include "vsd.ih" VSD:: { } simrisc-14.05.00/vsd/poscheck.cc0000644000175000017500000000025014034554241015277 0ustar frankfrank//#define XERR #include "vsd.ih" // static void VSD::posCheck(double &value) { if (value < 0) { Err::msgTxt(Err::NEGATIVE); value = 0; } } simrisc-14.05.00/xerr/0000755000175000017500000000000014034554241013360 5ustar frankfranksimrisc-14.05.00/xerr/xerr.ih0000644000175000017500000000131314034554241014660 0ustar frankfrank// define X to activate the xerr/xerr2 macros: // xerr(insertion) // inserts the '<<' concatenated elements into std::cerr // preceded by the name of the source file, and ended by '\n' // xerr2(insertion, code) // performs the insertion if X is defined, and (unconditionally) // executes the statement(s) in `code'. `code' must be valid // C(++) code. // #ifdef XERR #include #define xerr(insertion) std::cerr << __FILE__": " << insertion << '\n' #define xerr2(insertion, b) \ { std::cerr << __FILE__": " << insertion << '\n'; b; } #else #define xerr(insertion) #define xerr2(insertion, b) b #endif