lily/moment.cc

   1 /*
   2   moment.cc --  implement Moment
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1999--2002 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7
   8  */
   9
  10
  11 #include "lily-guile.hh"
  12 #include "moment.hh"
  13 #include "warn.hh"
  14 #include "ly-smobs.icc"
  15
  16
  17 IMPLEMENT_SIMPLE_SMOBS (Moment);
  18 IMPLEMENT_TYPE_P (Moment, "moment?");
  19
  20 SCM
  21 Moment::mark_smob (SCM)
  22 {
  23   return SCM_EOL;
  24 }
  25
  26
  27 SCM
  28 Moment::smobbed_copy () const
  29 {
  30   Moment * m = new Moment (*this);
  31   return m->smobbed_self ();
  32 }
  33
  34
  35 int
  36 Moment::print_smob (SCM s, SCM port, scm_print_state *)
  37 {
  38   Moment  *r = (Moment *) ly_cdr (s);
  39
  40   scm_puts ("#<Mom ", port);
  41   String str (r->str ());
  42   scm_puts ((char *)str.ch_C (), port);
  43   scm_puts (" >", port);
  44
  45   return 1;
  46 }
  47
  48 /*
  49   TODO: add optional factor argument.
  50  */
  51 LY_DEFINE (make_moment,"make-moment", 2,0,0, (SCM n, SCM d),
  52            "create the rational number with main timing @var{n}/@var{d}.
  53
  54
  55 Moment is a point in musical time. It is consists of a pair of
  56 rationals (@var{m},@var{g}), where @var{m} is the timing for the  main
  57 notes, and @var{g} the timing for  grace notes. In absence of grace
  58 notes, @var{g} is zero.
  59 ")
  60 {
  61   Moment m (Rational (1,1));
  62
  63   if (SCM_INUMP (n) && SCM_INUMP (d))
  64     {
  65       m =  Moment (Rational (gh_scm2int (n), gh_scm2int (d)));
  66     }
  67   else
  68     {
  69       ::error ("make-moment takes two integer arguments. Using 1/1");
  70     }
  71
  72   return m.smobbed_copy ();
  73 }
  74
  75 SCM
  76 Moment::equal_p (SCM a, SCM b)
  77 {
  78   Moment *m1 = unsmob_moment (a);
  79   Moment *m2 = unsmob_moment (b);
  80
  81   return (*m1 == *m2) ? SCM_BOOL_T : SCM_BOOL_F;
  82 }
  83
  84 /****************************************************************/
  85
  86 int
  87 compare (Moment const &a, Moment const &b)
  88 {
  89   return Moment::compare (a,b);
  90 }
  91
  92 int
  93 Moment::compare (Moment const &a, Moment const &b)
  94 {
  95   int c = Rational::compare (a.main_part_,b.main_part_);
  96   if (c)
  97     return c;
  98
  99   return Rational::compare (a.grace_part_, b.grace_part_);
 100 }
 101
 102 Moment::Moment ()
 103 {
 104
 105 }
 106
 107 Moment::Moment (int m)
 108 {
 109   main_part_ = Rational(m);
 110   grace_part_  = Rational( 0);
 111 }
 112
 113 Moment::Moment (Rational m, Rational g)
 114 {
 115   main_part_ = m;
 116   grace_part_  = g;
 117 }
 118
 119 Moment::Moment (Rational m)
 120 {
 121   main_part_ = m;
 122   grace_part_  = Rational (0);
 123 }
 124
 125 void
 126 Moment::operator += (Moment const &src)
 127 {
 128   main_part_ +=src.main_part_ ;
 129   grace_part_ += src.grace_part_;
 130 }
 131 void
 132 Moment::operator -= (Moment const &src)
 133 {
 134   main_part_ -= src.main_part_ ;
 135   grace_part_ -= src.grace_part_;
 136 }
 137
 138 /*
 139   only take the main part of SRC for multiplication.
 140  */
 141 void
 142 Moment::operator *= (Moment const &src)
 143 {
 144   main_part_ *= src.main_part_ ;
 145   grace_part_ *= src.main_part_;
 146 }
 147
 148 /*
 149   only take the main part of SRC for multiplication.
 150  */
 151 void
 152 Moment::operator /= (Moment const &src)
 153 {
 154   main_part_ /= src.main_part_ ;
 155   grace_part_ /= src.main_part_;
 156 }
 157
 158
 159 #if 0
 160 Moment::operator Rational()
 161 {
 162   return main_part_;
 163 }
 164 #endif
 165
 166 int
 167 Moment::den () const { return main_part_.den (); }
 168
 169 int
 170 Moment::num () const { return main_part_.num (); }
 171
 172 bool
 173 Moment::to_bool () const
 174 {
 175   return main_part_ || grace_part_;
 176 }
 177
 178 void
 179 Moment::set_infinite (int k)
 180 {
 181   main_part_.set_infinite (k);
 182 }
 183
 184
 185 String
 186 Moment::str () const
 187 {
 188   String s =  main_part_.str ();
 189   if (grace_part_)
 190     {
 191       s += "G" + grace_part_.str ();
 192     }
 193   return s;
 194 }
 195
 196 Moment
 197 Moment::operator - () const
 198 {
 199   Moment m;
 200   m.grace_part_ = - grace_part_;
 201   m. main_part_ = - main_part_ ;
 202   return m;
 203 }
 204
 205
 206 #ifdef STREAM_SUPPORT
 207 std::ostream &
 208 operator << (std::ostream &os, Moment const &m)
 209 {
 210   os << m.str ();
 211   return os;
 212 }
 213 #endif