2003 -> 2004

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

diff --git a/flower/include/interval.hh b/flower/include/interval.hh
index e02a7495a8fbeb8f4e794e545d4c10a176e812a7..be5f560d7e1e3bd17d1d76141b5a8f0a4f15eac5 100644 (file)
--- a/flower/include/interval.hh
+++ b/flower/include/interval.hh
@@ -1,20 +1,20 @@
 /*
   interval.hh -- part of flowerlib
   
-  (c) 1996 Han-Wen Nienhuys
+  (c) 1996--2004 Han-Wen Nienhuys
 */
 
 #ifndef INTERVAL_HH
 #define INTERVAL_HH
 
 #include <assert.h> 
-#include "fproto.hh"
+#include "flower-proto.hh"
 #include "real.hh"
 #include "drul-array.hh"
 
 /** a T interval.  this represents the closed interval [left,right].
   No invariants. T must be a totally ordered ring (with division, anyway ..)
-  At instantiation, the function infinity() has to be defined explicitely.
+  At instantiation, the function infinity () has to be defined explicitely.
   
   */
 template<class T>
@@ -22,14 +22,22 @@ struct Interval_t : public Drul_array<T> {
 
   /* ************** */
     
-  static T infinity() ;
-  static String T_to_str (T arg);
-  T center() { return (elem (LEFT) + elem (RIGHT)) / T(2);}
+  static T infinity () ;
+  static String T_to_string (T arg);
+  T center () const {
+    assert (!is_empty ());
+    return (elem (LEFT) + elem (RIGHT)) / T (2);
+  }
   void translate (T t)
     {
       elem (LEFT) += t;
       elem (RIGHT) += t;
     }
+  void widen (T t)
+  {
+    elem (LEFT) -= t;
+    elem (RIGHT) += t;    
+  }
   
   /**
     PRE
@@ -37,16 +45,26 @@ struct Interval_t : public Drul_array<T> {
     */
   void unite (Interval_t<T> h);
   void intersect (Interval_t<T> h);
-
-  T length() const;
-  void set_empty() ;
-  bool empty_b() const { return elem (LEFT) > elem (RIGHT); }
+  void add_point (T p) {
+    elem(LEFT) = elem (LEFT) <? p;
+    elem(RIGHT) = elem (RIGHT) >? p;
+  }
+  T length () const;
+  T delta () const;
+  void set_empty () ;
+  void set_full ();
+
+  /*
+    TODO: strip hungarian suffix.
+   */
+  bool is_empty () const { return elem (LEFT) > elem (RIGHT); }
   bool contains_b (Interval_t<T> const&) const;
-  Interval_t() {
-    set_empty();
+  Interval_t () {
+    set_empty ();
   }
   Interval_t (T m, T M) : Drul_array<T> (m,M)
-    {}
+    {
+    }
   Interval_t<T> &operator -= (T r) {
     *this += -r;
     return *this;
@@ -57,25 +75,39 @@ struct Interval_t : public Drul_array<T> {
     elem (RIGHT) +=r;
     return *this;
   }
-  Interval_t<T> &operator *=(T r) {
-    elem (LEFT) *= r;
-    elem (RIGHT) *= r;
-    if (r < T(0)) {
-      T t = elem (LEFT);
-      elem (LEFT) = elem (RIGHT);
-      elem (RIGHT) = t;
-    }
+  Interval_t<T> &operator *= (T r) {
+    if (!is_empty ())
+      {
+       elem (LEFT) *= r;
+       elem (RIGHT) *= r;
+       if (r < T (0))
+         swap();
+
+      }
     return *this;
   }
-  String str() const;    
-  void print () const;
-  bool elem_b (T r);
+
+  Real linear_combination (Real x) const {
+    Drul_array<Real> da (elem (LEFT),
+                        elem (RIGHT));
+    return ::linear_combination (da, x);
+  }
+  String to_string () const;    
+
+  bool contains (T r);
   void negate () {
     T r = -elem (LEFT);
     T l = -elem (RIGHT);
     elem (LEFT) = l;
     elem (RIGHT) =r;
   }
+  
+  void swap ()
+  {
+    T t = elem (LEFT);
+    elem (LEFT) = elem (RIGHT);
+    elem (RIGHT) = t;
+  }
 };
 
 
@@ -99,7 +131,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>
@@ -113,7 +145,7 @@ intersection (Interval_t<T> a, Interval_t<T> const&b)
 
 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;
@@ -138,13 +170,13 @@ 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;
@@ -152,11 +184,11 @@ 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;
 }
 
-// again? see fproto.hh
+// again? see flower-proto.hh
 typedef Interval_t<Real> Interval;
 typedef Interval_t<int> Slice; // weird name