release: 1.3.4

[lilypond.git] / lily / misc.cc

diff --git a/lily/misc.cc b/lily/misc.cc
index 5ee56d8045d50d573af86298729445659663e40d..3f1f2ad949fb052023c6a682e44e1a3cc4bf1d3a 100644 (file)
--- a/lily/misc.cc
+++ b/lily/misc.cc
@@ -3,43 +3,118 @@
 
   source file of the GNU LilyPond music typesetter
 
-  (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+  (c)  1997--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+    Jan Nieuwenhuizen <janneke@gnu.org>
 */
 
 #include <math.h>
 
-#include "item.hh"
 #include "misc.hh"
-#include "moment.hh"
+
+#ifndef STANDALONE
+#include "item.hh"
+#endif
 
 int
 intlog2(int d) {
-    int i=0;
-    while (!(d&1)) {
+  int i=0;
+  while (!(d&1)) 
+    {
        d/= 2;
        i++;
     }
-    assert(!(d/2));
-    return i;
+  assert (!(d/2));
+  return i;
 }
 
 double
 log_2(double x) {
-    return log(x)  /log(2.0);
+  return log (x)  /log (2.0);
 }
 
-#if 1
+#ifndef STANDALONE
 Interval
-itemlist_width(const Array<Item*> &its)
+itemlist_width (const Array<Item*> &its)
 {
-    Interval iv ;
-    iv.set_empty();
-     
-    for (int j =0; j < its.size(); j++){
-       iv.unite (its[j]->width());
+  Interval iv ;
+  iv.set_empty();
+   
+  for (int j =0; j < its.size(); j++)
+    {
+       iv.unite (its[j]->extent (X_AXIS));
 
     }
-    return iv;
+  return iv;
 }
 
 #endif
+
+
+/*
+  TODO
+    group in some Array_*
+    make more generic / templatise
+ */
+int
+get_lower_bound (Array<Real> const& positions, Real x)
+{
+  if (x < positions[0])
+    return 0;
+  for (int i = 1; i < positions.size (); i++)
+    if (x < positions[i])
+      return i - 1;
+  return positions.size () - 1;
+}
+
+Slice
+get_bounds_slice (Array<Real> const& positions, Real x)
+{
+  int l = get_lower_bound (positions, x);
+  int u = positions.size () - 1 <? l + 1;
+  if (x < positions[l])
+    u = l;
+  return Slice (l, u);
+}
+
+Interval
+get_bounds_iv (Array<Real> const& positions, Real x)
+{
+  Slice slice = get_bounds_slice (positions, x);
+  return Interval (positions[slice[SMALLER]], positions[slice[BIGGER]]);
+}
+
+// silly name
+Interval
+quantise_iv (Array<Real> const& positions, Real period, Real x)
+{
+  /*
+    ugh
+    assume that 
+      * positions are sorted, 
+      * positions are nonnegative
+      * period starts at zero
+   */
+
+  int n = (int)(x / period);
+  Real frac = (x / period - n) * period;
+  if (frac < 0)
+    {
+      frac += period;
+      n--;
+    }
+
+  Slice slice = get_bounds_slice (positions, frac);
+  Interval iv(positions[slice[SMALLER]], positions[slice[BIGGER]]);
+
+  if (slice[SMALLER] == slice[BIGGER])
+    {
+      if (slice[SMALLER] == 0)
+       iv[SMALLER] = - period + positions.top ();
+      else
+       iv[BIGGER] = period + positions[0];
+    }
+
+  iv += period * n;
+
+  return iv;
+}