rdkit_chem 2025.09.3.1-x86_64-linux

data/Code/RubyWrappers/Dict.i

@@ -0,0 +1,45 @@
+/* 
+*
+*  Copyright (c) 2015, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+* 
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met: 
+*
+*     * Redistributions of source code must retain the above copyright 
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following 
+*       disclaimer in the documentation and/or other materials provided 
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc. 
+*       nor the names of its contributors may be used to endorse or promote 
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <RDGeneral/types.h>
+#include <RDGeneral/Dict.h>
+%}
+
+// This requires SWIG 4.2 or higher
+%include "std_string_view.i"
+
+%ignore RDKit::Dict::Pair;
+%ignore RDKit::PairHolder;
+%include <RDGeneral/Dict.h>
+
+

data/Code/RubyWrappers/DistGeom.i

@@ -0,0 +1,217 @@
+/*
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+*       nor the names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+%{
+#include <DistGeom/ChiralSet.h>
+#include <DistGeom/BoundsMatrix.h>
+#include <DistGeom/DistGeomUtils.h>
+#include <GraphMol/DistGeomHelpers/BoundsMatrixBuilder.h>
+#include <GraphMol/DistGeomHelpers/Embedder.h>
+#include <DistGeom/TriangleSmooth.h>
+#include <GraphMol/ROMol.h>
+%}
+
+// This prevents duplicate definitions in Ruby code (due to 2 C++ functions resolving to the same Ruby function)
+%ignore RDKit::DGeomHelpers::initBoundsMat(DistGeom::BoundsMatPtr, double, double);
+%ignore RDKit::DGeomHelpers::initBoundsMat(DistGeom::BoundsMatPtr,double);
+%ignore RDKit::DGeomHelpers::initBoundsMat(DistGeom::BoundsMatPtr);
+
+// This conflicts with definitions in UFF::, so ignore and make it a method on the bounds matrix
+%ignore DistGeom::constructForceField;
+
+%include <DistGeom/ChiralSet.h>
+%include <DistGeom/BoundsMatrix.h>
+%include <GraphMol/DistGeomHelpers/BoundsMatrixBuilder.h>
+%include <DistGeom/DistGeomUtils.h>
+%include <DistGeom/TriangleSmooth.h>
+
+
+%ignore RDKit::DGeomHelpers::EmbedMolecule;
+%ignore RDKit::DGeomHelpers::EmbedMultipleConfs;
+// make sure the struct has a copy constructor:
+%copyctor RDKit::DGeomHelpers::EmbedParameters;
+
+// we want to ignore the const global parameter objects because SWIG does a
+// poor job of making them read-only when they are exposed.
+%ignore RDKit::DGeomHelpers::KDG;
+%ignore RDKit::DGeomHelpers::ETDG;
+%ignore RDKit::DGeomHelpers::ETKDG;
+%ignore RDKit::DGeomHelpers::ETKDGv2;
+%ignore RDKit::DGeomHelpers::ETKDGv3;
+%ignore RDKit::DGeomHelpers::srETKDGv3;
+
+%include <GraphMol/DistGeomHelpers/Embedder.h>
+
+// create functions to return copies of the global parameter objects
+%newobject RDKit::DGeomHelpers::getKDG;
+%newobject RDKit::DGeomHelpers::getETDG;
+%newobject RDKit::DGeomHelpers::getETKDG;
+%newobject RDKit::DGeomHelpers::getETKDGv2;
+%newobject RDKit::DGeomHelpers::getETKDGv3;
+%newobject RDKit::DGeomHelpers::getsrETKDGv3;
+%inline {
+  namespace RDKit{
+    namespace DGeomHelpers {
+      EmbedParameters *getKDG() {
+        return new EmbedParameters(KDG);
+      }
+      EmbedParameters *getETDG() {
+        return new EmbedParameters(ETDG);
+      }
+      EmbedParameters *getETKDG() {
+        return new EmbedParameters(ETKDG);
+      }
+      EmbedParameters *getETKDGv2() {
+        return new EmbedParameters(ETKDGv2);
+      }
+      EmbedParameters *getETKDGv3() {
+        return new EmbedParameters(ETKDGv3);
+      }
+      EmbedParameters *getsrETKDGv3() {
+        return new EmbedParameters(srETKDGv3);
+      }
+    }
+  }
+}
+
+// A class to hang special distance geometry methods on.
+%inline {
+  namespace DistGeom {
+    class DistanceGeom {
+      public:
+
+      /* From Embedder.h */
+      static int EmbedMolecule(RDKit::ROMol &mol,
+        unsigned int maxIterations=0, int seed=-1,
+        bool clearConfs=true,
+        bool useRandomCoords=false,double boxSizeMult=2.0,
+        bool randNegEig=true,
+        unsigned int numZeroFail=1,
+        const std::map<int,RDGeom::Point3D> *coordMap=0,
+        double optimizerForceTol=1e-3,
+        bool ignoreSmoothingFailures=false,
+        bool enforceChirality=true,
+        bool useExpTorsionAnglePrefs=false,
+        bool useBasicKnowledge=false,
+        bool verbose=false,
+        double basinThresh=5.0) {
+
+        return RDKit::DGeomHelpers::EmbedMolecule(mol,
+          maxIterations, seed,
+          clearConfs,
+          useRandomCoords, boxSizeMult,
+          randNegEig,
+          numZeroFail,
+          coordMap,
+          optimizerForceTol,
+          ignoreSmoothingFailures,
+          enforceChirality,
+          useExpTorsionAnglePrefs,
+          useBasicKnowledge,
+          verbose,
+          basinThresh);
+      }
+
+      static int EmbedMolecule(RDKit::ROMol &mol,RDKit::DGeomHelpers::EmbedParameters &params) {
+        return RDKit::DGeomHelpers::EmbedMolecule(mol,params);
+      }
+
+      static RDKit::INT_VECT EmbedMultipleConfs(RDKit::ROMol &mol,
+        unsigned int numConfs=10,
+        unsigned int maxIterations=30,
+        int seed=-1, bool clearConfs=true,
+      	bool useRandomCoords=false,double boxSizeMult=2.0,
+        bool randNegEig=true, unsigned int numZeroFail=1,
+        double pruneRmsThresh=-1.0,
+        const std::map<int,RDGeom::Point3D> *coordMap=0,
+        double optimizerForceTol=1e-3,
+        bool ignoreSmoothingFailures=false,
+        bool enforceChirality=true,
+        bool useExpTorsionAnglePrefs=false,
+        bool useBasicKnowledge=false,
+        bool verbose=false,
+        double basinThresh=5.0) {
+
+        return RDKit::DGeomHelpers::EmbedMultipleConfs(mol,
+          numConfs,
+          maxIterations,
+          seed, clearConfs,
+          useRandomCoords,boxSizeMult,
+          randNegEig, numZeroFail,
+          pruneRmsThresh,
+          coordMap,
+          optimizerForceTol,
+          ignoreSmoothingFailures,
+          enforceChirality,
+          useExpTorsionAnglePrefs,
+          useBasicKnowledge,
+          verbose,
+          basinThresh);
+      }
+      static RDKit::INT_VECT EmbedMultipleConfs(RDKit::ROMol &mol,
+                                                unsigned int numConfs,
+                                                RDKit::DGeomHelpers::EmbedParameters &params) {
+        return RDKit::DGeomHelpers::EmbedMultipleConfs(mol, numConfs, params);
+      }
+
+      static void SetTopolBounds(RDKit::ROMol &mol,
+        DistGeom::BoundsMatrix* mmat,
+        bool set15bounds=true, bool scaleVDW=false) {
+
+        DistGeom::BoundsMatPtr* mmatAsSmartPtr = new DistGeom::BoundsMatPtr(mmat);
+        RDKit::DGeomHelpers::setTopolBounds(mol, *mmatAsSmartPtr, set15bounds, scaleVDW);
+      }
+
+      static ForceFields::ForceField *ConstructForceField(DistGeom::BoundsMatrix& mmat,
+         RDGeom::PointPtrVect &positions, const VECT_CHIRALSET &csets,
+         double weightChiral=1.0,
+         double weightFourthDim=0.1,
+         std::map< std::pair<int,int>,double> *extraWeights=0,
+         double basinSizeTol=5.0) {
+
+        return DistGeom::constructForceField(mmat, positions, csets,
+          weightChiral,
+          weightFourthDim,
+          extraWeights,
+          basinSizeTol);
+      }
+
+      // This is hard to override in Ruby, so do it here.
+      static bool ComputeInitialCoords(const RDNumeric::SymmMatrix<double> &distmat,
+        std::vector<RDGeom::Point3D *> &positions, bool randNegEig=false,
+        unsigned int numZeroFail=2) {
+
+        return DistGeom::computeInitialCoords(distmat, (RDGeom::PointPtrVect &) positions, randNegEig, numZeroFail);
+      }
+    };
+  }
+}

