Index: src/Actions/FragmentationAction/CreateAdjacencyAction.cpp
===================================================================
--- src/Actions/FragmentationAction/CreateAdjacencyAction.cpp	(revision cff66ce85fbde649305dc9b561722a14ecc7a26c)
+++ src/Actions/FragmentationAction/CreateAdjacencyAction.cpp	(revision 607eab6774ab70357425ace73b68c00a831b78da)
@@ -133,6 +133,6 @@
                           ASSERT(OtherWalker,"TesselPoint that was not an atom retrieved from LinkedNode");
                           //Log() << Verbose(1) << "Checking distance " << OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size) << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
-                          range<double> MinMaxDistanceSquared(0.,0.);
-                          BG->getMinMaxDistanceSquared(Walker, OtherWalker, MinMaxDistanceSquared);
+                          const range<double> MinMaxDistanceSquared(
+                              BG->getMinMaxDistanceSquared(Walker, OtherWalker));
                           const double distance = domain.periodicDistanceSquared(OtherWalker->getPosition(),Walker->getPosition());
                           const bool status = MinMaxDistanceSquared.isInRange(distance);
Index: src/bondgraph.cpp
===================================================================
--- src/bondgraph.cpp	(revision cff66ce85fbde649305dc9b561722a14ecc7a26c)
+++ src/bondgraph.cpp	(revision 607eab6774ab70357425ace73b68c00a831b78da)
@@ -97,61 +97,63 @@
 }
 
-void BondGraph::CovalentMinMaxDistance(
+range<double> BondGraph::CovalentMinMaxDistance(
     const element * const Walker,
-    const element * const OtherWalker,
-    range<double> &MinMaxDistance) const
-{
+    const element * const OtherWalker) const
+{
+  range<double> MinMaxDistance(0.,0.);
   MinMaxDistance.first = OtherWalker->getCovalentRadius() + Walker->getCovalentRadius();
   MinMaxDistance.first *= (IsAngstroem) ? 1. : 1. / AtomicLengthToAngstroem;
   MinMaxDistance.last = MinMaxDistance.first + BondThreshold;
   MinMaxDistance.first -= BondThreshold;
-}
-
-void BondGraph::BondLengthMatrixMinMaxDistance(
+  return MinMaxDistance;
+}
+
+range<double> BondGraph::BondLengthMatrixMinMaxDistance(
     const element * const Walker,
-    const element * const OtherWalker,
-    range<double> &MinMaxDistance) const
+    const element * const OtherWalker) const
 {
   ASSERT(BondLengthMatrix, "BondGraph::BondLengthMatrixMinMaxDistance() called without NULL BondLengthMatrix.");
   ASSERT(Walker, "BondGraph::BondLengthMatrixMinMaxDistance() - illegal element given.");
   ASSERT(OtherWalker, "BondGraph::BondLengthMatrixMinMaxDistance() - illegal other element given.");
+  range<double> MinMaxDistance(0.,0.);
   MinMaxDistance.first = GetBondLength(Walker->getAtomicNumber()-1, OtherWalker->getAtomicNumber()-1);
   MinMaxDistance.first *= (IsAngstroem) ? 1. : 1. / AtomicLengthToAngstroem;
   MinMaxDistance.last = MinMaxDistance.first + BondThreshold;
   MinMaxDistance.first -= BondThreshold;
-}
-
-void BondGraph::getMinMaxDistance(
+  return MinMaxDistance;
+}
+
+range<double> BondGraph::getMinMaxDistance(
     const element * const Walker,
-    const element * const OtherWalker,
-    range<double> &MinMaxDistance) const
-{
+    const element * const OtherWalker) const
+{
+  range<double> MinMaxDistance(0.,0.);
   if (BondLengthMatrix == NULL) {// safety measure if no matrix has been parsed yet
     LOG(2, "INFO: Using Covalent radii criterion for [min,max) distances.");
-    CovalentMinMaxDistance(Walker, OtherWalker, MinMaxDistance);
+    MinMaxDistance = CovalentMinMaxDistance(Walker, OtherWalker);
   } else {
     LOG(2, "INFO: Using Covalent radii criterion for [min,max) distances.");
-    BondLengthMatrixMinMaxDistance(Walker, OtherWalker, MinMaxDistance);
-  }
-}
-
-void BondGraph::getMinMaxDistance(
+    MinMaxDistance = BondLengthMatrixMinMaxDistance(Walker, OtherWalker);
+  }
+  return MinMaxDistance;
+}
+
+range<double> BondGraph::getMinMaxDistance(
     const BondedParticle * const Walker,
-    const BondedParticle * const OtherWalker,
-    range<double> &MinMaxDistance) const
-{
-  getMinMaxDistance(Walker->getType(), OtherWalker->getType(),MinMaxDistance);
-}
-
-void BondGraph::getMinMaxDistanceSquared(
+    const BondedParticle * const OtherWalker) const
+{
+  return getMinMaxDistance(Walker->getType(), OtherWalker->getType());
+}
+
+range<double> BondGraph::getMinMaxDistanceSquared(
     const BondedParticle * const Walker,
-    const BondedParticle * const OtherWalker,
-    range<double> &MinMaxDistance) const
+    const BondedParticle * const OtherWalker) const
 {
   // use non-squared version
-  getMinMaxDistance(Walker, OtherWalker,MinMaxDistance);
+  range<double> MinMaxDistance(getMinMaxDistance(Walker, OtherWalker));
   // and square
   MinMaxDistance.first *= MinMaxDistance.first;
   MinMaxDistance.last *= MinMaxDistance.last;
+  return MinMaxDistance;
 }
 
