Changeset 0275ad


Ignore:
Timestamp:
Feb 3, 2011, 9:59:57 AM (15 years ago)
Author:
Frederik Heber <heber@…>
Branches:
Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, Candidate_v1.7.0, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable
Children:
9964ff, c14c78
Parents:
1ee3b8d
git-author:
Frederik Heber <heber@…> (01/07/11 00:15:49)
git-committer:
Frederik Heber <heber@…> (02/03/11 09:59:57)
Message:

Final step in Random numbers is done ...

Files:
10 added
44 edited

Legend:

Unmodified
Added
Removed

  • configure.ac

    r1ee3b8d r0275ad  
    115115#AC_MSG_NOTICE(["GLU_CFLAGS: $GLU_CFLAGS, GLU_CXXFLAGS: $GLU_CXXFLAGS, GLU_LDFLAGS: $GLU_LDFLAGS, GLU_LIBS: $GLU_LIBS"])
    116116
    117 # CodePatterns library (needs PrototypeFactory::getPrototype())
     117# CodePatterns library (needs ManipulablePrototypeFactory pattern)
    118118AM_PATH_CODEPATTERNS([1.0.7], $have_debug,,[AC_MSG_ERROR([Missing CodePatterns library, please specify PKG_CONFIG_PATH or use --with-codepatterns...])])
    119119

  • src/Actions/RandomNumbersAction/SetRandomNumbersDistributionAction.cpp

    r1ee3b8d r0275ad  
    2525#include "World.hpp"
    2626
    27 #include "RandomNumbers/RandomNumberGeneratorFactory.hpp"
     27#include "RandomNumbers/RandomNumberDistributionFactory.hpp"
     28#include "RandomNumbers/RandomNumberDistribution.hpp"
     29#include "RandomNumbers/RandomNumberDistribution_Parameters.hpp"
    2830
    2931#include <iostream>
    … …  
    4345  getParametersfromValueStorage();
    4446
    45   CommandSetRandomNumbersDistributionState *state =
    46       new CommandSetRandomNumbersDistributionState(
    47           RandomNumberGeneratorFactory::getInstance().getDistributionName(),
    48           params);
    49   RandomNumberGeneratorFactory::getInstance().setDistribution(params.distribution_type);
     47  // note down old type
     48  std::string oldtype = RandomNumberDistributionFactory::getInstance().getCurrentTypeName();
     49  DoLog(1) && (Log() << Verbose(1) << "Current distribution is " << oldtype << std::endl);
    5050
     51  // set the new default
     52  RandomNumberDistributionFactory::getInstance().setCurrentType(params.distribution_type);
    5153  DoLog(0) && (Log() << Verbose(0) << "Distribution of random number generator is now: "
    52       << RandomNumberGeneratorFactory::getInstance().getDistributionName() << std::endl);
     54      << RandomNumberDistributionFactory::getInstance().getCurrentTypeName() << std::endl);
    5355
    54   return Action::state_ptr(state);
     56  // note down old parameters
     57  RandomNumberDistribution_Parameters *oldparameters =
     58      RandomNumberDistributionFactory::getInstance().getPrototype().getParameterSet();
     59  // set each parameter (that is not -1);
     60  if (!params.parameters.isDefault()) {
     61    RandomNumberDistribution_Parameters *oldparameters =
     62        RandomNumberDistributionFactory::getInstance().getPrototype().getParameterSet();
     63    oldparameters->update(params.parameters);
     64    DoLog(1) && (Log() << Verbose(1) << "Changing prototype's parameters to "
     65        << params.parameters << "." << std::endl);
     66    RandomNumberDistributionFactory::getInstance().manipulatePrototype(*oldparameters);
     67  }
     68
     69  {
     70    RandomNumberDistribution_Parameters *currentparameters =
     71        RandomNumberDistributionFactory::getInstance().getPrototype().getParameterSet();
     72    DoLog(1) && (Log() << Verbose(1) << "Its parameters are: " << *currentparameters << std::endl);
     73    delete  currentparameters;
     74  }
     75
     76  CommandSetRandomNumbersDistributionState *newstate =
     77      new CommandSetRandomNumbersDistributionState(oldtype,*oldparameters,params);
     78  delete oldparameters;
     79  return Action::state_ptr(newstate);
    5580}
    5681
    … …  
    5883  CommandSetRandomNumbersDistributionState *state = assert_cast<CommandSetRandomNumbersDistributionState*>(_state.get());
    5984
     85  // note down old type for redo
     86  std::string newtype = RandomNumberDistributionFactory::getInstance().getCurrentTypeName();
     87  DoLog(1) && (Log() << Verbose(1) << "Newly set distribution was " << newtype << std::endl);
     88
     89  // note down old parameters for redo
     90  RandomNumberDistribution_Parameters *newparameters =
     91      RandomNumberDistributionFactory::getInstance().getPrototype().getParameterSet();
     92
     93  // set the new default
     94  RandomNumberDistributionFactory::getInstance().setCurrentType(state->old_distribution_type);
     95  DoLog(0) && (Log() << Verbose(0) << "Distribution of random number generator is again: "
     96      << RandomNumberDistributionFactory::getInstance().getCurrentTypeName() << std::endl);
     97
     98  // set each parameter back (that is not -1);
     99  if (!state->old_parameters.isDefault()) {
     100    DoLog(1) && (Log() << Verbose(1) << "Changing back prototype's parameters to "
     101        << state->old_parameters << "." << std::endl);
     102    RandomNumberDistributionFactory::getInstance().manipulatePrototype(state->old_parameters);
     103  }
     104
     105  {
     106    RandomNumberDistribution_Parameters *currentparameters =
     107        RandomNumberDistributionFactory::getInstance().getPrototype().getParameterSet();
     108    DoLog(1) && (Log() << Verbose(1) << "Its parameters are: " << *currentparameters << std::endl);
     109    delete  currentparameters;
     110  }
     111
    60112  CommandSetRandomNumbersDistributionState *newstate =
    61       new CommandSetRandomNumbersDistributionState(
    62           RandomNumberGeneratorFactory::getInstance().getDistributionName(),
    63           state->params);
    64   RandomNumberGeneratorFactory::getInstance().setDistribution(state->old_distribution_type);
    65 
    66   DoLog(0) && (Log() << Verbose(0) << "Distribution of random number generator is undone to: "
    67       << RandomNumberGeneratorFactory::getInstance().getDistributionName() << std::endl);
    68 
     113      new CommandSetRandomNumbersDistributionState(newtype,*newparameters,params);
     114  delete newparameters;
    69115  return Action::state_ptr(newstate);
    70116}

  • src/Actions/RandomNumbersAction/SetRandomNumbersDistributionAction.def

    r1ee3b8d r0275ad  
    77
    88// all includes and forward declarations necessary for non-integral types below
    9 class MoleculeListClass;
     9#include "RandomNumbers/RandomNumberDistribution_Parameters.hpp"
    1010
    1111// i.e. there is an integer with variable name Z that can be found in
    1212// ValueStorage by the token "Z" -> first column: int, Z, "Z"
    1313// "undefine" if no parameters are required, use (NODEFAULT) for each (undefined) default value
    14 #define paramtypes (std::string)
    15 #define paramtokens ("set-random-number-distribution")
    16 #define paramdescriptions ("name of the distribution from boost::random")
    17 #undef paramdefaults
    18 #define paramreferences (distribution_type)
     14#define paramtypes (std::string)(class RandomNumberDistribution_Parameters)
     15#define paramtokens ("set-random-number-distribution")("random-number-distribution-parameters")
     16#define paramdescriptions ("name of the distribution from boost::random")("parameter set for requested distribution")
     17#define paramdefaults (NODEFAULT)("p=-1")
     18#define paramreferences (distribution_type)(parameters)
    1919
    20 #define statetypes (std::string)
    21 #define statereferences (old_distribution_type)
     20#define statetypes (std::string)(RandomNumberDistribution_Parameters)
     21#define statereferences (old_distribution_type)(old_parameters)
    2222
    2323// some defines for all the names, you may use ACTION, STATE and PARAMS

  • src/Actions/RandomNumbersAction/SetRandomNumbersEngineAction.cpp

    r1ee3b8d r0275ad  
    2626
    2727#include "RandomNumbers/RandomNumberEngine.hpp"
     28#include "RandomNumbers/RandomNumberEngine_Parameters.hpp"
    2829#include "RandomNumbers/RandomNumberEngineFactory.hpp"
    2930
    3031#include <iostream>
    31 #include <fstream>
     32#include <sstream>
    3233#include <string>
    3334
    … …  
    4445  getParametersfromValueStorage();
    4546
    46   // create a new state for undo
    47   CommandSetRandomNumbersEngineState *state =
    48       new CommandSetRandomNumbersEngineState(
    49           RandomNumberEngineFactory::getInstance().getCurrentTypeName(),
    50           RandomNumberEngineFactory::getInstance().getPrototype().getseed(),
    51           params);
    52   // set new default
     47  // note down old type
     48  std::string oldtype = RandomNumberEngineFactory::getInstance().getCurrentTypeName();
     49  DoLog(1) && (Log() << Verbose(1) << "Current engine is " << oldtype << std::endl);
     50
     51  // set the new default
    5352  RandomNumberEngineFactory::getInstance().setCurrentType(params.engine_type);
    54   // set new seed if given, have to use ugly const_cast as prototype is not manipulable
    55   if (params.seed != -1) {
    56     RandomNumberEngine &engine =
    57         const_cast<RandomNumberEngine &>(
    58             RandomNumberEngineFactory::getInstance().getPrototype(params.engine_type)
    59             );
    60     engine.seed(params.seed);
     53  DoLog(0) && (Log() << Verbose(0) << "Engine of random number generator is now: "
     54      << RandomNumberEngineFactory::getInstance().getCurrentTypeName() << std::endl);
     55
     56  // note down old parameters
     57  RandomNumberEngine_Parameters *oldparameters =
     58      RandomNumberEngineFactory::getInstance().getPrototype().getParameterSet();
     59  // set each parameter (that is not -1);
     60  {
     61    std::stringstream input(params.parameters);
     62    RandomNumberEngine_Parameters *currentparameters =
     63        RandomNumberEngineFactory::getInstance().getPrototype().getParameterSet();
     64    input >> *currentparameters;  // add new values on top
     65    if (!currentparameters->isDefault()) {
     66      DoLog(1) && (Log() << Verbose(1) << "Changing prototype's parameters." << std::endl);
     67      RandomNumberEngineFactory::getInstance().manipulatePrototype(*currentparameters);
     68    }
     69    delete currentparameters;
    6170  }
    6271
    63   DoLog(0) && (Log() << Verbose(0) << "Default random number engine is now: "
    64       << RandomNumberEngineFactory::getInstance().getCurrentTypeName() << std::endl);
     72  {
     73    RandomNumberEngine_Parameters *currentparameters =
     74        RandomNumberEngineFactory::getInstance().getPrototype().getParameterSet();
     75    DoLog(1) && (Log() << Verbose(1) << "Its parameters are: " << *currentparameters << std::endl);
     76    delete  currentparameters;
     77  }
    6578
    66   return Action::state_ptr(state);
     79  std::stringstream output;
     80  output << *oldparameters;
     81  CommandSetRandomNumbersEngineState *newstate =
     82      new CommandSetRandomNumbersEngineState(oldtype,output.str(),params);
     83  delete oldparameters;
     84  return Action::state_ptr(newstate);
    6785}
    6886
    … …  
    7189      assert_cast<CommandSetRandomNumbersEngineState*>(_state.get());
    7290
    73   // create a new state for redo
    74   CommandSetRandomNumbersEngineState *newstate =
    75       new CommandSetRandomNumbersEngineState(
    76           RandomNumberEngineFactory::getInstance().getCurrentTypeName(),
    77           RandomNumberEngineFactory::getInstance().getPrototype().getseed(),
    78           state->params);
    79   // set new default
     91  // note down old type for redo
     92  std::string newtype = RandomNumberEngineFactory::getInstance().getCurrentTypeName();
     93  DoLog(1) && (Log() << Verbose(1) << "Newly set engine was " << newtype << std::endl);
     94
     95  // note down old parameters for redo
     96  RandomNumberEngine_Parameters *newparameters =
     97      RandomNumberEngineFactory::getInstance().getPrototype().getParameterSet();
     98
     99  // set the new default
    80100  RandomNumberEngineFactory::getInstance().setCurrentType(state->old_engine_type);
    81   RandomNumberEngine &engine = const_cast<RandomNumberEngine &>(
    82       RandomNumberEngineFactory::getInstance().getPrototype(state->params.engine_type)
    83     );
    84   // set new seed if given, have to use ugly const_cast as prototype is not manipulable
    85   if (state->params.seed != -1) {
    86     engine.seed(state->params.seed);
     101  DoLog(0) && (Log() << Verbose(0) << "Engine of random number generator is again: "
     102      << RandomNumberEngineFactory::getInstance().getCurrentTypeName() << std::endl);
     103
     104  // set each parameter back (that is not -1);
     105  {
     106    std::stringstream input(state->old_parameters);
     107    RandomNumberEngine_Parameters *currentparameters =
     108        RandomNumberEngineFactory::getInstance().getPrototype().getParameterSet();
     109    input >> *currentparameters;
     110    if (!currentparameters->isDefault()) {
     111      DoLog(1) && (Log() << Verbose(1) << "Changing prototype's parameters." << std::endl);
     112      RandomNumberEngineFactory::getInstance().manipulatePrototype(*currentparameters);
     113    }
     114    delete currentparameters;
    87115  }
    88116
    89   DoLog(0) && (Log() << Verbose(0) << "Default random number engine is undone to: "
    90       << RandomNumberEngineFactory::getInstance().getCurrentTypeName() << std::endl);
     117  {
     118    RandomNumberEngine_Parameters *currentparameters =
     119        RandomNumberEngineFactory::getInstance().getPrototype().getParameterSet();
     120    DoLog(1) && (Log() << Verbose(1) << "Its parameters are: " << *currentparameters << std::endl);
     121    delete  currentparameters;
     122  }
    91123
     124  std::stringstream output;
     125  output << *newparameters;
     126  CommandSetRandomNumbersEngineState *newstate =
     127      new CommandSetRandomNumbersEngineState(newtype,output.str(),params);
     128  delete newparameters;
    92129  return Action::state_ptr(newstate);
    93130}

  • src/Actions/RandomNumbersAction/SetRandomNumbersEngineAction.def

    r1ee3b8d r0275ad  
    77
    88// all includes and forward declarations necessary for non-integral types below
    9 class MoleculeListClass;
    109
    1110// i.e. there is an integer with variable name Z that can be found in
    1211// ValueStorage by the token "Z" -> first column: int, Z, "Z"
    1312// "undefine" if no parameters are required, use (NODEFAULT) for each (undefined) default value
    14 #define paramtypes (std::string)(int)
    15 #define paramtokens ("set-random-number-engine")("random-number-seed")
     13#define paramtypes (std::string)(std::string)
     14#define paramtokens ("set-random-number-engine")("random-number-engine-parameters")
    1615#define paramdescriptions ("name of the pseudo-random engine from boost::random")("seed of the pseudo-random number sequence")
    17 #define paramdefaults (NODEFAULT)("-1")
    18 #define paramreferences (engine_type)(seed)
     16#define paramdefaults (NODEFAULT)("seed=-1")
     17#define paramreferences (engine_type)(parameters)
    1918
    20 #define statetypes (std::string)(int)
    21 #define statereferences (old_engine_type)(old_seed)
     19#define statetypes (std::string)(std::string)
     20#define statereferences (old_engine_type)(old_parameters)
    2221
    2322// some defines for all the names, you may use ACTION, STATE and PARAMS

  • src/Actions/ValueStorage.cpp

    r1ee3b8d r0275ad  
    3434#include "LinearAlgebra/RealSpaceMatrix.hpp"
    3535#include "LinearAlgebra/Vector.hpp"
     36#include "RandomNumbers/RandomNumberDistribution_Parameters.hpp"
    3637#include "atom.hpp"
    3738#include "Box.hpp"
    … …  
    145146          "ValueStorage::queryCurrentValue() - BoxVector in value map has only "+toString(i)+" components!");
    146147    }
     148  } else
     149    throw IllegalTypeException(__FILE__,__LINE__);
     150}
     151
     152void ValueStorage::queryCurrentValue(const char * name, class RandomNumberDistribution_Parameters &_T) {
     153  if (typeid( RandomNumberDistribution_Parameters ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
     154    std::istringstream stream(CurrentValueMap[name]);
     155    DoLog(0) && (Log() << Verbose(0) << "ValueStorage::queryCurrentValue() for "+toString(name)+" is "+CurrentValueMap[name]+"." << std::endl);
     156    CurrentValueMap.erase(name);
     157    stream >> _T;
     158    ASSERT(!stream.fail(),
     159        "ValueStorage::queryCurrentValue() - RandomNumberDistribution_Parameters in value map has only no components!");
    147160  } else
    148161    throw IllegalTypeException(__FILE__,__LINE__);
    … …  
    309322}
    310323
     324void ValueStorage::setCurrentValue(const char * name, class RandomNumberDistribution_Parameters &_T)
     325{
     326  if (typeid( RandomNumberDistribution_Parameters ) == *(OptionRegistry_instance.getOptionByName(name)->getType())){
     327    std::ostringstream stream;
     328    stream << _T;
     329    CurrentValueMap[name] = stream.str();
     330    DoLog(0) && (Log() << Verbose(0) << "ValueStorage::setCurrentValue() for "+toString(name)+" to "+stream.str()+"." << std::endl);
     331  } else
     332    throw IllegalTypeException(__FILE__,__LINE__);
     333}
     334
    311335void ValueStorage::setCurrentValue(const char * name, std::vector<const atom *>&_T)
    312336{

  • src/Actions/ValueStorage.hpp

    r1ee3b8d r0275ad  
    3838class molecule;
    3939class Vector;
     40class RandomNumberDistribution_Parameters;
    4041
    4142namespace po = boost::program_options;
    … …  
    4950 * I.e. this is the interface implemented in MapOfActions which both can safely rely on
    5051 * to store&retrieve/exchange values.
     52 *
     53 * \section <ValueStorage> (ValueStorage howto)
     54 *
     55 * If you ever need to add a particular class to the ValueStorage, do as follows:
     56 * -# add a specialized queryCurrentValue and setCurrentValue to the definition
     57 *    of ValueStorage.
     58 * -# implement both in the declaration of ValueStorage.
     59 * -# in the implementation either directly implement the serializing of the
     60 *    class' members to a stringstream or use an already implemented operator<<
     61 *    or operator<<, respectively.
     62 *
    5163 */
    5264class ValueStorage : public Singleton<ValueStorage> {
    … …  
    6274  void queryCurrentValue(const char * name, class Vector &_T);
    6375  void queryCurrentValue(const char * name, class BoxVector &_T);
     76  void queryCurrentValue(const char * name, class RandomNumberDistribution_Parameters &_T);
    6477  void queryCurrentValue(const char * name, std::vector<const atom *>&_T);
    6578  void queryCurrentValue(const char * name, std::vector<const element *>&_T);
    … …  
    106119  void setCurrentValue(const char * name, class Box &_T);
    107120  void setCurrentValue(const char * name, class Vector &_T);
     121  void setCurrentValue(const char * name, class RandomNumberDistribution_Parameters &_T);
    108122  void setCurrentValue(const char * name, std::vector<const atom *>&_T);
    109123  void setCurrentValue(const char * name, std::vector<const element *>&_T);

  • src/RandomNumbers/Makefile.am

    r1ee3b8d r0275ad  
    1010RANDOMSOURCE = \
    1111        RandomNumberDistribution_Encapsulation.cpp \
     12        RandomNumberDistribution_Parameters.cpp \
    1213        RandomNumberDistributionFactory.cpp \
    1314        RandomNumberEngine_Encapsulation.cpp \
     15        RandomNumberEngine_Parameters.cpp \
    1416        RandomNumberEngineFactory.cpp \
    1517        RandomNumberGenerator.cpp \
    … …  
    2022RANDOMHEADER = \
    2123        RandomNumberDistribution.hpp \
     24        RandomNumberDistribution_Parameters.hpp \
    2225        RandomNumberDistribution_Encapsulation.hpp \
    2326        RandomNumberDistributionFactory.hpp \
    2427        RandomNumberEngine.hpp \
    2528        RandomNumberEngine_Encapsulation.hpp \
     29        RandomNumberEngine_Parameters.hpp \
    2630        RandomNumberEngineFactory.hpp \
    2731        RandomNumberGenerator.hpp \

  • src/RandomNumbers/RandomNumberDistribution.hpp

    r1ee3b8d r0275ad  
    1616class RandomNumberDistributionFactoryTest;
    1717class RandomNumberGenerator;
     18class RandomNumberDistribution_Parameters;
    1819
    1920/** Abstract base class for a random number distribution.
    … …  
    3738
    3839public:
    39   /** Getter for smallest value the engine produces.
     40  /** Getter for the whole set of possible parameters.
     41   *
     42   * @return filled instance of RandomNumberDistribution_Parameters
     43   */
     44  virtual RandomNumberDistribution_Parameters* getParameterSet() const=0;
     45
     46  /** Getter for smallest value the uniform_... engines produces.
    4047   *
    4148   * @return smallest value
    … …  
    4350  virtual double min() const=0;
    4451
    45   /** Getter for largest value the engine produces.
     52  /** Getter for largest value the uniform_... engines produces.
    4653   *
    4754   * @return largest value
    … …  
    5663  virtual double p() const=0;
    5764
     65  /** Getter for binomial_distribution's parameter t.
     66   *
     67   * @return t
     68   */
     69  virtual double t() const=0;
     70
     71  /** Getter for cauchy_distribution parameter median.
     72   *
     73   * @return median
     74   */
     75  virtual double median() const=0;
     76
     77  /** Getter for cauchy_distribution parameter sigma.
     78   *
     79   * @return sigma
     80   */
     81  virtual double sigma() const=0;
     82
     83  /** Getter for gamma_distribution parameter alpha.
     84   *
     85   * @return alpha
     86   */
     87  virtual double alpha() const=0;
     88
     89  /** Getter for poisson_distribution's parameter mean.
     90   *
     91   * @return mean
     92   */
     93  virtual double mean() const=0;
     94
     95  /** Getter for triangle_distribution parameter a.
     96   *
     97   * @return a
     98   */
     99  virtual double a() const=0;
     100
     101  /** Getter for triangle_distribution parameter b.
     102   *
     103   * @return b
     104   */
     105  virtual double b() const=0;
     106
     107  /** Getter for triangle_distribution parameter c.
     108   *
     109   * @return c
     110   */
     111  virtual double c() const=0;
     112
     113  /** Getter for exponential_distribution parameter lambda.
     114   *
     115   * @return lambda
     116   */
     117  virtual double lambda() const=0;
     118
    58119  /** Getter for the type name of the internal distribution.
    59120   *
     121   * @return name of distribution
    60122   */
    61123  virtual std::string name()=0;

  • src/RandomNumbers/RandomNumberDistributionFactory.cpp

    r1ee3b8d r0275ad  
    4242
    4343#include "RandomNumberDistribution_Encapsulation.hpp"
     44#include "RandomNumberDistribution_Parameters.hpp"
    4445
    4546#include "RandomNumberDistributionFactory.hpp"
    … …  
    4748// has to be included BEFORE PrototypeFactory_impl.hpp!
    4849#include "RandomNumberDistributionFactory.def"
    49 #include "CodePatterns/PrototypeFactory_impl.hpp"
     50#include "CodePatterns/ManipulablePrototypeFactory_impl.hpp"
    5051
    5152RandomNumberDistributionFactory::RandomNumberDistributionFactory()
    … …  
    6061
    6162CONSTRUCT_SINGLETON(RandomNumberDistributionFactory)
    62 CONSTRUCT_PROTOTYPEFACTORY(RandomNumberDistribution)
     63CONSTRUCT_MANIPULABLEPROTOTYPEFACTORY(RandomNumberDistribution, RandomNumberDistribution_Parameters)
    6364
    6465#include "RandomNumberDistributionFactory.undef"

  • src/RandomNumbers/RandomNumberDistributionFactory.def

    r1ee3b8d r0275ad  
    2525#define FactoryNAME RandomNumberDistributionFactory
    2626#define Abstract_Interface_Class RandomNumberDistribution
     27#define Abstract_Parameter_Class RandomNumberDistribution_Parameters
    2728#define Abstract_Encapsulation_Class RandomNumberDistribution_Encapsulation
    2829#define type_name_space boost::

  • src/RandomNumbers/RandomNumberDistributionFactory.hpp

    r1ee3b8d r0275ad  
    2121#include "RandomNumberDistributionFactory.undef"
    2222
    23 #include "CodePatterns/PrototypeFactory.hpp"
     23#include "CodePatterns/ManipulablePrototypeFactory.hpp"
    2424
    2525#include <map>
    2626
    2727class RandomNumberDistribution;
     28class RandomNumberDistribution_Parameters;
    2829class RandomNumberDistributionFactoryUnitTest;
     30class CommandSetRandomNumbersDistributionAction;
    2931
    3032/** This is the abstract factory class for random number distributions.
    … …  
    3941class RandomNumberDistributionFactory :
    4042  public Singleton<RandomNumberDistributionFactory>,
    41   public PrototypeFactory<RandomNumberDistribution>
     43  public ManipulablePrototypeFactory<RandomNumberDistribution, RandomNumberDistribution_Parameters>
    4244{
    4345  friend class Singleton<RandomNumberDistributionFactory>;
    4446  friend class RandomNumberDistributionFactoryTest;
     47  friend class CommandSetRandomNumbersDistributionAction;
    4548
    4649protected:

  • src/RandomNumbers/RandomNumberDistributionFactory.undef

    r1ee3b8d r0275ad  
    55#undef FactoryNAME
    66#undef Abstract_Interface_Class
     7#undef Abstract_Parameter_Class
    78#undef Abstract_Encapsulation_Class
    89#undef type_name_space

  • src/RandomNumbers/RandomNumberDistribution_Encapsulation.cpp

    r1ee3b8d r0275ad  
    2424#include "RandomNumberDistribution_Encapsulation.hpp"
    2525
     26/* =========  manipulatedclone() ================ */
     27
     28template <>
     29RandomNumberDistribution_Encapsulation< boost::uniform_smallint<> >::
     30RandomNumberDistribution_Encapsulation (const RandomNumberDistribution_Parameters&_params) :
     31  distribution_type(_params.min, _params.max)
     32{}
     33
     34template <>
     35RandomNumberDistribution_Encapsulation< boost::uniform_int<> >::
     36RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params) :
     37  distribution_type(_params.min, _params.max)
     38{}
     39
     40template <>
     41RandomNumberDistribution_Encapsulation< boost::uniform_real<> >::
     42RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params) :
     43  distribution_type(_params.min, _params.max)
     44{}
     45
     46template <>
     47RandomNumberDistribution_Encapsulation< boost::bernoulli_distribution<> >::
     48RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params) :
     49  distribution_type(_params.p)
     50{}
     51
     52template <>
     53RandomNumberDistribution_Encapsulation< boost::binomial_distribution<> >::
     54RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params) :
     55  distribution_type((int)_params.t, _params.p)
     56{}
     57
     58template <>
     59RandomNumberDistribution_Encapsulation< boost::cauchy_distribution<> >::
     60RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params) :
     61  distribution_type(_params.median, _params.sigma)
     62{}
     63
     64template <>
     65RandomNumberDistribution_Encapsulation< boost::gamma_distribution<> >::
     66RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params) :
     67  distribution_type(_params.alpha)
     68{}
     69
     70template <>
     71RandomNumberDistribution_Encapsulation< boost::poisson_distribution<> >::
     72RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params) :
     73  distribution_type(_params.mean)
     74{}
     75
     76template <>
     77RandomNumberDistribution_Encapsulation< boost::geometric_distribution<> >::
     78RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params) :
     79  distribution_type(_params.p)
     80{}
     81
     82template <>
     83RandomNumberDistribution_Encapsulation< boost::triangle_distribution<> >::
     84RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params) :
     85  distribution_type(_params.a, _params.b, _params.c)
     86{}
     87
     88template <>
     89RandomNumberDistribution_Encapsulation< boost::exponential_distribution<> >::
     90RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params) :
     91  distribution_type(_params.lambda)
     92{}
     93
     94template <>
     95RandomNumberDistribution_Encapsulation< boost::normal_distribution<> >::
     96RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params) :
     97  distribution_type(_params.mean, _params.sigma)
     98{}
     99
     100template <>
     101RandomNumberDistribution_Encapsulation< boost::lognormal_distribution<> >::
     102RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params) :
     103  distribution_type(_params.mean, _params.sigma)
     104{}
    26105
    27106/* ===============  min() ======================= */

  • src/RandomNumbers/RandomNumberDistribution_Encapsulation.hpp

    r1ee3b8d r0275ad  
    3737#include <boost/random/uniform_smallint.hpp>
    3838
    39 #include "CodePatterns/Clone.hpp"
     39#include "CodePatterns/ManipulableClone.hpp"
    4040#include "RandomNumberDistribution.hpp"
     41
     42#include "RandomNumberDistribution_Parameters.hpp"
    4143
    4244class RandomNumberDistributionFactory;
    … …  
    5254class RandomNumberDistribution_Encapsulation :
    5355  public RandomNumberDistribution,
    54   public Clone<RandomNumberDistribution>
     56  public ManipulableClone<RandomNumberDistribution, RandomNumberDistribution_Parameters>
    5557{
    5658    /**
    … …  
    6163
    6264public:
    63 
    64   /** Getter for smallest value the engine produces.
     65  /** Getter for the whole set of possible parameters.
     66   *
     67   * @return filled instance of RandomNumberDistribution_Parameters
     68   */
     69  RandomNumberDistribution_Parameters* getParameterSet() const
     70  {
     71    RandomNumberDistribution_Parameters *params = new RandomNumberDistribution_Parameters();
     72    params->getParameters(this);
     73    return params;
     74  }
     75
     76  /** Getter for smallest value the uniform_... engines produces.
    6577   *
    6678   * @return smallest value
    6779   */
    6880  double min() const {
    69     ASSERT(0, "min() not implemented for "+name());
    70     return -1.;
    71   }
    72 
    73   /** Getter for largest value the engine produces.
     81    return RandomNumberDistribution_Parameters::noset_value;
     82  }
     83
     84  /** Getter for largest value the uniform_... engines produces.
    7485   *
    7586   * @return largest value
    7687   */
    7788  double max() const {
    78     ASSERT(0, "max() not implemented for "+name());
    79     return -1.;
     89    return RandomNumberDistribution_Parameters::noset_value;
    8090  }
    8191
    … …  
    8595   */
    8696  double p() const {
    87     ASSERT(0, "p() not implemented for "+name());
    88     return -1.;
     97    return RandomNumberDistribution_Parameters::noset_value;
    8998  }
    9099
    … …  
    94103   */
    95104  double t() const {
    96     ASSERT(0, "t() not implemented for "+name());
    97     return -1.;
     105    return RandomNumberDistribution_Parameters::noset_value;
    98106  }
    99107
    … …  
    103111   */
    104112  double median() const {
    105     ASSERT(0, "median() not implemented for "+name());
    106     return -1.;
     113    return RandomNumberDistribution_Parameters::noset_value;
    107114  }
    108115
    … …  
    112119   */
    113120  double sigma() const {
    114     ASSERT(0, "sigma() not implemented for "+name());
    115     return -1.;
     121    return RandomNumberDistribution_Parameters::noset_value;
    116122  }
    117123
    … …  
    121127   */
    122128  double alpha() const {
    123     ASSERT(0, "alpha() not implemented for "+name());
    124     return -1.;
     129    return RandomNumberDistribution_Parameters::noset_value;
    125130  }
    126131
    … …  
    130135   */
    131136  double mean() const {
    132     ASSERT(0, "mean() not implemented for "+name());
    133     return -1.;
     137    return RandomNumberDistribution_Parameters::noset_value;
    134138  }
    135139
    … …  
    139143   */
    140144  double a() const {
    141     ASSERT(0, "a() not implemented for "+name());
    142     return -1.;
     145    return RandomNumberDistribution_Parameters::noset_value;
    143146  }
    144147
    … …  
    148151   */
    149152  double b() const {
    150     ASSERT(0, "b() not implemented for "+name());
    151     return -1.;
     153    return RandomNumberDistribution_Parameters::noset_value;
    152154  }
    153155
    … …  
    157159   */
    158160  double c() const {
    159     ASSERT(0, "c() not implemented for "+name());
    160     return -1.;
     161    return RandomNumberDistribution_Parameters::noset_value;
    161162  }
    162163
    … …  
    166167   */
    167168  double lambda() const {
    168     ASSERT(0, "lambda() not implemented for "+name());
    169     return -1.;
     169    return RandomNumberDistribution_Parameters::noset_value;
    170170  }
    171171
    … …  
    193193  RandomNumberDistribution* clone() const {
    194194    RandomNumberDistribution* MyClone = NULL;
    195     MyClone = new RandomNumberDistribution_Encapsulation<distribution>();
     195    RandomNumberDistribution_Parameters *params = getParameterSet();
     196    MyClone = new RandomNumberDistribution_Encapsulation<distribution>(*params);
     197    delete params;
    196198    return MyClone;
     199  }
     200
     201  /** Clones and manipulates the current instance.
     202   *
     203   * Implementation of ManipulableClone pattern.
     204   *
     205   * @param _params set of parameters to instantiate manipulated clone with
     206   * @return interface reference to cloned&manipulated instance
     207   */
     208  ManipulableClone<RandomNumberDistribution, RandomNumberDistribution_Parameters>*
     209  manipulatedclone(const RandomNumberDistribution_Parameters&_params) const
     210  {
     211    RandomNumberDistribution_Encapsulation<distribution>* newproto =
     212    new RandomNumberDistribution_Encapsulation<distribution>(_params);
     213    return newproto;
    197214  }
    198215
    … …  
    205222  {}
    206223
     224  /** Constructor that instantiates a specific random number generator and
     225   * distribution.
     226   *
     227   * @param _params set of parameters to instantiate manipulated clone with
     228   * @param _distribution_type instance of the desired distribution
     229   */
     230  RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params)
     231  {}
     232
    207233  /** Destructor of the class.
    208234   *
    … …  
    216242// template member functions for the desired cases.
    217243
     244/* =========  manipulatedclone() ================ */
     245
     246template <>
     247RandomNumberDistribution_Encapsulation< boost::uniform_smallint<> >::
     248RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params);
     249
     250template <>
     251RandomNumberDistribution_Encapsulation< boost::uniform_int<> >::
     252RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params);
     253
     254template <>
     255RandomNumberDistribution_Encapsulation< boost::uniform_real<> >::
     256RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params);
     257
     258template <>
     259RandomNumberDistribution_Encapsulation< boost::bernoulli_distribution<> >::
     260RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params);
     261
     262template <>
     263RandomNumberDistribution_Encapsulation< boost::binomial_distribution<> >::
     264RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params);
     265
     266template <>
     267RandomNumberDistribution_Encapsulation< boost::cauchy_distribution<> >::
     268RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params);
     269
     270template <>
     271RandomNumberDistribution_Encapsulation< boost::gamma_distribution<> >::
     272RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params);
     273
     274template <>
     275RandomNumberDistribution_Encapsulation< boost::poisson_distribution<> >::
     276RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params);
     277
     278template <>
     279RandomNumberDistribution_Encapsulation< boost::geometric_distribution<> >::
     280RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params);
     281
     282template <>
     283RandomNumberDistribution_Encapsulation< boost::triangle_distribution<> >::
     284RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params);
     285
     286template <>
     287RandomNumberDistribution_Encapsulation< boost::exponential_distribution<> >::
     288RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params);
     289
     290template <>
     291RandomNumberDistribution_Encapsulation< boost::normal_distribution<> >::
     292RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params);
     293
     294template <>
     295RandomNumberDistribution_Encapsulation< boost::lognormal_distribution<> >::
     296RandomNumberDistribution_Encapsulation(const RandomNumberDistribution_Parameters&_params);
     297
    218298/* ===============  min() ======================= */
    219299

  • src/RandomNumbers/RandomNumberEngine.hpp

    r1ee3b8d r0275ad  
    1616class RandomNumberEngineFactoryTest;
    1717class RandomNumberGenerator;
     18class RandomNumberEngine_Parameters;
    1819
    1920/** Abstract base class for a random number engine.
    … …  
    3738
    3839public:
     40  /** Getter for the whole set of possible parameters.
     41   *
     42   * @return filled instance of RandomNumberEngine_Parameters
     43   */
     44  virtual RandomNumberEngine_Parameters* getParameterSet() const=0;
     45
    3946  /** Set the generator's seed.
    4047   *

  • src/RandomNumbers/RandomNumberEngineFactory.cpp

    r1ee3b8d r0275ad  
    4040
    4141#include "RandomNumberEngine_Encapsulation.hpp"
     42#include "RandomNumberEngine_Parameters.hpp"
    4243
    4344#include "RandomNumberEngineFactory.hpp"
    … …  
    4546// has to be included BEFORE PrototypeFactory_impl.hpp!
    4647#include "RandomNumberEngineFactory.def"
    47 #include "CodePatterns/PrototypeFactory_impl.hpp"
     48#include "CodePatterns/ManipulablePrototypeFactory_impl.hpp"
    4849
    4950RandomNumberEngineFactory::RandomNumberEngineFactory()
    … …  
    5859
    5960CONSTRUCT_SINGLETON(RandomNumberEngineFactory)
    60 CONSTRUCT_PROTOTYPEFACTORY(RandomNumberEngine)
     61CONSTRUCT_MANIPULABLEPROTOTYPEFACTORY(RandomNumberEngine, RandomNumberEngine_Parameters)
    6162
    6263#include "RandomNumberEngineFactory.undef"

  • src/RandomNumbers/RandomNumberEngineFactory.def

    r1ee3b8d r0275ad  
    3939#define FactoryNAME RandomNumberEngineFactory
    4040#define Abstract_Interface_Class RandomNumberEngine
     41#define Abstract_Parameter_Class RandomNumberEngine_Parameters
    4142#define Abstract_Encapsulation_Class RandomNumberEngine_Encapsulation
    4243#define type_name_space boost::

  • src/RandomNumbers/RandomNumberEngineFactory.hpp

    r1ee3b8d r0275ad  
    2121#include "RandomNumberEngineFactory.undef"
    2222
    23 #include "CodePatterns/PrototypeFactory.hpp"
     23#include "CodePatterns/ManipulablePrototypeFactory.hpp"
    2424
    2525#include <map>
    2626
    2727class RandomNumberEngine;
     28class RandomNumberEngine_Parameters;
    2829class RandomNumberEngineFactoryUnitTest;
    2930class CommandSetRandomNumbersEngineAction;
    … …  
    4041class RandomNumberEngineFactory :
    4142  public Singleton<RandomNumberEngineFactory>,
    42   public PrototypeFactory<RandomNumberEngine>
     43  public ManipulablePrototypeFactory<RandomNumberEngine,RandomNumberEngine_Parameters>
    4344{
    4445  friend class Singleton<RandomNumberEngineFactory>;

  • src/RandomNumbers/RandomNumberEngineFactory.undef

    r1ee3b8d r0275ad  
    77#undef FactoryNAME
    88#undef Abstract_Interface_Class
     9#undef Abstract_Parameter_Class
    910#undef Abstract_Encapsulation_Class
    1011#undef type_name_space

  • src/RandomNumbers/RandomNumberEngine_Encapsulation.hpp

    r1ee3b8d r0275ad  
    3131#include <boost/random/xor_combine.hpp>
    3232
    33 #include "CodePatterns/Clone.hpp"
     33#include "CodePatterns/ManipulableClone.hpp"
    3434#include "RandomNumberEngine.hpp"
    3535
    3636class RandomNumberEngineFactory;
     37
     38#include "RandomNumberEngine_Parameters.hpp"
    3739
    3840/** Template class that encapsulates the random number engines from
    … …  
    4648class RandomNumberEngine_Encapsulation :
    4749  public RandomNumberEngine,
    48   public Clone<RandomNumberEngine>
     50  public ManipulableClone<RandomNumberEngine, RandomNumberEngine_Parameters>
    4951{
    5052    /**
    … …  
    5557
    5658public:
     59  /** Getter for the whole set of possible parameters.
     60   *
     61   * @return filled instance of RandomNumberEngine_Parameters
     62   */
     63    RandomNumberEngine_Parameters* getParameterSet() const
     64  {
     65    RandomNumberEngine_Parameters *params = new RandomNumberEngine_Parameters();
     66    params->getParameters(this);
     67    return params;
     68  }
     69
    5770  /** Set the engine's seed.
    5871   *
    … …  
    110123   */
    111124  RandomNumberEngine* clone() const {
    112     RandomNumberEngine* MyClone = NULL;
     125    RandomNumberEngine_Parameters *params = getParameterSet();
     126    RandomNumberEngine* MyClone = new RandomNumberEngine_Encapsulation<engine>(*params);
     127    //MyClone->seed(getseed());
     128    return MyClone;
     129  }
     130
     131  /** Clones and manipulates the current instance.
     132   *
     133   * Implementation of ManipulableClone pattern.
     134   *
     135   * @param _params set of parameters to instantiate manipulated clone with
     136   * @return interface reference to cloned&manipulated instance
     137   */
     138  ManipulableClone<RandomNumberEngine, RandomNumberEngine_Parameters>*
     139  manipulatedclone(const RandomNumberEngine_Parameters &_params) const {
     140    RandomNumberEngine_Encapsulation<engine>* MyClone = NULL;
    113141    MyClone = new RandomNumberEngine_Encapsulation<engine>();
    114     MyClone->seed(getseed());
     142    MyClone->value_seed = _params.seed;
     143    MyClone->seed(_params.seed);
    115144    return MyClone;
    116145  }
    … …  
    125154  {}
    126155
     156  /** Constructor that instantiates a specific random number generator and
     157   * distribution.
     158   * @param _engine_type instance of the desired engine
     159   */
     160  RandomNumberEngine_Encapsulation(const RandomNumberEngine_Parameters &_params) :
     161    value_seed(_params.seed)
     162  {}
     163
    127164  /** Destructor of the class.
    128165   *

  • src/RandomNumbers/RandomNumberGeneratorFactory.def

    r1ee3b8d r0275ad  
    2727 */
    2828#define engine_seq \
    29 (minstd_rand0)\
     29(minstd_rand0)
     30/*
    3031(minstd_rand)\
    3132(rand48)\
    … …  
    3637(mt11213b)\
    3738(mt19937)
     39*/
    3840
    3941#define engine_seq_a \
    40 (lagged_fibonacci607)\
     42(lagged_fibonacci607)
     43/*
    4144(lagged_fibonacci1279)\
    4245(lagged_fibonacci2281)\
    … …  
    5558(ranlux64_3_01)\
    5659(ranlux64_4_01)
    57 
     60*/
    5861#endif /* RANDOMNUMBERGENERATORFACTORY_DEF_ */

  • src/RandomNumbers/unittests/RandomNumberDistributionFactoryUnitTest.cpp

    r1ee3b8d r0275ad  
    7373  rndA_1 = NULL;
    7474  rndA_2 = NULL;
     75  rndA_3 = NULL;
    7576  RandomNumberDistributionFactory::getInstance();
    7677}
    … …  
    8182  delete rndA_1;
    8283  delete rndA_2;
     84  delete rndA_3;
    8385  RandomNumberDistributionFactory::purgeInstance();
    8486}
    … …  
    103105  // check one of the distributions in the table
    104106  rndA = RandomNumberDistributionFactory::getInstance().
    105       PrototypeTable[RandomNumberDistributionFactory::uniform_smallint]->clone();
     107      ManipulablePrototypeTable[RandomNumberDistributionFactory::uniform_smallint]->clone();
    106108  CPPUNIT_ASSERT_EQUAL(
    107109      std::string(typeid(boost::uniform_smallint<> ).name()),
    … …  
    114116}
    115117
     118void RandomNumberDistributionFactoryTest::PrototypeManipulationTest()
     119{
     120  // make unmodified clone
     121  rndA_1 = RandomNumberDistributionFactory::getInstance().
     122      getProduct(RandomNumberDistributionFactory::uniform_smallint);
     123
     124  // do something with the prototype
     125  RandomNumberDistribution_Parameters *params =
     126      rndA_1->getParameterSet();
     127  CPPUNIT_ASSERT( 20. != rndA_1->max() );
     128  params->max = 20.;
     129  RandomNumberDistributionFactory::getInstance().
     130      manipulatePrototype(RandomNumberDistributionFactory::uniform_smallint, *params);
     131  // ... and check max
     132  rndA_2 = RandomNumberDistributionFactory::getInstance().
     133      getProduct(RandomNumberDistributionFactory::uniform_smallint);
     134  CPPUNIT_ASSERT_EQUAL( 20., rndA_2->max());
     135  CPPUNIT_ASSERT( rndA_1->max() != rndA_2->max());
     136  // ... and check min (remains the same)
     137  CPPUNIT_ASSERT( rndA_1->min() == rndA_2->min());
     138
     139  // do something with the prototype again
     140  params->max = 25.;
     141  RandomNumberDistributionFactory::getInstance().
     142      manipulatePrototype(std::string("uniform_smallint"), *params);
     143  // ... and check
     144  rndA_3 = RandomNumberDistributionFactory::getInstance().
     145      getProduct(RandomNumberDistributionFactory::uniform_smallint);
     146  CPPUNIT_ASSERT_EQUAL( 25., rndA_3->max());
     147  CPPUNIT_ASSERT( rndA_1->max() != rndA_3->max());
     148  CPPUNIT_ASSERT( rndA_2->max() != rndA_3->max());
     149
     150  delete params;
     151}

  • src/RandomNumbers/unittests/RandomNumberDistributionFactoryUnitTest.hpp

    r1ee3b8d r0275ad  
    2323  CPPUNIT_TEST_SUITE( RandomNumberDistributionFactoryTest );
    2424  CPPUNIT_TEST ( DistributionTest );
     25  CPPUNIT_TEST ( PrototypeManipulationTest );
    2526  CPPUNIT_TEST_SUITE_END();
    2627
    … …  
    3031
    3132  void DistributionTest();
     33  void PrototypeManipulationTest();
    3234
    3335private:
    … …  
    3537  RandomNumberDistribution * rndA_1;
    3638  RandomNumberDistribution * rndA_2;
     39  RandomNumberDistribution * rndA_3;
    3740};
    3841

  • src/RandomNumbers/unittests/RandomNumberEngineFactoryUnitTest.cpp

    r1ee3b8d r0275ad  
    7777  rndA_1 = NULL;
    7878  rndA_2 = NULL;
     79  rndA_3 = NULL;
    7980  RandomNumberEngineFactory::getInstance();
    8081}
    … …  
    8586  delete rndA_1;
    8687  delete rndA_2;
     88  delete rndA_3;
    8789  RandomNumberEngineFactory::purgeInstance();
    8890}
    … …  
    107109  // check one of the engines in the table
    108110  rndA = RandomNumberEngineFactory::getInstance().
    109       PrototypeTable[RandomNumberEngineFactory::minstd_rand0]->clone();
     111      ManipulablePrototypeTable[RandomNumberEngineFactory::minstd_rand0]->clone();
    110112  CPPUNIT_ASSERT_EQUAL(
    111113      std::string(typeid(boost::minstd_rand0).name()),
    … …  
    117119}
    118120
     121void RandomNumberEngineFactoryTest::PrototypeManipulationTest()
     122{
     123  // make unmodified clone
     124  rndA_1 = RandomNumberEngineFactory::getInstance().
     125      getProduct(RandomNumberEngineFactory::minstd_rand0);
     126
     127  // obtain manipulator
     128  RandomNumberEngine &prototype = RandomNumberEngineFactory::getInstance().
     129      getPrototype(RandomNumberEngineFactory::minstd_rand0);
     130
     131  // change the prototype directly
     132  CPPUNIT_ASSERT ( 0 != prototype.getseed() );
     133  prototype.seed(0);
     134
     135  // check that prototype has indeed been manipulated
     136  rndA_2 = RandomNumberEngineFactory::getInstance().
     137      getProduct(RandomNumberEngineFactory::minstd_rand0);
     138  CPPUNIT_ASSERT_EQUAL( (unsigned int)0, rndA_2->getseed() );
     139  CPPUNIT_ASSERT( rndA_2->getseed() != rndA_1->getseed());
     140
     141  // manipulate prototype
     142  RandomNumberEngine_Parameters *params = rndA_1->getParameterSet();
     143  CPPUNIT_ASSERT ( rndA_1->getseed() != (unsigned int)3 );
     144  params->seed = 3;
     145  RandomNumberEngineFactory::getInstance().
     146        manipulatePrototype(RandomNumberEngineFactory::minstd_rand0, *params);
     147
     148  //
     149  rndA_3 = RandomNumberEngineFactory::getInstance().
     150      getProduct(RandomNumberEngineFactory::minstd_rand0);
     151  CPPUNIT_ASSERT_EQUAL( (unsigned int)3, rndA_3->getseed() );
     152  CPPUNIT_ASSERT( rndA_3->getseed() != rndA_1->getseed());
     153
     154  delete params;
     155}
     156

  • src/RandomNumbers/unittests/RandomNumberEngineFactoryUnitTest.hpp

    r1ee3b8d r0275ad  
    2323  CPPUNIT_TEST_SUITE( RandomNumberEngineFactoryTest );
    2424  CPPUNIT_TEST ( EngineTest );
     25  CPPUNIT_TEST ( PrototypeManipulationTest );
    2526  CPPUNIT_TEST_SUITE_END();
    2627
    … …  
    3031
    3132  void EngineTest();
     33  void PrototypeManipulationTest();
    3234
    3335private:
    … …  
    3537  RandomNumberEngine *rndA_1;
    3638  RandomNumberEngine *rndA_2;
     39  RandomNumberEngine *rndA_3;
    3740};
    3841

  • src/UIElements/CommandLineUI/CommandLineDialog.cpp

    r1ee3b8d r0275ad  
    108108}
    109109
     110void CommandLineDialog::queryRandomNumberDistribution_Parameters(const char* title, string _description){
     111  registerQuery(new RandomNumberDistribution_ParametersCommandLineQuery(title, _description));
     112}
     113
    110114/************************** Query Infrastructure ************************/
    111115/*       ---> shifted to folder Query                                   */

  • src/UIElements/CommandLineUI/CommandLineDialog.hpp

    r1ee3b8d r0275ad  
    5151  virtual void queryElements(const char*, std::string = "");
    5252  virtual void queryFile(const char*, std::string = "");
    53 
     53  virtual void queryRandomNumberDistribution_Parameters(const char*, std::string = "");
    5454protected:
    55   // specialized stuff for text queries
     55  // specialized stuff for command line queries
     56  // all placed into Query/CommandLineQuery.hpp
     57  // !please adhere to alphabetical ordering!
    5658  class AtomCommandLineQuery;
    5759  class AtomsCommandLineQuery;
    … …  
    7274  class VectorCommandLineQuery;
    7375  class VectorsCommandLineQuery;
     76  class RandomNumberDistribution_ParametersCommandLineQuery;
    7477};
    7578

  • src/UIElements/CommandLineUI/CommandLineParser.cpp

    r1ee3b8d r0275ad  
    326326        ;
    327327      break;
     328    case TypeEnumContainer::RandomNumberDistribution_ParametersType:
     329      OptionList->add_options()
     330        (currentOption->getKeyAndShortForm().c_str(),
     331            currentOption->hasDefaultValue() ?
     332                  po::value < std::string >()->default_value(boost::lexical_cast< std::string >(currentOption->getDefaultValue().c_str())) :
     333                  po::value < std::string >(),
     334                  currentOption->getDescription().c_str())
     335        ;
     336      break;
    328337  }
    329338}

  • src/UIElements/CommandLineUI/Query/CommandLineQuery.hpp

    r1ee3b8d r0275ad  
    143143};
    144144
     145class CommandLineDialog::RandomNumberDistribution_ParametersCommandLineQuery : public Dialog::RandomNumberDistribution_ParametersQuery {
     146public:
     147  RandomNumberDistribution_ParametersCommandLineQuery(std::string title, std::string _description = "");
     148  virtual ~RandomNumberDistribution_ParametersCommandLineQuery();
     149  virtual bool handle();
     150};
     151
    145152#endif /* COMMANDLINEQUERY_HPP_ */

  • src/UIElements/CommandLineUI/TypeEnumContainer.cpp

    r1ee3b8d r0275ad  
    3636#include "element.hpp"
    3737#include "molecule.hpp"
     38#include "RandomNumbers/RandomNumberDistribution_Parameters.hpp"
    3839
    3940/** Constructor for class TypeEnumContainer.
    … …  
    6364  TypeEnumMap[&typeid(const element *)] = ElementType;
    6465  TypeEnumMap[&typeid(std::vector<const element *>)] = ListOfElementsType;
     66  TypeEnumMap[&typeid(RandomNumberDistribution_Parameters)] = RandomNumberDistribution_ParametersType;
    6567
    6668  // for debugging: list all stored types

  • src/UIElements/CommandLineUI/TypeEnumContainer.hpp

    r1ee3b8d r0275ad  
    4444        ListOfMoleculesType,
    4545        ElementType,
    46         ListOfElementsType
     46        ListOfElementsType,
     47        RandomNumberDistribution_ParametersType
    4748  };
    4849

  • src/UIElements/Dialog.cpp

    r1ee3b8d r0275ad  
    186186}
    187187
     188template <> void Dialog::query< RandomNumberDistribution_Parameters >(const char *token, std::string description)
     189{
     190  queryRandomNumberDistribution_Parameters(token, description);
     191}
     192
    188193/************************** Query Infrastructure ************************/
    189194/*       ---> shifted to folder Query                                   */

  • src/UIElements/Dialog.hpp

    r1ee3b8d r0275ad  
    2020
    2121#include <boost/filesystem.hpp>
    22 
    2322#include "Box.hpp"
    2423#include "LinearAlgebra/Vector.hpp"
     24#include "RandomNumbers/RandomNumberDistribution_Parameters.hpp"
    2525
    2626class atom;
    … …  
    142142 *   -# you probably also need a QtDialog::...QueryPipe() to handle the signal/slot stuff,
    143143 *      Qt's moc does not like nested classes. Hence, this has to go extra.
     144 *   -# TypeEnumContainer add new type to query
     145 *   -# CommandLineParser::AddOptionToParser() add new type to query
     146 *   -# CommandLineParser_valdiates.[ch]pp: If given above as a new type
     147 *      program_options::value, define and implement a validate() function here.
    144148 *
    145149 */
    … …  
    170174  virtual void queryElements(const char*, std::string = "")=0;
    171175  virtual void queryFile(const char*, std::string = "")=0;
     176  virtual void queryRandomNumberDistribution_Parameters(const char*, std::string = "")=0;
    172177
    173178  virtual bool display();
    … …  
    419424  };
    420425
     426  class RandomNumberDistribution_ParametersQuery : public Query {
     427  public:
     428    RandomNumberDistribution_ParametersQuery(std::string title, std::string _description = "");
     429    virtual ~RandomNumberDistribution_ParametersQuery();
     430    virtual bool handle()=0;
     431    virtual void setResult();
     432  protected:
     433    RandomNumberDistribution_Parameters tmp;
     434  };
     435
    421436void registerQuery(Query* query);
    422437

  • src/UIElements/Makefile.am

    r1ee3b8d r0275ad  
    6767  Query/MoleculesQuery.cpp \
    6868  Query/Query.cpp \
     69  Query/RandomNumberDistribution_ParametersQuery.cpp \
    6970  Query/StringQuery.cpp \
    7071  Query/StringsQuery.cpp \
    … …  
    103104  TextUI/Query/VectorTextQuery.cpp \
    104105  TextUI/Query/VectorsTextQuery.cpp \
     106  TextUI/Query/RandomNumberDistribution_ParametersTextQuery.cpp \
    105107  TextUI/TextDialog.cpp \
    106108  TextUI/TextStatusIndicator.cpp \
    … …  
    133135  CommandLineUI/Query/VectorCommandLineQuery.cpp \
    134136  CommandLineUI/Query/VectorsCommandLineQuery.cpp \
     137  CommandLineUI/Query/RandomNumberDistribution_ParametersCommandLineQuery.cpp \
    135138  CommandLineUI/CommandLineDialog.cpp \
    136139  CommandLineUI/CommandLineParser.cpp \
    … …  
    169172  Qt4/Pipe/VectorQtQueryPipe.hpp \
    170173  Qt4/Pipe/VectorsQtQueryPipe.hpp \
     174        Qt4/Pipe/RandomNumberDistribution_ParametersQtQueryPipe.hpp \
    171175        Menu/Qt4/QtMenuPipe.hpp \
    172176        Views/Qt4/QtWorldView.hpp \
    … …  
    191195  Qt4/Pipe/VectorQtQueryPipe.cpp \
    192196  Qt4/Pipe/VectorsQtQueryPipe.cpp \
     197        Qt4/Pipe/RandomNumberDistribution_ParametersQtQueryPipe.cpp \
    193198  Qt4/Query/AtomQtQuery.cpp \
    194199  Qt4/Query/AtomsQtQuery.cpp \
    … …  
    209214  Qt4/Query/VectorQtQuery.cpp \
    210215  Qt4/Query/VectorsQtQuery.cpp \
     216        Qt4/Query/RandomNumberDistribution_ParametersQtQuery.cpp \
    211217        Qt4/QtMainWindow.cpp \
    212218        Qt4/QtDialog.cpp \

  • src/UIElements/Qt4/QtDialog.cpp

    r1ee3b8d r0275ad  
    165165}
    166166
     167void QtDialog::queryRandomNumberDistribution_Parameters(const char* title, std::string)
     168{
     169  registerQuery(new RandomNumberDistribution_ParametersQtQuery(title,inputLayout,this));
     170}
     171
    167172/************************** Query Infrastructure ************************/
    168173/*       ---> shifted to folder Query                                   */

  • src/UIElements/Qt4/QtDialog.hpp

    r1ee3b8d r0275ad  
    5050  virtual void queryElements(const char*,std::string = "");
    5151  virtual void queryFile(const char*,std::string = "");
     52  virtual void queryRandomNumberDistribution_Parameters(const char*,std::string = "");
    5253
    5354  virtual bool display();
    … …  
    7475  class VectorQtQuery;
    7576  class VectorsQtQuery;
     77  class RandomNumberDistribution_ParametersQtQuery;
    7678
    7779private:

  • src/UIElements/Qt4/Query/QtQuery.hpp

    r1ee3b8d r0275ad  
    1717#include "Qt4/QtDialog.hpp"
    1818
     19class QHBoxLayout;
    1920class QBoxLayout;
    2021class QDialogButtonBox;
    … …  
    2425class QLineEdit;
    2526class QListWidget;
     27class QPushButton;
    2628class QTableWidget;
     29class QTextEdit;
    2730class QComboBox;
    2831
    … …  
    4649class VectorQtQueryPipe;
    4750class VectorsQtQueryPipe;
    48 
     51class RandomNumberDistribution_ParametersQtQueryPipe;
    4952
    5053class QtDialog::AtomQtQuery : public Dialog::AtomQuery {
    … …  
    310313};
    311314
     315class QtDialog::RandomNumberDistribution_ParametersQtQuery : public Dialog::RandomNumberDistribution_ParametersQuery {
     316public:
     317  RandomNumberDistribution_ParametersQtQuery(std::string title,QBoxLayout *,QtDialog *);
     318  virtual ~RandomNumberDistribution_ParametersQtQuery();
     319  virtual bool handle();
     320private:
     321  QBoxLayout *parent;
     322  QHBoxLayout *thisLayout;
     323  QLabel *titleLabel;
     324  QTextEdit *inputBox;
     325  QPushButton *okButton;
     326
     327  RandomNumberDistribution_ParametersQtQueryPipe *pipe;
     328};
     329
    312330#endif /* QTQUERY_HPP_ */

  • src/UIElements/TextUI/Query/TextQuery.hpp

    r1ee3b8d r0275ad  
    143143};
    144144
     145class TextDialog::RandomNumberDistribution_ParametersTextQuery : public Dialog::RandomNumberDistribution_ParametersQuery {
     146public:
     147  RandomNumberDistribution_ParametersTextQuery(std::string title, std::string _description = NULL);
     148  virtual ~RandomNumberDistribution_ParametersTextQuery();
     149  virtual bool handle();
     150};
     151
    145152#endif /* TEXTQUERY_HPP_ */

  • src/UIElements/TextUI/TextDialog.cpp

    r1ee3b8d r0275ad  
    106106}
    107107
     108void TextDialog::queryRandomNumberDistribution_Parameters(const char* title, std::string description){
     109  registerQuery(new RandomNumberDistribution_ParametersTextQuery(title,description));
     110}
     111
    108112/************************** Query Infrastructure ************************/
    109113/*       ---> shifted to folder Query                                   */

  • src/UIElements/TextUI/TextDialog.hpp

    r1ee3b8d r0275ad  
    4848  virtual void queryElements(const char*, std::string = "");
    4949  virtual void queryFile(const char*, std::string = "");
     50  virtual void queryRandomNumberDistribution_Parameters(const char*, std::string = "");
    5051
    5152protected:
    … …  
    7172  class VectorTextQuery;
    7273  class VectorsTextQuery;
     74  class RandomNumberDistribution_ParametersTextQuery;
    7375};
    7476

  • src/unittests/DummyUI.hpp

    r1ee3b8d r0275ad  
    4141  virtual void queryElements(const char*, std::string = ""){}
    4242  virtual void queryFile(const char*, std::string = ""){}
     43  virtual void queryRandomNumberDistribution_Parameters(const char*, std::string = ""){}
    4344};
    4445

  • tests/regression/RandomNumbers/Distribution/testsuite-set-random-number-distribution.at

    r1ee3b8d r0275ad  
    33AT_SETUP([Random numbers - set the distribution with Undo/Redo])
    44AT_KEYWORDS([random numbers])
    5 AT_CHECK([../../molecuilder -v 3 --set-random-number-distribution uniform_int], 0, [stdout], [stderr])
     5AT_CHECK([../../molecuilder -v 3 --set-random-number-distribution "uniform_int" --random-number-distribution-parameters "max=20;"], 0, [stdout], [stderr])
    66AT_CHECK([fgrep "uniform_int" stdout], 0, [ignore], [ignore])
    7 AT_CHECK([../../molecuilder -v 3 --set-random-number-distribution uniform_int --undo], 0, [stdout], [stderr])
     7AT_CHECK([fgrep "Its parameters are: min=0;max=20;p=-1;t=-1;median=-1;sigma=-1;alpha=-1;mean=-1;a=-1;b=-1;c=-1;lambda=-1;" stdout], 0, [ignore], [ignore])
     8AT_CHECK([../../molecuilder -v 3 --set-random-number-distribution "uniform_int" --random-number-distribution-parameters "max=20;" --undo], 0, [stdout], [stderr])
    89AT_CHECK([fgrep "uniform_smallint" stdout], 0, [ignore], [ignore])
    9 AT_CHECK([../../molecuilder -v 3 --set-random-number-distribution uniform_int --undo --redo], 0, [stdout], [stderr])
     10AT_CHECK([fgrep "Its parameters are: min=0;max=9;p=-1;t=-1;median=-1;sigma=-1;alpha=-1;mean=-1;a=-1;b=-1;c=-1;lambda=-1;" stdout], 0, [ignore], [ignore])
     11AT_CHECK([../../molecuilder -v 3 --set-random-number-distribution "uniform_int" --random-number-distribution-parameters "max=20;" --undo --redo], 0, [stdout], [stderr])
    1012AT_CHECK([fgrep -c "uniform_int" stdout], 0, [stdout], [ignore])
     13AT_CHECK([fgrep "3" stdout], 0, [ignore], [ignore])
     14AT_CHECK([../../molecuilder -v 3 --set-random-number-distribution "uniform_int" --random-number-distribution-parameters "max=20;" --undo --redo], 0, [stdout], [stderr])
     15AT_CHECK([fgrep -c "Its parameters are: min=0;max=20;p=-1;t=-1;median=-1;sigma=-1;alpha=-1;mean=-1;a=-1;b=-1;c=-1;lambda=-1;" stdout], 0, [stdout], [ignore])
    1116AT_CHECK([fgrep "2" stdout], 0, [stdout], [ignore])
    1217AT_CLEANUP

  • tests/regression/RandomNumbers/Engine/testsuite-set-random-number-engine.at

    r1ee3b8d r0275ad  
    33AT_SETUP([Random numbers - set the engine with Undo/Redo])
    44AT_KEYWORDS([random numbers])
    5 AT_CHECK([../../molecuilder -v 3 --set-random-number-engine lagged_fibonacci607], 0, [stdout], [stderr])
     5AT_CHECK([../../molecuilder -v 3 --set-random-number-engine "lagged_fibonacci607" --random-number-engine-parameters "seed=2;"], 0, [stdout], [stderr])
    66AT_CHECK([fgrep "lagged_fibonacci607" stdout], 0, [ignore], [ignore])
    7 AT_CHECK([../../molecuilder -v 3 --set-random-number-engine lagged_fibonacci607 --undo], 0, [stdout], [stderr])
     7AT_CHECK([fgrep "Its parameters are: seed=2;" stdout], 0, [ignore], [ignore])
     8AT_CHECK([../../molecuilder -v 3 --set-random-number-engine "lagged_fibonacci607" --random-number-engine-parameters "seed=2;" --undo], 0, [stdout], [stderr])
    89AT_CHECK([fgrep "minstd_rand0" stdout], 0, [ignore], [ignore])
    9 AT_CHECK([../../molecuilder -v 3 --set-random-number-engine lagged_fibonacci607 --undo --redo], 0, [stdout], [stderr])
     10AT_CHECK([fgrep "Its parameters are: seed=1;" stdout], 0, [ignore], [ignore])
     11AT_CHECK([../../molecuilder -v 3 --set-random-number-engine "lagged_fibonacci607" --random-number-engine-parameters "seed=2;" --undo --redo], 0, [stdout], [stderr])
    1012AT_CHECK([fgrep -c "lagged_fibonacci607" stdout], 0, [stdout], [ignore])
     13AT_CHECK([fgrep "3" stdout], 0, [stdout], [ignore])
     14AT_CHECK([../../molecuilder -v 3 --set-random-number-engine "lagged_fibonacci607" --random-number-engine-parameters "seed=2;" --undo --redo], 0, [stdout], [stderr])
     15AT_CHECK([fgrep -c "Its parameters are: seed=2;" stdout], 0, [stdout], [ignore])
    1116AT_CHECK([fgrep "2" stdout], 0, [stdout], [ignore])
    1217AT_CLEANUP
Note: See TracChangeset for help on using the changeset viewer.