release: 0.0.26

[lilypond.git] / src / break.cc

diff --git a/src/break.cc b/src/break.cc
index 6cb1d3303b4a4d823aa4bb1c5278f8496b212080..f3832cf0f608fb3848d1c2a1ad0e66cc27307103 100644 (file)
--- a/src/break.cc
+++ b/src/break.cc
@@ -2,134 +2,109 @@
     do calculations for breaking problem
     
     */
+#include "break.hh"
 #include "paper.hh"
 #include "linespace.hh"
 #include "debug.hh"
 #include "scoreline.hh"
 #include "pscore.hh"
 
+
+/*
+  return all breakable columns
+ */
+Array<PCol *>
+Break_algorithm::find_breaks() const
+{
+    Array<PCol *> retval;
+    for (iter_top(pscore_.cols,c); c.ok(); c++)
+       if (c->breakable())
+           retval.push(c);
+
+    return retval;
+}
+
 // construct an appropriate Spacing_problem and solve it. 
-svec<Real>
-PScore::solve_line(svec<const PCol *> curline) const
+Array<Real>
+Break_algorithm::solve_line(Line_of_cols curline) const
 {
    Spacing_problem sp;
 
    sp.add_column(curline[0], true, 0.0);
-   for (int i=1; i< curline.sz()-1; i++)
+   for (int i=1; i< curline.size()-1; i++)
        sp.add_column(curline[i]);
-   sp.add_column(curline.last(), true, paper_->linewidth);
+   sp.add_column(curline.last(), true, linelength);
 
    // misschien  moeven uit Spacing_problem? 
-   for (PCursor<Idealspacing *> i(suz); i.ok(); i++) {
+   for (iter_top(pscore_.suz,i); i.ok(); i++) {
        sp.add_ideal(i);
    }
-   svec<Real> the_sol=sp.solve();
+   Array<Real> the_sol=sp.solve();
    return the_sol;
 }
 
+Break_algorithm::Break_algorithm(PScore&s)
+    :pscore_(s)
+{
+    linelength = s.paper_l_->linewidth;
+}
+
 bool
-PScore::feasible(svec<const PCol *> curline) const
+Break_algorithm::feasible(Line_of_cols curline) const
 {
     Real l =0;
-    for (int i=0; i < curline.sz(); i++)
+    for (int i=0; i < curline.size(); i++)
        l +=curline[i]->width().length();
-    return l < paper_->linewidth;    
+    return l < linelength;    
 }
 
 void
-PScore::problem_OK() const
+Break_algorithm::problem_OK() const
 {
-    if (!cols.size())
-       error("PScore::problem_OK(): Score does not have any columns");
-    PCursor<PCol *> start(cols);
-    PCursor<PCol *> end (((PScore*)this)->cols.bottom());
+    if (!pscore_.cols.size())
+       error("Score does not have any columns");
+#ifndef NDEBUG
+    iter_top(pscore_.cols,start);
+    PCursor<PCol *> end (pscore_.cols.bottom());
     
     assert(start->breakable());    
     assert(end->breakable());
-}
-
-struct Col_configuration {
-    svec<const PCol*> line;
-    svec<Real> config;
-    Real energy;
-
-    Col_configuration() {
-       energy = INFTY;
-    }
-    void add(const PCol*c) { line.add(c);}
-    void setsol(svec<Real> sol) {
-       config = sol;
-       energy = config.last();
-       config.pop();
-    }
-    void print() const {
-#ifndef NPRINT
-       mtor << "energy : " << energy << '\n';
-       mtor << "line of " << config.sz() << " cols\n";
 #endif
-    }
-};
+}
 
-/// wordwrap type algorithm
-/* el stupido. This should be done more accurately:
+/****************/
 
-   It would be nice to have a Dynamic Programming type of algorithm
-   similar to TeX's
-   
-    */
+Col_configuration::Col_configuration()
+{
+    energy = INFTY;
+}
 
 void
-PScore::calc_breaking()
+Col_configuration::add( PCol*c)
 {
-    OK();
-    problem_OK();
-    PCursor<PCol *> curcol(cols);
-           
-    svec<const PCol *> breakpoints(find_breaks());
-    assert(breakpoints.sz()>=2);
-    for (int i=0 ; i < breakpoints.sz() -1; ) {
-       Col_configuration minimum;
-       Col_configuration current;
-
-        // do  another line
-       PCol *post = breakpoints[i]->postbreak;
-       current.add( post);
-       curcol++;               // skip the breakable.
-       i++;
-
-       while (i < breakpoints.sz()) {
+    cols.push(c);
+}
 
-           // add another measure.
-           while (breakpoints[i] != curcol.ptr()){
-               
-               current.add(curcol);
-               curcol++;
-           }
-           current.add(breakpoints[i]->prebreak );
-           if (!feasible(current.line)) {
-               if (!minimum.line.sz())
-                   error("sorry, this measure is too long");
-               break;
-           }
-           current.setsol(solve_line(current.line));
-           current.print();
-           
-           if (current.energy < minimum.energy) {              
-               minimum = current;         
-           } else {            // we're one col too far.
-               i--;
-               while (curcol.ptr() != breakpoints[i])
-                   curcol --;
-               
-               break;
-           }
-       
-           current.line.last()=breakpoints[i];
-           curcol ++;
-           i++;
-       }
-       mtor << "Adding line, next breakpoint " << i << '\n';
-       add_line(minimum.line, minimum.config); 
-    }
+void
+Col_configuration::setsol(Array<Real> sol)
+{
+    config = sol;
+    energy = config.last();
+    config.pop();
 }
 
+void
+Col_configuration::print() const
+{
+#ifndef NPRINT
+    mtor << "energy : " << energy << '\n';
+    mtor << "line of " << config.size() << " cols\n";
+#endif
+}
+void
+Col_configuration::OK()const
+{
+#ifndef NDEBUG
+    assert(config.size() == cols.size());
+#endif
+}