data/Code/RubyWrappers/DiversityPick.h

@@ -0,0 +1,49 @@
+#include <RDGeneral/export.h>
+#include <list>
+#include <map>
+#include <DataStructs/BitOps.h>
+#include <DataStructs/ExplicitBitVect.h>
+#include <SimDivPickers/MaxMinPicker.h>
+#include <RDGeneral/Exceptions.h>
+
+namespace {
+class taniFunctor {
+ public:
+  taniFunctor(const std::vector<ExplicitBitVect> &ebvs, bool useCache)
+      : df_useCache(useCache), d_ebvs(ebvs) {}
+  double operator()(unsigned int i, unsigned int j) {
+    double res;
+    if (df_useCache) {
+      std::pair<unsigned int, unsigned int> idxPair(i, j);
+      if (this->d_cache.count(idxPair) > 0) {
+        res = this->d_cache[idxPair];
+      } else {
+        res = 1. - TanimotoSimilarity(d_ebvs[i], d_ebvs[j]);
+        this->d_cache[idxPair] = res;
+      }
+    } else {
+      res = 1. - TanimotoSimilarity(d_ebvs[i], d_ebvs[j]);
+    }
+    return res;
+  }
+
+ private:
+  bool df_useCache;
+  const std::vector<ExplicitBitVect> &d_ebvs;
+  std::map<std::pair<unsigned int, unsigned int>, double> d_cache;
+};
+}  // namespace
+
+std::vector<int> pickUsingFingerprints(
+    const std::vector<ExplicitBitVect> &ebvs, unsigned int nToPick,
+    int seed = -1, std::vector<int> firstPicks = std::vector<int>(),
+    bool useCache = true) {
+  if (nToPick >= ebvs.size())
+    throw ValueErrorException("nToPick is larger than the vector size");
+  std::vector<int> res;
+
+  RDPickers::MaxMinPicker picker;
+  taniFunctor ftor(ebvs, useCache);
+  res = picker.lazyPick(ftor, ebvs.size(), nToPick, firstPicks, seed);
+  return res;
+}

