1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
|
//=============================================================================
// MuseScore
// Music Composition & Notation
//
// Copyright (C) 2019 Werner Schweer
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2
// as published by the Free Software Foundation and appearing in
// the file LICENCE.GPL
//=============================================================================
// everything contained in .h file for performance reasons
#ifndef __FRACTION_H__
#define __FRACTION_H__
#include "config.h"
#include "mscore.h"
namespace Ms {
//---------------------------------------------------------
// gcd
// greatest common divisor. always returns a positive val
// however, since int / uint = uint by C++ rules,
// return int to avoid accidental implicit unsigned cast
//---------------------------------------------------------
static int_least64_t gcd(int_least64_t a, int_least64_t b)
{
int bp;
if (b > a) { bp = b; b = a; a = bp; } // Saves one % if true
while (b != 0) {
bp = b; b = a % b; a = bp;
}
return (a >= 0 ? a : -a);
}
//---------------------------------------------------------
// Fraction
//---------------------------------------------------------
class Fraction {
// ensure 64 bit to avoid overflows in comparisons
int_least64_t _numerator { 0 };
int_least64_t _denominator { 1 };
public:
#if 0
// implicit conversion from int to Fraction: this is convenient but may hide some potential bugs
constexpr Fraction(int z=0, int n=1) : _numerator(z), _denominator(n) {}
#else
// no implicit conversion from int to Fraction:
constexpr Fraction() {}
constexpr Fraction(int z, int n) : _numerator { n < 0 ? -z : z }, _denominator { n < 0 ? -n : n } { }
#endif
int numerator() const { return _numerator; }
int denominator() const { return _denominator; }
int_least64_t& rnumerator() { return _numerator; }
int_least64_t& rdenominator() { return _denominator; }
void setNumerator(int v) { _numerator = v; }
void setDenominator(int v) {
if (v < 0) { _numerator = -_numerator; _denominator = -v; }
else _denominator = v;
}
void set(int z, int n) {
if (n < 0) { _numerator = -z; _denominator = -n; }
else { _numerator = z; _denominator = n; }
}
bool isZero() const { return _numerator == 0; }
bool isNotZero() const { return _numerator != 0; }
bool isValid() const { return _denominator != 0; }
// check if two fractions are identical (numerator & denominator)
// == operator checks for equal value:
bool identical(const Fraction& v) const {
return (_numerator == v._numerator) &&
(_denominator == v._denominator);
}
Fraction absValue() const {
return Fraction(qAbs(_numerator), _denominator); }
// --- reduction --- //
void reduce()
{
const int g = gcd(_numerator, _denominator);
_numerator /= g; _denominator /= g;
}
Fraction reduced() const
{
const int g = gcd(_numerator, _denominator);
return Fraction(_numerator / g, _denominator / g);
}
// --- comparison --- //
bool operator<(const Fraction& val) const
{
return _numerator * val._denominator < val._numerator * _denominator;
}
bool operator<=(const Fraction& val) const
{
return _numerator * val._denominator <= val._numerator * _denominator;
}
bool operator>=(const Fraction& val) const
{
return _numerator * val._denominator >= val._numerator * _denominator;
}
bool operator>(const Fraction& val) const
{
return _numerator * val._denominator > val._numerator * _denominator;
}
bool operator==(const Fraction& val) const
{
return _numerator * val._denominator == val._numerator * _denominator;
}
bool operator!=(const Fraction& val) const
{
return _numerator * val._denominator != val._numerator * _denominator;
}
// --- arithmetic --- //
Fraction& operator+=(const Fraction& val)
{
if (_denominator == val._denominator)
_numerator += val._numerator; // Common enough use case to be handled separately for efficiency
else {
const int g = gcd(_denominator, val._denominator);
const int m1 = val._denominator / g; // This saves one division over straight lcm
_numerator = _numerator * m1 + val._numerator * (_denominator / g);
_denominator = m1 * _denominator;
}
return *this;
}
Fraction& operator-=(const Fraction& val)
{
if (_denominator == val._denominator)
_numerator -= val._numerator; // Common enough use case to be handled separately for efficiency
else {
const int g = gcd(_denominator, val._denominator);
const int m1 = val._denominator / g; // This saves one division over straight lcm
_numerator = _numerator * m1 - val._numerator * (_denominator / g);
_denominator = m1 * _denominator;
}
return *this;
}
Fraction& operator*=(const Fraction& val)
{
_numerator *= val._numerator;
_denominator *= val._denominator;
if (val._denominator != 1) reduce(); // We should be free to fully reduce here
return *this;
}
Fraction& operator*=(int val)
{
_numerator *= val;
return *this;
}
Fraction& operator/=(const Fraction& val)
{
const int sign = (val._numerator >= 0 ? 1 : -1);
_numerator *= (sign*val._denominator);
_denominator *= (sign*val._numerator);
if (val._numerator != sign) reduce();
return *this;
}
#if 0
Fraction& operator/=(int val)
{
_denominator *= val;
return *this;
}
#endif
Fraction operator+(const Fraction& v) const { return Fraction(*this) += v; }
Fraction operator-(const Fraction& v) const { return Fraction(*this) -= v; }
Fraction operator-() const { return Fraction(-_numerator, _denominator); }
Fraction operator*(const Fraction& v) const { return Fraction(*this) *= v; }
Fraction operator/(const Fraction& v) const { return Fraction(*this) /= v; }
// Fraction operator/(int v) const { return Fraction(*this) /= v; }
//---------------------------------------------------------
// fromTicks
//---------------------------------------------------------
static Fraction fromTicks(int ticks)
{
if (ticks == -1)
return Fraction(-1,1); // HACK
return Fraction(ticks, MScore::division * 4).reduced();
}
//---------------------------------------------------------
// eps
/// A very small fraction, corresponds to 1 MIDI tick
//---------------------------------------------------------
static Fraction eps() { return Fraction(1, MScore::division * 4); }
//---------------------------------------------------------
// ticks
//---------------------------------------------------------
int ticks() const
{
if (_numerator == -1 && _denominator == 1) // HACK
return -1;
// MScore::division - ticks per quarter note
// MScore::division * 4 - ticks per whole note
// result: rounded (MScore::division * 4 * _numerator * 1.0 / _denominator) value
const int sgn = (_numerator < 0) ? -1 : 1;
const auto result = sgn * (static_cast<int_least64_t>(sgn * _numerator) * MScore::division * 4 + (_denominator/2)) / _denominator;
return static_cast<int>(result);
}
QString print() const { return QString("%1/%2").arg(_numerator).arg(_denominator); }
QString toString() const { return print(); }
static Fraction fromString(const QString& str) {
const int i = str.indexOf('/');
return (i == -1) ? Fraction(str.toInt(), 1) : Fraction(str.leftRef(i).toInt(), str.midRef(i+1).toInt());
}
operator QVariant() const { return QVariant::fromValue(*this); }
};
inline Fraction operator*(const Fraction& f, int v) { return Fraction(f) *= v; }
inline Fraction operator*(int v, const Fraction& f) { return Fraction(f) *= v; }
} // namespace Ms
Q_DECLARE_METATYPE(Ms::Fraction);
#endif
|