@@ -189,6 +191,6 @@
                         ASSERT(OtherWalker != NULL,
                             "BondGraph::CreateAdjacency() - TesselPoint that was not an atom retrieved from LinkedNode");
-                        range<double> MinMaxDistanceSquared(0.,0.);
-                        getMinMaxDistanceSquared(Walker, OtherWalker, MinMaxDistanceSquared);
+                        const range<double> MinMaxDistanceSquared(
+                            getMinMaxDistanceSquared(Walker, OtherWalker));
                         const double distance = domain.periodicDistanceSquared(OtherWalker->getPosition(),Walker->getPosition());
                         LOG(2, "INFO: Checking squared distance " << distance << " against typical bond length of " << MinMaxDistanceSquared << ".");
Index: src/bondgraph.hpp
===================================================================
--- src/bondgraph.hpp	(revision cff66ce85fbde649305dc9b561722a14ecc7a26c)
+++ src/bondgraph.hpp	(revision 607eab6774ab70357425ace73b68c00a831b78da)
@@ -92,6 +92,5 @@
           otheriter != PresentElements.end();
           ++otheriter) {
-        range<double> MinMaxDistance(0.,0.);
-        getMinMaxDistance((*iter),(*otheriter), MinMaxDistance);
+        const range<double> MinMaxDistance(getMinMaxDistance((*iter),(*otheriter)));
         if (MinMaxDistance.last > max_distance)
           max_distance = MinMaxDistance.last;
@@ -105,10 +104,9 @@
    * \param *Walker first BondedParticle
    * \param *OtherWalker second BondedParticle
-   * \param &MinMaxDistance Range for interval on return
-   */
-  void getMinMaxDistance(
+   * \return Range with bond interval
+   */
+  range<double> getMinMaxDistance(
       const BondedParticle * const Walker,
-      const BondedParticle * const OtherWalker,
-      range<double> &MinMaxDistance) const;
+      const BondedParticle * const OtherWalker) const;
 
   /** Returns SQUARED bond criterion for given pair based on a bond length matrix.
@@ -117,10 +115,9 @@
    * \param *Walker first BondedParticle
    * \param *OtherWalker second BondedParticle
-   * \param &MinMaxDistance Range for interval on return
-   */
-  void getMinMaxDistanceSquared(
+   * \return Range with bond interval
+   */
+  range<double> getMinMaxDistanceSquared(
       const BondedParticle * const Walker,
-      const BondedParticle * const OtherWalker,
-      range<double> &MinMaxDistance) const;
+      const BondedParticle * const OtherWalker) const;
 
   /** Creates the adjacency list for a given \a Range of iterable atoms.
@@ -319,10 +316,9 @@
    * \param *Walker first BondedParticle
    * \param *OtherWalker second BondedParticle
-   * \param &MinMaxDistance Range for interval on return
-   */
-  void getMinMaxDistance(
+   * \return Range with bond interval
+   */
+  range<double> getMinMaxDistance(
       const element * const Walker,
-      const element * const OtherWalker,
-      range<double> &MinMaxDistance) const;
+      const element * const OtherWalker) const;
 
   /** Returns bond criterion for given pair of elements based on a bond length matrix.
@@ -331,20 +327,18 @@
    * \param *Walker first element
    * \param *OtherWalker second element
-   * @param MinMaxDistance reference to range type set on return
-   */
-  void BondLengthMatrixMinMaxDistance(
+   * \return Range with bond interval
+   */
+  range<double> BondLengthMatrixMinMaxDistance(
       const element * const Walker,
-      const element * const OtherWalker,
-      range<double> &MinMaxDistance) const;
+      const element * const OtherWalker) const;
 
   /** Returns bond criterion for given pair of elements based on covalent radius.
    * \param *Walker first element
    * \param *OtherWalker second element
-   * @param MinMaxDistance reference to range type set on return
-   */
-  void CovalentMinMaxDistance(
+   * \return Range with bond interval
+   */
+  range<double> CovalentMinMaxDistance(
       const element * const Walker,
-      const element * const OtherWalker,
-      range<double> &MinMaxDistance) const;
+      const element * const OtherWalker) const;
 
 
Index: src/molecule.cpp
===================================================================
--- src/molecule.cpp	(revision cff66ce85fbde649305dc9b561722a14ecc7a26c)
+++ src/molecule.cpp	(revision 607eab6774ab70357425ace73b68c00a831b78da)
@@ -344,7 +344,7 @@
    // the problem is not the H being out of the box, but InBondvector have the wrong direction
    // due to TopReplacement or Origin being on the wrong side!
-  range<double> MinMaxBondDistance(0.,0.);
   const BondGraph * const BG = World::getInstance().getBondGraph();
-  BG->getMinMaxDistance(TopOrigin,TopReplacement,MinMaxBondDistance);
+  const range<double> MinMaxBondDistance(
+      BG->getMinMaxDistance(TopOrigin,TopReplacement));
   if (!MinMaxBondDistance.isInRange(bondlength)) {
 //    Log() << Verbose(4) << "InBondvector is: ";
Index: src/molecule_fragmentation.cpp
===================================================================
--- src/molecule_fragmentation.cpp	(revision cff66ce85fbde649305dc9b561722a14ecc7a26c)
+++ src/molecule_fragmentation.cpp	(revision 607eab6774ab70357425ace73b68c00a831b78da)
@@ -1811,6 +1811,6 @@
           tmp = fabs(Binder->leftatom->at(i) - Binder->rightatom->at(i));
           //Log() << Verbose(3) << "Checking " << i << "th distance of " << *Binder->leftatom << " to " << *Binder->rightatom << ": " << tmp << "." << endl;
-          range<double> MinMaxDistance(0.,0.);
-          BG->getMinMaxDistance(Binder->leftatom, Binder->rightatom, MinMaxDistance);
+          const range<double> MinMaxDistance(
+              BG->getMinMaxDistance(Binder->leftatom, Binder->rightatom));
           if (!MinMaxDistance.isInRange(tmp)) {
             DoLog(2) && (Log() << Verbose(2) << "Correcting at bond " << *Binder << "." << endl);
@@ -1826,6 +1826,6 @@
       for (int i=NDIM;i--;) {
         tmp = Binder->leftatom->at(i) - Binder->rightatom->at(i);
-        range<double> MinMaxDistance(0.,0.);
-        BG->getMinMaxDistance(Binder->leftatom, Binder->rightatom, MinMaxDistance);
+        const range<double> MinMaxDistance(
+            BG->getMinMaxDistance(Binder->leftatom, Binder->rightatom));
         if (fabs(tmp) > MinMaxDistance.last)  // check against Min is not useful for components
           Translationvector[i] = (tmp < 0) ? +1. : -1.;
Index: src/molecule_geometry.cpp
===================================================================
--- src/molecule_geometry.cpp	(revision cff66ce85fbde649305dc9b561722a14ecc7a26c)
+++ src/molecule_geometry.cpp	(revision 607eab6774ab70357425ace73b68c00a831b78da)
@@ -393,6 +393,6 @@
             for (int j=0;j<NDIM;j++) {
               tmp = (*iter)->at(j) - (*Runner)->GetOtherAtom(*iter)->at(j);
-              range<double> MinMaxBondDistance(0.,0.);
-              BG->getMinMaxDistance((*iter), (*Runner)->GetOtherAtom(*iter), MinMaxBondDistance);
+              const range<double> MinMaxBondDistance(
+                  BG->getMinMaxDistance((*iter), (*Runner)->GetOtherAtom(*iter)));
               if (fabs(tmp) > MinMaxBondDistance.last) {  // check against Min is not useful for components
                 flag = false;
