RDKit
Open-source cheminformatics and machine learning.
RandomSample.h
Go to the documentation of this file.
1 //
2 // Copyright (c) 2015, Novartis Institutes for BioMedical Research Inc.
3 // All rights reserved.
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following
13 // disclaimer in the documentation and/or other materials provided
14 // with the distribution.
15 // * Neither the name of Novartis Institutes for BioMedical Research Inc.
16 // nor the names of its contributors may be used to endorse or promote
17 // products derived from this software without specific prior written
18 // permission.
19 //
20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 //
32 
33 #include <RDGeneral/export.h>
34 #ifndef RGROUP_RANDOM_SAMPLE_H
35 #define RGROUP_RANDOM_SAMPLE_H
36 
38 #include <boost/random.hpp>
39 #include <boost/random/uniform_int_distribution.hpp>
40 #include <sstream>
41 
42 namespace RDKit {
43 
44 //! This is a class for fully randomly sampling reagents.
45 // Note that this enumerator never halts.
46 /*!
47  basic usage:
48 
49  \verbatim
50  std::vector<MOL_SPTR_VECT> bbs;
51  bbs.push_back( bbs_for_reactants_1 );
52  bbs.push_back( bbs_for_reactants_2 );
53 
54  RandomSampleStrategy rgroups;
55  rgroups.initialize(rxn, bbs);
56  for(size_t i=0; i<num_samples && rgroups; ++i) {
57  MOL_SPTR_VECT rvect = getReactantsFromRGroups(bbs, rgroups.next());
58  std::vector<MOL_SPTR_VECT> lprops = rxn.RunReactants(rvect);
59  ...
60  }
61  \endverbatim
62 
63  See EnumerationStrategyBase for more details and usage.
64 */
66  : public EnumerationStrategyBase {
67  boost::uint64_t m_numPermutationsProcessed{};
68  boost::minstd_rand m_rng;
69  std::vector<boost::random::uniform_int_distribution<>> m_distributions;
70 
71  public:
74 
75  m_rng(),
76  m_distributions() {
77  for (size_t i = 0; i < m_permutation.size(); ++i) {
78  m_distributions.emplace_back(0, m_permutation[i] - 1);
79  }
80  }
81 
83 
84  virtual void initializeStrategy(const ChemicalReaction &,
85  const EnumerationTypes::BBS &) {
86  m_distributions.clear();
87  for (size_t i = 0; i < m_permutationSizes.size(); ++i) {
88  m_distributions.emplace_back(
89  0, m_permutationSizes[i] - 1);
90  }
91 
92  m_numPermutationsProcessed = 0;
93  }
94 
95  virtual const char *type() const { return "RandomSampleStrategy"; }
96 
97  //! The current permutation {r1, r2, ...}
98  virtual const EnumerationTypes::RGROUPS &next() {
99  for (size_t i = 0; i < m_permutation.size(); ++i) {
100  m_permutation[i] = m_distributions[i](m_rng);
101  }
102 
103  ++m_numPermutationsProcessed;
104 
105  return m_permutation;
106  }
107 
108  virtual boost::uint64_t getPermutationIdx() const {
109  return m_numPermutationsProcessed;
110  }
111 
112  virtual operator bool() const { return true; }
113 
115  return new RandomSampleStrategy(*this);
116  }
117 
118  private:
119 #ifdef RDK_USE_BOOST_SERIALIZATION
120  friend class boost::serialization::access;
121 
122  template <class Archive>
123  void save(Archive &ar, const unsigned int /*version*/) const {
124  // invoke serialization of the base class
125  ar << boost::serialization::base_object<const EnumerationStrategyBase>(
126  *this);
127  ar << m_numPermutationsProcessed;
128 
129  std::stringstream random;
130  random << m_rng;
131  std::string s = random.str();
132  ar << s;
133  }
134 
135  template <class Archive>
136  void load(Archive &ar, const unsigned int /*version*/) {
137  // invoke serialization of the base class
138  ar >> boost::serialization::base_object<EnumerationStrategyBase>(*this);
139  ar >> m_numPermutationsProcessed;
140  std::string s;
141  ar >> s;
142  std::stringstream random(s);
143  random >> m_rng;
144 
145  // reset the uniform distributions
146  m_distributions.clear();
147  for (size_t i = 0; i < m_permutationSizes.size(); ++i) {
148  m_distributions.emplace_back(
149  0, m_permutationSizes[i] - 1);
150  }
151  }
152 
153  template <class Archive>
154  void serialize(Archive &ar, const unsigned int file_version) {
155  boost::serialization::split_member(ar, *this, file_version);
156  }
157 #endif
158 };
159 } // namespace RDKit
160 
161 #ifdef RDK_USE_BOOST_SERIALIZATION
162 BOOST_CLASS_VERSION(RDKit::RandomSampleStrategy, 1)
163 #endif
164 
165 #endif
This is a class for storing and applying general chemical reactions.
Definition: Reaction.h:119
void initialize(const ChemicalReaction &reaction, const EnumerationTypes::BBS &building_blocks)
This is a class for fully randomly sampling reagents.
Definition: RandomSample.h:66
virtual void initializeStrategy(const ChemicalReaction &, const EnumerationTypes::BBS &)
Definition: RandomSample.h:84
virtual const EnumerationTypes::RGROUPS & next()
The current permutation {r1, r2, ...}.
Definition: RandomSample.h:98
virtual const char * type() const
Definition: RandomSample.h:95
virtual boost::uint64_t getPermutationIdx() const
Returns how many permutations have been processed by this strategy.
Definition: RandomSample.h:108
EnumerationStrategyBase * copy() const
copy the enumeration strategy complete with current state
Definition: RandomSample.h:114
#define RDKIT_CHEMREACTIONS_EXPORT
Definition: export.h:86
std::vector< boost::uint64_t > RGROUPS
std::vector< MOL_SPTR_VECT > BBS
Std stuff.
Definition: Abbreviations.h:17