* The grand 2005-2006 replace.

[lilypond.git] / flower / include / interval.hh

diff --git a/flower/include/interval.hh b/flower/include/interval.hh
index 3c319cf9d34fe67d289d3fd5e9fed4f9045e0112..9190f28544597f53664f78815f7b753a6a97fb21 100644 (file)
--- a/flower/include/interval.hh
+++ b/flower/include/interval.hh
@@ -1,12 +1,14 @@
 /*
   interval.hh -- part of flowerlib
 
-  (c) 1996--2005 Han-Wen Nienhuys
+  (c) 1996--2006 Han-Wen Nienhuys
 */
 
 #ifndef INTERVAL_HH
 #define INTERVAL_HH
 
+#include <math.h>
+
 #include "flower-proto.hh"
 #include "drul-array.hh"
 
@@ -50,8 +52,8 @@ struct Interval_t : public Drul_array<T>
   void intersect (Interval_t<T> h);
   void add_point (T p)
   {
-    elem_ref (LEFT) = elem (LEFT) <? p;
-    elem_ref (RIGHT) = elem (RIGHT) >? p;
+    elem_ref (LEFT) = min (elem (LEFT), p);
+    elem_ref (RIGHT) = max (elem (RIGHT), p);
   }
   T length () const;
   T delta () const;
@@ -70,22 +72,27 @@ struct Interval_t : public Drul_array<T>
   {
     set_empty ();
   }
+  Interval_t (Drul_array<T> const &src)
+    : Drul_array<T> (src)
+  {
+  }
+
   Interval_t (T m, T M) : Drul_array<T> (m, M)
   {
   }
-  Interval_t<T> &operator-= (T r)
+  Interval_t<T> &operator -= (T r)
   {
     *this += -r;
     return *this;
   }
 
-  Interval_t<T> &operator+= (T r)
+  Interval_t<T> &operator += (T r)
   {
     elem_ref (LEFT) += r;
-    elem_ref (RIGHT) +=r;
+    elem_ref (RIGHT) += r;
     return *this;
   }
-  Interval_t<T> &operator*= (T r)
+  Interval_t<T> &operator *= (T r)
   {
     if (!is_empty ())
       {
@@ -93,7 +100,6 @@ struct Interval_t : public Drul_array<T>
        elem_ref (RIGHT) *= r;
        if (r < T (0))
          swap ();
-
       }
     return *this;
   }
@@ -105,13 +111,13 @@ struct Interval_t : public Drul_array<T>
   }
   String to_string () const;
 
-  bool contains (T r);
+  bool contains (T r) const;
   void negate ()
   {
     T r = -elem (LEFT);
     T l = -elem (RIGHT);
     elem_ref (LEFT) = l;
-    elem_ref (RIGHT) =r;
+    elem_ref (RIGHT) = r;
   }
 
   void swap ()
@@ -120,20 +126,25 @@ struct Interval_t : public Drul_array<T>
     elem_ref (LEFT) = elem (RIGHT);
     elem_ref (RIGHT) = t;
   }
+
+  static int left_comparison (Interval_t<T> const &a, Interval_t<T> const &b)
+  {
+    return sign (a[LEFT] - b[RIGHT]);
+  }
 };
 
 /**
    inclusion ordering. Crash if not  comparable.
 */
 template<class T>
-int Interval__compare (const Interval_t<T>&, Interval_t<T> const &);
+int Interval__compare (const Interval_t<T> &, Interval_t<T> const &);
 
 /**
    Inclusion ordering.  return -2 if not comparable
 */
 template<class T>
 int
-_Interval__compare (const Interval_t<T>&a, Interval_t<T> const &b);
+_Interval__compare (const Interval_t<T> &a, Interval_t<T> const &b);
 
 /*
   INLINE
@@ -141,7 +152,7 @@ _Interval__compare (const Interval_t<T>&a, Interval_t<T> const &b);
 
 #include "compare.hh"
 
-TEMPLATE_INSTANTIATE_COMPARE (Interval_t<T>&, Interval__compare, template<class T>);
+TEMPLATE_INSTANTIATE_COMPARE (Interval_t<T> &, Interval__compare, template<class T>);
 
 template<class T>
 inline Interval_t<T>
@@ -149,12 +160,11 @@ intersection (Interval_t<T> a, Interval_t<T> const &b)
 {
   a.intersect (b);
   return a;
-
 }
 
 template<class T>
 inline
-Interval_t<T> operator+ (T a, Interval_t<T> i)
+Interval_t<T> operator + (T a, Interval_t<T> i)
 {
   i += a;
   return i;
@@ -162,7 +172,7 @@ Interval_t<T> operator+ (T a, Interval_t<T> i)
 
 template<class T>
 inline
-Interval_t<T> operator- (Interval_t<T> i, T a)
+Interval_t<T> operator - (Interval_t<T> i, T a)
 {
   i += -a;
   return i;
@@ -170,7 +180,7 @@ Interval_t<T> operator- (Interval_t<T> i, T a)
 
 template<class T>
 inline
-Interval_t<T> operator- (T a, Interval_t<T> i)
+Interval_t<T> operator - (T a, Interval_t<T> i)
 {
   i.negate ();
   i += a;
@@ -179,14 +189,14 @@ Interval_t<T> operator- (T a, Interval_t<T> i)
 
 template<class T>
 inline
-Interval_t<T> operator+ (Interval_t<T> i, T a)
+Interval_t<T> operator + (Interval_t<T> i, T a)
 {
   return a + i;
 }
 
 template<class T>
 inline
-Interval_t<T> operator* (T a, Interval_t<T> i)
+Interval_t<T> operator * (T a, Interval_t<T> i)
 {
   i *= a;
   return i;
@@ -194,9 +204,9 @@ Interval_t<T> operator* (T a, Interval_t<T> i)
 
 template<class T>
 inline
-Interval_t<T> operator* (Interval_t<T> i, T a)
+Interval_t<T> operator * (Interval_t<T> i, T a)
 {
-  return a*i;
+  return a * i;
 }
 
 template<class T>
@@ -207,7 +217,6 @@ Interval_t<T>::center () const
   return (elem (LEFT) + elem (RIGHT)) / T (2);
 }
 
-// again? see flower-proto.hh
 typedef Interval_t<Real> Interval;
 typedef Interval_t<int> Slice; // weird name