X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=flower%2Finclude%2Finterval.hh;h=045b10389e7df10655d5ac88b702d0ef540759d2;hb=f74485aafac3d2435e99a84fd4de8a70031d343f;hp=e02a7495a8fbeb8f4e794e545d4c10a176e812a7;hpb=8f58f4428d70961938e9151097886d861b3faeb3;p=lilypond.git diff --git a/flower/include/interval.hh b/flower/include/interval.hh index e02a7495a8..045b10389e 100644 --- a/flower/include/interval.hh +++ b/flower/include/interval.hh @@ -1,119 +1,162 @@ /* interval.hh -- part of flowerlib - - (c) 1996 Han-Wen Nienhuys + + (c) 1996--2007 Han-Wen Nienhuys */ #ifndef INTERVAL_HH #define INTERVAL_HH -#include -#include "fproto.hh" -#include "real.hh" +#include + +#include "flower-proto.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. - - */ +/* 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. */ template -struct Interval_t : public Drul_array { +struct Interval_t : public Drul_array +{ + Drul_array::at; - /* ************** */ - - 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; void translate (T t) - { - elem (LEFT) += t; - elem (RIGHT) += t; - } - + { + at (LEFT) += t; + at (RIGHT) += t; + } + void widen (T t) + { + at (LEFT) -= t; + at (RIGHT) += t; + } + + T distance (T t) const + { + if (t > at (RIGHT)) + return T (t - at (RIGHT)); + else if (t < at (LEFT)) + return T (at (LEFT) - t); + else + return T (0); + } /** - PRE - *this and h are comparable - */ + PRE + *this and h are comparable + */ void unite (Interval_t h); void intersect (Interval_t h); + void add_point (T p) + { + at (LEFT) = min (at (LEFT), p); + at (RIGHT) = max (at (RIGHT), p); + } + T length () const; + T delta () const; + void set_empty (); + void set_full (); + + bool is_empty () const + { + return at (LEFT) > at (RIGHT); + } + bool superset (Interval_t const &) const; + Interval_t () + { + set_empty (); + } + Interval_t (Drul_array const &src) + : Drul_array (src) + { + } - T length() const; - void set_empty() ; - bool empty_b() const { return elem (LEFT) > elem (RIGHT); } - bool contains_b (Interval_t const&) const; - Interval_t() { - set_empty(); + Interval_t (T m, T M) : Drul_array (m, M) + { } - Interval_t (T m, T M) : Drul_array (m,M) - {} - Interval_t &operator -= (T r) { + Interval_t &operator -= (T r) + { *this += -r; return *this; } - Interval_t &operator += (T r) { - elem (LEFT) += r; - elem (RIGHT) +=r; + Interval_t &operator += (T r) + { + at (LEFT) += r; + at (RIGHT) += r; return *this; } - Interval_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 &operator *= (T r) + { + if (!is_empty ()) + { + at (LEFT) *= r; + at (RIGHT) *= r; + if (r < T (0)) + swap (); + } return *this; } - String str() const; - void print () const; - bool elem_b (T r); - void negate () { - T r = -elem (LEFT); - T l = -elem (RIGHT); - elem (LEFT) = l; - elem (RIGHT) =r; + + Real linear_combination (Real x) const; + string to_string () const; + + bool contains (T r) const; + void negate () + { + T r = -at (LEFT); + T l = -at (RIGHT); + at (LEFT) = l; + at (RIGHT) = r; } -}; + void swap () + { + T t = at (LEFT); + at (LEFT) = at (RIGHT); + at (RIGHT) = t; + } + + static bool left_less (Interval_t const &a, Interval_t const &b) + { + return a[LEFT] < b[RIGHT]; + } +}; /** - inclusion ordering. Crash if not comparable. - */ + inclusion ordering. Crash if not comparable. +*/ template -int Interval__compare (const Interval_t&,Interval_t const&); +int Interval__compare (const Interval_t &, Interval_t const &); /** Inclusion ordering. return -2 if not comparable - */ +*/ template int -_Interval__compare (const Interval_t&a,Interval_t const&b); - +_Interval__compare (const Interval_t &a, Interval_t const &b); /* INLINE - */ +*/ #include "compare.hh" -TEMPLATE_INSTANTIATE_COMPARE(Interval_t&, Interval__compare, template); - +TEMPLATE_INSTANTIATE_COMPARE (Interval_t &, Interval__compare, template); template inline Interval_t -intersection (Interval_t a, Interval_t const&b) +intersection (Interval_t a, Interval_t const &b) { a.intersect (b); return a; - } template inline -Interval_t operator +(T a,Interval_t i) +Interval_t operator + (T a, Interval_t i) { i += a; return i; @@ -129,7 +172,7 @@ Interval_t operator - (Interval_t i, T a) template inline -Interval_t operator - (T a,Interval_t i) +Interval_t operator - (T a, Interval_t i) { i.negate (); i += a; @@ -138,13 +181,14 @@ Interval_t operator - (T a,Interval_t i) template inline -Interval_t operator +(Interval_t i,T a){ - return a+i; +Interval_t operator + (Interval_t i, T a) +{ + return a + i; } template inline -Interval_t operator *(T a,Interval_t i) +Interval_t operator * (T a, Interval_t i) { i *= a; return i; @@ -152,11 +196,19 @@ Interval_t operator *(T a,Interval_t i) template inline -Interval_t operator *(Interval_t i,T a){ - return a*i; +Interval_t operator * (Interval_t i, T a) +{ + return a * i; +} + +template +inline T +Interval_t::center () const +{ + assert (!is_empty ()); + return (at (LEFT) + at (RIGHT)) / T (2); } -// again? see fproto.hh typedef Interval_t Interval; typedef Interval_t Slice; // weird name