api: added logP and molarRefractivity, removed Python implementation

api/c/indigo/indigo.h

@@ -672,6 +672,8 @@ CEXPORT double indigoTPSA(int molecule, int includeSP);
 CEXPORT int indigoNumRotatableBonds(int molecule);
 CEXPORT int indigoNumHydrogenBondAcceptors(int molecule);
 CEXPORT int indigoNumHydrogenBondDonors(int molecule);
+CEXPORT double indigoCLogP(int molecule);
+CEXPORT double indigoCMolarRefractivity(int molecule);
 
 CEXPORT const char* indigoCanonicalSmiles(int molecule);
 CEXPORT const char* indigoLayeredCode(int molecule);

api/c/indigo/src/indigo_calc.cpp

@@ -7,6 +7,7 @@
 
 #include "indigo_molecule.h"
 #include "indigo_reaction.h"
+#include "molecule/crippen.h"
 
 IndigoMoleculeGross::IndigoMoleculeGross() : IndigoObject(GROSS_MOLECULE)
 {
@@ -191,3 +192,33 @@ CEXPORT int indigoNumHydrogenBondDonors(const int molecule)
     }
     INDIGO_END(-1);
 }
+
+CEXPORT double indigoCLogP(const int molecule)
+{
+    INDIGO_BEGIN
+    {
+        auto& obj = self.getObject(molecule);
+        if (IndigoMolecule::is(obj))
+        {
+            auto& mol = obj.getMolecule();
+            return Crippen::logP(mol);
+        }
+        throw IndigoError("incorrect object type for cLogP calculation: %s, should be molecule", obj.debugInfo());
+    }
+    INDIGO_END(-1);
+}
+
+CEXPORT double indigoCMolarRefractivity(const int molecule)
+{
+    INDIGO_BEGIN
+    {
+        auto& obj = self.getObject(molecule);
+        if (IndigoMolecule::is(obj))
+        {
+            auto& mol = obj.getMolecule();
+            return Crippen::molarRefractivity(mol);
+        }
+        throw IndigoError("incorrect object type for cLogP calculation: %s, should be molecule", obj.debugInfo());
+    }
+    INDIGO_END(-1);
+}

api/cpp/src/IndigoMolecule.cpp

@@ -56,3 +56,13 @@ int IndigoMolecule::numHydrogenBondDonors() const
 {
     return session()->_checkResult(indigoNumHydrogenBondDonors(id()));
 }
+
+double IndigoMolecule::cLogP() const
+{
+    return session()->_checkResultFloat(indigoCLogP(id()));
+}
+
+double IndigoMolecule::cMolarRefractivity() const
+{
+    return session()->_checkResultFloat(indigoCMolarRefractivity(id()));
+}

api/cpp/src/IndigoMolecule.h

@@ -39,6 +39,8 @@ namespace indigo_cpp
         int numRotatableBonds() const;
         int numHydrogenBondAcceptors() const;
         int numHydrogenBondDonors() const;
+        double cLogP() const;
+        double cMolarRefractivity() const;
     };
 
     using IndigoMoleculeSPtr = std::shared_ptr<IndigoMolecule>;

api/cpp/tests/basic/molecule.cpp

@@ -107,3 +107,29 @@ TEST(Molecule, numHydrogenBondDonors)
         EXPECT_EQ(3, molecule.numHydrogenBondDonors());
     }
 }
+
+TEST(Molecule, cLogP)
+{
+    const auto& session = IndigoSession::create();
+    {
+        const auto& molecule = session->loadMolecule(CAFFEINE);
+        EXPECT_NEAR(0.062, molecule.cLogP(), 1e-2);
+    }
+    {
+        const auto& molecule = session->loadMolecule(SULFASALAZINE);
+        EXPECT_NEAR(3.7, molecule.cLogP(), 1e-2);
+    }
+}
+
+TEST(Molecule, cMolarRefractivity)
+{
+    const auto& session = IndigoSession::create();
+    {
+        const auto& molecule = session->loadMolecule(CAFFEINE);
+        EXPECT_NEAR(49.1, molecule.cMolarRefractivity(), 1e-2);
+    }
+    {
+        const auto& molecule = session->loadMolecule(SULFASALAZINE);
+        EXPECT_NEAR(100.73, molecule.cMolarRefractivity(), 1e-2);
+    }
+}

api/cpp/tests/common.h.in

@@ -3,6 +3,7 @@
 #include <string>
 
 #define METHANE "C"
+#define BENZENE "C1=CC=CC=C1"
 #define CAFFEINE "CN1C=NC2=C1C(=O)N(C(=O)N2C)C"
 #define SULFASALAZINE "C1=CC=NC(=C1)NS(=O)(=O)C2=CC=C(C=C2)N=NC3=CC(=C(C=C3)O)C(=O)O"
 

api/dotnet/src/IndigoLib.cs

