refactor the division/quantisation helpers

...no need to keep them in util.hpp, as they
are used rather occasionally, while util.hpp
is used pervasively.

src/lib/time.cpp

@@ -22,7 +22,7 @@
 
 #include "lib/time.h"
 #include "lib/error.hpp"
-#include "lib/util.hpp"
+#include "lib/util-quant.hpp"
 
 extern "C" {
 #include "lib/tmpbuf.h"

src/lib/time/mutation.cpp

@@ -27,6 +27,7 @@
 #include "lib/time/timecode.hpp"
 #include "lib/time/mutation.hpp"
 //#include "lib/time.h"
+#include "lib/util-quant.hpp"
 #include "lib/util.hpp"
 
 //#include <tr1/functional>

src/lib/time/timecode.cpp

@@ -27,6 +27,7 @@
 #include "lib/time/formats.hpp"
 #include "lib/time.h"
 #include "lib/util.hpp"
+#include "lib/util-quant.hpp"
 
 #include <tr1/functional>
 #include <boost/regex.hpp>

src/lib/util-quant.hpp

@@ -0,0 +1,119 @@
+/*
+  UTIL-QUANT.hpp  -  helper functions to deal with division and quantisation
+
+  Copyright (C)         Lumiera.org
+    2011,               Hermann Vosseler <Ichthyostega@web.de>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of
+  the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+
+#ifndef LIB_UTIL_QUANT_H
+#define LIB_UTIL_QUANT_H
+
+#include <cstdlib>
+
+
+
+namespace util {
+  
+  
+  /** helper to treat int or long division uniformly */
+  template<typename I>
+  struct IDiv
+    {
+      I quot;
+      I rem;
+      
+      IDiv (I num, I den)
+        : quot(num/den)
+        , rem(num - quot*den)
+        { }
+    };
+  
+  template<>
+  struct IDiv<int>
+    : div_t
+    {
+      IDiv<int> (int num, int den)
+        : div_t(div (num,den))
+        { }
+    };
+  
+  template<>
+  struct IDiv<long>
+    : ldiv_t
+    {
+      IDiv<long> (long num, long den)
+        : ldiv_t(ldiv (num,den))
+        { }
+    };
+  
+  template<>
+  struct IDiv<long long>
+    : lldiv_t
+    {
+      IDiv<long long> (long long num, long long den)
+        : lldiv_t(lldiv (num,den))
+        { }
+    };
+  
+  
+  /** floor function for integer arithmetics.
+   *  Unlike the built-in integer division, this function
+   *  always rounds towards the next \em smaller integer,
+   *  even for negative numbers.
+   * @warning floor on doubles performs way better
+   * @see UtilFloordiv_test
+   */
+  template<typename I>
+  inline I
+  floordiv (I num, I den)
+  {
+    if (0 < (num^den))
+      return num/den;
+    else
+      { // truncate similar to floor()
+        IDiv<I> res(num,den);
+        return (res.rem)? res.quot-1   // negative results truncated towards next smaller int
+                        : res.quot;   //..unless the division result not truncated at all
+      }
+  }
+  
+  /** scale wrapping operation.
+   *  Quantises the numerator value into the scale given by the denominator.
+   *  Unlike the built-in integer division, this function always rounds towards
+   *  the next \em smaller integer and also relates the remainder (=modulo) to
+   *  this next lower scale grid point.
+   * @return quotient and remainder packed into a struct
+   * @see UtilFloorwarp_test
+   */
+  template<typename I>
+  inline IDiv<I>
+  floorwrap (I num, I den)
+  {
+    IDiv<I> res(num,den);
+    if (0 > (num^den) && res.rem)
+      {  // negative results
+        //  wrapped similar to floor()
+        --res.quot;
+        res.rem = den - (-res.rem);
+      }
+    return res;
+  }
+  
+} // namespace util
+#endif /*UTIL_QUANT_H*/

src/lib/util.hpp

@@ -21,8 +21,8 @@
 */
 
 
-#ifndef UTIL_HPP_
-#define UTIL_HPP_
+#ifndef LIB_UTIL_H
+#define LIB_UTIL_H
 
 #include <set>
 #include <string>
@@ -57,90 +57,6 @@ namespace util {
   }
   
   
-  /** helper to treat int or long division uniformly */
-  template<typename I>
-  struct IDiv
-    {
-      I quot;
-      I rem;
-      
-      IDiv (I num, I den)
-        : quot(num/den)
-        , rem(num - quot*den)
-        { }
-    };
-  
-  template<>
-  struct IDiv<int>
-    : div_t
-    {
-      IDiv<int> (int num, int den)
-        : div_t(div (num,den))
-        { }
-    };
-  
-  template<>
-  struct IDiv<long>
-    : ldiv_t
-    {
-      IDiv<long> (long num, long den)
-        : ldiv_t(ldiv (num,den))
-        { }
-    };
-  
-  template<>
-  struct IDiv<long long>
-    : lldiv_t
-    {
-      IDiv<long long> (long long num, long long den)
-        : lldiv_t(lldiv (num,den))
-        { }
-    };
-  
-  
-  /** floor function for integer arithmetics.
-   *  Unlike the built-in integer division, this function
-   *  always rounds towards the next \em smaller integer,
-   *  even for negative numbers.
-   * @warning floor on doubles performs way better
-   * @see UtilFloordiv_test
-   */
-  template<typename I>
-  inline I
-  floordiv (I num, I den)
-  {
-    if (0 < (num^den))
-      return num/den;
-    else
-      { // truncate similar to floor()
-        IDiv<I> res(num,den);
-        return (res.rem)? res.quot-1   // negative results truncated towards next smaller int
-                        : res.quot;   //..unless the division result not truncated at all
-      }
-  }
-  
-  /** scale wrapping operation.
-   *  Quantises the numerator value into the scale given by the denominator.
-   *  Unlike the built-in integer division, this function always rounds towards
-   *  the next \em smaller integer and also relates the remainder (=modulo) to
-   *  this next lower scale grid point.
-   * @return quotient and remainder packed into a struct
-   * @see UtilFloorwarp_test
-   */
-  template<typename I>
-  inline IDiv<I>
-  floorwrap (I num, I den)
-  {
-    IDiv<I> res(num,den);
-    if (0 > (num^den) && res.rem)
-      {  // negative results
-        //  wrapped similar to floor()
-        --res.quot;
-        res.rem = den - (-res.rem);
-      }
-    return res;
-  }
-  
   
   /*  ======== generic empty check =========  */
   

tests/lib/util-floordiv-test.cpp

@@ -22,6 +22,7 @@
 
 
 #include "lib/test/run.hpp"
+#include "lib/util-quant.hpp"
 #include "lib/util.hpp"
 
 #include <cmath>

tests/lib/util-floorwrap-test.cpp

@@ -23,7 +23,7 @@
 
 #include "lib/test/run.hpp"
 #include "lib/test/test-helper.hpp"
-#include "lib/util.hpp"
+#include "lib/util-quant.hpp"
 
 #include <cmath>
 #include <iostream>
@@ -36,6 +36,7 @@ using std::endl;
 using boost::format;
 using boost::lexical_cast;
 using lib::test::showType;
+using util::floorwrap;
 
 
 namespace util {