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            2, 2, 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            "@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 (gh_number_p (length), length, SCM_ARG1, __FUNCTION__, "integer");
 162   SCM_ASSERT_TYPE (gh_number_p (dotcount), dotcount, SCM_ARG2, __FUNCTION__, "integer");
 163
 164   bool compress = false;
 165   if (num != SCM_UNDEFINED)
 166     {
 167       SCM_ASSERT_TYPE (gh_number_p (num), length, SCM_ARG3, __FUNCTION__, "integer");
 168       compress = true;
 169     }
 170   else
 171     num = gh_int2scm (1);
 172
 173   if (den != SCM_UNDEFINED)
 174     {
 175       SCM_ASSERT_TYPE (gh_number_p (den), length, SCM_ARG4, __FUNCTION__, "integer");
 176       compress = true;
 177     }
 178   else
 179     den = gh_int2scm (1);
 180
 181   Duration p (gh_scm2int (length), gh_scm2int (dotcount));
 182   if (compress)
 183     p = p.compressed (Rational (gh_scm2int (num), gh_scm2int (den)));
 184
 185   return p.smobbed_copy ();
 186 }
 187
 188 LY_DEFINE (duration_log, "ly:duration-log",
 189            1, 0, 0, (SCM dur),
 190           "Extract the duration log from @var{dur}")
 191 {
 192   SCM_ASSERT_TYPE (unsmob_duration (dur), dur, SCM_ARG1, __FUNCTION__, "duration");
 193   return gh_int2scm (unsmob_duration (dur)->duration_log ());
 194 }
 195
 196 LY_DEFINE (dot_count_log, "ly:duration-dot-count", 1, 0, 0, (SCM dur),
 197           "Extract the dot count from @var{dur}"
 198 )
 199 {
 200   SCM_ASSERT_TYPE (unsmob_duration (dur), dur, SCM_ARG1, __FUNCTION__, "duration");
 201   return gh_int2scm (unsmob_duration (dur)->dot_count ());
 202 }
 203
 204
 205 LY_DEFINE (ly_intlog2, "ly:intlog2",
 206            1, 0, 0, (SCM d),
 207           "The 2-logarithm of 1/@var{d}.")
 208 {
 209   SCM_ASSERT_TYPE (gh_number_p (d), d, SCM_ARG1, __FUNCTION__, "integer");
 210   int log = intlog2 (gh_scm2int (d));
 211   return gh_int2scm (log);
 212 }
 213
 214 LY_DEFINE (compression_factor, "ly:duration-factor",
 215            1, 0, 0, (SCM dur),
 216           "Extract the compression factor from @var{dur}. Return as a pair.")
 217 {
 218   SCM_ASSERT_TYPE (unsmob_duration (dur), dur, SCM_ARG1, __FUNCTION__, "duration");
 219   Rational r = unsmob_duration (dur)->factor ();
 220   return gh_cons (gh_int2scm (r.num ()), gh_int2scm (r.den ()));
 221 }
 222
 223 int
 224 Duration::duration_log () const
 225 {
 226   return durlog_;
 227 }
 228
 229 int
 230 Duration::dot_count () const
 231 {
 232   return dots_;
 233 }