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 SCM
  52 make_rational (SCM n, SCM d)
  53 {
  54   Moment m (Rational (1,1));
  55
  56   if (SCM_INUMP (n) && SCM_INUMP (d))
  57     {
  58       m =  Moment (Rational (gh_scm2int (n), gh_scm2int (d)));
  59     }
  60   else
  61     {
  62       ::error ("make-moment takes two integer arguments. Using 1/1");
  63     }
  64
  65   return m.smobbed_copy ();
  66 }
  67
  68
  69 void
  70 init_moments ()
  71 {
  72   scm_c_define_gsubr ("make-moment", 2 , 0, 0, (Scheme_function_unknown) make_rational);
  73 }
  74
  75 ADD_SCM_INIT_FUNC (moms,init_moments);
  76
  77 SCM
  78 Moment::equal_p (SCM a, SCM b)
  79 {
  80   Moment *m1 = unsmob_moment (a);
  81   Moment *m2 = unsmob_moment (b);
  82
  83   return (*m1 == *m2) ? SCM_BOOL_T : SCM_BOOL_F;
  84 }
  85
  86 /****************************************************************/
  87
  88 int
  89 compare (Moment const &a, Moment const &b)
  90 {
  91   return Moment::compare (a,b);
  92 }
  93
  94 int
  95 Moment::compare (Moment const &a, Moment const &b)
  96 {
  97   int c = Rational::compare (a.main_part_,b.main_part_);
  98   if (c)
  99     return c;
 100
 101   return Rational::compare (a.grace_part_, b.grace_part_);
 102 }
 103
 104 Moment::Moment ()
 105 {
 106
 107 }
 108
 109 Moment::Moment (int m)
 110 {
 111   main_part_ = Rational(m);
 112   grace_part_  = Rational( 0);
 113 }
 114
 115 Moment::Moment (Rational m, Rational g)
 116 {
 117   main_part_ = m;
 118   grace_part_  = g;
 119 }
 120
 121 Moment::Moment (Rational m)
 122 {
 123   main_part_ = m;
 124   grace_part_  = Rational (0);
 125 }
 126
 127 void
 128 Moment::operator += (Moment const &src)
 129 {
 130   main_part_ +=src.main_part_ ;
 131   grace_part_ += src.grace_part_;
 132 }
 133 void
 134 Moment::operator -= (Moment const &src)
 135 {
 136   main_part_ -= src.main_part_ ;
 137   grace_part_ -= src.grace_part_;
 138 }
 139
 140 /*
 141   only take the main part of SRC for multiplication.
 142  */
 143 void
 144 Moment::operator *= (Moment const &src)
 145 {
 146   main_part_ *= src.main_part_ ;
 147   grace_part_ *= src.main_part_;
 148 }
 149
 150 /*
 151   only take the main part of SRC for multiplication.
 152  */
 153 void
 154 Moment::operator /= (Moment const &src)
 155 {
 156   main_part_ /= src.main_part_ ;
 157   grace_part_ /= src.main_part_;
 158 }
 159
 160
 161 #if 0
 162 Moment::operator Rational()
 163 {
 164   return main_part_;
 165 }
 166 #endif
 167
 168 int
 169 Moment::den () const { return main_part_.den (); }
 170
 171 int
 172 Moment::num () const { return main_part_.num (); }
 173
 174 bool
 175 Moment::to_bool () const
 176 {
 177   return main_part_ || grace_part_;
 178 }
 179
 180 void
 181 Moment::set_infinite (int k)
 182 {
 183   main_part_.set_infinite (k);
 184 }
 185
 186
 187 String
 188 Moment::str () const
 189 {
 190   String s =  main_part_.str ();
 191   if (grace_part_)
 192     {
 193       s += "G" + grace_part_.str ();
 194     }
 195   return s;
 196 }
 197
 198 Moment
 199 Moment::operator - () const
 200 {
 201   Moment m;
 202   m.grace_part_ = -grace_part_;
 203   m.main_part_ = -main_part_;
 204   return m;
 205 }
 206
 207 ostream &
 208 operator << (ostream &os, Moment const &m)
 209 {
 210   os << m.str ();
 211   return os;
 212 }