diff --git a/Code/GraphMol/Descriptors/PBF.cpp b/Code/GraphMol/Descriptors/PBF.cpp
index 972203a86..4f9fc7f1d 100644
--- a/Code/GraphMol/Descriptors/PBF.cpp
+++ b/Code/GraphMol/Descriptors/PBF.cpp
@@ -3,7 +3,7 @@
 //  All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
-//modification, are permitted provided that the following conditions are
+// modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
@@ -14,7 +14,8 @@
 //       with the distribution.
 //     * Neither the name of Institue of Cancer Research.
 //       nor the names of its contributors may be used to endorse or promote
-//       products derived from this software without specific prior written permission.
+//       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
@@ -28,18 +29,23 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
-// For more information on the Plane of Best Fit please see http://pubs.acs.org/doi/abs/10.1021/ci300293f
+// For more information on the Plane of Best Fit please see
+// http://pubs.acs.org/doi/abs/10.1021/ci300293f
 //
 //  If this code has been useful to you, please include the reference
 //  in any work which has made use of it:
 
-//  Plane of Best Fit: A Novel Method to Characterize the Three-Dimensionality of Molecules, Nicholas C. Firth, Nathan Brown, and Julian Blagg, Journal of Chemical Information and Modeling 2012 52 (10), 2516-2525
+//  Plane of Best Fit: A Novel Method to Characterize the Three-Dimensionality
+//  of Molecules, Nicholas C. Firth, Nathan Brown, and Julian Blagg, Journal of
+//  Chemical Information and Modeling 2012 52 (10), 2516-2525
 
 //
 //
 // Created by Nicholas Firth, November 2011
-// Modified by Greg Landrum for inclusion in the RDKit distribution November 2012
-// Further modified by Greg Landrum for inclusion in the RDKit core September 2016
+// Modified by Greg Landrum for inclusion in the RDKit distribution November
+// 2012
+// Further modified by Greg Landrum for inclusion in the RDKit core September
+// 2016
 //
 
 #include <GraphMol/RDKitBase.h>
