lily/duration.cc

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