Don't do (index < array.size()-1). This is incorrect if size==0.
Real offset
= -skyline_meshing_distance (apes[i]->right_skyline_, left_skyline);
if (isinf (offset))
- offset = (i < apes.size () - 1) ? apes[i + 1]->offset_ : 0.0;
+ offset = (i + 1 < apes.size ()) ? apes[i + 1]->offset_ : 0.0;
else
offset -= padding;
if (!scm_is_vector (extents))
{
extents = scm_c_make_vector (breaks.size () - 1, SCM_EOL);
- for (vsize i = 0; i < breaks.size () - 1; i++)
+ for (vsize i = 0; i + 1 < breaks.size (); i++)
{
int st = Paper_column::get_rank (cols[breaks[i]]);
int ed = Paper_column::get_rank (cols[breaks[i+1]]);
/*
notes above and below the interval covered by 1st and last note.
*/
- for (vsize i = 1; i < positions.size () - 1; i++)
+ for (vsize i = 1; i + 1 < positions.size (); i++)
{
above = above || (positions[i] > covering[UP]);
below = below || (positions[i] < covering[DOWN]);
*/
int dy = positions.back () - positions[0];
int closest = max (beam_dir * positions.back (), beam_dir * positions[0]);
- for (vsize i = 2; !concave && i < positions.size () - 1; i++)
+ for (vsize i = 2; !concave && i + 1 < positions.size (); i++)
{
int inner_dy = positions[i] - positions[i - 1];
if (sign (inner_dy) != sign (dy)
}
bool all_closer = true;
- for (vsize i = 1; all_closer && i < positions.size () - 1; i++)
+ for (vsize i = 1; all_closer && i + 1 < positions.size (); i++)
{
all_closer = all_closer
&& (beam_dir * positions[i] > closest);
Real dy = positions.back () - positions[0];
Real slope = dy / Real (positions.size () - 1);
Real concaveness = 0.0;
- for (vsize i = 1; i < positions.size () - 1; i++)
+ for (vsize i = 1; i + 1 < positions.size (); i++)
{
Real line_y = slope * i + positions[0];
bool inside_stem = (event_dir == LEFT)
? segs[j].stem_index_ > 0
- : segs[j].stem_index_ < stems.size () - 1;
+ : segs[j].stem_index_ + 1 < stems.size () ;
bool event = on_bound
|| abs (segs[j].rank_ - segs[j+event_dir].rank_) > 1
{
int count = beaming->beamlet_count (i, d);
if (i > 0
- && i < stems.size () -1
+ && i + 1 < stems.size ()
&& Stem::is_invisible (stem))
count = min (count, beaming->beamlet_count (i,-d));
vsize k = 0;
for (vsize i = 0; i < infos_.size(); i++)
{
- while (j < group_starts.size() - 1
+ while (j + 1 < group_starts.size()
&& group_starts[j+1] <= infos_[i].start_moment_)
j++;
infos_[i].group_start_ = group_starts[j];
infos_[i].beat_length_ = beat_length;
- while (k < beat_starts.size() - 1
+ while (k + 1 < beat_starts.size()
&& beat_starts[k+1] <= infos_[i].start_moment_)
k++;
else
{
extra_right_space = distance;
- if (idx < offsets.size() - 1)
+ if (idx + 1 < offsets.size()t)
offsets[idx+1] = extents[idx][RIGHT] + distance;
}
other_lines.length (),
other_lines.length () - first_line.length (),
ragged_right_);
- for (vsize i = 0; i < breaks_.size () - 1; i++)
+ for (vsize i = 0; i + 1 < breaks_.size (); i++)
{
Real max_ext = 0;
for (vsize j = i + 1; j < breaks_.size (); j++)
for (vsize i = 0; i < start_.size (); i++)
{
vsize j;
- for (j = 0; j < breaks_.size () - 1 && breaks_[j] < start_[i]; j++)
+ for (j = 0; j + 1 < breaks_.size () && breaks_[j] < start_[i]; j++)
;
starting_breakpoints_.push_back (j);
start_[i] = breaks_[j];
&& !dirs[next_nonneutral])
next_nonneutral++;
- while (last_nonneutral == VPOS || last_nonneutral < dirs.size () - 1)
+ while (last_nonneutral == VPOS || last_nonneutral + 1 < dirs.size ())
{
Direction d1 = CENTER;
Direction d2 = CENTER;
if (Rhythmic_head::dot_count (current) > 0)
// Move dots above/behind the ligature.
{
- if (i < primitives.size () - 1)
+ if (i + 1 < primitives.size ())
// dot in the midst => move above head
{
// FIXME: Amount of vertical dot-shift should depend on
vector<Break_position> chunks = chunk_list (start_break, end_break);
assert (chunks.size () == div.size () + 1);
- for (vsize i = 0; i < chunks.size () - 1; i++)
+ for (vsize i = 0; i + 1 < chunks.size (); i++)
{
vsize sys = next_system (chunks[i]);
if (all_[sys].pscore_)
vector<Line_details> ret;
assert (chunks.size () == div.size () + 1);
- for (vsize i = 0; i < chunks.size () - 1; i++)
+ for (vsize i = 0; i + 1 < chunks.size (); i++)
{
vsize sys = next_system (chunks[i]);
if (all_[sys].pscore_)
Line_division ret;
ret.resize (chunks.size () - 1, 1);
- for (vsize i = 0; i < chunks.size () - 1; i++)
+ for (vsize i = 0; i + 1 < chunks.size (); i++)
{
vsize sys = next_system (chunks[i]);
if (all_[sys].pscore_)
bool ragged_last)
{
/* if there is a forced break, this reduces to 2 1-page problems */
- for (vsize i = 0; i < lines.size () - 1; i++)
+ for (vsize i = 0; i + 1 < lines.size (); i++)
if (lines[i].page_permission_ == ly_symbol2scm ("force"))
{
vector<Line_details> lines1 (lines.begin (), lines.begin () + i + 1);
if (ragged || ragged_last)
page2_force[page2_force.size () - 1 - i] =
- (page2.force_ < 0 && i < page1_force.size () - 1) ? infinity_f : 0;
+ (page2.force_ < 0 && i + 1 < page1_force.size ()) ? infinity_f : 0;
else
page2_force[page2_force.size () - 1 - i] = page2.force_;
}
+ ((cur_rod_height > 0) ? lines[i].padding_: 0);
if ((next_height > page_height && cur_rod_height > 0)
- || (i < lines.size () - 1 && lines[i].page_permission_ == ly_symbol2scm ("force")))
+ || (i + 1 < lines.size () && lines[i].page_permission_ == ly_symbol2scm ("force")))
{
ret++;
cur_rod_height = ext_len + (rag ? lines[i].space_ : 0);
/* it's possible that the last of my newly-split events overlaps the next repeat_penalty,
in which case we need to refilter that event */
- if (rep_index < repeat_penalties_.size () - 1
+ if (rep_index + 1 < repeat_penalties_.size ()
&& split.size ()
&& split.back ().duration_[RIGHT] > repeat_penalties_[rep_index+1].duration_[LEFT])
{
state_.clear ();
message (_f ("Calculating page and line breaks (%d possible page breaks)...",
(int)breaks_.size () - 1) + " ");
- for (vsize i = 0; i < breaks_.size () - 1; i++)
+ for (vsize i = 0; i + 1 < breaks_.size (); i++)
{
calc_subproblem (i);
progress_indication (string ("[") + to_string (i + 1) + "]");
for (vsize j = 0; j < soln[i].page_count_; j++)
lines_per_page.push_back (soln[i].system_count_[j]);
- if (i < soln.size () - 1 && (soln[i].first_page_number_ + soln[i].page_count_) % 2)
+ if (i + 1 < soln.size () && (soln[i].first_page_number_ + soln[i].page_count_) % 2)
/* add a blank page */
lines_per_page.push_back (0);
}
breaks.clear ();
breaks.push_back (0);
cols.push_back (Column_description ());
- for (vsize i = 1; i < non_loose.size () - 1; i++)
+ for (vsize i = 1; i + 1 < non_loose.size (); i++)
{
if (Paper_column::is_breakable (non_loose[i]))
breaks.push_back (cols.size ());
breaks.push_back (cols.size ());
force.resize (breaks.size () * breaks.size (), infinity_f);
- for (vsize b = 0; b < breaks.size () - 1; b++)
+ for (vsize b = 0; b + 1 < breaks.size (); b++)
{
cols[breaks[b]] = get_column_description (non_loose, breaks[b], true);
vsize st = breaks[b];
Column_x_positions ret;
ret.cols_.push_back (dynamic_cast<Item*> (columns[0])->find_prebroken_piece (RIGHT));
- for (vsize i = 1; i < columns.size () - 1; i++)
+ for (vsize i = 1; i + 1 < columns.size (); i++)
{
if (is_loose (columns[i]))
ret.loose_cols_.push_back (columns[i]);
/* since we've already put our line-ending column in the column list, we can ignore
the end_XXX_ fields of our column_description */
- for (vsize i = 0; i < ret.cols_.size () - 1; i++)
+ for (vsize i = 0; i + 1 < ret.cols_.size (); i++)
{
cols.push_back (get_column_description (ret.cols_, i, i == 0));
spacer.add_spring (cols[i].ideal_, cols[i].inverse_hooke_);
/*
Check if breaking constraints are met.
*/
- for (vsize i = 1; i < ret.cols_.size () - 1; i++)
+ for (vsize i = 1; i + 1 < ret.cols_.size (); i++)
{
SCM p = ret.cols_[i]->get_property ("line-break-permission");
if (p == ly_symbol2scm ("force"))
{
Grob *c = cols->at (i);
- bool loose = (i > 0 && i < cols->size () - 1)
+ bool loose = (i > 0 && i + 1 < cols->size ())
&& is_loose_column (cols->at (i - 1), c, cols->at (i + 1), options);
if (loose)
cols[i]->set_object ("left-neighbors", ga_scm);
}
extract_grob_set (cols[i], "right-neighbors", rns);
- if (rns.empty () && i < cols.size () - 1)
+ if (rns.empty () && i + 1 < cols.size ())
{
SCM ga_scm = Grob_array::make_array ();
Grob_array *ga = unsmob_grob_array (ga_scm);
vector<Real> clique_spacing;
clique_spacing.push_back (0.0);
- for (vsize j = 1; j < clique.size () - 1; j ++)
+ for (vsize j = 1; j + 1 < clique.size (); j ++)
{
Grob *clique_col = clique[j];
for (vsize i = 0; i < cols.size (); i++)
{
Paper_column *col = dynamic_cast<Paper_column *> (cols[i]);
- Paper_column *next = (i < cols.size()-1) ? dynamic_cast<Paper_column *> (cols[i+1]) : 0;
+ Paper_column *next = (i + 1 < cols.size ()) ? dynamic_cast<Paper_column *> (cols[i+1]) : 0;
if (i > 0)
generate_pair_spacing (me, prev, col, next, options);
}
}
- for (vsize i = 1; i < tie_configs->size() - 1; i++)
+ for (vsize i = 1; i + 1 < tie_configs->size (); i++)
{
Tie_configuration &conf = tie_configs->at (i);
if (conf.dir_)
tuplets_[i].stop_moment_.grace_part_ = 0;
- if (i < tuplets_.size () - 1 && tuplets_[i + 1].bracket_)
+ if (i + 1 < tuplets_.size () && tuplets_[i + 1].bracket_)
Tuplet_bracket::add_tuplet_bracket (tuplets_[i].bracket_, tuplets_[i + 1].bracket_);
if (i > 0 && tuplets_[i - 1].bracket_)