2005-05-01 Han-Wen Nienhuys <hanwen@xs4all.nl>
+ * flower/*.cc: remove <? and >?
+
+ * lily/*.cc: remove <? and >?
+
* lily/tweak-registration.cc (insert_tweak_from_file): dubious
bugfix. Make sure that 0x0 isn't passed into scm_cons(). Fixes
crash with tweak editor.
int wid = 0;
for (int i = 0; l[i].shortname_char_ || l[i].longname_str0_; i++)
{
- wid = wid >? l[i].str_for_help ().length ();
+ wid = max (wid, l[i].str_for_help ().length ());
}
for (int i = 0; l[i].shortname_char_ || l[i].longname_str0_; i++)
return function (t1, t2) op 0; \
}
-#define GPP_MINMAX_OPERATOR(type, op, opp) \
- inline type \
- operator op (type t1, type t2) \
- { \
- return (t1 opp t2) ? t1 : t2; \
- }
-
-#if defined (__GNUG__) && ! defined (__STRICT_ANSI__)
-#define GPP_MINMAX(type, prefix) \
- prefix GPP_MINMAX_OPERATOR (type, <?, <) \
- prefix GPP_MINMAX_OPERATOR (type, >?, >)
-#else
-#define GPP_MINMAX (type, prefix)
-#endif
-
/** handy notations for a signed comparison.
make the operators{<,<=,==,>=,>} and the MAX and MIN of two.
Please fill a & in the type argument if necessary.
prefix ONE_OPERATOR (type, function, !=) \
prefix ONE_OPERATOR (type, function, <) \
prefix ONE_OPERATOR (type, function, <=) \
- GPP_MINMAX (type, prefix) \
prefix inline type max (type t1, type t2) { return (t1 > t2) ? t1 : t2; } \
prefix inline type min (type t1, type t2) { return (t1 < t2) ? t1 : t2; } \
\
void intersect (Interval_t<T> h);
void add_point (T p)
{
- elem_ref (LEFT) = elem (LEFT) <? p;
- elem_ref (RIGHT) = elem (RIGHT) >? p;
+ elem_ref (LEFT) = min (elem (LEFT), p);
+ elem_ref (RIGHT) = max (elem (RIGHT), p);
}
T length () const;
T delta () const;
void
Interval_t<T>::unite (Interval_t<T> h)
{
- elem_ref (LEFT) = h.elem (LEFT) <? elem (LEFT);
- elem_ref (RIGHT) = h.elem (RIGHT) >? elem (RIGHT);
+ elem_ref (LEFT) = min (h.elem (LEFT), elem (LEFT));
+ elem_ref (RIGHT) = max (h.elem (RIGHT), elem (RIGHT));
}
template<class T>
void
Interval_t<T>::intersect (Interval_t<T> h)
{
-#if defined (__GNUG__) && !defined (__STRICT_ANSI__)
- elem_ref (LEFT) = h.elem (LEFT) >? elem (LEFT);
- elem_ref (RIGHT) = h.elem (RIGHT) <? elem (RIGHT);
-#else
elem_ref (LEFT) = max (h.elem (LEFT), elem (LEFT));
elem_ref (RIGHT) = min (h.elem (RIGHT), elem (RIGHT));
-#endif
}
-#if 0 //this is called intersection
-template<class T>
-Interval_t<T>
-intersect (Interval_t<T> x, Interval_t<T> const &y)
-{
- x.intersect (y);
- return x;
-}
-#endif
+
template<class T>
String
typedef double Real;
extern const Real infinity_f;
+using namespace std;
template<class T> inline T abs (T x)
{
return 0;
}
-template<class T> inline T max (T x, T y)
-{
- return x >? y;
-}
template<class T> inline T sqr (T x)
{
return x * x;
}
-template<class T> inline T min (T x, T y)
-{
- return x <? y;
-}
inline Real
distance (Real x, Real y)
#ifndef STRINGDATA_INL
#define STRINGDATA_INL
+#include "string-data.hh"
+
+#include <algorithm>
#include <cassert>
#include <cstring>
-
#include <memory.h>
-#include "string-data.hh"
+using namespace std;
+
const int INITIALMAX = 8;
#include <sys/types.h>
if (j > maxlen)
{
Byte *p = new Byte[j + 1];
- memcpy (p, data_byte_, (maxlen <? length_) + 1);
+ memcpy (p, data_byte_, min (maxlen, length_) + 1);
maxlen = j;
delete[] data_byte_;
data_byte_ = p;
String
String_convert::pad_to (String s, int n)
{
- return s + to_string (' ' , (n - s.length ()) >? 0);
+ return s + to_string (' ' , max (n - s.length (), 0));
}
/*
don't forget the terminating '\0'
*/
- int f = (s1.length () <? s2.length ());
+ int f = min (s1.length (), s2.length ());
int cmp_length = 1+ f;
int i = memcmp (p1, p2, cmp_length);
return i;
font_info_ = fi;
design_size_ = 1.0;
- for (int i = 256 >? fi->numOfChars; i--;)
+ for (int i = max (256, fi->numOfChars); i--;)
ascii_to_metric_idx_.push (-1);
for (int i = 0; i < fi->numOfChars; i++)
dy *= stacking_dir;
if (j)
{
- dy = (dy >? threshold[SMALLER])
- <? threshold[BIGGER];
+ dy = min (max (dy, threshold[SMALLER]),
+ threshold[BIGGER]);
}
where_f += stacking_dir * dy;
durlog - 2);
stems_->push (stem);
last_add_mom_ = now;
- extend_mom_ = (extend_mom_ >? now) + m->get_length ();
+ extend_mom_ = max (extend_mom_, now) + m->get_length ();
}
}
note is reached in the opposite direction as the last-first dy
*/
int dy = positions.top () - positions[0];
- int closest = (beam_dir * positions.top ()) >? (beam_dir * positions[0]);
+ int closest = max (beam_dir * positions.top (), beam_dir * positions[0]);
for (int i = 2; !concave && i < positions.size () - 1; i++)
{
int inner_dy = positions[i] - positions[i - 1];
{
Real line_y = slope * i + positions[0];
- concaveness += (beam_dir * (positions[i] - line_y)) >? 0.0;
+ concaveness += max (beam_dir * (positions[i] - line_y), 0.0);
}
concaveness /= positions.size ();
scm_int2num (durlog));
Moment stem_location = now - beam_start_mom_ + beam_start_location_;
beam_info_->add_stem (stem_location,
- (durlog- 2) >? 0);
+ max (durlog- 2, 0));
Beam::add_stem (beam_, stem);
}
}
Jan Nieuwenhuizen <janneke@gnu.org>
*/
+#include "beam.hh"
+
+#include <algorithm>
#include <math.h>
#include "warn.hh"
#include "staff-symbol-referencer.hh"
-#include "beam.hh"
#include "stem.hh"
#include "output-def.hh"
#include "group-interface.hh"
Stem_info info = stem_infos[i];
Direction d = info.dir_;
- score[d] += limit_penalty * (0 >? (d * (info.shortest_y_ - current_y)));
+ score[d] += limit_penalty * max (0.0, (d * (info.shortest_y_ - current_y)));
Real ideal_diff = d * (current_y - info.ideal_y_);
Real ideal_score = shrink_extra_weight (ideal_diff, 1.5);
Direction d = DOWN;
do
{
- score[d] /= (count[d] >? 1);
+ score[d] /= max (count[d], 1);
}
while (flip (&d) != DOWN);
dem += DAMPING_DIRECTION_PENALTY;
}
- dem += MUSICAL_DIRECTION_FACTOR *(0 >? (fabs (dy) - fabs (dy_mus)));
+ dem += MUSICAL_DIRECTION_FACTOR * max (0.0, (fabs (dy) - fabs (dy_mus)));
Real slope_penalty = IDEAL_SLOPE_FACTOR;
Drul_array<Real> y (yl, yr);
Drul_array<Direction> dirs (ldir, rdir);
- Real extra_demerit = SECONDARY_BEAM_DEMERIT / (beam_counts[LEFT] >? beam_counts[RIGHT]);
+ Real extra_demerit = SECONDARY_BEAM_DEMERIT / (max (beam_counts[LEFT], beam_counts[RIGHT]));
Direction d = LEFT;
Real dem = 0.0;
k <= radius + BEAM_EPS; k += 1.0)
if (gap.contains (k))
{
- Real dist = fabs (gap[UP] - k) <? fabs (gap[DOWN] - k);
+ Real dist = min (fabs (gap[UP] - k), fabs (gap[DOWN] - k));
/*
this parameter is tuned to grace-stem-length.ly
}
while ((flip (&d)) != LEFT);
- if ((beam_counts[LEFT] >? beam_counts[RIGHT]) >= 2)
+ if (max (beam_counts[LEFT], beam_counts[RIGHT]) >= 2)
{
Real straddle = 0.0;
Real sit = (thickness - slt) / 2;
for (SCM s = me->get_property ("stems"); scm_is_pair (s); s = scm_cdr (s))
{
Grob *stem = unsmob_grob (scm_car (s));
- m = m >? (Stem::beam_multiplicity (stem).length () + 1);
+ m = max (m, (Stem::beam_multiplicity (stem).length () + 1));
}
return m;
}
Real lw = nw_f;
Real rw = nw_f;
if (i > 0)
- rw = nw_f <? ((xposn - last_xposn) / 2);
+ rw = min (nw_f, ((xposn - last_xposn) / 2));
else
/*
TODO: 0.5 is a guess.
- 0.5;
if (st)
- lw = nw_f <? ((xposn - last_xposn) / 2);
+ lw = min (nw_f, ((xposn - last_xposn) / 2));
else
lw = me->get_bound (RIGHT)->relative_coordinate (xcommon, X_AXIS)
- last_xposn;
Grob *s = stems[i];
Direction sd = get_grob_direction (s);
- int center_distance = int (- d * Stem::head_positions (s) [-d]) >? 0;
+ int center_distance = max (int (- d * Stem::head_positions (s) [-d]), 0);
int current = sd ? (1 + d * sd) / 2 : center_distance;
if (current)
Real inter = 0.5;
Real hang = 1.0 - (thickness - slt) / 2;
- *dy = sign (*dy) * (fabs (*dy)
- >?
- (sit <? inter <? hang));
+ *dy = sign (*dy) * max (fabs (*dy),
+ min (min (sit, inter), hang));
}
}
if (i > 0
&& i < stems.size () -1
&& Stem::is_invisible (st))
- b = b <? beaming->infos_.elem (i).beams_i_drul_[-d];
+ b = min (b, beaming->infos_.elem (i).beams_i_drul_[-d]);
Stem::set_beaming (st, b, d);
}
= + staff_space * (robust_scm2double (stem->get_property ("stemlet-length"), 0.0)
+ robust_scm2double (rest->get_property ("minimum-distance"), 0.0));
- Real shift = d * (((beam_y - d * minimum_distance) - rest_dim) * d <? 0.0);
+ Real shift = d * min (((beam_y - d * minimum_distance) - rest_dim) * d, 0.0);
shift /= staff_space;
Real rad = Staff_symbol_referencer::line_count (rest) * staff_space / 2;
Should we take invisible stems into account?
*/
if (Stem::get_direction (stems[i]) == d)
- bc = bc >? (Stem::beam_multiplicity (stems[i]).length () + 1);
+ bc = max (bc, (Stem::beam_multiplicity (stems[i]).length () + 1));
}
return bc;
Beaming_info thisbeam = infos_.boundary (d, 0);
Beaming_info next = infos_.boundary (d, 1);
- return thisbeam.beams_i_drul_[-d] <? next.beams_i_drul_[d];
+ return min (thisbeam.beams_i_drul_[-d], next.beams_i_drul_[d]);
}
void
while (flip (&d) != LEFT);
int middle_beams = (split ? 1
- : splits[RIGHT].beam_extend_count (LEFT) <?
- splits[LEFT].beam_extend_count (RIGHT));
+ : min (splits[RIGHT].beam_extend_count (LEFT),
+ splits[LEFT].beam_extend_count (RIGHT)));
do
{
if (!contains (pos_str0))
return "";
- char const *begin_str0 = pos_str0 - 8 >? to_str0 ();
- char const *end_str0 = pos_str0 + 7 <? to_str0 () + length ();
+ char const *begin_str0 = max (pos_str0 - 8, to_str0 ());
+ char const *end_str0 = min (pos_str0 + 7, to_str0 () + length ());
String pre_string ((Byte const *)begin_str0, pos_str0 - begin_str0);
pre_string = String_convert::bin2hex (pre_string);
return h;
}
+
+Break_algorithm::~Break_algorithm ()
+{
+}
- extents[next_idx][LEFT];
/* should probably junk minimum-space */
else if (type == ly_symbol2scm ("minimum-space"))
- offsets[next_idx] = extents[idx][RIGHT] >? distance;
+ offsets[next_idx] = max (extents[idx][RIGHT], distance);
}
else
{
Rational total_dur = l.main_part_;
Rational note_dur = total_dur / Rational (elt_count * Repeated_music::repeat_count (repeat_));
- total_duration_flags_ = 0 >? (intlog2 (total_dur.den ()) - 2);
+ total_duration_flags_ = max (0, (intlog2 (total_dur.den ()) - 2));
flags_ = intlog2 (note_dur.den ()) -2;
int p = (pit ? pit->steps () : 0) + c0;
- pmax = pmax >? p;
- pmin = pmin <? p;
+ pmax = max (pmax, p);
+ pmin = min (pmin, p);
}
beacon_ = make_item ("ClusterSpannerBeacon", cluster_notes_[0]->self_scm ());
musiclen.grace_part_ = musiclen.main_part_;
musiclen.main_part_ = Rational (0, 1);
}
- note_end_mom_ = note_end_mom_ >? (now + musiclen);
+ note_end_mom_ = max (note_end_mom_, (now + musiclen));
do_nothing_until_ = Rational (0, 0);
return true;
add 20000 to the demerits, so that a break penalty
of -10000 won't change the result */
- demerit = (demerit + 20000) >? 2000;
+ demerit = max ((demerit + 20000), 2000.0);
demerit *= 10;
}
if (!now.main_part_.mod_rat (mom->main_part_))
{
- Item * it = make_item ("GridPoint", SCM_EOL);
+ make_item ("GridPoint", SCM_EOL);
}
}
}
Simple_spacer_wrapper *generate_spacing_problem (Link_array<Grob> const &, Interval) const;
virtual Array<Column_x_positions> do_solve () const = 0;
-
public:
+ virtual ~Break_algorithm ();
Simple_spacer *(*get_line_spacer) ();
Break_algorithm ();
void set_pscore (Paper_score *);
reqs[rank][vdir].ledger_extent_.unite (ledger_extent);
reqs[rank][vdir].head_extent_.unite (head_extent);
reqs[rank][vdir].position_
- = vdir * ((vdir * reqs[rank][vdir].position_) >? (vdir * pos));
+ = vdir * max (vdir * reqs[rank][vdir].position_, vdir * pos);
}
}
Real limit = (center + (both ? which * gap / 2 : 0));
lr.ledger_extent_.elem_ref (-which)
- = which * (which * lr.ledger_extent_[-which] >? which * limit);
+ = which * max (which * lr.ledger_extent_[-which], which * limit);
}
while (flip (&which) != LEFT);
}
head_size[LEFT]),
0.0);
- left_shorten = (-ledger_size[LEFT] + d) >? 0;
+ left_shorten = max (-ledger_size[LEFT] + d, 0.0);
/*
TODO: shorten 2 ledger lines for the case natural +
Line_interface::make_dashed_line (Real thick, Offset from, Offset to,
Real dash_period, Real dash_fraction)
{
- dash_fraction = (dash_fraction >? 0) <? 1.0;
+ dash_fraction = min (max (dash_fraction, 0.0), 1.0);
Real on = dash_fraction * dash_period + thick;
Real off = dash_period - on;
? 0.0
: robust_scm2double (dash_fraction, 0.4);
- fraction = (fraction >? 0) <? 1.0;
+ fraction = min (max (fraction, 0.0), 1.0);
Real period = Staff_symbol_referencer::staff_space (me)
* robust_scm2double (me->get_property ("dash-period"), 1.0);
Lookup::beam (Real slope, Real width, Real thick, Real blot)
{
Real height = slope * width;
- Real min_y = (0 <? height) - thick / 2;
- Real max_y = (0 >? height) + thick / 2;
+ Real min_y = min (0., height) - thick / 2;
+ Real max_y = max (0., height) + thick / 2;
Box b (Interval (0, width),
Interval (min_y, max_y));
{
Box b;
b[X_AXIS] = Interval (0, iv.length ());
- b[Y_AXIS] = Interval (0 <? protude, 0 >? protude);
+ b[Y_AXIS] = Interval (min (0., protude), max (0.0, protude));
Offset z1 (iv[LEFT], 0);
Offset z2 (iv[RIGHT], 0);
= left_point + (robust_scm2double (minlen, 0));
if (heads.size ())
- right_point = right_point >? heads.top ()->extent (common, X_AXIS)[RIGHT];
+ right_point = max (right_point, heads.top ()->extent (common, X_AXIS)[RIGHT]);
Real h = sl * robust_scm2double (me->get_property ("thickness"), 0);
Real pad = 2* h;
if (right_text)
- right_point = right_point <? (robust_relative_extent (right_text, common, X_AXIS)[LEFT] - pad);
+ right_point = min (right_point, (robust_relative_extent (right_text, common, X_AXIS)[LEFT] - pad));
/* run to end of line. */
if (me->get_bound (RIGHT)->break_status_dir ())
- right_point = right_point >? (robust_relative_extent (me->get_bound (RIGHT), common, X_AXIS)[LEFT] - pad);
+ right_point = max (right_point, (robust_relative_extent (me->get_bound (RIGHT), common, X_AXIS)[LEFT] - pad));
left_point += pad;
Real w = right_point - left_point;
&& !bounds[RIGHT]->break_status_dir ())
{
Real minimum_length = robust_scm2double (me->get_property ("minimum-length"), .3);
- dash_length = (l - 2 * padding) >? minimum_length;
+ dash_length = max ((l - 2 * padding), minimum_length);
}
Real space_left = l - dash_length - (n - 1) * dash_period;
&& !bounds[RIGHT]->break_status_dir ())
return SCM_EOL;
- space_left = space_left >? 0.0;
+ space_left = max (space_left, 0.0);
Box b (Interval (0, dash_length), Interval (h, h + th));
Stencil dash_mol (Lookup::round_filled_box (b, 0.8 * lt));
we gotta stay clear of sp_iv, so move a bit to the right if
needed.
*/
- x_off += (sp_iv[LEFT] - rx) >? 0;
+ x_off += max (sp_iv[LEFT] - rx, 0.0);
/*
center between stuff.
we gotta stay clear of sp_iv, so move a bit to the right if
needed.
*/
- Real x_off = (sp_iv[LEFT] - rx) >? 0;
+ Real x_off = max (sp_iv[LEFT] - rx, 0.0);
Stencil mol;
mol.add_stencil (symbol_stencil (me, space));
Real slt = me->get_layout ()->get_dimension (ly_symbol2scm ("linethickness"));
Real y = slt * thick_thick / 2 * ss;
Real ythick = hair_thick * slt * ss;
- Box b (Interval (0, 0 >? (width - 2 * ythick)), Interval (-y, y));
+ Box b (Interval (0.0, max (0.0, (width - 2 * ythick))), Interval (-y, y));
- Real blot = width ? (.8 * (y <? ythick)) : 0.0;
+ Real blot = width ? (.8 * min (y, ythick)) : 0.0;
Stencil m = Lookup::round_filled_box (b, blot);
Stencil yb = Lookup::round_filled_box (Box (Interval (-0.5, 0.5) * ythick, Interval (-ss, ss)), blot);
{
Music *m = unsmob_music (scm_car (s));
Moment l = m->get_length ();
- dur = dur >? l;
+ dur = max (dur, l);
}
return dur;
for (SCM s = l; scm_is_pair (s); s = scm_cdr (s))
{
- m = m <? unsmob_music (scm_car (s))->start_mom ();
+ m = min (m, unsmob_music (scm_car (s))->start_mom ());
}
return m;
}
Note_head::get_balltype (Grob *me)
{
SCM s = me->get_property ("duration-log");
- return scm_is_number (s) ? scm_to_int (s) <? 2 : 0;
+ return scm_is_number (s) ? min (scm_to_int (s), 2) : 0;
}
ADD_INTERFACE (Note_head, "note-head-interface",
Real chord_start = hp[sd];
Real stem_end = Stem::stem_end_position (stem);
- stem_posns[d] = Interval (chord_start <? stem_end, chord_start>? stem_end);
+ stem_posns[d] = Interval (min (chord_start, stem_end), max (chord_start, stem_end));
head_posns[d].unite (hp);
}
}
/*
Ugh. 7 is hardcoded.
*/
- correction = (correction / 7) <? 1.0;
+ correction = min (correction / 7, 1.0);
correction *= stem_dirs[LEFT];
correction
*= robust_scm2double (me->get_property ("stem-spacing-correction"), 0);
Real text_size = text.extent (X_AXIS).is_empty ()
? 0.0 : text.extent (X_AXIS)[RIGHT] + 0.3;
- span_points[LEFT] = span_points[LEFT]
- <? (span_points[RIGHT] - text_size
- - robust_scm2double (me->get_property ("minimum-length"), -1.0));
+ span_points[LEFT] =
+ min (span_points[LEFT],
+ (span_points[RIGHT] - text_size
+ - robust_scm2double (me->get_property ("minimum-length"), -1.0)));
Interval bracket_span_points = span_points;
bracket_span_points[LEFT] += text_size;
Moment p;
p.set_infinite (1);
if (first_iter_->ok ())
- p = p <? first_iter_->pending_moment ();
+ p = min (p, first_iter_->pending_moment ());
if (second_iter_->ok ())
- p = p <? second_iter_->pending_moment ();
+ p = min (p, second_iter_->pending_moment ());
return p;
}
Moment m (infty);
if (Music_wrapper_iterator::ok ())
- m = m <? Music_wrapper_iterator::pending_moment ();
+ m = min (m, Music_wrapper_iterator::pending_moment ());
/*
In case event_idx_ < 0, we're not initted yet, and the wrapped
music expression determines the starting moment.
*/
if (quote_ok ())
- m = m <? vector_moment (event_idx_) - start_moment_;
+ m = min (m, vector_moment (event_idx_) - start_moment_);
return m;
}
for (SCM s = children_list_; scm_is_pair (s); s = scm_cdr (s))
{
Music_iterator *it = unsmob_iterator (scm_car (s));
- next = next <? it->pending_moment ();
+ next = min (next, it->pending_moment ());
}
return next;
if (mus)
{
Moment m = mus->get_length ();
- shortest_playing = shortest_playing <? m;
+ shortest_playing = min (shortest_playing, m);
}
}
Moment starter;
Moment m = now_durations_[i].info_.music_cause ()->get_length ();
if (m.to_bool ())
{
- starter = starter <? m;
+ starter = min (starter, m);
playing_durations_.insert (now_durations_[i]);
}
}
now_durations_.clear ();
- shortest_playing = shortest_playing <? starter;
+ shortest_playing = min (shortest_playing, starter);
Paper_column *sc
= dynamic_cast<Paper_column *> (unsmob_grob (get_property ("currentMusicalColumn")));
space -= increment;
- dists[d] = dists[d] >? space;
+ dists[d] = max (dists[d], space);
}
else
{
Staff_spacing::get_spacing_params (sp,
&space, &fixed_space);
- dists[d] = dists[d] >? fixed_space;
+ dists[d] = max (dists[d], fixed_space);
}
}
}
SCM st = cols[i]->get_property ("shortest-starter-duration");
Moment this_shortest = *unsmob_moment (st);
assert (this_shortest.to_bool ());
- shortest_in_measure = shortest_in_measure <? this_shortest.main_part_;
+ shortest_in_measure = min (shortest_in_measure, this_shortest.main_part_);
}
else if (!shortest_in_measure.is_infinity ()
&& Item::is_breakable (cols[i]))
d = m->main_part_;
if (max_idx >= 0)
- d = d <? durations[max_idx];
+ d = min (d, durations[max_idx]);
return d;
}
TODO: this criterion is discontinuous in the derivative.
Maybe it should be continuous?
*/
- compound_fixed_note_space = compound_fixed_note_space <? compound_note_space;
+ compound_fixed_note_space = min (compound_fixed_note_space, compound_note_space);
bool packed = to_boolean (me->get_layout ()->c_variable ("packed"));
Real strength, distance;
}
assert (!isinf (compound_space));
- compound_space = compound_space >? compound_fixed;
+ compound_space = max (compound_space, compound_fixed);
/*
Hmm. we do 1/0 in the next thing. Perhaps we should check if this
Moment *dt = unsmob_moment (rc->get_property ("measure-length"));
if (dt)
{
- delta_t = delta_t <? * dt;
+ delta_t = min (delta_t, *dt);
/*
The following is an extra safety measure, such that
the length of a mmrest event doesn't cause havoc.
*/
- shortest_playing_len = shortest_playing_len <? * dt;
+ shortest_playing_len = min (shortest_playing_len, *dt);
}
}
Real dist = 0.0;
around to get chord tremolos to behave properly.
*/
- shortest_playing_len = shortest_playing_len >? delta_t;
+ shortest_playing_len = max (shortest_playing_len, delta_t);
if (delta_t.main_part_ && !lwhen.grace_part_)
{
dist = get_duration_space (me, shortest_playing_len, shortest.main_part_, expand_only);
projects / lilypond.git / commitdiff