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