data/Code/RubyWrappers/DiversityPick.i

@@ -0,0 +1,10 @@
+
+%{
+#include <DataStructs/BitOps.h>
+#include <DataStructs/ExplicitBitVect.h>
+#include "DiversityPick.h"
+%}
+
+%template(EBV_Vect) std::vector< ExplicitBitVect >;
+
+%include "DiversityPick.h";

data/Code/RubyWrappers/ErrorGenerator.i

@@ -0,0 +1,73 @@
+/* 
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+* 
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met: 
+*
+*     * Redistributions of source code must retain the above copyright 
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following 
+*       disclaimer in the documentation and/or other materials provided 
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc. 
+*       nor the names of its contributors may be used to endorse or promote 
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+%{
+#include <DistGeom/ChiralSet.h>
+#include <DistGeom/BoundsMatrix.h>
+#include <DistGeom/DistGeomUtils.h>
+#include <GraphMol/DistGeomHelpers/BoundsMatrixBuilder.h>
+#include <GraphMol/DistGeomHelpers/Embedder.h>
+#include <DistGeom/TriangleSmooth.h>
+#include <GraphMol/ROMol.h>
+%}
+
+
+// A class to generate errors at the C++ level to make sure they are trapped and don't kill the JVM.
+%inline {
+namespace BadCode {
+
+	class ErrorGenerator {
+
+	public:
+
+		void badAlloc_1() {
+			double* myarray= new double[2000000000];
+ 
+		};
+		void badAlloc_2() {
+			int* myarray= new int[-1];
+ 
+		};
+		void badCall () {
+			int (*f)() = NULL; 
+			(*f)();
+		};
+		int badAccess () {
+			int *i = (int *) -1; 
+			int j = *i;
+			return j;
+		};
+	};
+    }
+}
+
+

data/Code/RubyWrappers/ExplicitBitVect.i

@@ -0,0 +1,76 @@
+/*
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+*       nor the names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <DataStructs/BitVect.h>
+#include <DataStructs/ExplicitBitVect.h>
+%}
+
+%ignore ExplicitBitVect::dp_bits;
+%ignore ExplicitBitVect::getOnBits (IntVect& v) const;
+%ignore ExplicitBitVect::ExplicitBitVect(unsigned int,bool);
+
+%include <DataStructs/ExplicitBitVect.h>
+%newobject ExplicitBitVect::getOnBits;
+%extend ExplicitBitVect {
+  IntVect *getOnBits() {
+    IntVect* bits = new IntVect;
+    ($self)->getOnBits(*bits);
+    return bits;
+  }
+
+  void andOperator(const ExplicitBitVect & other) {
+    *($self) &= other;
+  }
+
+  void orOperator(const ExplicitBitVect & other) {
+    *($self) |= other;
+  }
+
+  void xorOperator(const ExplicitBitVect & other) {
+    *($self) ^= other;
+  }
+
+  void copy(const ExplicitBitVect &other) {
+    *($self) = other;
+  }
+
+  const std::string toByteArray() {
+    return ($self)->toString();
+  }
+
+  ExplicitBitVect(const std::vector<unsigned char> & data ) {
+    std::string str(data.begin(), data.end());
+    return new ExplicitBitVect(str);
+  }
+}

data/Code/RubyWrappers/FMCS.i

@@ -0,0 +1,63 @@
+/*
+*
+*  Copyright (c) 2014, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+*       nor the names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <GraphMol/FMCS/FMCS.h>
+%}
+
+%ignore MCSParameters;
+%ignore MCSParametersInternal;
+%ignore findMCS(const std::vector<ROMOL_SPTR>& mols, const MCSParameters* params);
+%ignore checkAtomRingMatch(const MCSAtomCompareParameters& p,
+                           const ROMol& mol1, unsigned int atom1,
+                           const ROMol& mol2, unsigned int atom2);
+%ignore checkAtomCharge(const MCSAtomCompareParameters& p,
+                        const ROMol& mol1, unsigned int atom1,
+                        const ROMol& mol2, unsigned int atom2);
+%ignore checkAtomChirality(const MCSAtomCompareParameters& p,
+                           const ROMol& mol1, unsigned int atom1,
+                           const ROMol& mol2, unsigned int atom2);
+%ignore checkBondStereo(const MCSBondCompareParameters& p,
+                        const ROMol& mol1, unsigned int bond1,
+                        const ROMol& mol2, unsigned int bond2);
+%ignore checkBondRingMatch(const MCSBondCompareParameters &p,
+                           const ROMol& mol1, unsigned int bond1,
+                           const ROMol& mol2, unsigned int bond2,
+                           void* v_ringMatchMatrixSet);
+%include <GraphMol/FMCS/FMCS.h>
+
+%{
+
+  RDKit::MCSResult findMCS(const std::vector<RDKit::ROMOL_SPTR>& mols){
+    return RDKit::findMCS(mols,static_cast<const RDKit::MCSParameters *>(NULL));
+  };
+%}

data/Code/RubyWrappers/FilterCatalog.i

@@ -0,0 +1,154 @@
+/*
+ *  Copyright (c) 2015, Novartis Institutes for BioMedical Research Inc.
+ *  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+ *       nor the names of its contributors may be used to endorse or promote
+ *       products derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+//%import "ROMol.i"
+%include "std_string.i"
+%include "std_vector.i"
+%include <boost_shared_ptr.i>
+%shared_ptr(RDKit::FilterCatalogEntry)
+
+%{
+#include <../RDGeneral/Dict.h>
+#include <../Catalogs/Catalog.h>
+#include <../Catalogs/CatalogParams.h>
+#include <GraphMol/FilterCatalog/FilterMatcherBase.h>
+#include <GraphMol/FilterCatalog/FilterCatalogEntry.h>
+#include <GraphMol/FilterCatalog/FilterCatalog.h>
+
+// bug fix for swig, it removes these from their namespaces
+typedef RDCatalog::Catalog<RDKit::FilterCatalogEntry, RDKit::FilterCatalogParams>::paramType_t paramType_t;
+
+typedef std::vector<std::string> STR_VECT;
+%}
+
+// FilterCatalog vector templates removed - Ruby SWIG lacks swig::traits for custom shared_ptr types
+// %template(FilterCatalogEntry_Vect) std::vector< boost::shared_ptr<RDKit::FilterCatalogEntry> >;
+// %template(FilterCatalogEntry_VectVect) std::vector<std::vector< boost::shared_ptr<const RDKit::FilterCatalogEntry> > >;
+// %template(FilterCatalogEntryVect) std::vector< const RDKit::FilterCatalogEntry* >;
+%template(UChar_Vect) std::vector<unsigned char>;
+// %template(FilterMatch_Vect) std::vector<RDKit::FilterMatch>;
+
+%include <../RDGeneral/Dict.h>
+%include <../Catalogs/Catalog.h>
+%include <../Catalogs/CatalogParams.h>
+%include <GraphMol/Substruct/SubstructMatch.h>
+
+
+%extend RDKit::FilterMatch {
+  MatchVectType getAtomMatches() {
+    return ($self)->atomPairs;
+  }
+ }
+
+%newobject RDKit::FilterCatalogEntry::getProp;
+%extend RDKit::FilterCatalogEntry {
+  std::string getProp(const std::string key){
+    std::string res;
+    ($self)->getProp(key, res);
+    return res;
+  }
+
+  std::vector<RDKit::FilterMatch> getFilterMatches(const ROMol &mol) {
+    std::vector<RDKit::FilterMatch> matches;
+    ($self)->getFilterMatches(mol, matches);
+    return matches;
+  }
+ }
+
+%extend RDKit::FilterCatalog {
+  FilterCatalog(const std::vector<unsigned char> & data ) {
+    std::string str(data.begin(), data.end());
+    return new RDKit::FilterCatalog(str);
+  }
+
+  static bool canSerialize() {
+    return RDKit::FilterCatalogCanSerialize();
+  }
+
+  // boost does a bad job of wrapping shared_ptr<const T> so we will do the
+  //  unthinkable and cast away const.
+  //  Also we can't use FilterCatalog::SENTRY because swig thinks it is a new
+  //   type.  Bad swig!
+  boost::shared_ptr<RDKit::FilterCatalogEntry> getFirstMatch(const ROMol &mol) {
+    RDKit::FilterCatalog::CONST_SENTRY res = self->getFirstMatch(mol);
+    return boost::const_pointer_cast<RDKit::FilterCatalogEntry>(res);
+  }
+
+  std::vector<boost::shared_ptr<RDKit::FilterCatalogEntry> > getMatches(const ROMol &mol) {
+    std::vector<RDKit::FilterCatalog::CONST_SENTRY> matches = self->getMatches(mol);
+    std::vector<RDKit::FilterCatalog::SENTRY> res;
+    res.reserve(matches.size());
+    for (size_t i=0; i< matches.size(); ++i) {
+      res.push_back( boost::const_pointer_cast<RDKit::FilterCatalogEntry>(matches[i]) );
+    }
+    return res;
+ }
+
+  // re-wrap swig is making duplicate entries for some strange reason
+  unsigned int addEntry(boost::shared_ptr<RDKit::FilterCatalogEntry> entry) {
+    return self->addEntry(entry);
+  }
+
+  bool removeEntry(boost::shared_ptr<RDKit::FilterCatalogEntry> entry) {
+    return self->removeEntry(entry);
+  }
+
+  // swig const-ptr shenanigans again
+  boost::shared_ptr<RDKit::FilterCatalogEntry> getEntry(unsigned int idx) const {
+    return boost::const_pointer_cast<RDKit::FilterCatalogEntry>(
+      self->getEntry(idx));
+  }
+
+  unsigned int getIdxForEntry(const boost::shared_ptr<FilterCatalogEntry> &entry) const {
+    return self->getIdxForEntry(entry);
+  }
+}
+
+%ignore RDKit::FilterCatalog(const std::string &);
+%ignore RDKit::FilterCatalog::getFirstMatch;
+%ignore RDKit::FilterCatalog::getMatches;
+%ignore RDKit::FilterCatalog::addEntry;
+%ignore RDKit::FilterCatalog::removeEntry;
+%ignore RDKit::FilterCatalog::setCatalogParams;
+%ignore RDKit::FilterCatalog::getIdxForEntry;
+%ignore RDKit::FilterCatalog::getEntryWithIdx;
+
+%ignore RDKit::FilterMatch::operator==;
+%ignore std::vector<RDKit::FilterMatch>::operator==;
+
+//%ignore RDKit::FilterCatalogEntry::getPropList;
+%ignore RDKit::Dict::getPropList;
+
+%immutable RDKit::DEFAULT_FILTERMATCHERBASE_NAME;
+
+%include <GraphMol/FilterCatalog/FilterMatcherBase.h>
+%include <GraphMol/FilterCatalog/FilterCatalogEntry.h>
+%include <GraphMol/FilterCatalog/FilterCatalog.h>