@@ -822,6 +822,12 @@ public static extern int indigoSetSGroupBrackets(int sgroup, int brk_style, floa
         [DllImport("indigo"), SuppressUnmanagedCodeSecurity]
         public static extern int indigoNumHydrogenBondDonors(int molecule);
 
+        [DllImport("indigo"), SuppressUnmanagedCodeSecurity]
+        public static extern double indigoCLogP(int molecule);
+
+        [DllImport("indigo"), SuppressUnmanagedCodeSecurity]
+        public static extern double indigoCMolarRefractivity(int molecule);
+
         [DllImport("indigo"), SuppressUnmanagedCodeSecurity]
         public static extern byte* indigoCanonicalSmiles(int molecule);
 

api/dotnet/src/IndigoObject.cs

@@ -1415,6 +1415,18 @@ public int numHydrogenBondDonors()
             return dispatcher.checkResult(IndigoLib.indigoNumHydrogenBondDonors(self));
         }
 
+        public double cLogP()
+        {
+            dispatcher.setSessionID();
+            return dispatcher.checkResult(IndigoLib.indigoCLogP(self));
+        }
+
+        public double cMolarRefractivity()
+        {
+            dispatcher.setSessionID();
+            return dispatcher.checkResult(IndigoLib.indigoCMolarRefractivity(self));
+        }
+
         public string canonicalSmiles()
         {
             dispatcher.setSessionID();

api/java/indigo/src/main/java/com/epam/indigo/IndigoLib.java

@@ -605,6 +605,10 @@ int indigoSetSGroupBrackets(
 
     int indigoNumHydrogenBondDonors(int molecule);
 
+    double indigoCLogP(int molecule);
+
+    double indigoCMolarRefractivity(int molecule);
+
     Pointer indigoCanonicalSmiles(int molecule);
 
     Pointer indigoLayeredCode(int molecule);

api/java/indigo/src/main/java/com/epam/indigo/IndigoObject.java

@@ -840,6 +840,16 @@ public int numHydrogenBondDonors() {
         return Indigo.checkResult(this, lib.indigoNumHydrogenBondDonors(self));
     }
 
+    public double cLogP() {
+        dispatcher.setSessionID();
+        return Indigo.checkResultDouble(this, lib.indigoCLogP(self));
+    }
+
+    public double cMolarRefractivity() {
+        dispatcher.setSessionID();
+        return Indigo.checkResultDouble(this, lib.indigoCMolarRefractivity(self));
+    }
+
     public String canonicalSmiles() {
         dispatcher.setSessionID();
         return Indigo.checkResultString(this, lib.indigoCanonicalSmiles(self));

api/python/indigo/__init__.py

@@ -39,7 +39,6 @@
 
 from indigo.exceptions import IndigoException
 from indigo.hybridization import get_hybridization
-from indigo.logp import get_logp, get_mr
 from indigo.salts import SALTS
 
 DECODE_ENCODING = "utf-8"
@@ -2584,21 +2583,27 @@ def iterateBonds(self):
             ),
         )
 
-    def logP(self) -> float:
-        """Molecule method returns calculated logP value
+    def cLogP(self):
+        """Molecule method returns calculated Crippen logP value
 
         Returns:
             float: calculated logP value of the molecule
         """
-        return get_logp(self)
+        self.dispatcher._setSessionId()
+        return self.dispatcher._checkResultFloat(
+            Indigo._lib.indigoCLogP(self.id)
+        )
 
-    def molarRefractivity(self) -> float:
-        """Molecule method returns calculated molar refractivity
+    def cMolarRefractivity(self):
+        """Molecule method returns calculated Crippen molar refractivity
 
         Returns:
             float: calculated value of molar refractivity
         """
-        return get_mr(self)
+        self.dispatcher._setSessionId()
+        return self.dispatcher._checkResultFloat(
+            Indigo._lib.indigoCMolarRefractivity(self.id)
+        )
 
     def bondOrder(self):
         """Bond method returns bond order
@@ -5068,6 +5073,10 @@ def __init__(self, path=None):
         Indigo._lib.indigoNumHydrogenBondAcceptors.argtypes = [c_int]
         Indigo._lib.indigoNumHydrogenBondDonors.restype = c_int
         Indigo._lib.indigoNumHydrogenBondDonors.argtypes = [c_int]
+        Indigo._lib.indigoCLogP.restype = c_double
+        Indigo._lib.indigoCLogP.argtypes = [c_int]
+        Indigo._lib.indigoCMolarRefractivity.restype = c_double
+        Indigo._lib.indigoCMolarRefractivity.argtypes = [c_int]
         Indigo._lib.indigoCanonicalSmiles.restype = c_char_p
         Indigo._lib.indigoCanonicalSmiles.argtypes = [c_int]
         Indigo._lib.indigoCanonicalSmarts.restype = c_char_p