lily/duration.cc

   1 /*
   2   duration.cc -- implement Duration
   3
   4   source file of the LilyPond music typesetter
   5
   6   (c) 1997--2004 Jan Nieuwenhuizen <janneke@gnu.org>
   7                  Han-Wen Nienhuys <hanwen@cs.uu.nl>
   8
   9 */
  10
  11 #include <assert.h>
  12
  13 #include "misc.hh"
  14 #include "lily-proto.hh"
  15 #include "string.hh"
  16 #include "moment.hh"
  17 #include "duration.hh"
  18 #include "ly-smobs.icc"
  19
  20
  21 int
  22 Duration::compare (Duration const &left, Duration const &right)
  23 {
  24   return Rational::compare (left.get_length (), right.get_length ());
  25 }
  26
  27 Duration::Duration ()
  28 {
  29   durlog_ = 0;
  30   dots_ = 0;
  31   factor_ = Rational (1, 1);
  32 }
  33
  34 Duration::Duration (int log, int d)
  35 {
  36   durlog_ = log;
  37   dots_ = d;
  38   factor_ = Rational (1, 1);
  39 }
  40
  41 Duration
  42 Duration::compressed (Rational m) const
  43 {
  44   Duration d (*this);
  45   d.factor_ *= m;
  46   return d;
  47 }
  48
  49 Rational
  50 Duration::get_length () const
  51 {
  52   Rational mom (1 << abs (durlog_));
  53
  54   if (durlog_> 0)
  55     mom = Rational (1) / mom;
  56
  57   Rational delta = mom;
  58   for (int i = 0; i < dots_; i++)
  59     {
  60       delta /= Rational (2);
  61       mom += delta;
  62     }
  63
  64   return mom * factor_;
  65 }
  66
  67 String
  68 Duration::to_string () const
  69 {
  70   String s;
  71
  72   if (durlog_ < 0  )
  73     s = "log = "  + ::to_string (durlog_);
  74   else
  75     s = ::to_string (1 << durlog_);
  76
  77   s += ::to_string ('.', dots_);
  78   if (factor_ != Moment (Rational (1, 1)))
  79     s += "*" + factor_.to_string ();
  80   return s;
  81 }
  82
  83
  84 IMPLEMENT_TYPE_P (Duration, "ly:duration?");
  85
  86 SCM
  87 Duration::mark_smob (SCM)
  88 {
  89   return SCM_EOL;
  90 }
  91
  92 IMPLEMENT_SIMPLE_SMOBS (Duration);
  93 int
  94 Duration::print_smob (SCM s, SCM port, scm_print_state *)
  95 {
  96   Duration  *r = (Duration *) ly_cdr (s);
  97
  98   scm_puts ("#<Duration ", port);
  99   scm_display (scm_makfrom0str (r->to_string ().to_str0 ()), port);
 100   scm_puts (" >", port);
 101
 102   return 1;
 103 }
 104
 105 SCM
 106 Duration::equal_p (SCM a , SCM b)
 107 {
 108   Duration  *p = (Duration *) ly_cdr (a);
 109   Duration  *q = (Duration *) ly_cdr (b);
 110
 111   bool eq = p->dots_ == q->dots_
 112     && p->durlog_ == q->durlog_
 113     && p->factor_ == q->factor_;
 114
 115   return eq ? SCM_BOOL_T : SCM_BOOL_F;
 116 }
 117
 118 MAKE_SCHEME_CALLBACK (Duration, less_p, 2);
 119 SCM
 120 Duration::less_p (SCM p1, SCM p2)
 121 {
 122   Duration *a = unsmob_duration (p1);
 123   Duration *b = unsmob_duration (p2);
 124
 125   if (compare (*a, *b) < 0)
 126     return SCM_BOOL_T;
 127   else
 128     return SCM_BOOL_F;
 129 }
 130
 131 LY_DEFINE (duration_less, "ly:duration<?",
 132            2, 0, 0, (SCM p1, SCM p2),
 133           "Is @var{p1} shorter than @var{p2}?")
 134 {
 135   Duration *a = unsmob_duration (p1);
 136   Duration *b = unsmob_duration (p2);
 137
 138   SCM_ASSERT_TYPE (a, p1, SCM_ARG1, __FUNCTION__, "Duration");
 139   SCM_ASSERT_TYPE (b, p2, SCM_ARG2, __FUNCTION__, "Duration");
 140
 141   if (Duration::compare (*a, *b) < 0)
 142     return SCM_BOOL_T;
 143   else
 144     return SCM_BOOL_F;
 145 }
 146
 147 LY_DEFINE (make_duration, "ly:make-duration",
 148            1, 3, 0, (SCM length, SCM dotcount, SCM num, SCM den),
 149            "@var{length} is the negative logarithm (base 2) of the duration:\n"
 150            "1 is a half note, 2 is a quarter note, 3 is an eighth\n"
 151            "note, etc.  The number of dots after the note is given by\n"
 152            "the optional argument @var{dotcount}.\n"
 153            "\n"
 154            "The duration factor is optionally given by @var{num}\n"
 155            "and @var{den}.\n\n"
 156            "A duration is a musical duration, "
 157            "i.e. a length of time described by a power of two "
 158            "(whole, half, quarter, etc.) and a number of augmentation\n"
 159            "dots. \n")
 160 {
 161   SCM_ASSERT_TYPE (scm_integer_p (length) == SCM_BOOL_T,
 162                    length, SCM_ARG1, __FUNCTION__, "integer");
 163
 164   int dots = 0;
 165   if (dotcount != SCM_UNDEFINED)
 166     {
 167       SCM_ASSERT_TYPE (scm_integer_p (dotcount) == SCM_BOOL_T,
 168                        dotcount, SCM_ARG2, __FUNCTION__, "integer");
 169       dots = gh_scm2int (dotcount);
 170     }
 171
 172   bool compress = false;
 173   if (num != SCM_UNDEFINED)
 174     {
 175       SCM_ASSERT_TYPE (gh_number_p (num), length, SCM_ARG3, __FUNCTION__, "integer");
 176       compress = true;
 177     }
 178   else
 179     num = gh_int2scm (1);
 180
 181   if (den != SCM_UNDEFINED)
 182     {
 183       SCM_ASSERT_TYPE (gh_number_p (den), length, SCM_ARG4, __FUNCTION__, "integer");
 184       compress = true;
 185     }
 186   else
 187     den = gh_int2scm (1);
 188
 189   Duration p (gh_scm2int (length), dots);
 190   if (compress)
 191     p = p.compressed (Rational (gh_scm2int (num), gh_scm2int (den)));
 192
 193   return p.smobbed_copy ();
 194 }
 195
 196 LY_DEFINE (duration_log, "ly:duration-log",
 197            1, 0, 0, (SCM dur),
 198           "Extract the duration log from @var{dur}")
 199 {
 200   SCM_ASSERT_TYPE (unsmob_duration (dur), dur, SCM_ARG1, __FUNCTION__, "duration");
 201   return gh_int2scm (unsmob_duration (dur)->duration_log ());
 202 }
 203
 204 LY_DEFINE (dot_count_log, "ly:duration-dot-count", 1, 0, 0, (SCM dur),
 205           "Extract the dot count from @var{dur}"
 206 )
 207 {
 208   SCM_ASSERT_TYPE (unsmob_duration (dur), dur, SCM_ARG1, __FUNCTION__, "duration");
 209   return gh_int2scm (unsmob_duration (dur)->dot_count ());
 210 }
 211
 212
 213 LY_DEFINE (ly_intlog2, "ly:intlog2",
 214            1, 0, 0, (SCM d),
 215           "The 2-logarithm of 1/@var{d}.")
 216 {
 217   SCM_ASSERT_TYPE (gh_number_p (d), d, SCM_ARG1, __FUNCTION__, "integer");
 218   int log = intlog2 (gh_scm2int (d));
 219   return gh_int2scm (log);
 220 }
 221
 222 LY_DEFINE (compression_factor, "ly:duration-factor",
 223            1, 0, 0, (SCM dur),
 224           "Extract the compression factor from @var{dur}. Return as a pair.")
 225 {
 226   SCM_ASSERT_TYPE (unsmob_duration (dur), dur, SCM_ARG1, __FUNCTION__, "duration");
 227   Rational r = unsmob_duration (dur)->factor ();
 228   return gh_cons (gh_int2scm (r.num ()), gh_int2scm (r.den ()));
 229 }
 230
 231 int
 232 Duration::duration_log () const
 233 {
 234   return durlog_;
 235 }
 236
 237 int
 238 Duration::dot_count () const
 239 {
 240   return dots_;
 241 }