RDKit
Open-source cheminformatics and machine learning.
FingerprintGenerator.h
Go to the documentation of this file.
1 //
2 // Copyright (C) 2018-2022 Boran Adas and other RDKit contributors
3 //
4 // @@ All Rights Reserved @@
5 // This file is part of the RDKit.
6 // The contents are covered by the terms of the BSD license
7 // which is included in the file license.txt, found at the root
8 // of the RDKit source tree.
9 //
10 
11 #include <RDGeneral/export.h>
12 #ifndef RD_FINGERPRINTGEN_H_2018_05
13 #define RD_FINGERPRINTGEN_H_2018_05
14 
18 #include <utility>
19 #include <vector>
20 #include <memory>
21 #include <cstdint>
22 
23 namespace RDKit {
24 class ROMol;
25 
27  using atomToBitsType = std::vector<std::vector<std::uint64_t>>;
29  std::map<std::uint64_t,
30  std::vector<std::pair<std::uint32_t, std::uint32_t>>>;
31  using bitPathsType = std::map<std::uint64_t, std::vector<std::vector<int>>>;
32  using atomCountsType = std::vector<unsigned int>;
33 
34  // numAtoms long
35  atomToBitsType *atomToBits = nullptr;
36 
37  // bitId -> vector of (atomId, radius) for morgan
38  // bitId -> (atom1, atom2) for atom pairs
39  bitInfoMapType *bitInfoMap = nullptr;
40 
41  // rdkit fp
42  // maps bitId -> vector of bond paths
43  bitPathsType *bitPaths = nullptr;
44 
45  // number of paths that set bits for each atom, must have the same size as
46  // atom count for molecule.
47  atomCountsType *atomCounts = nullptr;
48 
50  atomToBitsHolder.reset(new atomToBitsType);
51  atomToBits = atomToBitsHolder.get();
52  }
54  bitInfoMapHolder.reset(new bitInfoMapType);
55  bitInfoMap = bitInfoMapHolder.get();
56  }
58  bitPathsHolder.reset(new bitPathsType);
59  bitPaths = bitPathsHolder.get();
60  }
62  atomCountsHolder.reset(new atomCountsType);
63  atomCounts = atomCountsHolder.get();
64  }
65 
66  private:
67  std::unique_ptr<atomToBitsType> atomToBitsHolder;
68  std::unique_ptr<bitInfoMapType> bitInfoMapHolder;
69  std::unique_ptr<bitPathsType> bitPathsHolder;
70  std::unique_ptr<atomCountsType> atomCountsHolder;
71 };
72 
73 /*!
74  \brief Abstract base class that holds molecule independent arguments that are
75  common amongst all fingerprint types and classes inherited from this would
76  hold fingerprint type specific arguments
77 
78  */
80  : private boost::noncopyable {
81  public:
82  FingerprintArguments(bool countSimulation,
83  const std::vector<std::uint32_t> countBounds,
84  std::uint32_t fpSize,
85  std::uint32_t numBitsPerFeature = 1,
86  bool includeChirality = false);
89  std::vector<std::uint32_t> d_countBounds;
90  std::uint32_t d_fpSize;
91  std::uint32_t d_numBitsPerFeature;
92 
93  /**
94  \brief method that returns information string about the fingerprint specific
95  argument set and the arguments themselves
96 
97  \return std::string information string
98  */
99  virtual std::string infoString() const = 0;
100 
101  /**
102  \brief method that returns information string about common fingerprinting
103  arguments' values
104 
105  \return std::string information string
106  */
107  std::string commonArgumentsString() const;
108 
110 };
111 
112 /*!
113  \brief abstract base class that holds atom-environments that will be hashed to
114  generate the fingerprint
115 
116  */
117 template <typename OutputType>
118 class RDKIT_FINGERPRINTS_EXPORT AtomEnvironment : private boost::noncopyable {
119  public:
120  /*!
121  \brief calculates and returns the bit id to be set for this atom-environment
122 
123  \param arguments Fingerprinting type specific molecule independent
124  arguments
125  \param atomInvariants Atom-invariants to be used during hashing
126  \param bondInvariants Bond-invariants to be used during hashing
127  \param hashResults if set results will be ready to be modded
128 
129  \return OutputType calculated bit id for this environment
130  */
131  virtual OutputType getBitId(FingerprintArguments *arguments,
132  const std::vector<std::uint32_t> *atomInvariants,
133  const std::vector<std::uint32_t> *bondInvariants,
135  const bool hashResults = false,
136  const std::uint64_t fpSize = 0) const = 0;
138  size_t bitId) const = 0;
139 
140  virtual ~AtomEnvironment() {}
141 };
142 
143 /*!
144  \brief abstract base class that generates atom-environments from a molecule
145 
146  */
147 template <typename OutputType>
149  : private boost::noncopyable {
150  public:
151  /*!
152  \brief generate and return all atom-envorinments from a molecule
153 
154  \param mol molecule to generate the atom-environments from
155  \param arguments fingerprint type specific molecule independent
156  arguments
157  \param fromAtoms atoms to be used during environment generation,
158  usage of this parameter depends on the implementation of different
159  fingerprint types
160  \param ignoreAtoms atoms to be ignored during environment generation,
161  usage of this parameter depends on the implementation of different
162  fingerprint types
163  \param confId which conformation to use during environment
164  generation, needed for some fingerprint types
165  \param additionalOutput contains pointers for additional outputs of
166  fingerprinting operation, usage depends on implementation of the fingerprint
167  type
168  \param atomInvariants atom invariants to be used during environment
169  generation, in some cases some of the hashing can be done during environment
170  generation so it is also passed here
171  \param bondInvariants bond invariants to be used during environment
172  generation, same as atomInvariants it might be needed
173  \param hashResults if set results will be ready to be modded
174 
175  \return std::vector<AtomEnvironment *> atom-environments generated from
176  this molecule
177  */
178  virtual std::vector<AtomEnvironment<OutputType> *> getEnvironments(
179  const ROMol &mol, FingerprintArguments *arguments,
180  const std::vector<std::uint32_t> *fromAtoms = nullptr,
181  const std::vector<std::uint32_t> *ignoreAtoms = nullptr,
182  const int confId = -1, const AdditionalOutput *additionalOutput = nullptr,
183  const std::vector<std::uint32_t> *atomInvariants = nullptr,
184  const std::vector<std::uint32_t> *bondInvariants = nullptr,
185  const bool hashResults = false) const = 0;
186 
187  /**
188  \brief method that returns information about this /c AtomEnvironmentGenerator
189  and its arguments if any
190 
191  \return std::string information string
192  */
193  virtual std::string infoString() const = 0;
194  /*!
195  \brief Returns the size of the fingerprint based on arguments
196 
197  \return OutputType size of the fingerprint
198  */
199  virtual OutputType getResultSize() const = 0;
200 
202 
204 };
205 
206 /*!
207  \brief abstract base class for atom invariants generators
208 
209  */
211  : private boost::noncopyable {
212  public:
213  /*!
214  \brief get atom invariants from a molecule
215 
216  \param mol molecule to generate the atom invariants for
217 
218  \return std::vector<std::uint32_t> atom invariants generated for the given
219  molecule
220  */
221  virtual std::vector<std::uint32_t> *getAtomInvariants(
222  const ROMol &mol) const = 0;
223 
224  /**
225  \brief method that returns information about this /c AtomInvariantsGenerator
226  and its arguments
227 
228  \return std::string information string
229  */
230  virtual std::string infoString() const = 0;
231 
233  virtual AtomInvariantsGenerator *clone() const = 0;
234 };
235 
236 /*!
237  \brief abstract base class for bond invariants generators
238 
239  */
241  : private boost::noncopyable {
242  public:
243  /*!
244  \brief get bond invariants from a molecule
245 
246  \param mol molecule to generate the bond invariants for
247 
248  \return std::vector<std::uint32_t> bond invariants generated for the given
249  molecule
250  */
251  virtual std::vector<std::uint32_t> *getBondInvariants(
252  const ROMol &mol) const = 0;
253 
254  /**
255  \brief method that returns information about this /c BondInvariantsGenerator
256  and its arguments
257 
258  \return std::string information string
259  */
260  virtual std::string infoString() const = 0;
261 
263  virtual BondInvariantsGenerator *clone() const = 0;
264 }; // namespace RDKit
265 
266 /*!
267  \brief struct that makes calling the fingerprint generation functions easier
268 
269  FingerprintFuncArguments doesn't own any of the pointers it stores.
270 
271  */
273  const std::vector<std::uint32_t> *fromAtoms = nullptr;
274  const std::vector<std::uint32_t> *ignoreAtoms = nullptr;
275  int confId = -1;
277  const std::vector<std::uint32_t> *customAtomInvariants = nullptr;
278  const std::vector<std::uint32_t> *customBondInvariants = nullptr;
281  const std::vector<std::uint32_t> *fromAtoms_arg,
282  const std::vector<std::uint32_t> *ignoreAtoms_arg, int confId_arg,
283  AdditionalOutput *additionalOutput_arg,
284  const std::vector<std::uint32_t> *customAtomInvariants_arg,
285  const std::vector<std::uint32_t> *customBondInvariants_arg)
286  : fromAtoms(fromAtoms_arg),
287  ignoreAtoms(ignoreAtoms_arg),
288  confId(confId_arg),
289  additionalOutput(additionalOutput_arg),
290  customAtomInvariants(customAtomInvariants_arg),
291  customBondInvariants(customBondInvariants_arg){};
292 };
293 
294 /*!
295  \brief class that generates same fingerprint style for different output
296  formats
297 
298  */
299 template <typename OutputType>
301  : private boost::noncopyable {
302  FingerprintArguments *dp_fingerprintArguments;
303  AtomEnvironmentGenerator<OutputType> *dp_atomEnvironmentGenerator;
304  AtomInvariantsGenerator *dp_atomInvariantsGenerator;
305  BondInvariantsGenerator *dp_bondInvariantsGenerator;
306  const bool df_ownsAtomInvGenerator;
307  const bool df_ownsBondInvGenerator;
308 
309  std::unique_ptr<SparseIntVect<OutputType>> getFingerprintHelper(
310  const ROMol &mol, FingerprintFuncArguments &args,
311  const std::uint64_t fpSize = 0) const;
312 
313  public:
315  AtomEnvironmentGenerator<OutputType> *atomEnvironmentGenerator,
316  FingerprintArguments *fingerprintArguments,
317  AtomInvariantsGenerator *atomInvariantsGenerator = nullptr,
318  BondInvariantsGenerator *bondInvariantsGenerator = nullptr,
319  bool ownsAtomInvGenerator = false, bool ownsBondInvGenerator = false);
320 
322 
323  FingerprintArguments *getOptions() { return dp_fingerprintArguments; };
325  return dp_fingerprintArguments;
326  };
327 
328  std::unique_ptr<SparseIntVect<OutputType>> getSparseCountFingerprint(
329  const ROMol &mol, FingerprintFuncArguments &args) const;
330 
331  std::unique_ptr<SparseBitVect> getSparseFingerprint(
332  const ROMol &mol, FingerprintFuncArguments &args) const;
333 
334  std::unique_ptr<SparseIntVect<std::uint32_t>> getCountFingerprint(
335  const ROMol &mol, FingerprintFuncArguments &args) const;
336 
337  std::unique_ptr<ExplicitBitVect> getFingerprint(
338  const ROMol &mol, FingerprintFuncArguments &args) const;
339 
341  const ROMol &mol, const std::vector<std::uint32_t> *fromAtoms = nullptr,
342  const std::vector<std::uint32_t> *ignoreAtoms = nullptr, int confId = -1,
343  AdditionalOutput *additionalOutput = nullptr,
344  const std::vector<std::uint32_t> *customAtomInvariants = nullptr,
345  const std::vector<std::uint32_t> *customBondInvariants = nullptr) const {
346  FingerprintFuncArguments ffa(fromAtoms, ignoreAtoms, confId,
347  additionalOutput, customAtomInvariants,
348  customBondInvariants);
349  return getSparseCountFingerprint(mol, ffa).release();
350  };
351 
353  const ROMol &mol, const std::vector<std::uint32_t> *fromAtoms = nullptr,
354  const std::vector<std::uint32_t> *ignoreAtoms = nullptr, int confId = -1,
355  AdditionalOutput *additionalOutput = nullptr,
356  const std::vector<std::uint32_t> *customAtomInvariants = nullptr,
357  const std::vector<std::uint32_t> *customBondInvariants = nullptr) const {
358  FingerprintFuncArguments ffa(fromAtoms, ignoreAtoms, confId,
359  additionalOutput, customAtomInvariants,
360  customBondInvariants);
361  return getSparseFingerprint(mol, ffa).release();
362  };
363 
365  const ROMol &mol, const std::vector<std::uint32_t> *fromAtoms = nullptr,
366  const std::vector<std::uint32_t> *ignoreAtoms = nullptr, int confId = -1,
367  AdditionalOutput *additionalOutput = nullptr,
368  const std::vector<std::uint32_t> *customAtomInvariants = nullptr,
369  const std::vector<std::uint32_t> *customBondInvariants = nullptr) const {
370  FingerprintFuncArguments ffa(fromAtoms, ignoreAtoms, confId,
371  additionalOutput, customAtomInvariants,
372  customBondInvariants);
373  return getCountFingerprint(mol, ffa).release();
374  };
375 
377  const ROMol &mol, const std::vector<std::uint32_t> *fromAtoms = nullptr,
378  const std::vector<std::uint32_t> *ignoreAtoms = nullptr, int confId = -1,
379  AdditionalOutput *additionalOutput = nullptr,
380  const std::vector<std::uint32_t> *customAtomInvariants = nullptr,
381  const std::vector<std::uint32_t> *customBondInvariants = nullptr) const {
382  FingerprintFuncArguments ffa(fromAtoms, ignoreAtoms, confId,
383  additionalOutput, customAtomInvariants,
384  customBondInvariants);
385  return getFingerprint(mol, ffa).release();
386  };
387 
388  std::string infoString() const;
389 };
390 
393  const ROMol &, const std::vector<std::uint32_t> *,
394  const std::vector<std::uint32_t> *, int, AdditionalOutput *,
395  const std::vector<std::uint32_t> *,
396  const std::vector<std::uint32_t> *) const;
399  const ROMol &, const std::vector<std::uint32_t> *,
400  const std::vector<std::uint32_t> *, int, AdditionalOutput *,
401  const std::vector<std::uint32_t> *,
402  const std::vector<std::uint32_t> *) const;
405  const ROMol &, const std::vector<std::uint32_t> *,
406  const std::vector<std::uint32_t> *, int, AdditionalOutput *,
407  const std::vector<std::uint32_t> *,
408  const std::vector<std::uint32_t> *) const;
411  const ROMol &, const std::vector<std::uint32_t> *,
412  const std::vector<std::uint32_t> *, int, AdditionalOutput *,
413  const std::vector<std::uint32_t> *,
414  const std::vector<std::uint32_t> *) const;
417  const ROMol &, const std::vector<std::uint32_t> *,
418  const std::vector<std::uint32_t> *, int, AdditionalOutput *,
419  const std::vector<std::uint32_t> *,
420  const std::vector<std::uint32_t> *) const;
423  const ROMol &, const std::vector<std::uint32_t> *,
424  const std::vector<std::uint32_t> *, int, AdditionalOutput *,
425  const std::vector<std::uint32_t> *,
426  const std::vector<std::uint32_t> *) const;
429  const ROMol &, const std::vector<std::uint32_t> *,
430  const std::vector<std::uint32_t> *, int, AdditionalOutput *,
431  const std::vector<std::uint32_t> *,
432  const std::vector<std::uint32_t> *) const;
435  const ROMol &, const std::vector<std::uint32_t> *,
436  const std::vector<std::uint32_t> *, int, AdditionalOutput *,
437  const std::vector<std::uint32_t> *,
438  const std::vector<std::uint32_t> *) const;
439 
441 
442 //! used to indicate errors for unimplemented fp types in convenience
443 //! functions
445  : public std::exception {
446  public:
447  //! construct with an error message
448  UnimplementedFPException(const char *msg) : _msg(msg) {}
449  //! construct with an error message
450  UnimplementedFPException(std::string msg) : _msg(std::move(msg)) {}
451  //! get the error message
452  const char *what() const noexcept override { return _msg.c_str(); }
453  ~UnimplementedFPException() noexcept override = default;
454 
455  private:
456  std::string _msg;
457 };
458 
459 // convenience functions, fingerprint generation with default values
460 
462  const ROMol &mol, FPType fPType);
463 
465  FPType fPType);
466 
468  const ROMol &mol, FPType fPType);
469 
471  FPType fPType);
472 
473 RDKIT_FINGERPRINTS_EXPORT std::vector<SparseIntVect<std::uint64_t> *> *
474 getSparseCountFPBulk(const std::vector<const ROMol *> molVector, FPType fPType);
475 
477  const std::vector<const ROMol *> molVector, FPType fPType);
478 
479 RDKIT_FINGERPRINTS_EXPORT std::vector<SparseIntVect<std::uint32_t> *>
480  *getCountFPBulk(const std::vector<const ROMol *> molVector, FPType fPType);
481 
483  const std::vector<const ROMol *> molVector, FPType fPType);
484 
485 } // namespace RDKit
486 
487 #endif
a class for bit vectors that are densely occupied
abstract base class that generates atom-environments from a molecule
const FingerprintArguments * dp_fingerprintArguments
virtual std::string infoString() const =0
method that returns information about this /c AtomEnvironmentGenerator and its arguments if any
virtual OutputType getResultSize() const =0
Returns the size of the fingerprint based on arguments.
virtual std::vector< AtomEnvironment< OutputType > * > getEnvironments(const ROMol &mol, FingerprintArguments *arguments, const std::vector< std::uint32_t > *fromAtoms=nullptr, const std::vector< std::uint32_t > *ignoreAtoms=nullptr, const int confId=-1, const AdditionalOutput *additionalOutput=nullptr, const std::vector< std::uint32_t > *atomInvariants=nullptr, const std::vector< std::uint32_t > *bondInvariants=nullptr, const bool hashResults=false) const =0
generate and return all atom-envorinments from a molecule
abstract base class that holds atom-environments that will be hashed to generate the fingerprint
virtual void updateAdditionalOutput(AdditionalOutput *AdditionalOutput, size_t bitId) const =0
virtual OutputType getBitId(FingerprintArguments *arguments, const std::vector< std::uint32_t > *atomInvariants, const std::vector< std::uint32_t > *bondInvariants, AdditionalOutput *AdditionalOutput, const bool hashResults=false, const std::uint64_t fpSize=0) const =0
calculates and returns the bit id to be set for this atom-environment
abstract base class for atom invariants generators
virtual std::string infoString() const =0
method that returns information about this /c AtomInvariantsGenerator and its arguments
virtual AtomInvariantsGenerator * clone() const =0
virtual std::vector< std::uint32_t > * getAtomInvariants(const ROMol &mol) const =0
get atom invariants from a molecule
abstract base class for bond invariants generators
virtual std::string infoString() const =0
method that returns information about this /c BondInvariantsGenerator and its arguments
virtual BondInvariantsGenerator * clone() const =0
virtual std::vector< std::uint32_t > * getBondInvariants(const ROMol &mol) const =0
get bond invariants from a molecule
Abstract base class that holds molecule independent arguments that are common amongst all fingerprint...
virtual std::string infoString() const =0
method that returns information string about the fingerprint specific argument set and the arguments ...
FingerprintArguments(bool countSimulation, const std::vector< std::uint32_t > countBounds, std::uint32_t fpSize, std::uint32_t numBitsPerFeature=1, bool includeChirality=false)
std::string commonArgumentsString() const
method that returns information string about common fingerprinting arguments' values
std::vector< std::uint32_t > d_countBounds
class that generates same fingerprint style for different output formats
FingerprintGenerator(AtomEnvironmentGenerator< OutputType > *atomEnvironmentGenerator, FingerprintArguments *fingerprintArguments, AtomInvariantsGenerator *atomInvariantsGenerator=nullptr, BondInvariantsGenerator *bondInvariantsGenerator=nullptr, bool ownsAtomInvGenerator=false, bool ownsBondInvGenerator=false)
std::string infoString() const
std::unique_ptr< ExplicitBitVect > getFingerprint(const ROMol &mol, FingerprintFuncArguments &args) const
std::unique_ptr< SparseIntVect< std::uint32_t > > getCountFingerprint(const ROMol &mol, FingerprintFuncArguments &args) const
SparseIntVect< std::uint32_t > * getCountFingerprint(const ROMol &mol, const std::vector< std::uint32_t > *fromAtoms=nullptr, const std::vector< std::uint32_t > *ignoreAtoms=nullptr, int confId=-1, AdditionalOutput *additionalOutput=nullptr, const std::vector< std::uint32_t > *customAtomInvariants=nullptr, const std::vector< std::uint32_t > *customBondInvariants=nullptr) const
SparseBitVect * getSparseFingerprint(const ROMol &mol, const std::vector< std::uint32_t > *fromAtoms=nullptr, const std::vector< std::uint32_t > *ignoreAtoms=nullptr, int confId=-1, AdditionalOutput *additionalOutput=nullptr, const std::vector< std::uint32_t > *customAtomInvariants=nullptr, const std::vector< std::uint32_t > *customBondInvariants=nullptr) const
const FingerprintArguments * getOptions() const
FingerprintArguments * getOptions()
std::unique_ptr< SparseBitVect > getSparseFingerprint(const ROMol &mol, FingerprintFuncArguments &args) const
std::unique_ptr< SparseIntVect< OutputType > > getSparseCountFingerprint(const ROMol &mol, FingerprintFuncArguments &args) const
ExplicitBitVect * getFingerprint(const ROMol &mol, const std::vector< std::uint32_t > *fromAtoms=nullptr, const std::vector< std::uint32_t > *ignoreAtoms=nullptr, int confId=-1, AdditionalOutput *additionalOutput=nullptr, const std::vector< std::uint32_t > *customAtomInvariants=nullptr, const std::vector< std::uint32_t > *customBondInvariants=nullptr) const
SparseIntVect< OutputType > * getSparseCountFingerprint(const ROMol &mol, const std::vector< std::uint32_t > *fromAtoms=nullptr, const std::vector< std::uint32_t > *ignoreAtoms=nullptr, int confId=-1, AdditionalOutput *additionalOutput=nullptr, const std::vector< std::uint32_t > *customAtomInvariants=nullptr, const std::vector< std::uint32_t > *customBondInvariants=nullptr) const
a class for efficiently storing sparse vectors of ints
Definition: SparseIntVect.h:28
UnimplementedFPException(const char *msg)
construct with an error message
~UnimplementedFPException() noexcept override=default
UnimplementedFPException(std::string msg)
construct with an error message
const char * what() const noexcept override
get the error message
a class for bit vectors that are sparsely occupied.
Definition: SparseBitVect.h:34
#define RDKIT_FINGERPRINTS_EXPORT
Definition: export.h:177
RDKIT_FINGERPRINTS_EXPORT SparseIntVect< std::uint32_t > * getFingerprint(const ROMol &mol, unsigned int radius, std::vector< boost::uint32_t > *invariants=nullptr, const std::vector< boost::uint32_t > *fromAtoms=nullptr, bool useChirality=false, bool useBondTypes=true, bool useCounts=true, bool onlyNonzeroInvariants=false, BitInfoMap *atomsSettingBits=nullptr, bool includeRedundantEnvironments=false)
returns the Morgan fingerprint for a molecule
Std stuff.
Definition: Abbreviations.h:19
RDKIT_FINGERPRINTS_EXPORT std::vector< ExplicitBitVect * > * getFPBulk(const std::vector< const ROMol * > molVector, FPType fPType)
RDKIT_FINGERPRINTS_EXPORT std::vector< SparseIntVect< std::uint64_t > * > * getSparseCountFPBulk(const std::vector< const ROMol * > molVector, FPType fPType)
RDKIT_FINGERPRINTS_EXPORT std::vector< SparseIntVect< std::uint32_t > * > * getCountFPBulk(const std::vector< const ROMol * > molVector, FPType fPType)
RDKIT_FINGERPRINTS_EXPORT SparseBitVect * getSparseFP(const ROMol &mol, FPType fPType)
RDKIT_FINGERPRINTS_EXPORT ExplicitBitVect * getFP(const ROMol &mol, FPType fPType)
RDKIT_FINGERPRINTS_EXPORT SparseIntVect< std::uint64_t > * getSparseCountFP(const ROMol &mol, FPType fPType)
RDKIT_FINGERPRINTS_EXPORT std::vector< SparseBitVect * > * getSparseFPBulk(const std::vector< const ROMol * > molVector, FPType fPType)
RDKIT_FINGERPRINTS_EXPORT SparseIntVect< std::uint32_t > * getCountFP(const ROMol &mol, FPType fPType)
std::vector< std::vector< std::uint64_t > > atomToBitsType
std::vector< unsigned int > atomCountsType
std::map< std::uint64_t, std::vector< std::vector< int > >> bitPathsType
std::map< std::uint64_t, std::vector< std::pair< std::uint32_t, std::uint32_t > >> bitInfoMapType
struct that makes calling the fingerprint generation functions easier
const std::vector< std::uint32_t > * customAtomInvariants
const std::vector< std::uint32_t > * customBondInvariants
const std::vector< std::uint32_t > * fromAtoms
const std::vector< std::uint32_t > * ignoreAtoms
FingerprintFuncArguments(const std::vector< std::uint32_t > *fromAtoms_arg, const std::vector< std::uint32_t > *ignoreAtoms_arg, int confId_arg, AdditionalOutput *additionalOutput_arg, const std::vector< std::uint32_t > *customAtomInvariants_arg, const std::vector< std::uint32_t > *customBondInvariants_arg)