@@ -54,89 +60,93 @@
 #include <Eigen/Dense>
 
 namespace RDKit {
-namespace Descriptors{
+namespace Descriptors {
 namespace {
 
-double distanceFromAPlane(const RDGeom::Point3D &pt,const std::vector<double> &plane, double denom){
-  double numer=0.0;
-  numer = std::abs(pt.x*plane[0]+pt.y*plane[1]+pt.z*plane[2]+plane[3]);
+double distanceFromAPlane(const RDGeom::Point3D &pt,
+                          const std::vector<double> &plane, double denom) {
+  double numer = 0.0;
+  numer =
+      std::abs(pt.x * plane[0] + pt.y * plane[1] + pt.z * plane[2] + plane[3]);
 
-  return numer/denom;
+  return numer / denom;
 }
 
 bool getBestFitPlane(const Conformer &conf,
-                    const std::vector<RDGeom::Point3D> &points,
+                     const std::vector<RDGeom::Point3D> &points,
                      std::vector<double> &plane,
                      const std::vector<double> *weights) {
-  PRECONDITION((!weights || weights->size()>=points.size()),"bad weights vector");
-  PRECONDITION(plane.size()>=4,"bad plane");
-  RDGeom::Point3D origin(0,0,0);
-  double wSum=0.0;
+  PRECONDITION((!weights || weights->size() >= points.size()),
+               "bad weights vector");
+  PRECONDITION(plane.size() >= 4, "bad plane");
+  RDGeom::Point3D origin(0, 0, 0);
+  double wSum = 0.0;
 
-  for(unsigned int i=0;i<points.size();++i){
-    if(weights){
-      double w=(*weights)[i];
-      wSum+=w;
-      origin+=points[i]*w;
+  for (unsigned int i = 0; i < points.size(); ++i) {
+    if (weights) {
+      double w = (*weights)[i];
+      wSum += w;
+      origin += points[i] * w;
     } else {
-      wSum+=1;
-      origin+=points[i];
+      wSum += 1;
+      origin += points[i];
     }
   }
   origin /= wSum;
 
   Eigen::Matrix3d evects;
   Eigen::Vector3d evals;
-  MolTransforms::computePrincipalAxesAndMoments(conf,evects,evals,false,weights);
+  MolTransforms::computePrincipalAxesAndMomentsFromGyrationMatrix(
+      conf, evects, evals, false, weights);
   RDGeom::Point3D normal;
-  normal.x=evects(0,0);
-  normal.y=evects(1,0);
-  normal.z=evects(2,0);
+  normal.x = evects(0, 0);
+  normal.y = evects(1, 0);
+  normal.z = evects(2, 0);
 
   plane[0] = normal.x;
   plane[1] = normal.y;
   plane[2] = normal.z;
-  plane[3] = -1*normal.dotProduct(origin);
+  plane[3] = -1 * normal.dotProduct(origin);
   return true;
 }
 
-} //end of anonymous namespace
+}  // end of anonymous namespace
 
-double PBF(const ROMol& mol,int confId){
-  PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers")
+double PBF(const ROMol &mol, int confId) {
+  PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers")
   unsigned int numAtoms = mol.getNumAtoms();
-  if(numAtoms<4) return 0;
+  if (numAtoms < 4) return 0;
 
   const Conformer &conf = mol.getConformer(confId);
-  if(!conf.is3D()) return 0 ;
+  if (!conf.is3D()) return 0;
 
   std::vector<RDGeom::Point3D> points;
   points.reserve(numAtoms);
-  for(unsigned int i=0; i<numAtoms; ++i){
+  for (unsigned int i = 0; i < numAtoms; ++i) {
     points.push_back(conf.getAtomPos(i));
   }
 
   std::vector<double> plane(4);
-  if(!getBestFitPlane(conf,points,plane,NULL)){
+  if (!getBestFitPlane(conf, points, plane, NULL)) {
     // the eigenvalue calculation failed, return 0
     // FIX: throw an exception here?
     return 0.0;
   }
 
-  double denom=0.0;
-  for(unsigned int i=0; i<3; ++i){
-    denom += plane[i]*plane[i];
+  double denom = 0.0;
+  for (unsigned int i = 0; i < 3; ++i) {
+    denom += plane[i] * plane[i];
   }
   denom = sqrt(denom);
 
-  double res=0.0;
-  for(unsigned int i=0; i<numAtoms; ++i){
-    res+= distanceFromAPlane(points[i], plane, denom);
+  double res = 0.0;
+  for (unsigned int i = 0; i < numAtoms; ++i) {
+    res += distanceFromAPlane(points[i], plane, denom);
   }
   res /= numAtoms;
 
   return res;
 }
 
-} // end of Descriptors namespace
-} // end of RDKit namespace
+}  // end of Descriptors namespace
+}  // end of RDKit namespace
diff --git a/Code/GraphMol/Descriptors/PMI.cpp b/Code/GraphMol/Descriptors/PMI.cpp
index 9a0860dbd..380c61e4f 100644
--- a/Code/GraphMol/Descriptors/PMI.cpp
+++ b/Code/GraphMol/Descriptors/PMI.cpp
@@ -16,191 +16,217 @@
 #include <Eigen/Dense>
 
 namespace RDKit {
-namespace Descriptors{
+namespace Descriptors {
 namespace {
 
-bool getMoments(const ROMol& mol,int confId, bool useAtomicMasses,
-                double &pm1, double &pm2, double &pm3){
-  PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
-  const char *pn1 = useAtomicMasses ? "_PMI1_mass" : "_PMI1";
-  const char *pn2 = useAtomicMasses ? "_PMI2_mass" : "_PMI2";
-  const char *pn3 = useAtomicMasses ? "_PMI3_mass" : "_PMI3";
+bool getMoments(const ROMol& mol, int confId, bool useAtomicMasses, double& pm1,
+                double& pm2, double& pm3) {
+  PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
+  const char* pn1 = useAtomicMasses ? "_PMI1_mass" : "_PMI1";
+  const char* pn2 = useAtomicMasses ? "_PMI2_mass" : "_PMI2";
+  const char* pn3 = useAtomicMasses ? "_PMI3_mass" : "_PMI3";
 
-  if(mol.hasProp(pn1) && mol.hasProp(pn2) && mol.hasProp(pn3) ) {
-    mol.getProp(pn1,pm1);
-    mol.getProp(pn2,pm2);
-    mol.getProp(pn3,pm3);
+  if (mol.hasProp(pn1) && mol.hasProp(pn2) && mol.hasProp(pn3)) {
+    mol.getProp(pn1, pm1);
+    mol.getProp(pn2, pm2);
+    mol.getProp(pn3, pm3);
     return true;
   }
 
-  const Conformer &conf=mol.getConformer(confId);
+  const Conformer& conf = mol.getConformer(confId);
 
   Eigen::Matrix3d axes;
   Eigen::Vector3d moments;
   bool res;
-  bool ignoreHs=false;
-  if(useAtomicMasses){
+  bool ignoreHs = false;
+  if (useAtomicMasses) {
     std::vector<double> weights;
     weights.resize(mol.getNumAtoms());
-    for(ROMol::ConstAtomIterator cai=mol.beginAtoms();
-        cai!=mol.endAtoms();++cai){
+    for (ROMol::ConstAtomIterator cai = mol.beginAtoms(); cai != mol.endAtoms();
+         ++cai) {
       weights[(*cai)->getIdx()] = (*cai)->getMass();
     }
-    res = MolTransforms::computePrincipalAxesAndMoments(conf,axes,moments,ignoreHs,false,&weights);
+    res = MolTransforms::computePrincipalAxesAndMoments(
+        conf, axes, moments, ignoreHs, false, &weights);
   } else {
-    res = MolTransforms::computePrincipalAxesAndMoments(conf,axes,moments,ignoreHs);
+    res = MolTransforms::computePrincipalAxesAndMoments(conf, axes, moments,
+                                                        ignoreHs);
   }
-  if(res){
+  if (res) {
     pm1 = moments(0);
     pm2 = moments(1);
     pm3 = moments(2);
-    //std::cerr<<"   moments: "<<pm1<<" "<<pm2<<" "<<pm3<<std::endl;
-    mol.setProp(pn1,pm1,true);
-    mol.setProp(pn2,pm2,true);
-    mol.setProp(pn3,pm3,true);
+    mol.setProp(pn1, pm1, true);
+    mol.setProp(pn2, pm2, true);
+    mol.setProp(pn3, pm3, true);
+  }
+  return res;
+}
+bool getMomentsFromGyration(const ROMol& mol, int confId, bool useAtomicMasses,
+                            double& pm1, double& pm2, double& pm3) {
+  PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
+  const char* pn1 = useAtomicMasses ? "_PMI1_mass_cov" : "_PMI1_cov";
+  const char* pn2 = useAtomicMasses ? "_PMI2_mass_cov" : "_PMI2_cov";
+  const char* pn3 = useAtomicMasses ? "_PMI3_mass_cov" : "_PMI3_cov";
+
+  if (mol.hasProp(pn1) && mol.hasProp(pn2) && mol.hasProp(pn3)) {
+    mol.getProp(pn1, pm1);
+    mol.getProp(pn2, pm2);
+    mol.getProp(pn3, pm3);
+    return true;
+  }
+
+  const Conformer& conf = mol.getConformer(confId);
+
+  Eigen::Matrix3d axes;
+  Eigen::Vector3d moments;
+  bool res;
+  bool ignoreHs = false;
+  if (useAtomicMasses) {
+    std::vector<double> weights;
+    weights.resize(mol.getNumAtoms());
+    for (ROMol::ConstAtomIterator cai = mol.beginAtoms(); cai != mol.endAtoms();
+         ++cai) {
+      weights[(*cai)->getIdx()] = (*cai)->getMass();
+    }
+    res = MolTransforms::computePrincipalAxesAndMomentsFromGyrationMatrix(
+        conf, axes, moments, ignoreHs, false, &weights);
+  } else {
+    res = MolTransforms::computePrincipalAxesAndMomentsFromGyrationMatrix(
+        conf, axes, moments, ignoreHs);
+  }
+  if (res) {
+    pm1 = moments(0);
+    pm2 = moments(1);
+    pm3 = moments(2);
+    mol.setProp(pn1, pm1, true);
+    mol.setProp(pn2, pm2, true);
+    mol.setProp(pn3, pm3, true);
   }
   return res;
 }
 
-} // end of anonymous namespace
+}  // end of anonymous namespace
 
-double NPR1(const ROMol& mol, int confId, bool useAtomicMasses){
-  PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
-  double pm1,pm2,pm3;
-  if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
+double NPR1(const ROMol& mol, int confId, bool useAtomicMasses) {
+  PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
+  double pm1, pm2, pm3;
+  if (!getMoments(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
     // the eigenvector calculation failed
-    return 0.0; // FIX: throw an exception here?
+    return 0.0;  // FIX: throw an exception here?
   }
-  if(pm3<1e-8) return 0.0;
-  return pm1/pm3;
+  if (pm3 < 1e-8) return 0.0;
+  return pm1 / pm3;
 }
-double NPR2(const ROMol& mol, int confId, bool useAtomicMasses){
-  PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
-  double pm1,pm2,pm3;
-  if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
+double NPR2(const ROMol& mol, int confId, bool useAtomicMasses) {
+  PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
+  double pm1, pm2, pm3;
+  if (!getMoments(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
     // the eigenvector calculation failed
-    return 0.0; // FIX: throw an exception here?
+    return 0.0;  // FIX: throw an exception here?
   }
-  if(pm3<1e-8) return 0.0;
-  return pm2/pm3;
+  if (pm3 < 1e-8) return 0.0;
+  return pm2 / pm3;
 }
-double PMI1(const ROMol& mol, int confId, bool useAtomicMasses){
-  PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
-  double pm1,pm2,pm3;
-  if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
+double PMI1(const ROMol& mol, int confId, bool useAtomicMasses) {
+  PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
+  double pm1, pm2, pm3;
+  if (!getMoments(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
     // the eigenvector calculation failed
-    return 0.0; // FIX: throw an exception here?
+    return 0.0;  // FIX: throw an exception here?
   }
   return pm1;
 }
-double PMI2(const ROMol& mol, int confId, bool useAtomicMasses){
-  PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
-  double pm1,pm2,pm3;
-  if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
+double PMI2(const ROMol& mol, int confId, bool useAtomicMasses) {
+  PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
+  double pm1, pm2, pm3;
+  if (!getMoments(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
     // the eigenvector calculation failed
-    return 0.0; // FIX: throw an exception here?
+    return 0.0;  // FIX: throw an exception here?
   }
   return pm2;
 }
-double PMI3(const ROMol& mol, int confId, bool useAtomicMasses){
-  PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
-  double pm1,pm2,pm3;
-  if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
+double PMI3(const ROMol& mol, int confId, bool useAtomicMasses) {
+  PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
+  double pm1, pm2, pm3;
+  if (!getMoments(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
     // the eigenvector calculation failed
-    return 0.0; // FIX: throw an exception here?
+    return 0.0;  // FIX: throw an exception here?
   }
   return pm3;
 }
 
-double radiusOfGyration(const ROMol& mol,int confId,
-  bool useAtomicMasses){
-  PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
-  double pm1,pm2,pm3;
-  if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
+double radiusOfGyration(const ROMol& mol, int confId, bool useAtomicMasses) {
+  PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
+  double pm1, pm2, pm3;
+  if (!getMomentsFromGyration(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
     // the eigenvector calculation failed
-    return 0.0; // FIX: throw an exception here?
-  }
-  double denom;
-  if(useAtomicMasses){
-    denom = 0.0;
-    for(ROMol::ConstAtomIterator cai = mol.beginAtoms();
-        cai!=mol.endAtoms();++cai){
-      denom += (*cai)->getMass();
-    }
-  } else {
-    denom = mol.getNumAtoms();
-  }
-  if(denom<1e-8) return 0.0;
-  if(pm1<1e-4) {
-    // planar
-    return sqrt(sqrt(pm2*pm3)/denom);
-  } else {
-    return sqrt(2*M_PI*pow(pm1*pm2*pm3,1./3)/denom);
+    return 0.0;  // FIX: throw an exception here?
   }
+  return sqrt(pm1 + pm2 + pm3);
 }
 
-double inertialShapeFactor(const ROMol& mol,int confId,
-  bool useAtomicMasses){
-  PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
-  double pm1,pm2,pm3;
-  if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
+double inertialShapeFactor(const ROMol& mol, int confId, bool useAtomicMasses) {
+  PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
+  double pm1, pm2, pm3;
+  if (!getMoments(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
     // the eigenvector calculation failed
-    return 0.0; // FIX: throw an exception here?
+    return 0.0;  // FIX: throw an exception here?
   }
-  if(pm1<1e-4 || pm3<1e-4) {
+  if (pm1 < 1e-4 || pm3 < 1e-4) {
     // planar or no coordinates
     return 0.0;
   } else {
-    return pm2 / (pm1*pm3);
+    return pm2 / (pm1 * pm3);
   }
 }
-double eccentricity(const ROMol& mol,int confId,
-  bool useAtomicMasses){
-  PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
-  double pm1,pm2,pm3;
-  if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
+double eccentricity(const ROMol& mol, int confId, bool useAtomicMasses) {
+  PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
+  double pm1, pm2, pm3;
+  if (!getMoments(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
     // the eigenvector calculation failed
-    return 0.0; // FIX: throw an exception here?
+    return 0.0;  // FIX: throw an exception here?
   }
-  if(pm3<1e-4) {
+  if (pm3 < 1e-4) {
     // no coordinates
     return 0.0;
   } else {
-    return sqrt(pm3*pm3-pm1*pm1) / pm3;
-  }
-}
-double asphericity(const ROMol& mol,int confId,
-  bool useAtomicMasses){
-  PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
-  double pm1,pm2,pm3;
-  if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
-    // the eigenvector calculation failed
-    return 0.0; // FIX: throw an exception here?
-  }
-  if(pm3<1e-4) {
-    // no coordinates
-    return 0.0;
-  } else {
-    return 0.5 * (pow(pm3-pm2,2) + pow(pm3-pm1,2) + pow(pm2-pm1,2))/
-      (pm1*pm1+pm2*pm2+pm3*pm3);
-  }
-}
-double spherocityIndex(const ROMol& mol,int confId){
-  PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
-  bool useAtomicMasses=false;
-  double pm1,pm2,pm3;
-  if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
-    // the eigenvector calculation failed
-    return 0.0; // FIX: throw an exception here?
-  }
-  if(pm3<1e-4) {
-    // no coordinates
-    return 0.0;
-  } else {
-    return 3. * pm1 / (pm1+pm2+pm3);
+    return sqrt(pm3 * pm3 - pm1 * pm1) / pm3;
   }
 }
 
+double asphericity(const ROMol& mol, int confId, bool useAtomicMasses) {
+  PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
+  double pm1, pm2, pm3;
+  if (!getMomentsFromGyration(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
+    // the eigenvector calculation failed
+    return 0.0;  // FIX: throw an exception here?
+  }
+  if (pm3 < 1e-4) {
+    // no coordinates
+    return 0.0;
+  } else {
+    double denom = pm1 + pm2 + pm3;
 
-} // end of Descriptors namespace
-} // end of RDKit namespace
+    return 0.5 * (pow(pm1 - pm2, 2) + pow(pm1 - pm3, 2) + pow(pm2 - pm3, 2)) /
+           (denom * denom);
+  }
+}
+double spherocityIndex(const ROMol& mol, int confId) {
+  PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
+  bool useAtomicMasses = false;
+  double pm1, pm2, pm3;
+  if (!getMomentsFromGyration(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
+    // the eigenvector calculation failed
+    return 0.0;  // FIX: throw an exception here?
+  }
+  if (pm3 < 1e-4) {
+    // no coordinates
+    return 0.0;
+  } else {
+    return 3. * pm1 / (pm1 + pm2 + pm3);
+  }
+}
+
+}  // end of Descriptors namespace
+}  // end of RDKit namespace
diff --git a/Code/GraphMol/Descriptors/PMI.h b/Code/GraphMol/Descriptors/PMI.h
index 2eb4d25f1..95b11e676 100644
--- a/Code/GraphMol/Descriptors/PMI.h
+++ b/Code/GraphMol/Descriptors/PMI.h
@@ -13,90 +13,97 @@
 
 #ifdef RDK_BUILD_DESCRIPTORS3D
 namespace RDKit {
-  class ROMol;
-  namespace Descriptors {
-    //! Normalized principal moments ratio 1 (=I1/I3)
-    //!  from Sauer and Schwarz JCIM 43:987-1003 (2003)
-    //!  https://dx.doi.org/10.1021/ci025599w
-    double NPR1(const ROMol&, int confId=-1, bool useAtomicMasses=true);
-    const std::string NPR1Version = "1.0.0";
-    //! Normalized principal moments ratio 2 (=I2/I3)
-    //!  from Sauer and Schwarz JCIM 43:987-1003 (2003)
-    //!  https://dx.doi.org/10.1021/ci025599w
-    double NPR2(const ROMol&, int confId=-1, bool useAtomicMasses=true);
-    const std::string NPR2Version = "1.0.0";
+class ROMol;
+namespace Descriptors {
+//! Normalized principal moments ratio 1 (=I1/I3)
+//!  from Sauer and Schwarz JCIM 43:987-1003 (2003)
+//!  https://dx.doi.org/10.1021/ci025599w
+double NPR1(const ROMol&, int confId = -1, bool useAtomicMasses = true);
+const std::string NPR1Version = "1.0.0";
+//! Normalized principal moments ratio 2 (=I2/I3)
+//!  from Sauer and Schwarz JCIM 43:987-1003 (2003)
+//!  https://dx.doi.org/10.1021/ci025599w
+double NPR2(const ROMol&, int confId = -1, bool useAtomicMasses = true);
+const std::string NPR2Version = "1.0.0";
 
-    //! First (smallest) principal moment of inertia
-    double PMI1(const ROMol&, int confId=-1, bool useAtomicMasses=true);
-    const std::string PMI1Version = "1.0.0";
-    //! second principal moment of inertia
-    double PMI2(const ROMol&, int confId=-1, bool useAtomicMasses=true);
-    const std::string PMI2Version = "1.0.0";
-    //! Third (largest) principal moment of inertia
-    double PMI3(const ROMol&, int confId=-1, bool useAtomicMasses=true);
-    const std::string PMI3Version = "1.0.0";
+//! First (smallest) principal moment of inertia
+double PMI1(const ROMol&, int confId = -1, bool useAtomicMasses = true);
+const std::string PMI1Version = "1.0.0";
+//! second principal moment of inertia
+double PMI2(const ROMol&, int confId = -1, bool useAtomicMasses = true);
+const std::string PMI2Version = "1.0.0";
+//! Third (largest) principal moment of inertia
+double PMI3(const ROMol&, int confId = -1, bool useAtomicMasses = true);
+const std::string PMI3Version = "1.0.0";
 
-    /*!
-     Radius of gyration
-       from Todeschini and Consoni "Descriptors from Molecular Geometry"
-       Handbook of Chemoinformatics
-       http://dx.doi.org/10.1002/9783527618279.ch37
+/*!
+ Radius of gyration
+   from G. A. Arteca "Molecular Shape Descriptors"
+   Reviews in Computational Chemistry vol 9
+   http://dx.doi.org/10.1002/9780470125861.ch5
 
-     Definition:
-        for planar molecules: sqrt( sqrt(pm3*pm2)/MW )
-        for nonplanar molecules: sqrt( 2*pi*pow(pm3*pm2*pm1,1/3)/MW )
-    */
-    double radiusOfGyration(const ROMol&,int confId=-1,
-      bool useAtomicMasses=true);
-    const std::string radiusOfGyrationVersion = "1.0.0";
-    /*!
-     Inertial shape factor
-       from Todeschini and Consoni "Descriptors from Molecular Geometry"
-       Handbook of Chemoinformatics
-       http://dx.doi.org/10.1002/9783527618279.ch37
+ Definition (eq: A4):
+    sqrt(t_1 + t_2 + t_3) where t_i is the ith moment from the gyration matrix
+*/
+double radiusOfGyration(const ROMol&, int confId = -1,
+                        bool useAtomicMasses = true);
+const std::string radiusOfGyrationVersion = "1.0.0";
+/*!
+ Inertial shape factor
+   from Todeschini and Consoni "Descriptors from Molecular Geometry"
+   Handbook of Chemoinformatics
+   http://dx.doi.org/10.1002/9783527618279.ch37
 
-     Definition:
-       pm2 / (pm1*pm3)
-    */
-    double inertialShapeFactor(const ROMol&,int confId=-1,
-      bool useAtomicMasses=true);
-    const std::string inertialShapeFactorVersion = "1.0.0";
-    /*!
-     Molecular eccentricity
-       from Todeschini and Consoni "Descriptors from Molecular Geometry"
-       Handbook of Chemoinformatics
-       http://dx.doi.org/10.1002/9783527618279.ch37
+ Definition:
+   pm2 / (pm1*pm3)
+*/
+double inertialShapeFactor(const ROMol&, int confId = -1,
+                           bool useAtomicMasses = true);
+const std::string inertialShapeFactorVersion = "1.0.0";
+/*!
+ Molecular eccentricity
+   from G. A. Arteca "Molecular Shape Descriptors"
+   Reviews in Computational Chemistry vol 9
+   http://dx.doi.org/10.1002/9780470125861.ch5
 
-     Definition:
-     sqrt(pm3**2 -pm1**2) / pm3**2
-    */
-    double eccentricity(const ROMol&,int confId=-1,
-      bool useAtomicMasses=true);
-    const std::string eccentricityVersion = "1.0.0";
-  /*!
-     molecular asphericity
-       from Todeschini and Consoni "Descriptors from Molecular Geometry"
-       Handbook of Chemoinformatics
-       http://dx.doi.org/10.1002/9783527618279.ch37
+ Definition (eq 4):
+ sqrt(pm_3**2 -pm_1**2) / pm_3**2  where pm_i is the ith moment of inertia
+*/
+double eccentricity(const ROMol&, int confId = -1, bool useAtomicMasses = true);
+const std::string eccentricityVersion = "1.0.0";
+/*!
+ molecular asphericity
+   from A. Baumgaertner, "Shapes of flexible vesicles"
+   J. Chem. Phys. 98:7496 (1993)
+   http://dx.doi.org/10.1063/1.464689
 
-     Definition:
-     0.5 * ((pm3-pm2)**2 + (pm3-pm1)**2 + (pm2-pm1)**2)/(pm1**2+pm2**2+pm3**2)
-    */
-    double asphericity(const ROMol&,int confId=-1,
-      bool useAtomicMasses=true);
-    const std::string asphericityVersion = "1.0.0";
-    /*!
-     Spherocity index
-       from Todeschini and Consoni "Descriptors from Molecular Geometry"
-       Handbook of Chemoinformatics
-       http://dx.doi.org/10.1002/9783527618279.ch37
+   Definition (eq 11):
+   0.5 * ((t_3-t_2)**2 + (t_3-t_1)**2 + (t_2-t_1)**2)/(t_1+t_2+t_3)**2
+                  where t_i is the ith moment from the gyration matrix
 
-     Definition:
-     3 * pm1 / (pm1+pm2+pm3) where the moments are calculated without weights
-    */
-    double spherocityIndex(const ROMol&,int confId=-1);
-    const std::string spherocityIndexVersion = "1.0.0";
-  }
+   Some explanation of that definition: the text of the paper mentions axes
+   of inertia, but then the defintion of the radius of gyration in eq.9 clearly
+   uses the moments of the gyration matrix. The text under equation 11 has the
+   appropriate inequalities and limits for the moments of gyration, but the
+   description of the geometry provided corresponds to the moments of inertia.
+   The definition here corresponds to what Dragon generates and seem logical
+
+*/
+double asphericity(const ROMol&, int confId = -1, bool useAtomicMasses = true);
+const std::string asphericityVersion = "1.0.0";
+/*!
+ Spherocity index
+   from Todeschini and Consoni "Descriptors from Molecular Geometry"
+   Handbook of Chemoinformatics
+   http://dx.doi.org/10.1002/9783527618279.ch37
+
+ Definition:
+ 3 * t_1 / (t_1+t_2+t_3)
+    where the moments of the gyration matrix are calculated without weights
+*/
+double spherocityIndex(const ROMol&, int confId = -1);
+const std::string spherocityIndexVersion = "1.0.0";
+}
 }
 #endif
 #endif
diff --git a/Code/GraphMol/Descriptors/test3D.cpp b/Code/GraphMol/Descriptors/test3D.cpp
index b37ead27c..0619cc240 100644
--- a/Code/GraphMol/Descriptors/test3D.cpp
+++ b/Code/GraphMol/Descriptors/test3D.cpp
@@ -13,7 +13,6 @@
 #define _CRT_SECURE_NO_WARNINGS
 #endif
 
-
 #include <iostream>
 #include <fstream>
 
@@ -38,148 +37,151 @@
 using namespace RDKit;
 using namespace RDKit::Descriptors;
 
-bool compare(const std::string &inm,double ref,double val,double tol=1e-3){
-  if(fabs(ref-val)>.001){
-    std::cerr<<"value mismatch: "<<inm<<" "<<ref<<" "<<val<<std::endl;
+bool compare(const std::string &inm, double ref, double val,
+             double tol = 1e-3) {
+  if (fabs(ref - val) > tol) {
+    std::cerr << "value mismatch: " << inm << " " << ref << " " << val
+              << std::endl;
   }
-  return fabs(ref-val)<tol;
+  return fabs(ref - val) < tol;
 }
 
-void testPMI1(){
+void testPMI1() {
   BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
   BOOST_LOG(rdErrorLog) << "    Basic PMI tests." << std::endl;
 
   std::string pathName = getenv("RDBASE");
-  std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/PBF_egfr.sdf";
+  std::string sdfName =
+      pathName + "/Code/GraphMol/Descriptors/test_data/PBF_egfr.sdf";
 
-  RDKit::SDMolSupplier reader(sdfName,true,false);
-  std::string fName = pathName+"/Code/GraphMol/Descriptors/test_data/PMI_egfr.out";
+  RDKit::SDMolSupplier reader(sdfName, true, false);
+  std::string fName =
+      pathName + "/Code/GraphMol/Descriptors/test_data/PMI_egfr.out";
   std::ifstream instrm(fName.c_str());
-  int nDone=0;
-  while(!reader.atEnd()){
-    RDKit::ROMol *m=reader.next();
+  int nDone = 0;
+  while (!reader.atEnd()) {
+    RDKit::ROMol *m = reader.next();
     TEST_ASSERT(m);
     RDKit::ROMol mcpy(*m);
     std::string nm;
-    m->getProp("_Name",nm);
+    m->getProp("_Name", nm);
     std::string inm;
-    instrm>>inm;
-    TEST_ASSERT(inm==nm);
+    instrm >> inm;
+    TEST_ASSERT(inm == nm);
     double val;
-    double pmi1_m,pmi2_m,pmi3_m,pmi1_nom,pmi2_nom,pmi3_nom;
-    instrm>>pmi1_m;
-    instrm>>pmi2_m;
-    instrm>>pmi3_m;
-    instrm>>pmi1_nom;
-    instrm>>pmi2_nom;
-    instrm>>pmi3_nom;
+    double pmi1_m, pmi2_m, pmi3_m, pmi1_nom, pmi2_nom, pmi3_nom;
+    instrm >> pmi1_m;
+    instrm >> pmi2_m;
+    instrm >> pmi3_m;
+    instrm >> pmi1_nom;
+    instrm >> pmi2_nom;
+    instrm >> pmi3_nom;
 
     val = RDKit::Descriptors::PMI1(*m);
-    TEST_ASSERT(compare(inm,pmi1_m,val));
+    TEST_ASSERT(compare(inm, pmi1_m, val));
     val = RDKit::Descriptors::PMI2(*m);
-    TEST_ASSERT(compare(inm,pmi2_m,val));
+    TEST_ASSERT(compare(inm, pmi2_m, val));
     val = RDKit::Descriptors::PMI3(*m);
-    TEST_ASSERT(compare(inm,pmi3_m,val));
+    TEST_ASSERT(compare(inm, pmi3_m, val));
 
-    val = RDKit::Descriptors::PMI1(*m,-1,false);
-    TEST_ASSERT(compare(inm,pmi1_nom,val));
-    val = RDKit::Descriptors::PMI2(*m,-1,false);
-    TEST_ASSERT(compare(inm,pmi2_nom,val));
-    val = RDKit::Descriptors::PMI3(*m,-1,false);
-    TEST_ASSERT(compare(inm,pmi3_nom,val));
+    val = RDKit::Descriptors::PMI1(*m, -1, false);
+    TEST_ASSERT(compare(inm, pmi1_nom, val));
+    val = RDKit::Descriptors::PMI2(*m, -1, false);
+    TEST_ASSERT(compare(inm, pmi2_nom, val));
+    val = RDKit::Descriptors::PMI3(*m, -1, false);
+    TEST_ASSERT(compare(inm, pmi3_nom, val));
 
     // now try doing it in the reverse order to make sure caching doesn't
     // screw up.
-    val = RDKit::Descriptors::PMI1(mcpy,-1,false);
-    TEST_ASSERT(compare(inm,pmi1_nom,val));
-    val = RDKit::Descriptors::PMI2(mcpy,-1,false);
-    TEST_ASSERT(compare(inm,pmi2_nom,val));
-    val = RDKit::Descriptors::PMI3(mcpy,-1,false);
-    TEST_ASSERT(compare(inm,pmi3_nom,val));
+    val = RDKit::Descriptors::PMI1(mcpy, -1, false);
+    TEST_ASSERT(compare(inm, pmi1_nom, val));
+    val = RDKit::Descriptors::PMI2(mcpy, -1, false);
+    TEST_ASSERT(compare(inm, pmi2_nom, val));
+    val = RDKit::Descriptors::PMI3(mcpy, -1, false);
+    TEST_ASSERT(compare(inm, pmi3_nom, val));
     val = RDKit::Descriptors::PMI1(mcpy);
-    TEST_ASSERT(compare(inm,pmi1_m,val));
+    TEST_ASSERT(compare(inm, pmi1_m, val));
     val = RDKit::Descriptors::PMI2(mcpy);
-    TEST_ASSERT(compare(inm,pmi2_m,val));
+    TEST_ASSERT(compare(inm, pmi2_m, val));
     val = RDKit::Descriptors::PMI3(mcpy);
-    TEST_ASSERT(compare(inm,pmi3_m,val));
-
+    TEST_ASSERT(compare(inm, pmi3_m, val));
 
     delete m;
     ++nDone;
-}
+  }
   BOOST_LOG(rdErrorLog) << "  done" << std::endl;
 }
 
-void testPMIEdges(){
+void testPMIEdges() {
   BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
   BOOST_LOG(rdErrorLog) << "    PMI edge cases." << std::endl;
 
   {
     std::string pathName = getenv("RDBASE");
-    std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/linear.mol";
+    std::string sdfName =
+        pathName + "/Code/GraphMol/Descriptors/test_data/linear.mol";
 
-    RDKit::ROMol *m=MolFileToMol(sdfName);
+    RDKit::ROMol *m = MolFileToMol(sdfName);
     TEST_ASSERT(m);
     double val;
 
     val = RDKit::Descriptors::PMI1(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
     val = RDKit::Descriptors::PMI2(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) >= 10);
     val = RDKit::Descriptors::PMI3(*m);
-    TEST_ASSERT(val>=1e-4);
+    TEST_ASSERT(val >= 10);
+    TEST_ASSERT(RDKit::Descriptors::PMI3(*m) - RDKit::Descriptors::PMI2(*m) <
+                1e-2);
 
     delete m;
   }
   {
     std::string pathName = getenv("RDBASE");
-    std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/linear_2atom.mol";
+    std::string sdfName =
+        pathName + "/Code/GraphMol/Descriptors/test_data/linear_2atom.mol";
 
-    RDKit::ROMol *m=MolFileToMol(sdfName);
+    RDKit::ROMol *m = MolFileToMol(sdfName);
     TEST_ASSERT(m);
     double val;
 
     val = RDKit::Descriptors::PMI1(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
     val = RDKit::Descriptors::PMI2(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) >= 1);
     val = RDKit::Descriptors::PMI3(*m);
-    TEST_ASSERT(val>=1e-4);
+    TEST_ASSERT(val >= 1);
+    TEST_ASSERT(RDKit::Descriptors::PMI3(*m) - RDKit::Descriptors::PMI2(*m) <
+                1e-2);
 
     delete m;
   }
   {
     std::string pathName = getenv("RDBASE");
-    std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/planar.mol";
+    std::string sdfName =
+        pathName + "/Code/GraphMol/Descriptors/test_data/planar.mol";
 
-    RDKit::ROMol *m=MolFileToMol(sdfName);
+    RDKit::ROMol *m = MolFileToMol(sdfName);
     TEST_ASSERT(m);
-    double val;
-
-    val = RDKit::Descriptors::PMI1(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
-    val = RDKit::Descriptors::PMI2(*m);
-    TEST_ASSERT(val>=1e-4);
-    val = RDKit::Descriptors::PMI3(*m);
-    TEST_ASSERT(val>=1e-4);
 
+    TEST_ASSERT(RDKit::Descriptors::PMI2(*m) - RDKit::Descriptors::PMI1(*m) <
+                1e-2);
+    TEST_ASSERT(RDKit::Descriptors::PMI3(*m) - RDKit::Descriptors::PMI1(*m) >
+                10);
     delete m;
   }
   {
     std::string pathName = getenv("RDBASE");
-    std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/planar_3atom.mol";
+    std::string sdfName =
+        pathName + "/Code/GraphMol/Descriptors/test_data/planar_3atom.mol";
 
-    RDKit::ROMol *m=MolFileToMol(sdfName);
+    RDKit::ROMol *m = MolFileToMol(sdfName);
     TEST_ASSERT(m);
-    double val;
-
-    val = RDKit::Descriptors::PMI1(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
-    val = RDKit::Descriptors::PMI2(*m);
-    TEST_ASSERT(val>=1e-4);
-    val = RDKit::Descriptors::PMI3(*m);
-    TEST_ASSERT(val>=1e-4);
 
+    TEST_ASSERT(RDKit::Descriptors::PMI2(*m) - RDKit::Descriptors::PMI1(*m) <
+                1e-2);
+    TEST_ASSERT(RDKit::Descriptors::PMI3(*m) - RDKit::Descriptors::PMI1(*m) >
+                1);
     delete m;
   }
 
@@ -193,46 +195,86 @@ void testPMIEdges(){
     m.addAtom(new RDKit::Atom(6));
     m.addConformer(new RDKit::Conformer(m.getNumAtoms()));
     double val = RDKit::Descriptors::PMI1(m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
     val = RDKit::Descriptors::PMI2(m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
     val = RDKit::Descriptors::PMI3(m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
   }
 
   BOOST_LOG(rdErrorLog) << "  done" << std::endl;
 }
 
+void testPMI2() {
+  BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
+  BOOST_LOG(rdErrorLog) << "    More PMI/NPR tests." << std::endl;
 
-void testNPR1(){
+  std::string pathName = getenv("RDBASE");
+  std::string sdfName =
+      pathName + "/Code/GraphMol/Descriptors/test_data/pmi.sdf";
+
+  RDKit::SDMolSupplier reader(sdfName, true, false);
+  while (!reader.atEnd()) {
+    RDKit::ROMol *mnoh = reader.next();
+    TEST_ASSERT(mnoh);
+    bool explicitOnly = false, addCoords = true;
+    RDKit::ROMol *m = MolOps::addHs(*mnoh, explicitOnly, addCoords);
+    delete mnoh;
+    double pmi1 = RDKit::Descriptors::PMI1(*m);
+    double pmi2 = RDKit::Descriptors::PMI2(*m);
+    double pmi3 = RDKit::Descriptors::PMI3(*m);
+
+    double npr1 = RDKit::Descriptors::NPR1(*m);
+    double npr2 = RDKit::Descriptors::NPR2(*m);
+
+    // tolerances are coarse because the reference values come from MOE
+    // and the placement of Hs is not identical
+    TEST_ASSERT(compare("pmi1", m->getProp<double>("pmi1"), pmi1, pmi1 / 100));
+    TEST_ASSERT(compare("pmi2", m->getProp<double>("pmi2"), pmi2, pmi2 / 100));
+    TEST_ASSERT(compare("pmi3", m->getProp<double>("pmi3"), pmi3, pmi3 / 100));
+
+    TEST_ASSERT(compare("npr1", m->getProp<double>("npr1"), npr1, npr1 / 100));
+    TEST_ASSERT(compare("npr2", m->getProp<double>("npr2"), npr2, npr2 / 100));
+    delete m;
+  }
+  BOOST_LOG(rdErrorLog) << "  done" << std::endl;
+}
+
+void testNPR1() {
   BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
   BOOST_LOG(rdErrorLog) << "    Basic NPR tests." << std::endl;
 
   std::string pathName = getenv("RDBASE");
-  std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/PBF_egfr.sdf";
-  RDKit::SDMolSupplier reader(sdfName,true,false);
+  std::string sdfName =
+      pathName + "/Code/GraphMol/Descriptors/test_data/PBF_egfr.sdf";
+  RDKit::SDMolSupplier reader(sdfName, true, false);
 
-  int nDone=0;
-  while(!reader.atEnd()){
-    RDKit::ROMol *m=reader.next();
+  int nDone = 0;
+  while (!reader.atEnd()) {
+    RDKit::ROMol *m = reader.next();
     TEST_ASSERT(m);
     RDKit::ROMol mcpy(*m);
     std::string nm;
-    m->getProp("_Name",nm);
+    m->getProp("_Name", nm);
 
     double val;
-    double pmi1_m,pmi2_m,pmi3_m,pmi1_nom,pmi2_nom,pmi3_nom;
+    double pmi1_m, pmi2_m, pmi3_m, pmi1_nom, pmi2_nom, pmi3_nom;
     pmi1_m = RDKit::Descriptors::PMI1(*m);
     pmi2_m = RDKit::Descriptors::PMI2(*m);
     pmi3_m = RDKit::Descriptors::PMI3(*m);
-    pmi1_nom = RDKit::Descriptors::PMI1(*m,-1,false);
-    pmi2_nom = RDKit::Descriptors::PMI2(*m,-1,false);
-    pmi3_nom = RDKit::Descriptors::PMI3(*m,-1,false);
+    pmi1_nom = RDKit::Descriptors::PMI1(*m, -1, false);
+    pmi2_nom = RDKit::Descriptors::PMI2(*m, -1, false);
+    pmi3_nom = RDKit::Descriptors::PMI3(*m, -1, false);
 
     val = RDKit::Descriptors::NPR1(*m);
-    compare(nm,pmi1_m/pmi3_m,val);
+    compare(nm, pmi1_m / pmi3_m, val);
     val = RDKit::Descriptors::NPR2(*m);
-    compare(nm,pmi2_m/pmi3_m,val);
+    compare(nm, pmi2_m / pmi3_m, val);
+
+    val = RDKit::Descriptors::NPR1(*m, -1, false);
+    compare(nm, pmi1_nom / pmi3_nom, val);
+    val = RDKit::Descriptors::NPR2(*m, -1, false);
+    compare(nm, pmi2_nom / pmi3_nom, val);
 
     delete m;
     ++nDone;
@@ -240,67 +282,71 @@ void testNPR1(){
   BOOST_LOG(rdErrorLog) << "  done" << std::endl;
 }
 
-void testNPREdges(){
+void testNPREdges() {
   BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
   BOOST_LOG(rdErrorLog) << "    NPR edge cases." << std::endl;
 
   {
     std::string pathName = getenv("RDBASE");
-    std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/linear.mol";
+    std::string sdfName =
+        pathName + "/Code/GraphMol/Descriptors/test_data/linear.mol";
 
-    RDKit::ROMol *m=MolFileToMol(sdfName);
+    RDKit::ROMol *m = MolFileToMol(sdfName);
     TEST_ASSERT(m);
     double val;
 
     val = RDKit::Descriptors::NPR1(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
     val = RDKit::Descriptors::NPR2(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val - 1) < 1e-4);
 
     delete m;
   }
   {
     std::string pathName = getenv("RDBASE");
-    std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/linear_2atom.mol";
+    std::string sdfName =
+        pathName + "/Code/GraphMol/Descriptors/test_data/linear_2atom.mol";
 
-    RDKit::ROMol *m=MolFileToMol(sdfName);
+    RDKit::ROMol *m = MolFileToMol(sdfName);
     TEST_ASSERT(m);
     double val;
 
     val = RDKit::Descriptors::NPR1(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
     val = RDKit::Descriptors::NPR2(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val - 1) < 1e-4);
 
     delete m;
   }
   {
     std::string pathName = getenv("RDBASE");
-    std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/planar.mol";
+    std::string sdfName =
+        pathName + "/Code/GraphMol/Descriptors/test_data/planar.mol";
 
-    RDKit::ROMol *m=MolFileToMol(sdfName);
+    RDKit::ROMol *m = MolFileToMol(sdfName);
     TEST_ASSERT(m);
     double val;
 
     val = RDKit::Descriptors::NPR1(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val - 0.5) < 1e-4);
     val = RDKit::Descriptors::NPR2(*m);
-    TEST_ASSERT(val>=1e-4);
+    TEST_ASSERT(fabs(val - 0.5) < 1e-4);
 
     delete m;
   }
   {
     std::string pathName = getenv("RDBASE");
-    std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/planar_3atom.mol";
+    std::string sdfName =
+        pathName + "/Code/GraphMol/Descriptors/test_data/planar_3atom.mol";
 
-    RDKit::ROMol *m=MolFileToMol(sdfName);
+    RDKit::ROMol *m = MolFileToMol(sdfName);
     TEST_ASSERT(m);
     double val;
 
     val = RDKit::Descriptors::NPR1(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val - 0.5) < 1e-4);
     val = RDKit::Descriptors::NPR2(*m);
-    TEST_ASSERT(val>=1e-4);
+    TEST_ASSERT(fabs(val - 0.5) < 1e-4);
 
     delete m;
   }
@@ -314,61 +360,81 @@ void testNPREdges(){
     m.addAtom(new RDKit::Atom(6));
     m.addConformer(new RDKit::Conformer(m.getNumAtoms()));
     double val = RDKit::Descriptors::NPR1(m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
     val = RDKit::Descriptors::NPR2(m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
   }
 
   BOOST_LOG(rdErrorLog) << "  done" << std::endl;
 }
 
-void test3DEdges(){
+void test3DVals() {
+  BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
+  BOOST_LOG(rdErrorLog) << "    3D descriptors." << std::endl;
+  std::string rdbase = getenv("RDBASE");
+  {  // a disc (benzene)
+    std::string fName =
+        rdbase + "/Code/GraphMol/MolTransforms/test_data/github1262_1.mol";
+    RWMol *m = MolFileToMol(fName, true, false);
+    TEST_ASSERT(m);
+    double val;
+
+    val = RDKit::Descriptors::radiusOfGyration(*m);
+    TEST_ASSERT(fabs(val - 1.511) < 1e-2);
+    val = RDKit::Descriptors::eccentricity(*m);
+    TEST_ASSERT(fabs(val - 0.866) < 1e-2);
+    val = RDKit::Descriptors::asphericity(*m);
+    TEST_ASSERT(fabs(val - 0.25) < 1e-2);
+    val = RDKit::Descriptors::spherocityIndex(*m);
+    TEST_ASSERT(fabs(val) < 1e-2);
+
+    delete m;
+  }
+  {  // a rod (dimethyl acetylene)
+    std::string fName =
+        rdbase + "/Code/GraphMol/MolTransforms/test_data/github1262_2.mol";
+    RWMol *m = MolFileToMol(fName, true, false);
+    TEST_ASSERT(m);
+    double val;
+
+    val = RDKit::Descriptors::radiusOfGyration(*m);
+    TEST_ASSERT(fabs(val - 1.686) < 1e-2);
+    val = RDKit::Descriptors::eccentricity(*m);
+    TEST_ASSERT(fabs(val - 1.0) < 1e-2);
+    val = RDKit::Descriptors::asphericity(*m);
+    TEST_ASSERT(fabs(val - 0.875) < 1e-2);
+    val = RDKit::Descriptors::spherocityIndex(*m);
+    // nothing really precise to say here
+    TEST_ASSERT((0 < val) && (val < 0.25));
+
+    delete m;
+  }
+  {  // adamantane
+    std::string fName =
+        rdbase + "/Code/GraphMol/MolTransforms/test_data/github1262_3.mol";
+    RWMol *m = MolFileToMol(fName, true, false);
+    TEST_ASSERT(m);
+    double val;
+
+    val = RDKit::Descriptors::radiusOfGyration(*m);
+    TEST_ASSERT(fabs(val - 1.827) < 1e-2);
+    val = RDKit::Descriptors::eccentricity(*m);
+    TEST_ASSERT(fabs(val) < 1e-2);
+    val = RDKit::Descriptors::asphericity(*m);
+    TEST_ASSERT(fabs(val) < 1e-2);
+    val = RDKit::Descriptors::spherocityIndex(*m);
+    TEST_ASSERT(fabs(val - 1) < 1e-2);
+
+    delete m;
+  }
+
+  BOOST_LOG(rdErrorLog) << "  done" << std::endl;
+}
+
+void test3DEdges() {
   BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
   BOOST_LOG(rdErrorLog) << "    3D descriptor edge cases." << std::endl;
-
-  {
-    std::string pathName = getenv("RDBASE");
-    std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/linear.mol";
-
-    RDKit::ROMol *m=MolFileToMol(sdfName);
-    TEST_ASSERT(m);
-    double val;
-
-    val = RDKit::Descriptors::radiusOfGyration(*m);
-    TEST_ASSERT(fabs(val)<1e-2);
-    val = RDKit::Descriptors::inertialShapeFactor(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
-    val = RDKit::Descriptors::eccentricity(*m);
-    TEST_ASSERT(fabs(1.0-val)<1e-4);
-    val = RDKit::Descriptors::asphericity(*m);
-    TEST_ASSERT(fabs(1.0-val)<1e-4);
-    val = RDKit::Descriptors::spherocityIndex(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
-
-    delete m;
-  }
-  {
-    std::string pathName = getenv("RDBASE");
-    std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/planar.mol";
-
-    RDKit::ROMol *m=MolFileToMol(sdfName);
-    TEST_ASSERT(m);
-    double val;
-
-    val = RDKit::Descriptors::radiusOfGyration(*m);
-    TEST_ASSERT(fabs(val)>1e-2);
-    val = RDKit::Descriptors::inertialShapeFactor(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
-    val = RDKit::Descriptors::eccentricity(*m);
-    TEST_ASSERT(fabs(1.0-val)<1e-4);
-    val = RDKit::Descriptors::asphericity(*m);
-    TEST_ASSERT(fabs(0.5-val)<1e-4);
-    val = RDKit::Descriptors::spherocityIndex(*m);
-    TEST_ASSERT(fabs(val)<1e-4);
-
-    delete m;
-  }
-  { // octahedron
+  {  // octahedron
     RDKit::RWMol m;
     m.addAtom(new RDKit::Atom(1));
     m.addAtom(new RDKit::Atom(1));
@@ -377,23 +443,21 @@ void test3DEdges(){
     m.addAtom(new RDKit::Atom(1));
     m.addAtom(new RDKit::Atom(1));
     m.addConformer(new RDKit::Conformer(m.getNumAtoms()));
-    m.getConformer().setAtomPos(0,RDGeom::Point3D(1,0,0));
-    m.getConformer().setAtomPos(1,RDGeom::Point3D(-1,0,0));
-    m.getConformer().setAtomPos(2,RDGeom::Point3D(0,1,0));
-    m.getConformer().setAtomPos(3,RDGeom::Point3D(0,-1,0));
-    m.getConformer().setAtomPos(4,RDGeom::Point3D(0,0,1));
-    m.getConformer().setAtomPos(5,RDGeom::Point3D(0,0,-1));
+    m.getConformer().setAtomPos(0, RDGeom::Point3D(1, 0, 0));
+    m.getConformer().setAtomPos(1, RDGeom::Point3D(-1, 0, 0));
+    m.getConformer().setAtomPos(2, RDGeom::Point3D(0, 1, 0));
+    m.getConformer().setAtomPos(3, RDGeom::Point3D(0, -1, 0));
+    m.getConformer().setAtomPos(4, RDGeom::Point3D(0, 0, 1));
+    m.getConformer().setAtomPos(5, RDGeom::Point3D(0, 0, -1));
     double val;
     val = RDKit::Descriptors::radiusOfGyration(m);
-    TEST_ASSERT(fabs(val)>0.1);
-    val = RDKit::Descriptors::inertialShapeFactor(m);
-    TEST_ASSERT(fabs(val)>1);
+    TEST_ASSERT(fabs(val) > 0.1);
     val = RDKit::Descriptors::eccentricity(m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
     val = RDKit::Descriptors::asphericity(m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
     val = RDKit::Descriptors::spherocityIndex(m);
-    TEST_ASSERT(fabs(1.-val)<1e-4);
+    TEST_ASSERT(fabs(1. - val) < 1e-4);
   }
 
   {
@@ -407,31 +471,33 @@ void test3DEdges(){
     m.addConformer(new RDKit::Conformer(m.getNumAtoms()));
     double val;
     val = RDKit::Descriptors::radiusOfGyration(m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
     val = RDKit::Descriptors::inertialShapeFactor(m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
     val = RDKit::Descriptors::eccentricity(m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
     val = RDKit::Descriptors::asphericity(m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
     val = RDKit::Descriptors::spherocityIndex(m);
-    TEST_ASSERT(fabs(val)<1e-4);
+    TEST_ASSERT(fabs(val) < 1e-4);
   }
 
   BOOST_LOG(rdErrorLog) << "  done" << std::endl;
 }
 
-
-
 //-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
 //
 //-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
 int main() {
   RDLog::InitLogs();
-  test3DEdges();
+  testPMI1();
+  testPMI2();
+
+#if 1
+  testNPR1();
   testPMIEdges();
   testNPREdges();
-  testPMI1();
-  testNPR1();
-
+  test3DVals();
+  test3DEdges();
+#endif
 }
diff --git a/Code/GraphMol/Descriptors/test_data/PMI_egfr.out b/Code/GraphMol/Descriptors/test_data/PMI_egfr.out
index a5f820016..a395ae9d9 100644
--- a/Code/GraphMol/Descriptors/test_data/PMI_egfr.out
+++ b/Code/GraphMol/Descriptors/test_data/PMI_egfr.out
@@ -1,365 +1,365 @@
-ZINC02640583 3.0801 29.7186 611.2271 0.2847 2.6912 9.5101
-ZINC03815185 3.5346 27.0039 504.3305 0.2063 2.4595 10.6998
-ZINC00020644 2.6425 26.9142 503.4538 0.3094 3.1402 11.4473
-ZINC03815359 1.8104 25.1140 127.0568 0.2941 3.0868 11.3061
-ZINC03815360 1.0117 22.1038 144.9868 0.2901 3.0698 11.3354
-ZINC03815361 1.6029 25.6052 108.9653 0.3842 3.4720 12.5140
-ZINC00007282 2.4846 27.5291 203.4813 0.3024 3.1157 11.3806
-ZINC03815304 2.0897 26.3651 127.5708 0.3342 3.1706 12.1041
-ZINC03815353 22.4564 31.4503 114.5407 1.5892 3.8362 6.5291
-ZINC00118570 1.3943 18.6414 97.7103 0.2724 2.5262 10.8296
-ZINC03815331 1.5327 19.4748 96.5107 0.2958 2.3868 11.1637
-ZINC00151213 3.5669 25.5232 465.3378 0.3141 2.6207 10.9890
-ZINC00151212 2.7213 20.9339 122.5810 0.2925 2.5390 10.8807
-ZINC03815388 1.4185 25.7575 101.6433 0.2919 3.0555 11.2252
-ZINC00104621 2.1731 20.0218 108.5350 0.3994 2.8232 12.3101
-ZINC03815229 3.7147 25.0157 530.7980 0.3149 2.3985 10.8691
-ZINC03815317 4.7456 27.7210 86.8434 1.0672 2.9782 9.0980
-ZINC03815247 3.0364 25.4102 475.4405 0.2810 2.7007 10.2004
-ZINC03815375 4.3305 25.9187 462.6263 0.3794 2.5321 10.4342
-ZINC03815227 2.4708 27.4159 506.8760 0.1898 2.7792 10.9349
-ZINC03815274 1.3270 19.2506 115.7583 0.2608 2.4849 12.7037
-ZINC00151214 3.1339 23.2410 736.2225 0.3134 2.6437 11.0079
-ZINC03815386 11.3526 21.0966 450.7802 1.0822 1.8197 11.0230
-ZINC00118581 3.5709 24.8304 192.6177 0.3042 2.5827 10.9386
-ZINC03815055 3.6817 22.4606 836.7797 0.3022 2.5782 12.9045
-ZINC03815319 6.8681 21.5220 786.1869 1.1329 2.5498 10.1492
-ZINC03815146 4.2130 24.4087 535.5866 0.3000 2.5448 12.1103
-ZINC03815314 3.4217 57.8741 195.3103 0.8959 2.4918 10.6726
-ZINC03815398 9.8121 19.1927 130.6622 1.1623 2.3410 10.5614
-ZINC00104782 2.8524 20.2475 126.8371 0.4116 2.5932 14.0443
-ZINC03815197 3.5442 33.3375 596.9038 0.3190 2.3997 10.9896
-ZINC03815196 0.9500 31.5306 104.8934 0.2136 3.7684 12.1287
-ZINC03815276 0.8812 28.6923 488.0190 0.1132 3.2365 10.4524
-ZINC03815251 1.2764 31.0311 111.9996 0.3030 3.2794 13.0827
-ZINC03815264 3.1097 80.2402 538.0409 0.1941 2.9195 10.2118
-ZINC03815202 1.5646 29.5527 108.0422 0.3081 3.6911 11.4435
-ZINC03815203 3.2105 80.9649 537.2133 0.1955 2.9232 10.9743
-ZINC03815236 7.4008 32.6996 640.1130 0.2871 2.8416 10.2324
-ZINC03815238 5.9469 19.6415 123.0272 1.2927 2.1975 12.8994
-ZINC03815259 6.5526 19.6214 134.2680 1.0983 2.2664 12.1194
-ZINC03815280 1.2901 20.9120 134.0537 0.3059 2.6942 14.3518
-ZINC03815242 2.9597 42.3757 516.1766 0.1932 2.8317 10.9630
-ZINC03813425 18.7624 24.8798 430.3084 1.2052 2.6203 10.7186
-ZINC03815036 6.3566 26.1594 500.9108 0.4079 2.9438 11.1178
-ZINC03815410 9.5123 34.3412 435.7890 1.3063 2.2656 10.6805
-ZINC03815046 3.4430 27.7518 232.1838 0.2926 2.5460 12.8244
-ZINC03815035 7.1132 31.7527 473.7552 1.0026 3.3258 8.9279
-ZINC03815034 5.1396 26.0410 505.2368 0.3417 3.1100 11.4212
-ZINC03815282 4.9038 26.9602 534.2950 0.2822 2.7599 10.2037
-ZINC03815281 8.0616 23.6308 192.6667 1.1237 2.5178 10.1027
-ZINC03813430 4.2604 16.9351 664.1676 1.1521 2.3330 10.7735
-ZINC03813429 7.1823 23.3050 471.7129 1.1109 2.5517 10.1191
-ZINC03815072 3.5378 28.6953 572.3357 0.3057 2.5823 12.8792
-ZINC03815374 5.6247 25.1217 544.0283 0.3872 2.5267 10.5518
-ZINC03815124 6.5917 25.7393 101.8343 1.2222 2.8406 10.6321
-ZINC03815338 1.4839 50.9005 154.0863 0.2677 3.1516 11.2912
-ZINC03815176 6.8769 21.2675 105.6047 1.1141 2.6949 11.6898
-ZINC03815111 2.7953 20.3991 144.1591 0.2805 2.4905 12.7653
-ZINC03815343 3.5817 27.6171 502.3218 0.3182 2.6709 12.0961
-ZINC03815100 2.7732 35.8476 511.2191 0.2145 3.4303 10.4710
-ZINC03815101 3.1339 33.8291 519.3260 0.2207 3.3136 10.7558
-ZINC00020362 2.1102 27.7997 558.8167 0.2278 3.7932 12.7160
-ZINC03815232 3.5758 35.1689 612.7364 0.3558 2.8298 14.2766
-ZINC03815097 5.5374 22.8310 132.5972 1.2396 2.6567 14.3703
-ZINC03815163 3.5541 36.5281 611.3909 0.3424 2.7223 14.0004
-ZINC03815162 4.7922 23.3951 580.5819 0.3342 2.6870 15.2283
-ZINC03815029 7.8113 25.9661 544.6238 0.4435 3.0929 13.3585
-ZINC03815037 10.2974 39.3217 474.5641 1.0851 2.7762 12.9196
-ZINC03815038 5.5841 25.5238 572.6742 0.3433 2.8106 12.2288
-ZINC03815411 2.5146 31.1824 499.8055 0.2824 4.0495 10.0688
-ZINC03815159 7.0094 26.0184 718.8113 0.3583 3.0882 11.6707
-ZINC03815042 16.4190 29.2867 186.3169 1.3125 2.9108 11.2554
-ZINC03815286 3.4618 29.1038 553.9148 0.3440 2.4411 14.7767
-ZINC03815284 4.6689 22.7489 137.4907 0.9164 2.5940 13.2093
-ZINC03815144 3.4415 42.5563 497.5603 0.2752 4.3367 10.1968
-ZINC03815183 5.6638 26.5895 558.9469 0.3478 3.3013 13.3264
-ZINC03813424 12.4792 42.1919 374.8405 1.2435 3.3846 10.0882
-ZINC03815137 1.6807 27.5790 570.0587 0.2084 3.6576 12.5302
-ZINC02391776 5.0387 25.2263 557.8216 0.2980 2.9663 12.9163
-ZINC03815060 2.5896 30.7132 115.0409 0.7579 3.8403 12.3040
-ZINC03815140 6.1703 26.1022 551.1329 0.3726 3.4001 13.2952
-ZINC03815138 2.8040 30.2756 543.3491 0.2774 4.0754 10.2394
-ZINC03815143 1.4857 34.7568 112.7672 0.3168 4.4257 12.9706
-ZINC03815070 3.3029 41.3331 528.8407 0.2611 3.6458 12.6528
-ZINC03815320 4.9713 24.7335 576.1407 0.3773 2.2603 14.9528
-ZINC03815069 2.9482 43.3994 516.7938 0.2430 3.9372 12.2239
-ZINC03815332 5.0034 23.5154 587.2414 0.3513 2.7293 14.5762
-ZINC03815248 5.7710 23.7532 571.6996 0.3932 2.4591 15.2311
-ZINC03815373 4.4864 27.7421 129.7568 1.0674 2.7498 12.2562
-ZINC03815118 4.5082 26.3356 569.7949 0.3130 3.3222 13.0392
-ZINC03815117 7.1946 26.3622 553.6425 0.4123 3.0062 13.3551
-ZINC03815121 7.0742 26.7588 112.9301 1.1551 3.1477 12.6333
-ZINC03815335 3.7328 33.6183 589.9957 0.3539 2.6613 12.4590
-ZINC03815266 6.3488 28.1951 571.8773 0.4569 3.8583 12.9199
-ZINC03815125 11.1157 40.7042 499.0718 1.1156 3.0374 13.1889
-ZINC03815328 5.5587 23.9645 613.2192 0.3986 2.5157 16.8191
-ZINC03815136 4.8401 25.2081 612.8020 0.3076 2.8507 15.0085
-ZINC03815141 1.5488 39.2165 109.6781 0.3713 4.8364 12.4659
-ZINC03815033 11.2350 37.9837 510.7523 1.3083 2.5817 13.9836
-ZINC00116727 1.3089 30.5193 133.0445 0.3622 3.7455 13.8781
-ZINC03815406 5.4578 24.0424 653.6700 0.3084 2.5772 13.0944
-ZINC00020363 3.4623 46.7596 502.0294 0.3141 4.3844 11.9000
-ZINC02391785 5.0105 25.3307 604.2828 0.3152 2.8201 15.3885
-ZINC03815357 5.0139 22.5943 1049.6983 0.3083 2.5978 13.1133
-ZINC03815080 2.6300 30.1491 577.3952 0.2791 3.9216 12.4809
-ZINC03813428 6.5965 30.4845 139.8075 1.0080 2.8166 10.4313
-ZINC03815079 1.8462 29.7959 581.5337 0.2676 4.2337 12.0581
-ZINC00118594 6.0893 23.8840 178.3182 0.4557 2.8277 12.3621
-ZINC03815027 8.0274 28.0719 565.2599 0.4964 3.5218 13.1176
-ZINC03813434 14.4810 23.7280 520.9077 1.5172 3.3488 9.8543
-ZINC03815393 4.6892 22.8388 288.7785 0.2980 2.5462 13.0388
-ZINC03815187 5.0253 23.0719 625.5046 0.4233 2.5830 16.8409
-ZINC03815190 5.3210 22.3494 647.8644 0.3506 2.5408 18.4990
-ZINC00600292 6.4530 28.4804 625.4717 0.4100 3.8000 14.0629
-ZINC03815041 11.8605 73.9987 322.5237 0.9413 5.2055 10.3637
-ZINC03815212 8.8923 33.1139 747.5921 0.3780 3.2331 11.6714
-ZINC03815031 5.1866 40.5240 627.7386 0.4369 3.7199 14.1492
-ZINC03815045 10.1069 50.4763 569.8905 1.0494 2.8241 15.9884
-ZINC03815292 5.7751 23.9366 645.6246 0.6013 2.6564 16.3881
-ZINC00601499 3.4471 46.5413 690.0197 0.3127 2.5625 18.7055
-ZINC03815206 17.7468 24.9949 232.9904 0.9076 3.3410 14.0250
-ZINC01386818 3.1049 29.6024 167.4622 0.3824 3.7508 13.9432
-ZINC00009851 1.2140 29.3054 169.1254 0.3507 3.6563 15.1321
-ZINC03815362 6.8357 26.1451 177.2097 0.5087 3.0831 12.8835
-ZINC03815129 5.8055 26.8880 198.6478 0.4353 2.8540 14.2617
-ZINC03815235 5.1047 22.8230 707.2976 0.2965 2.5575 18.5659
-ZINC03815075 6.0943 25.9850 1035.0296 0.4113 3.8149 14.0796
-ZINC03813431 7.7723 21.4937 161.0004 1.2183 2.3987 10.3999
-ZINC01386782 1.0718 24.6132 814.5218 0.3754 3.7305 14.2649
-ZINC03815283 1.8783 68.5815 216.0656 0.2658 4.0103 13.4086
-ZINC03815250 4.7524 50.9325 598.4512 0.3356 3.1403 13.0025
-ZINC00116937 5.2109 29.9543 257.2815 0.3972 3.7772 14.0068
-ZINC03815334 5.1741 42.2025 563.2728 0.8533 3.9754 8.9349
-ZINC03815199 5.1639 49.0140 641.8840 0.3789 2.9752 14.9801
-ZINC03815088 3.5546 42.4396 183.6829 0.6418 4.1454 12.4633
-ZINC03815348 5.1727 48.2280 621.3441 0.3956 4.8418 13.3696
-ZINC03815258 7.0133 31.7568 657.1921 0.3380 2.9732 15.4485
-ZINC03815102 8.9388 63.4228 538.8212 1.1188 2.7663 13.7083
-ZINC03815043 25.0952 50.2335 389.0591 1.7972 4.1328 10.0899
-ZINC03815032 7.6033 95.9321 772.3180 0.4284 3.7990 14.4211
-ZINC03815050 14.9990 20.7526 632.7411 1.2799 2.6671 12.5946
-ZINC03815273 27.5889 39.7376 138.8623 1.6989 4.0846 9.0136
-ZINC03815119 10.1368 58.0929 576.5039 0.9952 3.0750 17.2075
-ZINC03815189 5.1577 42.6487 638.8627 0.2955 5.6578 13.0756
-ZINC03815278 8.5414 268.3438 589.2431 0.4625 3.8724 14.2194
-ZINC03815290 28.9735 40.0839 365.6048 1.7689 4.0755 9.0242
-ZINC00016978 5.0420 39.1153 270.7927 0.4096 3.7759 14.0965
-ZINC03815316 1.3327 28.0887 188.7900 0.3841 3.4433 18.7025
-ZINC03815384 5.1845 51.2045 128.9776 1.0030 4.5295 10.3356
-ZINC03815228 3.2494 90.6087 576.7578 0.4820 4.3946 20.6088
-ZINC03815397 5.0651 49.9130 114.5828 0.9746 4.3531 11.9137
-ZINC03815077 10.4934 65.3349 661.0210 1.0205 3.0973 19.9972
-ZINC03815300 5.0890 46.7589 586.3476 1.0130 4.5230 10.5636
-ZINC02572485 6.8628 33.4591 692.4366 0.4412 4.9258 16.5024
-ZINC03815298 5.3244 51.4114 216.6748 1.0067 4.5250 10.4633
-ZINC03815059 10.1878 32.0558 549.1714 1.1216 3.3850 11.1458
-ZINC03815201 11.7720 48.0025 643.7280 1.3005 2.7187 15.3792
-ZINC03815066 3.4766 30.9659 641.1929 0.6743 3.9489 13.4434
-ZINC04617768 8.6760 67.9287 621.7433 1.0340 5.3267 13.1296
-ZINC03815198 11.6066 67.4490 459.0621 1.4671 3.4840 13.8034
-ZINC04617774 12.6494 61.1252 658.0457 1.1400 3.2862 19.2287
-ZINC03815064 10.1283 79.2554 624.6928 1.0474 3.1725 17.0695
-ZINC03815087 18.9520 72.0885 420.1266 1.5698 4.4108 15.5795
-ZINC03815040 17.3314 32.5240 707.5437 1.5183 2.7986 16.1127
-ZINC03815049 18.1326 59.2002 640.6690 1.1542 4.0374 14.8740
-ZINC03815243 10.1384 46.9636 660.6019 1.2224 2.4310 21.7915
-ZINC03815026 8.4057 32.9998 686.1989 0.4840 4.8661 16.4617
-ZINC03815051 10.2879 80.4456 716.7764 1.0402 3.2461 20.1464
-ZINC03815044 6.9659 28.9251 226.2914 0.5690 3.7689 15.8035
-ZINC03815272 5.5967 39.9321 171.3677 0.8647 4.9454 16.4149
-ZINC03815172 26.7937 40.6152 336.6267 2.1750 4.1399 8.2329
-ZINC03815191 10.0633 48.2445 670.5817 1.3106 2.7416 17.9523
-ZINC03815063 10.9189 39.6704 743.9648 1.3868 2.4263 17.7814
-ZINC03815387 5.6889 50.9814 201.3199 0.9651 4.3649 14.5884
-ZINC03815218 7.0820 35.9712 733.3688 0.3306 2.8309 18.3261
-ZINC03815090 19.7839 77.6511 467.7188 1.6859 4.4004 18.4313
-ZINC04617771 17.1171 48.4474 625.1706 1.6276 4.2819 12.2556
-ZINC03815333 4.1446 32.7890 199.0960 0.7959 4.1617 18.4942
-ZINC03815237 10.6361 33.4368 685.4242 1.5639 2.5381 19.1085
-ZINC04617779 14.4174 62.2481 649.4801 1.1278 3.6075 18.2912
-ZINC03815175 10.1310 68.7005 706.1378 0.9809 3.1832 26.9274
-ZINC03815096 10.9179 98.1941 784.2749 1.0547 3.1537 19.5993
-ZINC03815358 9.4563 51.2077 223.5663 1.0307 4.5086 10.5775
-ZINC03815126 12.6741 46.6525 580.5334 1.3896 4.8042 11.1996
-ZINC03815404 6.2636 48.5285 160.8552 1.0206 4.3249 12.1151
-ZINC03815401 6.0202 49.0115 138.2635 1.2090 3.9598 15.6957
-ZINC03815108 19.7928 89.4520 510.4963 1.6559 4.4956 22.1028
-ZINC03815154 8.5515 50.9919 220.2240 1.4478 5.3911 23.8441
-ZINC04617776 16.8569 73.4008 500.5637 1.5173 4.2482 17.6645
-ZINC03815165 9.8842 80.4098 757.5846 1.1402 3.1925 30.8502
-ZINC03815352 6.1882 37.5056 202.4066 1.0123 4.9215 17.9755
-ZINC03815173 9.9671 84.1533 844.1115 1.1300 3.1735 35.6162
-ZINC03815367 3.7204 20.8477 115.6583 0.8692 2.5065 11.7555
-ZINC00109589 3.7365 20.3118 117.7157 0.8414 2.5224 11.6897
-ZINC03815364 2.1082 25.2357 129.6789 0.7184 2.9211 13.3238
-ZINC03815303 3.3197 30.2207 143.0733 0.7905 3.5294 14.0423
-ZINC03815312 4.6663 26.2188 128.5059 0.9534 2.9945 12.6011
-ZINC03815256 3.3196 40.1055 117.5422 0.7905 4.1353 12.5742
-ZINC03815253 3.1300 39.9078 128.2590 0.7683 4.2580 11.2027
-ZINC03815365 2.7586 33.1221 146.1594 0.6777 2.8993 15.6981
-ZINC01386812 2.9878 38.1877 139.4571 0.7502 3.8600 14.2523
-ZINC00020368 3.0025 38.8146 167.1622 0.7476 3.4624 18.1227
-ZINC03815297 5.0136 38.7230 147.4924 1.0990 3.9138 15.2838
-ZINC03815342 7.9308 34.9951 296.0252 0.5576 3.9477 14.9707
-ZINC03815083 4.8329 30.8296 121.1423 0.8896 3.1801 12.6484
-ZINC03815293 3.8447 26.2998 200.3378 0.3545 2.4555 10.5381
-ZINC03815310 3.6734 22.8856 248.1496 0.3463 2.3153 12.6938
-ZINC03815326 1.1329 32.6789 102.4499 0.3862 3.5898 11.7287
-ZINC03815341 1.6202 31.8066 125.2812 0.4027 3.6021 12.3618
-ZINC03815394 1.8097 35.1363 110.9254 0.4926 4.0723 12.8623
-ZINC03815277 1.0882 31.5182 121.3087 0.3962 3.4607 14.8127
-ZINC03815156 3.1987 41.4774 210.3355 0.2294 3.7454 11.7341
-ZINC03815244 3.7273 40.3201 536.3376 0.4251 3.7097 11.8245
-ZINC00020645 3.3757 41.4557 207.2809 0.4139 3.6656 11.7980
-ZINC03815402 2.1971 30.1382 140.3313 0.4788 3.2836 15.9760
-ZINC03815336 5.3912 29.9273 190.4203 0.5290 3.4361 14.0346
-ZINC00023489 5.0716 26.6857 239.7284 0.3568 2.2470 12.6165
-ZINC00007342 4.9491 26.1897 241.2471 0.3523 2.4375 12.3370
-ZINC03815231 5.2649 29.1528 244.6185 0.4081 3.4741 12.8216
-ZINC03815295 5.3535 32.9404 235.2480 0.4300 4.6180 11.7766
-ZINC03815257 11.4317 65.1123 211.5339 0.9100 8.0938 10.5132
-ZINC03815345 43.7078 55.8307 111.9607 1.2444 4.8666 13.3694
-ZINC03815368 9.1237 56.8264 111.3380 1.9022 6.1794 11.3024
-ZINC03815234 4.6754 37.1159 725.9089 0.2029 2.3887 13.7775
-ZINC03815200 5.8322 24.3840 609.1183 0.3530 2.9162 13.2483
-ZINC00006271 3.5197 39.3555 588.1213 0.2736 3.2072 13.3058
-ZINC04617767 3.5211 40.6218 591.2611 0.2690 2.9648 13.3686
-ZINC03815028 3.5631 39.7689 597.4111 0.2874 3.1899 12.7811
-ZINC03815058 3.5631 41.2116 594.9623 0.2847 3.0907 12.6742
-ZINC03815241 6.9353 29.2591 686.9333 0.2770 2.9295 13.1268
-ZINC03815054 3.6324 40.5229 600.5043 0.2943 2.9800 12.9320
-ZINC03815030 3.9729 44.3145 593.5970 0.3302 3.9805 12.7784
-ZINC02391775 3.4971 40.5637 632.3835 0.2946 2.7359 16.0586
-ZINC03815052 3.5312 45.7016 623.3138 0.3145 3.3649 15.6107
-ZINC03815057 3.5137 41.2529 635.6484 0.3084 2.8509 15.5605
-ZINC03815073 3.4769 39.5957 629.0278 0.2988 2.9828 15.7822
-ZINC03815249 4.4642 37.4292 786.9165 0.3491 2.8892 16.8465
-ZINC03815152 6.3754 50.1263 773.4424 0.4246 2.8779 17.6617
-ZINC03815116 10.2732 57.1923 592.9763 0.9765 5.3867 12.6602
-ZINC04617775 8.5118 45.8693 837.5017 0.7471 2.5394 22.1642
-ZINC03815233 4.1159 43.5508 866.3574 0.6990 2.2832 26.6272
-ZINC04617795 11.2368 44.3426 830.5891 0.7992 2.4988 21.7562
-ZINC03815239 9.7538 38.9849 816.7974 0.9275 2.6764 23.2574
-ZINC03815188 4.9047 41.3271 861.0376 0.5784 2.6374 21.9216
-ZINC03815095 11.5909 72.9028 595.7968 1.0433 5.9156 14.3936
-ZINC03815103 5.7037 41.2345 859.4428 0.6008 2.6113 22.3030
-ZINC03815209 10.0250 39.0470 820.4473 0.9199 2.4281 23.8348
-ZINC03815306 3.6654 73.6123 917.5873 0.6740 2.4860 25.1269
-ZINC03815208 15.9182 38.0292 857.6401 1.1585 2.9640 24.5676
-ZINC03815067 9.3763 94.3488 643.0497 0.9700 5.2165 14.5574
-ZINC03815382 2.6787 27.9037 266.2927 0.1833 2.4184 15.9431
-ZINC03815179 0.8838 25.7209 154.1975 0.1649 2.4712 18.1955
-ZINC03815112 1.6196 26.7291 166.7907 0.2727 2.8606 20.0135
-ZINC03815061 3.3094 26.2862 694.8298 0.1908 2.7148 18.3053
-ZINC03815048 3.6935 36.4904 700.7639 0.2021 2.5644 18.3870
-ZINC03815120 3.3962 42.0325 655.2896 0.2210 3.2213 16.3673
-ZINC03815084 3.8778 39.7831 760.9846 0.1968 2.7747 18.3280
-ZINC03815255 0.8447 26.5099 206.3294 0.1670 2.4985 18.4192
-ZINC03815186 1.6331 26.8434 221.0006 0.2767 2.8771 20.2495
-ZINC03815245 5.4097 31.7544 254.4987 0.3219 2.8574 20.0847
-ZINC03815322 3.0956 25.9268 596.5974 0.2548 2.5420 13.8272
-ZINC03815301 3.0173 29.8481 147.7305 0.7671 2.9174 16.5918
-ZINC00327021 3.2051 26.8219 144.7914 0.7453 3.0347 15.2074
-ZINC03815356 3.5888 31.5972 143.5607 0.8376 3.3426 15.6307
-ZINC03815340 3.7911 28.6080 139.1194 0.8464 3.4364 14.3505
-ZINC04617812 3.5889 31.5977 143.5603 0.8376 3.3427 15.6306
-ZINC04617811 3.7911 28.6083 139.1179 0.8464 3.4364 14.3505
-ZINC03815093 8.2533 28.1672 510.3932 0.4821 3.5697 10.7614
-ZINC03815222 8.9358 28.0526 511.6620 0.5122 3.4185 10.3199
-ZINC00006798 2.3677 42.4380 98.4375 0.5040 4.4545 11.6118
-ZINC01609260 3.6979 37.2983 104.9882 0.8250 3.7575 11.9570
-ZINC03815377 10.0965 33.9829 208.2650 0.8682 3.7776 12.0735
-ZINC03815366 5.4417 47.6948 121.4649 1.0012 4.5269 13.2945
-ZINC03815351 6.0836 43.7940 128.4898 1.0325 4.3437 14.3436
-ZINC03815376 3.3655 39.0079 153.8446 0.7782 3.7324 16.0630
-ZINC01609268 3.6361 37.4272 148.2598 0.8166 3.6287 15.8635
-ZINC03815391 8.7545 57.4848 138.6225 1.2893 5.2439 15.3639
-ZINC03815323 9.1271 53.6217 232.3228 1.2581 4.9640 25.0817
-ZINC03815390 5.7245 68.0927 216.2764 1.0311 6.6152 20.2510
-ZINC03815324 6.5756 55.0430 292.4884 1.0679 5.0585 30.5805
-ZINC03815025 5.0519 24.5424 626.7561 0.2695 3.2551 14.6625
-ZINC03815106 4.9734 24.9114 633.5179 0.2660 3.1458 14.1277
-ZINC04617810 1.5505 22.6508 189.6155 0.3538 2.7794 18.7675
-ZINC04617809 1.5505 22.6510 189.6149 0.3538 2.7794 18.7674
-ZINC03815339 3.2586 46.1171 116.4939 0.7890 4.4371 12.3275
-ZINC04617808 3.2586 46.1168 116.4952 0.7890 4.4370 12.3275
-ZINC04617792 3.3520 50.1757 106.2983 0.8104 5.0634 10.8026
-ZINC04617793 1.4793 27.0467 188.5370 0.3673 3.8175 18.2586
-ZINC03815184 1.4793 27.0466 188.5374 0.3673 3.8176 18.2586
-ZINC04617794 3.3518 50.1748 106.2984 0.8104 5.0633 10.8026
-ZINC04617801 5.8187 60.0431 106.6008 0.8833 6.2218 11.2560
-ZINC04617802 4.1840 31.3380 202.1591 0.4661 4.0692 20.2929
-ZINC04617803 3.8951 29.7071 207.4835 0.4486 3.9601 20.6972
-ZINC03815267 5.6345 59.8788 109.0295 0.8178 6.2333 11.5358
-ZINC04617798 2.6103 119.2837 189.8692 0.6870 11.5918 20.3970
-ZINC03815217 3.2799 81.7245 143.4065 0.8354 7.8151 15.4454
-ZINC04617797 2.7339 119.0755 189.8598 0.7129 11.5563 20.3943
-ZINC04617799 3.2391 83.1031 143.4294 0.8346 7.9380 15.4651
-ZINC03815395 6.9197 38.3109 95.8169 1.2407 3.9492 10.3705
-ZINC00021592 2.7796 53.6519 115.2296 0.6399 5.0887 12.6349
-ZINC03815265 6.7971 49.3206 237.0175 0.4107 5.3109 12.7124
-ZINC00839396 3.4467 96.5287 196.6345 0.4333 5.3576 13.6817
-ZINC03815082 3.7124 96.7957 182.6650 0.4319 5.6627 13.0981
-ZINC03815194 7.4802 47.3065 257.5270 0.8383 4.7412 15.0052
-ZINC00839389 11.6245 130.5250 243.2178 0.7401 5.2186 12.7802
-ZINC03815150 3.4259 92.4894 192.3062 0.4237 5.3993 14.4975
-ZINC03815169 3.6455 107.5983 180.7663 0.4726 6.0368 15.2191
-ZINC00839395 3.6481 100.4232 209.0234 0.5101 5.0866 17.0429
-ZINC03815219 3.3799 103.5448 211.7705 0.4843 5.2754 19.2788
-ZINC04617814 13.1493 28.3835 133.6191 1.9201 3.2195 13.4649
-ZINC03815409 13.5755 30.5796 123.8069 1.9656 3.4826 12.4445
-ZINC03815213 6.0207 56.4653 205.6988 0.6659 5.6790 8.8749
-ZINC03815151 5.4596 55.1184 201.4901 0.7074 5.8068 9.2482
-ZINC03815230 9.9460 63.2361 234.1895 0.7700 5.7939 9.4665
-ZINC00018522 2.0154 30.3215 183.7180 0.4382 3.6631 17.7178
-ZINC03815160 6.6947 92.8569 165.2870 0.8532 6.7135 10.7070
-ZINC03815171 4.5315 82.2156 149.3579 0.6500 7.3843 9.7082
-ZINC03815161 7.2725 133.7181 152.5670 0.9246 6.8015 13.7809
-ZINC03815158 5.9549 34.9301 152.3612 0.8643 3.9073 14.9651
-ZINC03815305 8.0959 32.6070 151.7302 1.1850 3.5828 15.5772
-ZINC03815157 12.8152 77.7913 459.5002 1.0203 5.2320 14.8304
-ZINC03815396 3.3511 33.3639 179.1872 0.4809 3.7066 18.4329
-ZINC03815371 4.6782 30.9087 181.0884 0.8525 3.3901 18.4943
-ZINC03815389 6.5712 27.1096 183.6598 0.8984 3.4133 18.2769
-ZINC03815403 7.6623 72.5561 210.7696 0.9321 6.9741 10.3733
-ZINC00006094 5.9610 61.2620 106.6019 0.9568 6.6245 8.4224
-ZINC00600430 8.3447 94.4086 132.1459 0.9733 6.7531 8.4501
-ZINC03815123 2.9271 47.2687 228.7693 0.5357 5.0319 22.3677
-ZINC03815071 18.9385 44.7967 719.5770 1.4155 3.6451 18.8246
-ZINC03815047 4.0388 106.0228 649.7154 0.4935 4.1382 22.1590
-ZINC03815094 7.1777 24.1058 250.7409 1.2353 2.7552 22.5268
-ZINC03815098 18.3582 31.6465 757.2868 1.7536 2.6809 20.0565
-ZINC03815164 6.4608 42.4490 224.0467 1.2250 4.4794 19.7275
-ZINC03815076 8.7615 107.0224 551.5783 1.0440 4.3586 20.1499
-ZINC03815354 16.8236 50.5634 254.0749 0.9539 2.7235 20.4080
-ZINC00838734 16.7798 50.4477 249.8347 0.9342 2.6776 21.6232
-ZINC00601820 16.7591 50.1319 259.4784 0.9113 2.6728 20.6406
-ZINC03815288 20.5854 49.2560 279.6875 0.9308 2.9412 21.9044
-ZINC03815350 21.4028 49.2150 250.7529 0.9401 3.6780 19.2410
-ZINC03815309 17.1705 47.1084 333.2633 0.9489 2.5209 27.4857
-ZINC03815223 15.8971 48.2459 325.4408 1.0255 2.4926 27.0690
-ZINC02047503 15.8941 47.8334 333.1977 1.0321 2.5650 26.1506
-ZINC03815370 19.7193 47.8061 283.3839 0.9341 3.2187 23.2701
-ZINC03815299 24.0559 50.4188 322.7077 1.0287 3.1086 22.6320
-ZINC03815128 13.8663 34.2042 750.5695 2.0077 4.0781 14.0965
-ZINC03815114 3.2940 47.2403 257.8616 0.8058 4.7282 25.3696
-ZINC03815099 11.0196 47.8810 175.1004 1.6266 4.7353 17.3447
-ZINC03815074 3.3493 117.0552 681.9084 0.5870 4.1006 24.6260
-ZINC03815065 9.5815 27.9104 776.4001 1.4207 3.5161 15.6960
-ZINC03815091 6.7289 89.3953 632.9107 1.2875 3.0235 24.8104
-ZINC03815279 10.8090 86.0518 703.4090 0.9112 5.8357 19.9567
-ZINC03815062 10.5038 73.4477 818.0296 1.1790 3.0173 26.2664
-ZINC03815132 5.4393 29.9330 322.8260 1.1465 3.3684 27.8204
-ZINC03815113 4.0973 141.3333 603.2610 0.5004 5.1999 22.4808
-ZINC03815105 13.9205 21.1988 985.6640 1.4239 3.1610 22.3197
-ZINC00837641 10.4046 116.9544 126.6226 1.3578 7.6826 8.9589
-ZINC03815109 11.8128 51.9263 230.8542 1.5342 5.6293 20.9176
-ZINC03815122 2.9388 151.9921 651.6918 0.4789 4.8530 26.8818
-ZINC03815147 16.2280 77.1168 594.0964 1.3823 5.9681 12.7042
-ZINC03815178 9.4212 40.2129 295.2748 1.4658 4.3415 27.0596
-ZINC03815155 10.8708 38.5367 310.5692 1.6096 4.1665 31.8768
-ZINC04617805 3.1017 116.5847 237.5021 0.7791 10.5000 22.5039
-ZINC04617806 3.1135 116.6808 237.2937 0.7660 10.5196 22.4947
-ZINC04617807 4.0078 77.6512 184.1165 0.9455 7.6422 16.2031
-ZINC03815325 3.7298 78.0525 184.8368 0.9269 7.6830 16.2412
+ZINC02640583 599.2117 4269.9056 4735.5939 74.3959 244.8702 305.0322
+ZINC03815185 645.2668 3676.3702 4217.3488 66.6464 272.6532 328.9826
+ZINC00020644 729.4222 4182.1244 4781.7255 110.3883 376.2160 466.7996
+ZINC03815359 598.3646 2605.9182 3122.7862 108.1908 371.2085 460.5746
+ZINC03815360 544.5062 2828.0298 3316.0472 107.5183 372.0158 460.9654
+ZINC03815361 642.6296 2515.8289 3071.4550 134.9644 451.4352 559.5077
+ZINC00007282 652.9996 3077.3227 3627.2404 109.3791 373.8566 463.8808
+ZINC03815304 661.6421 2901.3626 3460.0760 115.6603 410.4643 504.0659
+ZINC03815353 1182.4039 2249.8246 2507.4619 189.8890 284.1400 362.7856
+ZINC00118570 401.5551 1960.3341 2300.0592 78.3622 310.8581 373.9643
+ZINC03815331 410.4133 1961.2469 2303.6852 75.1139 320.8662 379.4129
+ZINC00151213 641.7339 3724.9411 4204.8398 82.1730 316.4858 381.0697
+ZINC00151212 472.8011 2371.1663 2739.7552 79.2821 312.8517 375.7514
+ZINC03815388 554.2523 2156.0761 2642.5090 100.4242 345.5143 428.4218
+ZINC00104621 483.1569 2353.2135 2734.5928 99.8997 393.9934 469.1312
+ZINC03815229 635.3409 4028.2519 4501.9643 73.2623 301.9674 358.2246
+ZINC03815317 757.6633 2145.1450 2633.9394 182.0420 457.4310 543.4283
+ZINC03815247 630.5845 3750.7052 4247.3877 80.5072 282.9995 348.3319
+ZINC03815375 647.9974 3705.2366 4155.3358 78.6088 291.9652 350.0888
+ZINC03815227 683.0811 3818.6559 4396.1606 80.1609 300.3655 370.2789
+ZINC03815274 432.7157 2420.5538 2790.3347 82.3720 388.9357 455.6575
+ZINC00151214 690.4184 4513.7667 5033.4272 82.7966 316.9955 382.2436
+ZINC03815386 694.5144 3763.4281 3869.4143 78.3496 326.8395 346.7519
+ZINC00118581 542.7043 2776.1965 3186.8265 80.8327 314.7969 378.5958
+ZINC03815055 704.4391 5418.7857 5926.9921 86.4118 396.2010 464.4795
+ZINC03815319 899.0547 5265.9943 5714.6886 165.7192 507.6959 571.4552
+ZINC03815146 652.1901 4538.4671 5012.5308 82.4989 359.8971 424.9964
+ZINC03815314 1118.0348 2783.3939 3665.0044 152.4459 520.5835 592.3998
+ZINC03815398 695.1849 3048.2686 3292.6407 157.6469 527.5658 580.6100
+ZINC00104782 512.6858 2830.9130 3215.3339 96.1545 462.5886 532.3990
+ZINC03815197 734.2960 4777.0904 5346.8638 73.4065 305.3312 361.5111
+ZINC03815196 712.8576 2342.4097 3007.0677 123.4395 382.6102 492.8094
+ZINC03815276 719.4543 3905.7322 4582.2251 100.4909 316.9702 410.6667
+ZINC03815251 685.1776 2518.9137 3136.5729 114.6354 428.3421 523.5881
+ZINC03815264 1171.2889 4277.3975 5316.3976 80.9539 270.5513 341.4139
+ZINC03815202 677.4399 2394.8696 2995.3194 123.9730 364.2974 469.1704
+ZINC03815203 1182.0537 4288.6670 5332.3110 84.2045 301.5825 375.2316
+ZINC03815236 857.4506 4891.7786 5545.1056 84.4735 284.0255 352.9967
+ZINC03815238 649.3294 3194.1211 3484.5723 167.5282 681.2232 724.6520
+ZINC03815259 643.7840 3234.6020 3530.9356 154.7754 608.0127 661.7429
+ZINC03815280 501.7138 2919.5687 3353.0010 96.0021 469.0438 545.4714
+ZINC03815242 924.6527 4070.7094 4869.6115 81.6711 301.2161 372.4567
+ZINC03813425 1074.1934 4334.3678 4404.3084 172.1473 536.5722 600.2514
+ZINC03815036 757.0144 4200.7026 4689.0357 97.1995 334.2441 407.7854
+ZINC03815410 1045.2156 4210.3534 4671.1698 160.7334 539.4059 582.5721
+ZINC03815046 614.7461 3442.6399 3923.5964 85.1585 393.5115 461.1135
+ZINC03815035 1058.5428 4079.4396 4742.5059 194.7790 446.8715 551.4181
+ZINC03815034 749.9068 4216.5514 4749.3251 103.5506 352.8872 435.9354
+ZINC03815282 744.7387 4322.4573 4891.9682 82.1383 283.1186 350.0170
+ZINC03815281 761.0149 3270.4347 3638.3185 163.8651 505.1856 567.9198
+ZINC03813430 642.8847 5500.6140 5834.5791 156.8264 536.6503 589.7915
+ZINC03813429 836.6410 4302.4800 4729.3848 164.8192 505.3481 570.1859
+ZINC03815072 734.5604 4656.0680 5225.6815 86.6383 395.5475 463.8444
+ZINC03815374 663.9238 4570.4990 5003.6743 78.6763 295.3523 353.1194
+ZINC03815124 802.1403 2687.8371 3116.4507 195.0167 569.0106 646.6922
+ZINC03815338 896.9460 2618.3768 3440.5168 99.1588 335.2088 418.8413
+ZINC03815176 717.7714 2814.5603 3163.9218 182.8347 614.5900 690.4679
+ZINC03815111 493.9969 2911.8791 3295.5177 83.1309 391.3742 457.6747
+ZINC03815343 699.6055 4256.6906 4783.7254 89.6725 372.4303 443.0092
+ZINC03815100 890.5110 4009.4917 4777.4586 102.0532 299.1947 389.2357
+ZINC03815101 867.9575 4075.7482 4809.0766 98.9597 307.3399 393.9419
+ZINC00020362 816.1340 4773.4725 5489.7513 128.6704 414.2010 528.2930
+ZINC03815232 888.4012 5272.9731 5985.7659 98.7534 453.6072 530.2984
+ZINC03815097 767.4980 3644.7761 4056.6131 198.7126 796.1054 868.3784
+ZINC03815163 892.1220 5273.4348 5991.5637 95.0057 444.6283 518.4049
+ZINC03815162 693.2342 5333.1291 5809.9288 99.7003 513.5607 591.2054
+ZINC03815029 845.6997 4891.1285 5405.4111 113.1644 441.6638 526.4423
+ZINC03815037 1213.9508 4940.0546 5545.8840 185.3424 672.2239 753.3969
+ZINC03815038 755.0907 5002.3876 5536.1136 94.6143 377.1621 451.1809
+ZINC03815411 895.3505 4117.5501 4889.0041 138.6224 331.2388 451.7851
+ZINC03815159 765.0108 5897.3178 6415.0329 103.3957 360.8715 442.7668
+ZINC03815042 1053.4172 3685.8938 3989.9754 202.7220 603.2606 679.9792
+ZINC03815286 730.0562 5037.7164 5591.2315 89.1219 483.8604 550.9679
+ZINC03815284 714.3514 3519.5107 3960.2117 172.0082 692.1600 774.3631
+ZINC03815144 1140.5581 4085.1190 5066.2775 142.9706 324.6336 450.5412
+ZINC03815183 829.2113 4926.2872 5522.6428 116.7730 437.5768 532.0890
+ZINC03813424 1430.4156 3869.4649 4586.3326 222.1473 543.9229 646.6940
+ZINC03815137 786.6047 4813.3458 5520.3352 115.9813 382.1585 485.6349
+ZINC02391776 753.5192 4929.8145 5469.4921 104.4578 422.8581 508.2408
+ZINC03815060 903.6187 3093.6130 3820.3566 234.5108 666.1594 823.3607
+ZINC03815140 838.5411 4906.7138 5482.7466 124.4981 451.0364 550.9418
+ZINC03815138 882.4503 4499.9475 5255.5080 130.5844 315.5046 429.4465
+ZINC03815143 857.3306 2689.9834 3467.5127 161.2460 451.7707 591.4737
+ZINC03815070 1126.4073 4398.5330 5374.8589 121.1136 400.3316 505.2547
+ZINC03815320 678.8194 5275.3298 5728.4017 81.7658 475.2336 533.6086
+ZINC03815069 1157.9675 4293.8922 5315.0594 129.5864 386.4747 500.9949
+ZINC03815332 693.8950 5347.9497 5819.0960 98.5770 477.6775 553.7732
+ZINC03815248 697.4969 5278.6312 5710.0899 91.2755 499.9782 566.0882
+ZINC03815373 818.5978 3313.2387 3845.2305 187.0432 652.8597 735.2932
+ZINC03815118 797.4233 4967.3093 5577.6222 112.6914 413.9198 507.2021
+ZINC03815117 831.1788 4918.2647 5455.7245 105.9735 426.7907 507.1999
+ZINC03815121 949.0012 3346.4585 3875.9428 232.3505 744.5737 852.1774
+ZINC03815335 816.1157 5474.2331 6091.9421 90.4543 384.3877 453.6095
+ZINC03815266 972.5208 5249.0698 5935.9573 155.3471 481.5634 604.0155
+ZINC03815125 1353.1588 5106.8896 5816.4490 195.1892 672.3089 762.6343
+ZINC03815328 729.5569 5985.1796 6447.4932 102.0006 602.6177 676.7191
+ZINC03815136 773.0487 5748.4152 6311.2700 107.3829 520.7477 607.2111
+ZINC03815141 1026.4882 2770.8853 3706.1130 192.6841 474.9782 640.1857
+ZINC03815033 1247.6116 5627.5238 6165.3894 198.3896 779.8866 844.8287
+ZINC00116727 778.5041 3220.8281 3918.5144 147.8762 512.6522 634.4506
+ZINC03815406 706.4418 6111.8795 6595.5799 86.5681 402.0841 470.1483
+ZINC00020363 1366.0877 4360.2655 5554.3223 164.4482 427.4917 569.9541
+ZINC02391785 780.3541 5722.5691 6280.1685 109.7357 549.6285 637.3026
+ZINC03815357 759.7901 7319.8833 7835.2769 87.1840 402.6479 471.3314
+ZINC03815080 935.7114 5097.7770 5904.7596 142.8243 433.8402 557.6867
+ZINC03813428 945.7079 3480.5675 4070.1624 179.7562 537.6467 622.6483
+ZINC03815079 928.7784 5085.7349 5917.0660 153.0428 419.0741 553.9222
+ZINC00118594 694.2208 3774.3201 4225.5744 101.7845 397.3506 470.8813
+ZINC03815027 979.5761 5238.2449 5865.4718 140.6375 476.4884 582.3801
+ZINC03813434 1200.0378 5096.8258 5456.2743 248.1663 579.9472 673.3578
+ZINC03815393 610.1467 4679.6740 5124.0327 85.3264 400.1023 467.5491
+ZINC03815187 719.6801 6091.9435 6567.6211 108.2275 621.5128 699.2629
+ZINC03815190 710.5713 6437.3042 6906.8938 104.0890 678.5856 757.4343
+ZINC00600292 978.6710 6022.4719 6718.1490 151.5614 521.0231 643.0647
+ZINC03815041 2407.3071 3735.1993 5541.6761 319.6307 587.8590 809.5964
+ZINC03815212 1030.2272 6681.3500 7381.0360 108.3336 361.4838 447.1345
+ZINC03815031 1153.5378 5924.5504 6811.0909 149.6473 525.1003 643.2892
+ZINC03815045 1408.8051 6811.5608 7574.9077 201.4251 885.9691 978.2534
+ZINC03815292 812.5981 6443.3569 6959.5641 123.7939 645.5991 723.6937
+ZINC00601499 1106.0211 6776.0957 7702.1702 97.7563 646.6166 723.1123
+ZINC03815206 968.3055 4455.0563 4787.4723 148.7034 522.6416 607.8110
+ZINC01386818 831.5965 3880.4092 4566.3511 148.7953 515.7237 636.9856
+ZINC00009851 783.7114 4023.9324 4727.9970 148.2586 572.8667 695.1707
+ZINC03815362 796.5429 3997.4771 4505.1054 118.5279 441.9406 526.8953
+ZINC03815129 776.5901 4400.4268 4932.6146 108.5448 485.0004 564.8179
+ZINC03815235 748.1578 7148.8468 7680.7076 99.8912 660.1821 739.3191
+ZINC03815075 1026.9274 7297.8694 8006.0301 152.1441 521.6747 644.2023
+ZINC03813431 814.7652 3947.3293 4320.6380 173.6197 557.6737 614.3325
+ZINC01386782 788.4832 7093.2033 7797.2619 147.8137 527.0520 647.8361
+ZINC03815283 1319.3006 3491.9278 4713.4515 153.9364 492.2783 627.0800
+ZINC03815250 1293.0910 5494.0405 6554.3050 111.2305 426.8193 516.5687
+ZINC00116937 889.3997 4520.4190 5207.1494 150.2791 518.5449 640.2251
+ZINC03815334 1274.9655 4773.9388 5741.1505 154.5192 313.2218 413.1281
+ZINC03815199 1300.4516 6259.5225 7297.1173 114.0394 522.2039 610.4791
+ZINC03815088 1308.5887 4583.8554 5693.0655 244.1472 668.3580 847.0463
+ZINC03815348 1446.1786 5969.1540 7149.0197 199.0221 523.0792 692.0360
+ZINC03815258 1070.9914 6511.6926 7294.9117 115.8915 552.5270 644.7618
+ZINC03815102 1602.1209 6571.2465 7583.4812 194.2558 741.3535 823.7287
+ZINC03815043 2159.7668 4820.8693 5498.9661 326.1499 653.7921 782.2456
+ZINC03815032 1317.0718 8602.0918 9579.2671 152.1858 534.5824 655.9213
+ZINC03815050 1111.3769 7049.5620 7296.2489 197.3504 693.7279 763.0850
+ZINC03815273 1593.4183 3188.3477 3630.2401 225.5569 417.7876 510.8310
+ZINC03815119 1608.3656 7271.2302 8212.4497 223.8582 1001.1495 1115.5362
+ZINC03815189 1443.3818 6120.6978 7336.1435 214.3167 481.3585 674.3998
+ZINC03815278 2183.6273 7346.3576 9023.6068 156.0588 528.5495 651.3048
+ZINC03815290 1868.4338 4162.6193 4408.8522 227.9290 420.9284 510.8851
+ZINC00016978 1004.6070 5182.5606 5978.9197 150.6799 522.2199 643.4062
+ZINC03815316 794.3820 4849.1600 5550.9262 153.0967 763.4640 885.8336
+ZINC03815384 1480.0091 3265.5519 4427.9764 210.2356 430.8671 564.8746
+ZINC03815228 2420.6961 6635.5658 8855.3706 209.6925 906.9046 1075.1474
+ZINC03815397 1466.0410 3190.5066 4342.9195 213.1070 515.5299 650.6697
+ZINC03815077 1723.4853 8996.5658 10020.4646 230.5977 1176.9924 1293.2886
+ZINC03815300 1559.9100 5509.4080 6719.4309 210.3661 439.9104 573.2908
+ZINC02572485 1282.1047 7363.9140 8322.1905 225.4144 711.6321 899.9845
+ZINC03815298 1516.1588 3924.9235 5110.7547 210.2040 435.8595 569.5542
+ZINC03815059 1397.7182 5845.4563 6569.5739 238.8534 650.1719 770.1314
+ZINC03815201 1491.2232 8154.4613 8840.2258 213.0198 884.0241 959.1871
+ZINC03815066 1099.7506 6440.1444 7316.2087 184.9289 564.7086 695.6952
+ZINC04617768 2255.1463 6950.0233 8635.6929 356.1950 793.1594 1033.5499
+ZINC03815198 2103.1085 5875.3048 7183.4052 277.2612 855.1442 968.0935
+ZINC04617774 1778.6197 8833.3563 9775.0301 247.8653 1140.6479 1260.8317
+ZINC03815064 1937.9586 8412.5919 9682.9255 223.6557 960.1929 1072.8266
+ZINC03815087 2496.1859 6089.5181 7370.2035 358.8322 1028.9562 1199.4152
+ZINC03815040 1428.8879 8701.6857 9002.6269 241.7484 987.3376 1059.0357
+ZINC03815049 1959.4599 8255.9305 9191.1051 275.1528 849.4918 1002.3000
+ZINC03815243 1442.5753 9038.4406 9747.7195 219.2014 1380.8308 1453.3500
+ZINC03815026 1305.3359 7356.3695 8275.8080 224.7042 711.7230 895.7674
+ZINC03815051 1974.1645 10418.2972 11683.4894 240.0341 1186.4467 1309.9787
+ZINC03815044 1022.4341 5701.8377 6381.6992 169.1748 638.5265 763.3230
+ZINC03815272 1328.7418 4938.9850 5924.7240 255.6475 760.3052 939.8567
+ZINC03815172 2295.3768 4569.8772 5022.6319 397.8382 655.6941 779.4858
+ZINC03815191 1545.4804 8878.4629 9678.4371 239.0839 1136.5119 1220.9397
+ZINC03815063 1425.4761 9339.3857 9955.0588 224.9700 1130.9193 1192.2520
+ZINC03815387 1592.9796 4499.7173 5741.3170 223.8589 653.2445 796.0392
+ZINC03815218 1184.0221 8020.5344 8889.9195 116.9763 690.2968 782.8107
+ZINC03815090 2650.9172 7401.1302 8729.6922 383.4360 1267.3838 1438.3946
+ZINC04617771 2036.8893 7409.9506 8320.0377 348.6565 819.1066 975.7115
+ZINC03815333 1096.7494 5586.6842 6412.1463 218.1352 848.7623 996.8604
+ZINC03815237 1351.0178 9087.6578 9614.6563 258.4213 1302.3590 1363.7349
+ZINC04617779 1971.7632 8921.7415 9944.5322 279.3838 1145.7185 1292.0244
+ZINC03815175 1899.6628 10821.1165 12011.1275 262.3389 1758.2257 1896.9670
+ZINC03815096 2101.3609 10962.1992 12305.1416 231.4623 1135.9749 1251.4153
+ZINC03815358 1647.3973 4422.2061 5608.4678 210.4903 441.1112 573.2712
+ZINC03815126 2004.9643 6637.5648 7811.0623 365.4345 742.7602 944.2269
+ZINC03815404 1549.9628 4417.0768 5578.2886 213.8193 525.4278 657.5979
+ZINC03815401 1595.7911 4353.0835 5528.9373 237.7662 777.6202 904.1544
+ZINC03815108 2858.6927 8949.1610 10446.8547 406.0037 1568.0757 1755.4958
+ZINC03815154 2063.3667 7903.0072 9318.6852 471.8835 1745.1419 2017.2264
+ZINC04617776 2481.6194 7931.9720 9252.1573 368.9908 1227.6308 1402.4132
+ZINC03815165 2136.1045 12603.6386 13999.6279 285.9617 2111.3680 2246.8169
+ZINC03815352 1407.3775 6167.2582 7155.9383 284.8204 911.4147 1099.0575
+ZINC03815173 2214.5261 15032.4481 16476.2478 296.9456 2535.4891 2676.4889
+ZINC03815367 522.3494 2488.3799 2827.1888 101.2720 378.7392 427.8600
+ZINC00109589 519.7983 2530.5823 2866.8106 104.2778 388.4621 440.5754
+ZINC03815364 685.6718 3256.6441 3797.8653 174.6964 674.0222 779.7551
+ZINC03815303 792.5350 3334.8306 3940.5992 151.1956 519.1471 615.0071
+ZINC03815312 811.2261 3379.4096 3908.4545 197.3950 677.7260 779.7789
+ZINC03815256 981.0218 2846.7122 3640.9744 172.4021 467.7629 584.8308
+ZINC03815253 1025.4089 3081.5306 3920.2291 180.9468 430.9561 556.5826
+ZINC03815365 818.2972 3621.2197 4274.7469 128.7715 589.5310 669.5058
+ZINC01386812 1029.8563 3631.1552 4471.0362 179.7955 585.0983 706.3801
+ZINC00020368 1016.4434 4324.3307 5154.0291 155.7684 698.2015 798.6491
+ZINC03815297 1161.1237 4109.6258 4946.0767 210.5401 688.0781 806.3010
+ZINC03815342 1105.0819 5930.2406 6667.8264 171.2012 590.0743 718.8973
+ZINC03815083 759.1204 2626.8748 3150.1878 138.3728 460.2930 538.1700
+ZINC03815293 552.7144 2871.1946 3284.8416 75.8691 294.0994 350.8261
+ZINC03815310 526.5219 3652.1384 4037.7495 77.1865 378.1629 435.2612
+ZINC03815326 797.8964 2479.8667 3205.8939 143.1372 436.1352 551.4667
+ZINC03815341 828.9971 3002.2933 3738.3177 148.1766 472.2864 590.6649
+ZINC03815394 935.1974 2859.7962 3681.6562 178.0297 520.8411 660.4507
+ZINC03815277 815.7581 3133.2696 3873.7774 150.4187 593.1438 712.6620
+ZINC03815156 1001.8107 3392.5467 4268.5199 127.1920 382.8307 495.3438
+ZINC03815244 1210.0705 4639.1712 5659.2736 148.8537 440.9840 559.2321
+ZINC00020645 1054.1503 3431.7521 4336.5277 146.8614 439.6260 556.6884
+ZINC03815402 842.9007 3674.6445 4387.8912 150.4994 658.1929 770.3851
+ZINC03815336 970.0126 4726.3386 5436.6695 154.6404 567.9805 681.3552
+ZINC00023489 617.1088 3707.3748 4140.2014 75.5108 376.2262 431.0429
+ZINC00007342 618.6195 3724.9627 4161.5334 83.6931 380.6788 443.2357
+ZINC03815231 778.1330 3992.3945 4562.8074 128.1122 436.5775 537.7576
+ZINC03815295 965.7777 4012.7884 4758.9254 181.7280 439.4373 590.2066
+ZINC03815257 2265.9283 4405.3944 6115.3517 378.1601 479.7767 781.4953
+ZINC03815345 2117.3326 4496.5649 5244.6975 274.9958 657.6209 820.6184
+ZINC03815368 2184.4165 3824.7129 5324.3414 412.1602 673.4364 891.5702
+ZINC03815234 819.0017 6165.6870 6836.3773 69.9740 377.4699 436.4875
+ZINC03815200 775.4229 5562.6933 6100.5747 101.3456 421.6421 501.1000
+ZINC00006271 1042.9703 5160.3104 6031.7004 111.3853 434.5412 528.4172
+ZINC04617767 1034.4350 5188.1826 6053.1198 100.2470 422.7669 506.3359
+ZINC03815028 1021.9877 5240.9175 6089.8905 107.7942 405.1207 495.0989
+ZINC03815058 1041.1607 5213.5352 6080.6991 104.6372 401.7261 488.7115
+ZINC03815241 852.0685 6046.1471 6676.5769 96.1952 402.1148 481.6892
+ZINC03815054 1015.0519 5285.0539 6122.4967 101.5034 410.0149 493.2707
+ZINC03815030 1247.5880 5421.7922 6469.2031 146.5628 445.6923 569.8019
+ZINC02391775 1056.9433 5955.4299 6833.7887 103.0365 556.0088 639.0159
+ZINC03815052 1214.9109 5854.4436 6888.1241 125.1018 541.4561 645.1704
+ZINC03815057 1067.4854 5979.1411 6864.4576 107.4165 539.5447 625.9877
+ZINC03815073 1066.9754 5921.8944 6808.4031 114.8556 562.8351 656.7762
+ZINC03815249 1122.6038 8366.4302 9246.3756 116.5809 619.0423 710.4855
+ZINC03815152 1311.1383 8579.2585 9540.7424 122.1911 669.1919 759.9640
+ZINC03815116 2115.2044 6185.9311 7697.6584 279.9823 600.0141 794.0621
+ZINC04617775 1355.3489 10074.7638 10908.3914 141.3195 985.1882 1062.2561
+ZINC03815233 1224.6465 10777.4141 11707.9501 137.1814 1257.0015 1329.8785
+ZINC04617795 1385.1570 9968.5851 10704.7484 138.5176 947.3287 1018.7118
+ZINC03815239 1344.6721 10033.2444 10724.0606 169.3843 1136.6923 1218.8890
+ZINC03815188 1222.1093 10106.6716 11008.6790 135.0599 944.9987 1031.4767
+ZINC03815095 2738.9227 6589.3899 8643.0539 320.1074 710.0957 934.2215
+ZINC03815103 1221.5636 10223.0592 11088.9402 138.1199 984.8653 1071.3135
+ZINC03815209 1330.2320 10083.8086 10764.9132 154.0069 1138.7139 1208.0901
+ZINC03815306 1539.7322 11405.1619 12664.3877 145.3592 1186.8432 1270.1914
+ZINC03815208 1557.8046 11266.2068 11735.5869 206.1240 1286.3053 1376.5801
+ZINC03815067 2917.1017 7902.7022 10199.9081 284.5803 714.2618 909.6018
+ZINC03815382 634.5575 4521.8402 5061.1362 78.0526 483.7924 550.8452
+ZINC03815179 530.6965 3918.1707 4401.4296 86.9916 605.8932 682.0001
+ZINC03815112 633.8664 4489.2874 5036.7691 112.8004 730.3048 823.4674
+ZINC03815061 745.5530 6969.4444 7579.7954 95.8833 610.3710 693.6637
+ZINC03815048 888.7740 6943.7874 7676.4849 91.2941 613.4386 691.3959
+ZINC03815120 1060.0178 6335.3953 7235.5281 113.5978 547.4148 646.4248
+ZINC03815084 1000.5670 7837.5616 8678.0063 98.0602 611.3186 696.3895
+ZINC03815255 581.7238 5261.1196 5792.8276 87.9620 613.3458 690.2854
+ZINC03815186 676.9534 5969.2924 6551.3942 113.5387 738.9446 832.5606
+ZINC03815245 917.4197 6583.7548 7265.6496 114.4545 734.6373 825.9151
+ZINC03815322 694.1064 5517.0227 6063.1357 86.7013 436.5423 507.4449
+ZINC03815301 739.9651 3851.2905 4407.6841 125.2752 590.2026 663.3117
+ZINC00327021 731.0917 3621.8216 4169.3280 132.2973 558.3430 638.4712
+ZINC03815356 853.1424 3929.6238 4560.9640 154.6683 609.3245 702.0123
+ZINC03815340 844.8657 3686.6089 4304.0862 162.7456 577.4828 675.9039
+ZINC04617812 853.1462 3929.6202 4560.9605 154.6694 609.3228 702.0110
+ZINC04617811 844.8718 3686.5732 4304.0562 162.7466 577.4799 675.9009
+ZINC03815093 966.2357 4510.8305 5112.8311 129.6578 359.7938 458.5940
+ZINC03815222 967.4324 4506.4222 5092.4989 121.8543 335.7958 425.8910
+ZINC00006798 1101.3101 2597.5671 3560.7331 173.5477 424.0505 562.3200
+ZINC01609260 1012.4102 2796.3070 3590.7528 164.9722 460.1536 565.7231
+ZINC03815377 1128.6842 3947.3911 4648.1374 167.2477 465.8999 570.6366
+ZINC03815366 1405.8716 3485.4851 4562.0404 221.1233 571.8279 712.8549
+ZINC03815351 1333.8141 3715.1840 4689.0517 215.0466 615.0430 747.4934
+ZINC03815376 1140.7680 4200.8222 5120.3364 180.4240 673.6458 791.8174
+ZINC01609268 1106.8611 4126.6710 4995.1277 177.8114 667.2024 779.6878
+ZINC03815391 1858.3644 4389.0950 5710.0130 287.4638 732.7443 906.7468
+ZINC03815323 2029.4745 8044.7804 9449.5954 329.7701 1396.0077 1592.4235
+ZINC03815390 2557.6327 7625.2110 9726.3125 412.9009 1149.2309 1450.7760
+ZINC03815324 2162.9581 10715.5296 12364.1254 361.4593 1867.2574 2102.7005
+ZINC03815025 819.7493 6005.9292 6605.9980 119.8331 507.6856 609.1960
+ZINC03815106 812.0772 6006.3299 6608.2691 109.1765 460.5981 552.7520
+ZINC04617810 647.3438 4967.3308 5517.7701 125.3294 764.8522 861.8763
+ZINC04617809 647.3486 4967.3137 5517.7551 125.3300 764.8504 861.8749
+ZINC03815339 1271.1895 3188.1339 4247.1772 209.0437 524.6594 670.5805
+ZINC04617808 1271.1829 3188.1640 4247.2007 209.0425 524.6595 670.5796
+ZINC04617792 1470.5562 3048.7269 4289.5300 252.5724 499.3591 682.2370
+ZINC04617793 834.5258 5189.1823 5923.9971 179.9474 800.9124 949.2735
+ZINC03815184 834.5254 5189.1854 5924.0015 179.9485 800.9115 949.2741
+ZINC04617794 1470.5282 3048.7279 4289.5087 252.5693 499.3591 682.2337
+ZINC04617801 1952.8471 3362.7665 4957.5935 319.7292 546.2678 786.5005
+ZINC04617802 1077.2495 6103.0393 6945.1843 204.0851 934.1542 1096.2936
+ZINC04617803 1025.0953 6239.8280 7048.2011 198.3935 951.5622 1109.5788
+ZINC03815267 1941.5882 3426.6425 5028.9840 317.3015 555.9131 799.6085
+ZINC04617798 4381.8011 7026.0660 11167.3841 749.0092 1286.1249 1951.3173
+ZINC03815217 3024.4453 5357.2533 8082.5535 527.6787 993.1268 1418.8893
+ZINC04617797 4378.3225 7031.1519 11158.2185 748.4180 1287.5371 1948.9873
+ZINC04617799 3072.2657 5358.3049 8133.9490 535.1307 994.2817 1427.5873
+ZINC03815395 1191.5322 2730.9516 3506.3177 207.5941 464.4465 572.7865
+ZINC00021592 1447.4652 3159.3441 4433.6660 211.9591 491.1673 655.7756
+ZINC03815265 1535.0089 4491.0166 5748.5453 211.7016 485.5552 666.8627
+ZINC00839396 2243.5734 4320.5661 6381.8077 220.0567 536.3714 723.4945
+ZINC03815082 2363.0883 3971.5580 6134.3260 231.5948 514.1402 712.9071
+ZINC03815194 1569.6608 5257.7844 6451.6002 223.1834 633.7435 789.8595
+ZINC00839389 2605.1984 4802.2110 6886.0283 220.4741 500.2512 665.9570
+ZINC03815150 2243.5641 4265.4593 6327.2100 227.1002 581.9295 775.9782
+ZINC03815169 2637.3674 4413.0489 6836.6849 266.8881 643.3600 871.4923
+ZINC00839395 2337.2256 5123.5721 7250.8948 229.4649 719.6724 907.3115
+ZINC03815219 2492.2460 5717.6241 8005.5520 259.1843 889.3394 1104.9366
+ZINC04617814 1172.0824 4059.0174 4431.1820 221.0035 661.5554 717.4275
+ZINC03815409 1246.4456 3797.5688 4221.2971 234.2715 619.6335 684.8656
+ZINC03815213 1692.0905 3607.6023 5004.7699 228.4147 343.4680 523.9384
+ZINC03815151 1690.1637 3567.4132 4968.2515 241.0269 368.3585 557.0361
+ZINC03815230 2011.7428 4589.5104 6108.2819 242.8664 378.7503 564.6340
+ZINC00018522 892.8053 4949.5698 5711.5798 164.0527 726.2419 855.2377
+ZINC03815160 2825.2285 3308.1520 5777.6736 302.6697 462.4061 696.8197
+ZINC03815171 2679.1569 3511.3288 5901.4414 353.5091 455.7621 752.0725
+ZINC03815161 3192.7790 4445.2649 7218.9851 339.9455 647.0415 905.6244
+ZINC03815158 1161.5651 4400.9158 5206.6336 195.6385 649.0085 773.7707
+ZINC03815305 1153.0146 4506.3549 5168.6288 195.4802 687.2492 785.5623
+ZINC03815157 2662.1100 6167.8392 8054.2148 381.3902 966.8927 1223.8033
+ZINC03815396 1019.4916 5103.8916 5928.6361 163.3119 737.6357 863.4396
+ZINC03815371 1001.9842 5254.2667 5957.9236 173.9486 793.2218 897.2615
+ZINC03815389 961.4364 5300.2968 5872.1140 172.4718 767.0119 867.6079
+ZINC03815403 2313.0423 4113.4697 6024.3631 316.2464 452.2160 693.8969
+ZINC00006094 1922.4248 2974.9099 4536.2773 303.2505 375.1691 601.8759
+ZINC00600430 2706.3233 3673.0270 5901.5743 309.0594 376.9369 608.1284
+ZINC03815123 1518.9491 6831.8379 8157.3511 244.9720 1007.7510 1205.5823
+ZINC03815071 1841.1395 10158.7136 10783.9303 293.5163 1173.9253 1303.2423
+ZINC03815047 2526.4433 8507.7934 10777.7106 189.8983 928.7508 1078.1827
+ZINC03815094 1053.9508 8245.1989 8781.5388 243.4173 1449.4858 1542.2017
+ZINC03815098 1590.1020 10401.7846 10580.5846 279.3763 1374.0362 1432.4562
+ZINC03815164 1626.8265 7341.7999 8485.2605 347.9652 1278.1018 1476.6211
+ZINC03815076 2643.5565 8890.1709 10920.2370 313.3505 1229.2435 1421.4900
+ZINC03815354 1215.8775 7511.1113 7602.6957 147.0958 854.4741 925.2604
+ZINC00838734 1207.9505 7547.7466 7643.0942 148.0810 924.8524 996.3310
+ZINC00601820 1196.3802 7640.9161 7730.9560 143.3624 862.0755 932.5358
+ZINC03815288 1347.7658 8407.8037 8557.1530 162.6254 959.0768 1043.5159
+ZINC03815350 1432.3454 7695.6801 7913.0219 198.5786 867.7884 985.5199
+ZINC03815309 1260.8435 10290.7573 10348.7064 156.1402 1279.5594 1350.2979
+ZINC03815223 1269.4634 10028.6638 10177.1707 158.3147 1264.2556 1330.2721
+ZINC02047503 1263.6174 10117.1731 10258.4743 161.8682 1223.2223 1292.1997
+ZINC03815370 1404.5085 8854.4857 9043.4709 186.8776 1089.1909 1191.9979
+ZINC03815299 1625.8986 9840.2731 10247.8460 177.9049 1017.4096 1106.8447
+ZINC03815128 1878.9426 9391.4909 10151.3168 395.5778 1046.7758 1181.3468
+ZINC03815114 1639.5592 8170.1173 9549.2345 282.2360 1334.9434 1534.9886
+ZINC03815099 2031.9397 6405.2072 7617.5631 432.6093 1290.0507 1501.4408
+ZINC03815074 2774.4771 9824.7719 12353.5265 225.0069 1210.2275 1378.8779
+ZINC03815065 1474.8598 9768.1985 10502.7516 320.8920 1112.5825 1248.7872
+ZINC03815091 2340.4969 10443.2273 12193.4444 284.5231 1722.4581 1837.0335
+ZINC03815279 2966.9397 9526.9921 11835.4511 350.8421 1085.1336 1341.2062
+ZINC03815062 1953.4362 13331.6310 14488.0859 255.9770 1674.1725 1786.3109
+ZINC03815132 1251.7332 10866.0548 11671.1508 288.9567 1853.8847 1996.0894
+ZINC03815113 3334.2608 8766.8196 11837.6622 250.8122 1011.1737 1217.9525
+ZINC03815105 1330.1636 13513.3935 13906.1115 279.6812 1448.3621 1554.3263
+ZINC00837641 3449.2578 3799.1928 6606.4576 379.6953 433.2987 698.9403
+ZINC03815109 2330.7692 8410.0905 9870.1007 508.6058 1594.0761 1884.8314
+ZINC03815122 3433.6832 10648.4818 13870.1606 271.9293 1395.3952 1618.4759
+ZINC03815147 3062.6491 7052.9531 9089.3071 360.1712 690.2386 914.9405
+ZINC03815178 1832.4639 10620.8745 11718.0143 412.3168 2025.2997 2229.4758
+ZINC03815155 1908.3681 12168.3329 13195.5006 438.9886 2544.9659 2739.2912
+ZINC04617805 4460.0497 8970.3736 13132.9632 710.5831 1466.8299 2079.2445
+ZINC04617806 4463.5519 8963.4441 13130.8215 710.9882 1465.4216 2079.8999
+ZINC04617807 3111.8907 6855.0093 9591.1315 541.0203 1080.3561 1502.2490
+ZINC03815325 3118.0557 6868.6956 9630.1130 542.4246 1081.5874 1507.2234
diff --git a/Code/GraphMol/Descriptors/test_data/pmi.py b/Code/GraphMol/Descriptors/test_data/pmi.py
index a00794e74..8809253de 100644
--- a/Code/GraphMol/Descriptors/test_data/pmi.py
+++ b/Code/GraphMol/Descriptors/test_data/pmi.py
@@ -11,38 +11,30 @@
 from rdkit import Chem
 from rdkit.Chem import AllChem
 import numpy as np
-from numpy import linalg
 
 
 def GetMoments(mol, includeWeights):
   conf = mol.GetConformer()
   if includeWeights:
-    weights = [x.GetMass() for x in mol.GetAtoms()]
+    masses = np.array([x.GetMass() for x in mol.GetAtoms()])
   else:
-    weights = [1.0] * mol.GetNumAtoms()
+    masses = [1.0] * mol.GetNumAtoms()
 
-  pts = [conf.GetAtomPosition(i) for i in range(mol.GetNumAtoms())]
-  wSum = sum(weights)
-  origin = np.sum([pts[i] * weights[i] for i in range(mol.GetNumAtoms())], 0)
-  origin /= wSum
-  sumXX = 0
-  sumXY = 0
-  sumXZ = 0
-  sumYY = 0
-  sumYZ = 0
-  sumZZ = 0
-  sums = np.zeros((3, 3), np.double)
-  for j, pt in enumerate(pts):
-    dp = weights[j] * (pt - origin)
-    for i in range(3):
-      sums[i, i] += dp[i] * dp[i]
-      for j in range(i + 1, 3):
-        sums[i, j] += dp[i] * dp[j]
-        sums[j, i] += dp[i] * dp[j]
-  sums /= wSum
-  vals, vects = linalg.eigh(sums)
-  vals = sorted(vals)
-  return vals
+  ps = conf.GetPositions()
+  mps = [x*y for x,y in zip(ps,masses)]
+  centroid = np.sum(mps,axis=0)/sum(masses)
+  cps = ps - centroid
+  xx = xy = xz = yy = yz = zz = 0.0
+  for m,p in zip(masses,cps):
+    xx += m*(p[1]*p[1] + p[2]*p[2])
+    yy += m*(p[0]*p[0] + p[2]*p[2])
+    zz += m*(p[1]*p[1] + p[0]*p[0])
+    xy -= m*p[0]*p[1]
+    xz -= m*p[0]*p[2]
+    yz -= m*p[1]*p[2]
+  covm = np.array([[xx,xy,xz],[xy,yy,yz],[xz,yz,zz]])
+  res = np.linalg.eigvals(covm)
+  return sorted(res)
 
 
 if __name__ == '__main__':
diff --git a/Code/GraphMol/Descriptors/test_data/pmi.sdf b/Code/GraphMol/Descriptors/test_data/pmi.sdf
new file mode 100644
index 000000000..1f2c64f18
--- /dev/null
+++ b/Code/GraphMol/Descriptors/test_data/pmi.sdf
@@ -0,0 +1,123 @@
+XX_0000000001_001_001_001
+     RDKit          3D
+
+  5  4  0  0  0  0  0  0  0  0999 V2000
+   -0.0372    1.5779    0.0423 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -0.0107    0.0264    0.0242 C   0  0  0  0  0  0  0  0  0  0  0  0
+    0.6771   -0.4966   -1.1839 N   0  0  0  0  0  0  0  0  0  0  0  0
+    0.7202   -1.9805   -1.2328 C   0  0  0  0  0  0  0  0  0  0  0  0
+    1.4448   -2.4914   -2.5064 C   0  0  0  0  0  0  0  0  0  0  0  0
+  1  2  1  0
+  2  3  1  0
+  3  4  1  0
+  4  5  1  0
+M  CHG  1   3   1
+M  END
+
+>  <SMILES_USERINPUT>
+CCNCC
+
+>  <STATUS>
+OK
+
+>  <COMMENT>
+correct SMILES  3D structure successfully generated (#structures: 1; Protonation Abundance: 99.95%; Tautomerisation Abundance: 100%)
+
+>  <npr2>
+0.94636673
+
+>  <npr1>
+0.11207375
+
+>  <pmi2>
+251.33347
+
+>  <pmi1>
+29.764236
+
+>  <pmi3>
+265.57724
+
+>  <pmi>
+273.33746
+
+>  <pmiY>
+167.30069
+
+>  <pmiZ>
+75.545876
+
+>  <pmiX>
+30.490913
+
+
+$$$$
+XX_0000000002_001_001_001
+     RDKit          3D
+
+ 12 12  0  0  0  0  0  0  0  0999 V2000
+    0.1906    1.4156    0.2263 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -0.0330   -0.1087    0.0412 C   0  0  0  0  0  0  0  0  0  0  0  0
+    0.7670   -0.7169   -0.9973 O   0  0  0  0  0  0  0  0  0  0  0  0
+    2.1979   -0.6480   -0.8048 C   0  0  0  0  0  0  0  0  0  0  0  0
+    2.8054    0.6364   -1.4304 C   0  0  0  0  0  0  0  0  0  0  0  0
+    3.8673    0.1208   -2.4291 C   0  0  0  0  0  0  0  0  0  0  0  0
+    3.3100   -1.1675   -2.8908 N   0  0  0  0  0  0  0  0  0  0  0  0
+    2.8358   -1.7942   -1.6373 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.5059   -0.3843   -0.3459 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.7966    0.2344   -1.5223 F   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.6904   -1.7245   -0.4953 F   0  0  0  0  0  0  0  0  0  0  0  0
+   -2.3503    0.0713    0.6196 F   0  0  0  0  0  0  0  0  0  0  0  0
+  1  2  1  0
+  2  3  1  0
+  2  9  1  0
+  3  4  1  0
+  4  8  1  0
+  4  5  1  0
+  5  6  1  0
+  6  7  1  0
+  7  8  1  0
+  9 10  1  0
+  9 11  1  0
+  9 12  1  0
+M  CHG  1   7   1
+M  END
+
+>  <SMILES_USERINPUT>
+C1CNCC1OC(C(F)(F)F)C
+
+>  <STATUS>
+OK
+
+>  <COMMENT>
+correct SMILES  3D structure successfully generated (#structures: 4; Protonation Abundance: 99.88%; Tautomerisation Abundance: 100%)
+
+>  <npr2>
+0.91831785
+
+>  <npr1>
+0.22067128
+
+>  <pmi2>
+1084.2975
+
+>  <pmi1>
+260.55609
+
+>  <pmi3>
+1180.7432
+
+>  <pmi>
+1262.7983
+
+>  <pmiY>
+167.13344
+
+>  <pmiZ>
+209.69215
+
+>  <pmiX>
+885.97278
+
+
+$$$$
\ No newline at end of file
diff --git a/Code/GraphMol/MolTransforms/MolTransforms.cpp b/Code/GraphMol/MolTransforms/MolTransforms.cpp
index 1de08edb8..f1f6ed3d5 100644
--- a/Code/GraphMol/MolTransforms/MolTransforms.cpp
+++ b/Code/GraphMol/MolTransforms/MolTransforms.cpp
@@ -59,52 +59,51 @@ RDGeom::Point3D computeCentroid(const Conformer &conf, bool ignoreHs) {
 }
 namespace {
 void computeCovarianceTerms(const Conformer &conf,
-  const RDGeom::Point3D &center,
-  double &xx, double &xy, double &xz, double &yy, double &yz, double &zz,
-  bool normalize, bool ignoreHs,
-  const std::vector<double> *weights ){
-    PRECONDITION(!weights || weights->size()>=conf.getNumAtoms(), "bad weights vector");
-
-    xx = xy = xz = yy = yz = zz = 0.0;
-    const ROMol &mol = conf.getOwningMol();
-    double wSum = 0.0;
-    for (ROMol::ConstAtomIterator cai = mol.beginAtoms();
-        cai != mol.endAtoms(); cai++) {
-      if (((*cai)->getAtomicNum() == 1) && (ignoreHs)) {
-        continue;
-      }
-      RDGeom::Point3D loc = conf.getAtomPos((*cai)->getIdx());
-      loc -= center;
-      if(weights) {
-        double w = (*weights)[(*cai)->getIdx()];
-        wSum += w;
-        loc *= w;
-      } else {
-        wSum+=1.0;
-      }
-      xx += loc.x * loc.x;
-      xy += loc.x * loc.y;
-      xz += loc.x * loc.z;
-      yy += loc.y * loc.y;
-      yz += loc.y * loc.z;
-      zz += loc.z * loc.z;
+                            const RDGeom::Point3D &center, double &xx,
+                            double &xy, double &xz, double &yy, double &yz,
+                            double &zz, bool normalize, bool ignoreHs,
+                            const std::vector<double> *weights) {
+  PRECONDITION(!weights || weights->size() >= conf.getNumAtoms(),
+               "bad weights vector");
 
+  xx = xy = xz = yy = yz = zz = 0.0;
+  const ROMol &mol = conf.getOwningMol();
+  double wSum = 0.0;
+  for (ROMol::ConstAtomIterator cai = mol.beginAtoms(); cai != mol.endAtoms();
+       cai++) {
+    if (((*cai)->getAtomicNum() == 1) && (ignoreHs)) {
+      continue;
     }
-    if (normalize) {
-      xx /= wSum;
-      xy /= wSum;
-      xz /= wSum;
-      yy /= wSum;
-      yz /= wSum;
-      zz /= wSum;
+    RDGeom::Point3D loc = conf.getAtomPos((*cai)->getIdx());
+    loc -= center;
+    double w = 1.0;
+    if (weights) {
+      w = (*weights)[(*cai)->getIdx()];
     }
+    wSum += w;
+    xx += w * loc.x * loc.x;
+    xy += w * loc.x * loc.y;
+    xz += w * loc.x * loc.z;
+    yy += w * loc.y * loc.y;
+    yz += w * loc.y * loc.z;
+    zz += w * loc.z * loc.z;
+  }
+  if (normalize) {
+    xx /= wSum;
+    xy /= wSum;
+    xz /= wSum;
+    yy /= wSum;
+    yz /= wSum;
+    zz /= wSum;
+  }
 }
 
 RDNumeric::DoubleSymmMatrix *computeCovarianceMatrix(
     const Conformer &conf, const RDGeom::Point3D &center, bool normalize,
     bool ignoreHs) {
   double xx, xy, xz, yy, yz, zz;
-  computeCovarianceTerms(conf,center,xx,xy,xz,yy,yz,zz,normalize,ignoreHs,NULL);
+  computeCovarianceTerms(conf, center, xx, xy, xz, yy, yz, zz, normalize,
+                         ignoreHs, NULL);
   RDNumeric::DoubleSymmMatrix *res = new RDNumeric::DoubleSymmMatrix(3, 3);
   res->setVal(0, 0, xx);
   res->setVal(0, 1, xy);
@@ -114,69 +113,147 @@ RDNumeric::DoubleSymmMatrix *computeCovarianceMatrix(
   res->setVal(2, 2, zz);
   return res;
 }
+
+void computeInertiaTerms(const Conformer &conf, const RDGeom::Point3D &center,
+                         double &xx, double &xy, double &xz, double &yy,
+                         double &yz, double &zz, bool ignoreHs,
+                         const std::vector<double> *weights) {
+  PRECONDITION(!weights || weights->size() >= conf.getNumAtoms(),
+               "bad weights vector");
+
+  xx = xy = xz = yy = yz = zz = 0.0;
+  const ROMol &mol = conf.getOwningMol();
+  for (ROMol::ConstAtomIterator cai = mol.beginAtoms(); cai != mol.endAtoms();
+       cai++) {
+    if (((*cai)->getAtomicNum() == 1) && (ignoreHs)) {
+      continue;
+    }
+    RDGeom::Point3D loc = conf.getAtomPos((*cai)->getIdx());
+    loc -= center;
+    double w = 1.0;
+    if (weights) {
+      w = (*weights)[(*cai)->getIdx()];
+    }
+    xx += w * (loc.y * loc.y + loc.z * loc.z);
+    yy += w * (loc.x * loc.x + loc.z * loc.z);
+    zz += w * (loc.y * loc.y + loc.x * loc.x);
+    xy -= w * loc.x * loc.y;
+    xz -= w * loc.x * loc.z;
+    yz -= w * loc.z * loc.y;
+  }
+}
 }
 #ifdef RDK_HAS_EIGEN3
 #include <Eigen/Dense>
 
-bool computePrincipalAxesAndMoments(
-    const RDKit::Conformer &conf,
-    Eigen::Matrix3d &axes,
-    Eigen::Vector3d &moments,
-    bool ignoreHs,
-    bool force,
-    const std::vector<double> *weights){
-  PRECONDITION((!weights || weights->size()>=conf.getNumAtoms()),"bad weights vector");
+bool computePrincipalAxesAndMoments(const RDKit::Conformer &conf,
+                                    Eigen::Matrix3d &axes,
+                                    Eigen::Vector3d &moments, bool ignoreHs,
+                                    bool force,
+                                    const std::vector<double> *weights) {
+  PRECONDITION((!weights || weights->size() >= conf.getNumAtoms()),
+               "bad weights vector");
   const char *axesPropName = ignoreHs ? "_principalAxes_noH" : "_principalAxes";
-  const char *momentsPropName = ignoreHs ? "_principalMoments_noH" : "_principalMoments";
-  if(!weights && !force &&
-      conf.getOwningMol().hasProp(axesPropName) &&
-      conf.getOwningMol().hasProp(momentsPropName) ){
-    conf.getOwningMol().getProp(axesPropName,axes);
-    conf.getOwningMol().getProp(momentsPropName,moments);
+  const char *momentsPropName =
+      ignoreHs ? "_principalMoments_noH" : "_principalMoments";
+  if (!weights && !force && conf.getOwningMol().hasProp(axesPropName) &&
+      conf.getOwningMol().hasProp(momentsPropName)) {
+    conf.getOwningMol().getProp(axesPropName, axes);
+    conf.getOwningMol().getProp(momentsPropName, moments);
     return true;
   }
-  const ROMol &mol=conf.getOwningMol();
-  RDGeom::Point3D origin(0,0,0);
-  double wSum=0.0;
-  for(unsigned int i=0;i<conf.getNumAtoms();++i){
-    if(ignoreHs && mol.getAtomWithIdx(i)->getAtomicNum()==1) continue;
-    double w=1.0;
-    if(weights){
-      w=(*weights)[i];
+  const ROMol &mol = conf.getOwningMol();
+  RDGeom::Point3D origin(0, 0, 0);
+  double wSum = 0.0;
+  for (unsigned int i = 0; i < conf.getNumAtoms(); ++i) {
+    if (ignoreHs && mol.getAtomWithIdx(i)->getAtomicNum() == 1) continue;
+    double w = 1.0;
+    if (weights) {
+      w = (*weights)[i];
     }
-    wSum+=w;
-    origin+=conf.getAtomPos(i)*w;
+    wSum += w;
+    origin += conf.getAtomPos(i) * w;
   }
   // std::cerr<<"  origin: "<<origin<<" "<<wSum<<std::endl;
   origin /= wSum;
 
-  double sumXX,sumXY,sumXZ,sumYY,sumYZ,sumZZ;
-  computeCovarianceTerms(conf,origin,sumXX,sumXY,sumXZ,sumYY,sumYZ,sumZZ,
-      true,ignoreHs,weights);
+  double sumXX, sumXY, sumXZ, sumYY, sumYZ, sumZZ;
+  computeInertiaTerms(conf, origin, sumXX, sumXY, sumXZ, sumYY, sumYZ, sumZZ,
+                      ignoreHs, weights);
 
   Eigen::Matrix3d mat;
-  mat << sumXX, sumXY, sumXZ,
-    sumXY, sumYY, sumYZ,
-    sumXZ, sumYZ, sumZZ;
+  mat << sumXX, sumXY, sumXZ, sumXY, sumYY, sumYZ, sumXZ, sumYZ, sumZZ;
   // std::cerr<<"  matrix: "<<mat<<std::endl;
   Eigen::SelfAdjointEigenSolver<Eigen::Matrix3d> eigensolver(mat);
-  if(eigensolver.info()!=Eigen::Success){
-    BOOST_LOG(rdErrorLog)<<"eigenvalue calculation did not converge"<<std::endl;
+  if (eigensolver.info() != Eigen::Success) {
+    BOOST_LOG(rdErrorLog) << "eigenvalue calculation did not converge"
+                          << std::endl;
     return false;
   }
 
   axes = eigensolver.eigenvectors();
   moments = eigensolver.eigenvalues();
-  if(!weights) {
-    conf.getOwningMol().setProp(axesPropName,axes, true);
-    conf.getOwningMol().setProp(momentsPropName,moments, true);
+  if (!weights) {
+    conf.getOwningMol().setProp(axesPropName, axes, true);
+    conf.getOwningMol().setProp(momentsPropName, moments, true);
+  }
+  return true;
+}
+bool computePrincipalAxesAndMomentsFromGyrationMatrix(
+    const RDKit::Conformer &conf, Eigen::Matrix3d &axes,
+    Eigen::Vector3d &moments, bool ignoreHs, bool force,
+    const std::vector<double> *weights) {
+  PRECONDITION((!weights || weights->size() >= conf.getNumAtoms()),
+               "bad weights vector");
+  const char *axesPropName =
+      ignoreHs ? "_principalAxes_noH_cov" : "_principalAxes_cov";
+  const char *momentsPropName =
+      ignoreHs ? "_principalMoments_noH_cov" : "_principalMoments_cov";
+  if (!weights && !force && conf.getOwningMol().hasProp(axesPropName) &&
+      conf.getOwningMol().hasProp(momentsPropName)) {
+    conf.getOwningMol().getProp(axesPropName, axes);
+    conf.getOwningMol().getProp(momentsPropName, moments);
+    return true;
+  }
+  const ROMol &mol = conf.getOwningMol();
+  RDGeom::Point3D origin(0, 0, 0);
+  double wSum = 0.0;
+  for (unsigned int i = 0; i < conf.getNumAtoms(); ++i) {
+    if (ignoreHs && mol.getAtomWithIdx(i)->getAtomicNum() == 1) continue;
+    double w = 1.0;
+    if (weights) {
+      w = (*weights)[i];
+    }
+    wSum += w;
+    origin += conf.getAtomPos(i) * w;
+  }
+  // std::cerr<<"  origin: "<<origin<<" "<<wSum<<std::endl;
+  origin /= wSum;
+
+  double sumXX, sumXY, sumXZ, sumYY, sumYZ, sumZZ;
+  computeCovarianceTerms(conf, origin, sumXX, sumXY, sumXZ, sumYY, sumYZ, sumZZ,
+                         true, ignoreHs, weights);
+
+  Eigen::Matrix3d mat;
+  mat << sumXX, sumXY, sumXZ, sumXY, sumYY, sumYZ, sumXZ, sumYZ, sumZZ;
+  // std::cerr<<"  matrix: "<<mat<<std::endl;
+  Eigen::SelfAdjointEigenSolver<Eigen::Matrix3d> eigensolver(mat);
+  if (eigensolver.info() != Eigen::Success) {
+    BOOST_LOG(rdErrorLog) << "eigenvalue calculation did not converge"
+                          << std::endl;
+    return false;
+  }
+
+  axes = eigensolver.eigenvectors();
+  moments = eigensolver.eigenvalues();
+  if (!weights) {
+    conf.getOwningMol().setProp(axesPropName, axes, true);
+    conf.getOwningMol().setProp(momentsPropName, moments, true);
   }
   return true;
 }
 #endif
 
-
-
 RDGeom::Transform3D *computeCanonicalTransform(const Conformer &conf,
                                                const RDGeom::Point3D *center,
                                                bool normalizeCovar,
@@ -356,8 +433,8 @@ void setBondLength(Conformer &conf, unsigned int iAtomId, unsigned int jAtomId,
   }
 }
 
-double getAngleRad(const Conformer &conf, unsigned int iAtomId, unsigned int jAtomId,
-                   unsigned int kAtomId) {
+double getAngleRad(const Conformer &conf, unsigned int iAtomId,
+                   unsigned int jAtomId, unsigned int kAtomId) {
   const RDGeom::POINT3D_VECT &pos = conf.getPositions();
   URANGE_CHECK(iAtomId, pos.size() - 1);
   URANGE_CHECK(jAtomId, pos.size() - 1);
diff --git a/Code/GraphMol/MolTransforms/MolTransforms.h b/Code/GraphMol/MolTransforms/MolTransforms.h
index 12ef23af7..c6cc8fdab 100644
--- a/Code/GraphMol/MolTransforms/MolTransforms.h
+++ b/Code/GraphMol/MolTransforms/MolTransforms.h
@@ -43,28 +43,53 @@ RDGeom::Point3D computeCentroid(const RDKit::Conformer &conf,
                                 bool ignoreHs = true);
 
 #ifdef RDK_HAS_EIGEN3
-//! Compute principal axes and moments for a conformer
+//! Compute principal axes and moments of inertia for a conformer
 /*!
+  These values are calculated from the inertia tensor:
+    Iij = - sum_{s=1..N}(w_s * r_{si} * r_{sj}) i != j
+    Iii = sum_{s=1..N} sum_{j!=i} (w_s * r_{sj} * r_{sj})
+  where the coordinates are relative to the center of mass.
+
+
   \param conf       Conformer of interest
   \param axes       used to return the principal axes
   \param  moments    used to return the principal moments
   \param ignoreHs   If true, ignore hydrogen atoms
-  \param force      If true, the calculation will be carried out even if a cached value is present
+  \param force      If true, the calculation will be carried out even if a
+  cached value is present
   \param weights    If present used to weight the atomic coordinates
 
   \returns whether or not the calculation was successful
 */
-bool computePrincipalAxesAndMoments(
-    const RDKit::Conformer &conf,
-    Eigen::Matrix3d &axes,
-    Eigen::Vector3d &moments,
-    bool ignoreHs = true,
-    bool force = false,
+bool computePrincipalAxesAndMoments(const RDKit::Conformer &conf,
+                                    Eigen::Matrix3d &axes,
+                                    Eigen::Vector3d &moments,
+                                    bool ignoreHs = false, bool force = false,
+                                    const std::vector<double> *weights = NULL);
+//! Compute principal axes and moments from the gyration matrix of a conformer
+/*!
+
+  These values are calculated from the gyration matrix/tensor:
+    Iij = sum_{s=1..N}(w_s * r_{si} * r_{sj}) i != j
+    Iii = sum_{s=1..N} sum_{t!=s}(w_s * r_{si} * r_{ti})
+  where the coordinates are relative to the center of mass.
+
+  \param conf       Conformer of interest
+  \param axes       used to return the principal axes
+  \param  moments    used to return the principal moments
+  \param ignoreHs   If true, ignore hydrogen atoms
+  \param force      If true, the calculation will be carried out even if a
+  cached value is present
+  \param weights    If present used to weight the atomic coordinates
+
+  \returns whether or not the calculation was successful
+*/
+bool computePrincipalAxesAndMomentsFromGyrationMatrix(
+    const RDKit::Conformer &conf, Eigen::Matrix3d &axes,
+    Eigen::Vector3d &moments, bool ignoreHs = false, bool force = false,
     const std::vector<double> *weights = NULL);
 #endif
 
-
-
 //! Compute the transformation require to orient the conformation
 //! along the principal axes about the center; i.e. center is made to coincide
 // with the
diff --git a/Code/GraphMol/MolTransforms/test1.cpp b/Code/GraphMol/MolTransforms/test1.cpp
index 7ec0b8917..0fd3a89f7 100644
--- a/Code/GraphMol/MolTransforms/test1.cpp
+++ b/Code/GraphMol/MolTransforms/test1.cpp
@@ -1,6 +1,5 @@
-//  $Id$
 //
-//   Copyright (C) 2003-2006 Rational Discovery LLC
+//   Copyright (C) 2003-2017 Greg Landrum and Rational Discovery LLC
 //
 //   @@ All Rights Reserved @@
 //  This file is part of the RDKit.
@@ -202,6 +201,71 @@ void testGetSetDihedral() {
   TEST_ASSERT(RDKit::feq(dihedral, -120.0));
 }
 
+#ifndef RDK_HAS_EIGEN3
+void testGithub1262() {}
+#else
+void _calcAxesAndMoments(RWMol *m, Eigen::Matrix3d &axes,
+                         Eigen::Vector3d &moments) {
+  TEST_ASSERT(m);
+  Conformer &conf = m->getConformer();
+  std::vector<double> weights;
+  weights.resize(m->getNumAtoms());
+  for (ROMol::AtomIterator cai = m->beginAtoms(); cai != m->endAtoms(); ++cai) {
+    weights[(*cai)->getIdx()] = (*cai)->getMass();
+  }
+
+  bool ignoreHs = false, force = true;
+  computePrincipalAxesAndMoments(conf, axes, moments, ignoreHs, force,
+                                 &weights);
+}
+
+void testGithub1262() {
+  std::string rdbase = getenv("RDBASE");
+  {  // a disc (benzene)
+    std::string fName =
+        rdbase + "/Code/GraphMol/MolTransforms/test_data/github1262_1.mol";
+    RWMol *m = MolFileToMol(fName, true, false);
+    TEST_ASSERT(m);
+    Eigen::Matrix3d axes;
+    Eigen::Vector3d moments;
+    _calcAxesAndMoments(m, axes, moments);
+    TEST_ASSERT((moments(2) - moments(0)) > 10.);
+    TEST_ASSERT((moments(2) - moments(1)) > 10.);
+    TEST_ASSERT((moments(1) - moments(0)) < 1e-2);
+
+    delete m;
+  }
+  {  // a rod
+    std::string fName =
+        rdbase + "/Code/GraphMol/MolTransforms/test_data/github1262_2.mol";
+    RWMol *m = MolFileToMol(fName, true, false);
+    TEST_ASSERT(m);
+    Eigen::Matrix3d axes;
+    Eigen::Vector3d moments;
+    _calcAxesAndMoments(m, axes, moments);
+    TEST_ASSERT((moments(2) - moments(0)) > 10.);
+    TEST_ASSERT((moments(2) - moments(1)) < 1e-2);
+    TEST_ASSERT((moments(1) - moments(0)) > 10);
+
+    delete m;
+  }
+  {  // adamantane
+    std::string fName =
+        rdbase + "/Code/GraphMol/MolTransforms/test_data/github1262_3.mol";
+    RWMol *m = MolFileToMol(fName, true, false);
+    TEST_ASSERT(m);
+    Eigen::Matrix3d axes;
+    Eigen::Vector3d moments;
+    _calcAxesAndMoments(m, axes, moments);
+    TEST_ASSERT((moments(2) - moments(0)) < 1e-2);
+    TEST_ASSERT((moments(2) - moments(1)) < 1e-2);
+    TEST_ASSERT((moments(1) - moments(0)) < 1e-2);
+
+    delete m;
+  }
+}
+#endif
+
 int main() {
   // test1();
   std::cout << "***********************************************************\n";
@@ -219,6 +283,9 @@ int main() {
   std::cout << "\t---------------------------------\n";
   std::cout << "\t testGetSetDihedral \n\n";
   testGetSetDihedral();
+  std::cout << "\t---------------------------------\n";
+  std::cout << "\t testGithub1262: PMI descriptors incorrect  \n\n";
+  testGithub1262();
   std::cout << "***********************************************************\n";
   return (0);
 }
diff --git a/Code/GraphMol/MolTransforms/test_data/github1262_1.mol b/Code/GraphMol/MolTransforms/test_data/github1262_1.mol
new file mode 100644
index 000000000..16c9e8041
--- /dev/null
+++ b/Code/GraphMol/MolTransforms/test_data/github1262_1.mol
@@ -0,0 +1,29 @@
+benzene
+     RDKit          3D
+
+ 12 12  0  0  0  0  0  0  0  0999 V2000
+    1.2930    0.5342    0.0022 C   0  0  0  0  0  0  0  0  0  0  0  0
+    0.1839    1.3868   -0.0124 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.1091    0.8526   -0.0146 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.2930   -0.5342   -0.0022 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -0.1839   -1.3868    0.0124 C   0  0  0  0  0  0  0  0  0  0  0  0
+    1.1091   -0.8526    0.0146 C   0  0  0  0  0  0  0  0  0  0  0  0
+    2.2934    0.9475    0.0038 H   0  0  0  0  0  0  0  0  0  0  0  0
+    0.3262    2.4598   -0.0220 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.9672    1.5122   -0.0258 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -2.2934   -0.9475   -0.0038 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -0.3262   -2.4598    0.0220 H   0  0  0  0  0  0  0  0  0  0  0  0
+    1.9672   -1.5122    0.0258 H   0  0  0  0  0  0  0  0  0  0  0  0
+  1  2  2  0
+  2  3  1  0
+  3  4  2  0
+  4  5  1  0
+  5  6  2  0
+  6  1  1  0
+  1  7  1  0
+  2  8  1  0
+  3  9  1  0
+  4 10  1  0
+  5 11  1  0
+  6 12  1  0
+M  END
diff --git a/Code/GraphMol/MolTransforms/test_data/github1262_2.mol b/Code/GraphMol/MolTransforms/test_data/github1262_2.mol
new file mode 100644
index 000000000..da33ff14f
--- /dev/null
+++ b/Code/GraphMol/MolTransforms/test_data/github1262_2.mol
@@ -0,0 +1,24 @@
+rod
+     RDKit          3D
+
+ 10  9  0  0  0  0  0  0  0  0999 V2000
+    2.0570    0.0543    0.1822 C   0  0  0  0  0  0  0  0  0  0  0  0
+    0.6002    0.0158    0.0532 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -0.6002   -0.0158   -0.0532 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -2.0570   -0.0543   -0.1822 C   0  0  0  0  0  0  0  0  0  0  0  0
+    2.3299    0.4769    1.1710 H   0  0  0  0  0  0  0  0  0  0  0  0
+    2.4635   -0.9743    0.0949 H   0  0  0  0  0  0  0  0  0  0  0  0
+    2.4830    0.6895   -0.6215 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -2.4976    0.8223    0.3359 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -2.4445   -0.9876    0.2758 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -2.3342   -0.0268   -1.2561 H   0  0  0  0  0  0  0  0  0  0  0  0
+  1  2  1  0
+  2  3  3  0
+  3  4  1  0
+  1  5  1  0
+  1  6  1  0
+  1  7  1  0
+  4  8  1  0
+  4  9  1  0
+  4 10  1  0
+M  END
diff --git a/Code/GraphMol/MolTransforms/test_data/github1262_3.mol b/Code/GraphMol/MolTransforms/test_data/github1262_3.mol
new file mode 100644
index 000000000..1273aae54
--- /dev/null
+++ b/Code/GraphMol/MolTransforms/test_data/github1262_3.mol
@@ -0,0 +1,59 @@
+adamantane
+     RDKit          3D
+
+ 26 28  0  0  0  0  0  0  0  0999 V2000
+    0.9283    1.4942   -0.2956 C   0  0  0  0  0  0  0  0  0  0  0  0
+    0.4514    1.0012    1.0893 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.0903    0.8936    1.0930 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.5432   -0.1064    0.0051 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -0.9283   -1.4942    0.2956 C   0  0  0  0  0  0  0  0  0  0  0  0
+    0.6136   -1.3898    0.2909 C   0  0  0  0  0  0  0  0  0  0  0  0
+    1.0903   -0.8936   -1.0930 C   0  0  0  0  0  0  0  0  0  0  0  0
+    0.4781    0.4950   -1.3853 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.0636    0.3881   -1.3783 C   0  0  0  0  0  0  0  0  0  0  0  0
+    1.0636   -0.3881    1.3783 C   0  0  0  0  0  0  0  0  0  0  0  0
+    2.0363    1.5911   -0.3034 H   0  0  0  0  0  0  0  0  0  0  0  0
+    0.5063    2.5015   -0.5062 H   0  0  0  0  0  0  0  0  0  0  0  0
+    0.7758    1.7206    1.8722 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.5412    1.8922    0.9023 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.4450    0.5552    2.0913 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -2.6522   -0.1829    0.0088 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.2807   -1.8667    1.2825 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.2618   -2.2258   -0.4729 H   0  0  0  0  0  0  0  0  0  0  0  0
+    1.0546   -2.3886    0.4999 H   0  0  0  0  0  0  0  0  0  0  0  0
+    2.2006   -0.8309   -1.1122 H   0  0  0  0  0  0  0  0  0  0  0  0
+    0.7856   -1.6166   -1.8813 H   0  0  0  0  0  0  0  0  0  0  0  0
+    0.8217    0.8508   -2.3808 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.5141    1.3796   -1.6044 H   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.3991   -0.3165   -2.1708 H   0  0  0  0  0  0  0  0  0  0  0  0
+    2.1735   -0.3182    1.3944 H   0  0  0  0  0  0  0  0  0  0  0  0
+    0.7397   -0.7449    2.3807 H   0  0  0  0  0  0  0  0  0  0  0  0
+  1  2  1  0
+  2  3  1  0
+  3  4  1  0
+  4  5  1  0
+  5  6  1  0
+  6  7  1  0
+  7  8  1  0
+  8  9  1  0
+  6 10  1  0
+  8  1  1  0
+  9  4  1  0
+ 10  2  1  0
+  1 11  1  0
+  1 12  1  0
+  2 13  1  0
+  3 14  1  0
+  3 15  1  0
+  4 16  1  0
+  5 17  1  0
+  5 18  1  0
+  6 19  1  0
+  7 20  1  0
+  7 21  1  0
+  8 22  1  0
+  9 23  1  0
+  9 24  1  0
+ 10 25  1  0
+ 10 26  1  0
+M  END