]> git.donarmstrong.com Git - lilypond.git/blob - lily/duration.cc
Release: bump VERSION_DEVEL.
[lilypond.git] / lily / duration.cc
1 /*
2   This file is part of LilyPond, the GNU music typesetter.
3
4   Copyright (C) 1997--2014 Jan Nieuwenhuizen <janneke@gnu.org>
5   Han-Wen Nienhuys <hanwen@xs4all.nl>
6
7   LilyPond is free software: you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation, either version 3 of the License, or
10   (at your option) any later version.
11
12   LilyPond is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "duration.hh"
22
23 #include "misc.hh"
24 #include "lily-proto.hh"
25
26
27 int
28 Duration::compare (Duration const &left, Duration const &right)
29 {
30   return Rational::compare (left.get_length (), right.get_length ());
31 }
32
33 Duration::Duration ()
34 {
35   durlog_ = 0;
36   dots_ = 0;
37   factor_ = Rational (1, 1);
38 }
39
40 Duration::Duration (int log, int d)
41 {
42   durlog_ = log;
43   dots_ = d;
44   factor_ = Rational (1, 1);
45 }
46
47 Duration::Duration (Rational r, bool scale)
48 {
49   factor_ = Rational (1, 1);
50
51   if (r.num () == 0.0)
52     {
53       durlog_ = 0;
54       dots_ = 0;
55     }
56   else
57     {
58       /* we want to find the integer k for which 2q/p > 2^k >= q/p.
59          It's simple to check that k' = \floor \log q - \floor \log p
60          satisfies the left inequality and is within a factor of 2 of
61          satistying the right one. Therefore either k = k' or k = k'+1 */
62
63       int p = (int) r.num ();
64       int q = (int) r.den ();
65       int k = intlog2 (q) - intlog2 (p);
66       if (shift_left (p, k) < q)
67         k++;
68
69       assert (shift_left (p, k) >= q && shift_left (p, (k - 1)) < q);
70
71       /* If we were to write out log (p/q) in base 2, then the position of the
72          first non-zero bit (ie. k in our notation) would be the durlog
73          and the number of consecutive 1s after that bit would be the number of
74          dots */
75       p = shift_left (p, k) - q;
76       dots_ = 0;
77       while ((p *= 2) >= q)
78         {
79           p -= q;
80           dots_++;
81         }
82
83       /* we only go up to 64th notes */
84       if (k > 6)
85         {
86           durlog_ = 6;
87           dots_ = 0;
88         }
89       else
90         durlog_ = k;
91
92       if (scale || k > 6)
93         factor_ = r / get_length ();
94     }
95 }
96
97 Duration
98 Duration::compressed (Rational m) const
99 {
100   Duration d (*this);
101   d.factor_ *= m;
102   return d;
103 }
104
105 Rational
106 Duration::get_length () const
107 {
108   Rational mom (1 << abs (durlog_));
109
110   if (durlog_ > 0)
111     mom = Rational (1) / mom;
112
113   Rational delta = mom;
114   for (int i = 0; i < dots_; i++)
115     {
116       delta /= Rational (2);
117       mom += delta;
118     }
119
120   return mom * factor_;
121 }
122
123 string
124 Duration::to_string () const
125 {
126   string s;
127
128   if (durlog_ < 0)
129     s = "log = " + ::to_string (durlog_);
130   else
131     s = ::to_string (1 << durlog_);
132
133   s += ::to_string ('.', dots_);
134   if (factor_ != Moment (Rational (1, 1)))
135     s += "*" + factor_.to_string ();
136   return s;
137 }
138
139 const char Duration::type_p_name_[] = "ly:duration?";
140
141
142 int
143 Duration::print_smob (SCM s, SCM port, scm_print_state *)
144 {
145   Duration *r = (Duration *) SCM_CELL_WORD_1 (s);
146
147   scm_puts ("#<Duration ", port);
148   scm_display (ly_string2scm (r->to_string ()), port);
149   scm_puts (" >", port);
150
151   return 1;
152 }
153
154 SCM
155 Duration::equal_p (SCM a, SCM b)
156 {
157   Duration *p = (Duration *) SCM_CELL_WORD_1 (a);
158   Duration *q = (Duration *) SCM_CELL_WORD_1 (b);
159
160   bool eq = p->dots_ == q->dots_
161             && p->durlog_ == q->durlog_
162             && p->factor_ == q->factor_;
163
164   return eq ? SCM_BOOL_T : SCM_BOOL_F;
165 }
166
167 int
168 Duration::duration_log () const
169 {
170   return durlog_;
171 }
172
173 int
174 Duration::dot_count () const
175 {
176   return dots_;
177 }