imported new rational type

This commit is contained in:
itsmattkc
2019-08-06 08:25:48 +10:00
parent f55094c5df
commit cee2b617a1
2 changed files with 418 additions and 393 deletions
+316 -320
View File
@@ -1,412 +1,408 @@
/*** //Copyright 2015 Adam Quintero
//This program is distributed under the terms of the GNU General Public License.
Olive - Non-Linear Video Editor
Copyright (C) 2019 Olive Team
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
***/
#include "rational.h" #include "rational.h"
rational::rational(const int64_t &numerator) : int rational::activeInstances = 0;
numerator_(numerator),
denominator_(1)
{
if (numerator_ == 0) {
denominator_ = 0;
}
}
rational::rational(const int64_t &numerator, const int64_t &denominator) :
numerator_(numerator),
denominator_(denominator)
{
if (denominator_ != 0) {
if (numerator_ != 0) {
FixSigns();
Reduce();
} else {
denominator_ = 0;
}
} else {
numerator_ = 0;
}
}
rational::rational(const AVRational &r) : rational::rational(const AVRational &r) :
numerator_(r.num), numer(r.num),
denominator_(r.den) denom(r.den)
{ {
} }
rational::rational(const rational &r) : rational::~rational()
numerator_(r.numerator_),
denominator_(r.denominator_)
{ {
activeInstances--;
} }
const rational &rational::operator=(const rational &r) //Function: print number to cout
{
if (this != &r) {
numerator_ = r.numerator_;
denominator_ = r.denominator_;
}
void rational::print(ostream &out) const
{
out << this->numer << "/" << this->denom;
}
//Function: ensures denom >= 0
void rational::fixSigns()
{
if(denom < 0)
{
denom = -denom;
numer = -numer;
}
if(numer == intType(0) || denom == intType(0))
{
numer = intType(0);
denom = intType(0);
}
}
//Function: ensures lowest form
void rational::reduce()
{
intType d = 1;
if(denom != 0 && numer !=0)
d = gcd(numer, denom);
if(d > 1)
{
numer /= d;
denom /= d;
}
}
//Function: finds greatest common denominator
intType rational::gcd(intType &x, intType &y)
{
if(y == 0)
return x;
else
{
intType tmp = x % y;
return gcd(y, tmp);
}
}
//Function: convert to double
double rational::toDouble() const
{
if(denom != 0)
return static_cast<double>(numer) / static_cast<double>(denom);
else
return static_cast<double>(0);
}
rational rational::flipped() const
{
return rational(denom, numer);
}
//Function: get active instances
int rational::getActiveInstances()
{
return activeInstances;
}
const intType &rational::numerator() const
{
return numer;
}
const intType &rational::denominator() const
{
return denom;
}
//Assignment Operators
const rational& rational::operator=(const rational &rhs)
{
if(this != &rhs)
{
numer = rhs.numer;
denom = rhs.denom;
}
return *this; return *this;
} }
const rational &rational::operator+=(const rational &r) const rational& rational::operator+=(const rational &rhs)
{ {
if (numerator_ * denominator_ == 0 && r.numerator_ * r.denominator_ == 0) { if(numer * denom == intType(0) && rhs.numer * rhs.denom == intType(0))
numerator_ = 0; {
denominator_ = 0; numer = intType(0);
} else { denom = intType(0);
if(numerator_ * denominator_ != 0 && r.numerator_ * r.denominator_ == 0) { }
// The other rational == 0, no addition needs to be done else
} else { if(numer * denom != intType(0) && rhs.numer * rhs.denom == intType(0))
if(numerator_ * denominator_ == 0 && r.numerator_ * r.denominator_ != 0)
{ {
numerator_ = r.numerator_;
denominator_ = r.denominator_;
} }
else
if(numer * denom == intType(0) && rhs.numer * rhs.denom != intType(0))
{
numer = rhs.numer;
denom = rhs.denom;
}
else else
{
numer = (numer * rhs.denom) + (rhs.numer * denom);
denom = denom * rhs.denom;
fixSigns();
reduce();
}
return *this;
}
const rational& rational::operator-=(const rational &rhs)
{
if(numer * denom == intType(0) && rhs.numer * rhs.denom == intType(0))
{
numer = intType(0);
denom = intType(0);
}
else
if(numer * denom != intType(0) && rhs.numer * rhs.denom == intType(0))
{ {
numerator_ = (numerator_ * r.denominator_) + (r.numerator_ * denominator_);
denominator_ = denominator_ * r.denominator_;
FixSigns();
Reduce();
} }
} else
} if(numer * denom == intType(0) && rhs.numer * rhs.denom != intType(0))
return *this; {
} numer = -(rhs.numer);
denom = rhs.denom;
const rational &rational::operator-=(const rational &r) }
{
if(numerator_ * denominator_ == 0 && r.numerator_ * r.numerator_ == 0) {
numerator_ = 0;
denominator_ = 0;
} else {
if(numerator_ * denominator_ != 0 && r.numerator_ * r.denominator_ == 0) {
} else {
if(numerator_ * denominator_ == 0 && r.numerator_ * r.denominator_ != 0) {
numerator_ = -(r.numerator_);
denominator_ = r.denominator_;
} else {
numerator_ = (numerator_ * r.denominator_) - (r.numerator_ * denominator_);
numerator_ = denominator_ * r.denominator_;
FixSigns();
Reduce();
}
}
}
return *this;
}
const rational &rational::operator/=(const rational &r)
{
numerator_ = numerator_ * r.denominator_;
denominator_ = denominator_ * r.numerator_;
FixSigns();
Reduce();
return *this;
}
const rational &rational::operator*=(const rational &r)
{
numerator_ = numerator_ * r.numerator_;
denominator_ = denominator_ * r.denominator_;
FixSigns();
Reduce();
return *this;
}
rational rational::operator+(const rational &r) const
{
rational result(*this);
result += r;
return result;
}
rational rational::operator-(const rational &r) const
{
rational result(*this);
result -= r;
return result;
}
rational rational::operator/(const rational &r) const
{
rational result(*this);
result /= r;
return result;
}
rational rational::operator*(const rational &r) const
{
rational result(*this);
result *= r;
return result;
}
bool rational::operator<(const rational &r) const
{
if (numerator_ * denominator_ == 0 && r.numerator_ * r.denominator_ == 0) {
return false;
} else {
if (numerator_ * denominator_ != 0 && r.numerator_ * r.denominator_ == 0) {
if(numerator_ * denominator_ < 0)
return true;
else else
return false; {
} numer = (numer * rhs.denom) - (rhs.numer * denom);
else { denom = denom * rhs.denom;
if (numerator_ * denominator_ == 0 && r.numerator_ * r.denominator_ != 0) { fixSigns();
if (r.numerator_ * r.denominator_ < 0) { reduce();
return false;
} else {
return true;
} }
} else { return *this;
return ((numerator_ * r.denominator_) < (denominator_ * r.numerator_));
}
}
}
} }
bool rational::operator<=(const rational &r) const const rational& rational::operator/=(const rational &rhs)
{ {
if(numerator_ * denominator_ == 0 && r.numerator_ * r.denominator_ == 0) { numer = numer * rhs.denom;
return true; denom = denom * rhs.numer;
} else { fixSigns();
if(numerator_ * denominator_ != 0 && r.numerator_ * r.denominator_ == 0) { reduce();
if(numerator_ * denominator_ < 0) { return *this;
return true;
} else {
return false;
}
} else {
if(numerator_ * denominator_ == 0 && r.numerator_ * r.denominator_ != 0) {
if(r.numerator_ * r.denominator_ < 0) {
return false;
} else {
return true;
}
} else {
return ((numerator_ * r.denominator_) <= (denominator_ * r.numerator_));
}
}
}
} }
bool rational::operator>(const rational &r) const const rational& rational::operator*=(const rational &rhs)
{ {
if(numerator_ * denominator_ == 0 && r.numerator_ * r.denominator_ == 0) { numer = numer * rhs.numer;
denom = denom * rhs.denom;
fixSigns();
reduce();
return *this;
}
//Binary math operators
rational rational::operator+(const rational &rhs) const
{
rational answer(*this);
answer += rhs;
return answer;
}
rational rational::operator-(const rational &rhs) const
{
rational answer(*this);
answer -= rhs;
return answer;
}
rational rational::operator/(const rational &rhs) const
{
rational answer(*this);
answer /= rhs;
return answer;
}
rational rational::operator*(const rational &rhs) const
{
rational answer(*this);
answer *= rhs;
return answer;
}
//Relational and equality operators
bool rational::operator<(const rational &rhs) const
{
if(numer * denom == intType(0) && rhs.numer * rhs.denom == intType(0))
return false; return false;
} else { else
if(numerator_ * denominator_ != 0 && r.numerator_ * r.denominator_ == 0) { if(numer * denom != intType(0) && rhs.numer * rhs.denom == intType(0))
if(numerator_ * denominator_ > 0) { {
return true; if(numer * denom < intType(0))
} else {
return false;
}
} else {
if(numerator_ * denominator_ == 0 && r.numerator_ * r.denominator_ != 0) {
if(r.numerator_ * r.denominator_ > 0) {
return false;
} else {
return true; return true;
} else
} else { return false;
return ((numerator_ * r.denominator_) > (denominator_ * r.numerator_));
} }
} else
} if(numer * denom == intType(0) && rhs.numer * rhs.denom != intType(0))
{
if(rhs.numer * rhs.denom < intType(0))
return false;
else
return true;
}
else
return ((numer * rhs.denom) < (denom * rhs.numer));
} }
bool rational::operator>=(const rational &r) const bool rational::operator<=(const rational &rhs) const
{ {
if(numerator_ * denominator_ == 0 && r.numerator_ * r.denominator_ == 0) { if(numer * denom == intType(0) && rhs.numer * rhs.denom == intType(0))
return true; return true;
} else { else
if(numerator_ * denominator_ != 0 && r.numerator_ * r.denominator_ == 0) { if(numer * denom != intType(0) && rhs.numer * rhs.denom == intType(0))
if(numerator_ * denominator_ > 0) { {
return true; if(numer * denom < intType(0))
} else {
return false;
}
} else {
if(numerator_ * denominator_ == 0 && r.numerator_ * r.denominator_ != 0) {
if(r.numerator_ * r.denominator_ > 0) {
return false;
} else {
return true; return true;
} else
} else { return false;
return ((numerator_ * r.denominator_) >= (denominator_ * r.numerator_));
} }
} else
} if(numer * denom == intType(0) && rhs.numer * rhs.denom != intType(0))
{
if(rhs.numer * rhs.denom < intType(0))
return false;
else
return true;
}
else
return ((numer * rhs.denom) <= (denom * rhs.numer));
} }
bool rational::operator==(const rational &r) const bool rational::operator>(const rational &rhs) const
{ {
return (numerator_ == r.numerator_ && denominator_ == r.denominator_); if(numer * denom == intType(0) && rhs.numer * rhs.denom == intType(0))
return false;
else
if(numer * denom != intType(0) && rhs.numer * rhs.denom == intType(0))
{
if(numer * denom > intType(0))
return true;
else
return false;
}
else
if(numer * denom == intType(0) && rhs.numer * rhs.denom != intType(0))
{
if(rhs.numer * rhs.denom > intType(0))
return false;
else
return true;
}
else
return ((numer * rhs.denom) > (denom * rhs.numer));
} }
bool rational::operator!=(const rational &r) const bool rational::operator>=(const rational &rhs) const
{ {
return (numerator_ != r.numerator_) || (denominator_ != r.denominator_); if(numer * denom == intType(0) && rhs.numer * rhs.denom == intType(0))
return true;
else
if(numer * denom != intType(0) && rhs.numer * rhs.denom == intType(0))
{
if(numer * denom > intType(0))
return true;
else
return false;
}
else
if(numer * denom == intType(0) && rhs.numer * rhs.denom != intType(0))
{
if(rhs.numer * rhs.denom > intType(0))
return false;
else
return true;
}
else
return ((numer * rhs.denom) >= (denom * rhs.numer));
} }
const rational &rational::operator++() bool rational::operator==(const rational &rhs) const
{ {
numerator_ += denominator_; return (numer == rhs.numer && denom == rhs.denom);
}
bool rational::operator!=(const rational &rhs) const
{
return (numer != rhs.numer) || (denom != rhs.denom);
}
//Unary operators
const rational& rational::operator++()
{
numer += denom;
return *this; return *this;
} }
rational rational::operator++(int) rational rational::operator++(int)
{ {
rational tmp = *this; rational tmp = *this;
numerator_ += denominator_; numer += denom;
return tmp; return tmp;
} }
const rational &rational::operator--() const rational& rational::operator--()
{ {
numerator_ -= denominator_; numer -= denom;
return *this; return *this;
} }
rational rational::operator--(int) rational rational::operator--(int)
{ {
rational tmp; rational tmp;
numerator_ -= denominator_; numer -= denom;
return tmp; return tmp;
} }
const rational &rational::operator+() const const rational& rational::operator+() const
{ {
return *this; return *this;
} }
rational rational::operator-() const rational rational::operator-() const
{ {
return rational(numerator_, -denominator_); return rational(numer, -denom);
} }
bool rational::operator!() const bool rational::operator!() const
{ {
return !numerator_; return !numer;
} }
double rational::ToDouble() const //IO
ostream& operator<<(ostream &out, const rational &value)
{ {
if (denominator_ == 0) { out << value.numer;
return 0; if(value.denom != 1)
} else { {
return static_cast<double>(numerator_)/static_cast<double>(denominator_); out << '/' << value.denom;
} return out;
} }
const int64_t &rational::numerator() const
{
return numerator_;
}
const int64_t &rational::denominator() const
{
return denominator_;
}
rational rational::flipped() const
{
return rational(denominator_, numerator_);
}
void rational::FixSigns()
{
// Ensures denominator is always positive (while numerator can be positive or negative)
if(denominator_ < 0) {
denominator_ = -denominator_;
numerator_ = -numerator_;
}
// Ensures if either are zero, they're both zero
if(numerator_ == 0 || denominator_ == 0) {
numerator_ = 0;
denominator_ = 0;
}
}
void rational::Reduce()
{
int64_t d = 1;
if(denominator_ != 0 && numerator_ != 0) {
d = GreatestCommonDenominator(numerator_, denominator_);
}
if(d > 1) {
numerator_ /= d;
denominator_ /= d;
}
}
int64_t rational::GreatestCommonDenominator(const int64_t& x, const int64_t& y)
{
if (y == 0) {
return x;
} else {
int64_t tmp = x % y;
return GreatestCommonDenominator(y, tmp);
}
}
std::ostream &operator<<(std::ostream &out, const rational &value)
{
out << value.numerator_;
if(value.denominator_ != 1)
{
out << '/' << value.denominator_;
return out;
}
return out; return out;
} }
std::istream &operator>>(std::istream &in, rational &value) istream& operator>>(istream &in, rational &value)
{ {
in >> value.numerator_; in >> value.numer;
value.denominator_ = 1; value.denom = 1;
char ch; char ch;
in.get(ch); in.get(ch);
if(!in.eof()) if(!in.eof())
{
if(ch == '/')
{ {
in >> value.denominator_; if(ch == '/')
value.FixSigns(); {
value.Reduce(); in >> value.denom;
value.fixSigns();
value.reduce();
}
else
in.putback(ch);
} }
else
in.putback(ch);
}
return in; return in;
} }
+100 -71
View File
@@ -1,71 +1,86 @@
/*** //Copyright 2015 Adam Quintero
//This program is distributed under the terms of the GNU General Public License.
Olive - Non-Linear Video Editor // Adapted by MattKC for the Olive Video Editor (2019)
Copyright (C) 2019 Olive Team
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
***/
#ifndef RATIONAL_H #ifndef RATIONAL_H
#define RATIONAL_H #define RATIONAL_H
// Adapted from https://github.com/angularadam/Qt-Class-rational used in compliance with the GNU General Public License
#include <iostream> #include <iostream>
/**
* Including AVFormat to support converting from AVRational to Olive's rational class
*/
extern "C" { extern "C" {
#include <libavformat/avformat.h> #include <libavformat/avformat.h>
} }
/** using namespace std;
* @brief A rational (numerator/denominator) class with C++ operations built in for ease of use.
* typedef long intType;
* Rationals in Olive most frequently represent timing information to easily handle timing in various different /*
* frame/sample rates without the inaccuracy/rounding errors of a floating point type. * Zero Handling
*/ * 0/0 = 0
class rational { * 0/non-zero = 0
* non-zero/0 = 0
*/
class rational
{
public: public:
// Constructors //constructors
rational(const int64_t& numerator = 0); rational(const intType &numerator = 0)
rational(const int64_t& numerator, const int64_t& denominator); :numer(numerator), denom(1)
rational(const AVRational& r); // Auto-convert from an FFmpeg AVRational {
rational(const rational& r); activeInstances++;
if(numer == 0)
denom = 0;
}
// Assignment Operators rational(const intType &numerator, const intType &denominator)
const rational& operator=(const rational& r); :numer(numerator), denom(denominator)
const rational& operator+=(const rational& r); {
const rational& operator-=(const rational& r); activeInstances++;
const rational& operator/=(const rational& r); if(denom != intType(0))
const rational& operator*=(const rational& r); {
if(numer != intType(0))
{
fixSigns();
reduce();
}
else
denom = intType(0);
}
else
numer = intType(0);
}
// Math Operators rational(const rational &rhs)
rational operator+(const rational& r) const; :numer(rhs.numer), denom(rhs.denom)
rational operator-(const rational& r) const; {
rational operator/(const rational& r) const; activeInstances++;
rational operator*(const rational& r) const; }
// Relational and Equality Operators rational(const AVRational& r);
bool operator<(const rational &r) const;
bool operator<=(const rational &r) const; //destructor
bool operator>(const rational &r) const; ~rational();
bool operator>=(const rational &r) const;
bool operator==(const rational &r) const; //Assignment Operators
bool operator!=(const rational &r) const; const rational& operator=(const rational &rhs);
const rational& operator+=(const rational &rhs);
const rational& operator-=(const rational &rhs);
const rational& operator/=(const rational &rhs);
const rational& operator*=(const rational &rhs);
//Binary math operators
rational operator+(const rational &rhs) const;
rational operator-(const rational &rhs) const;
rational operator/(const rational &rhs) const;
rational operator*(const rational &rhs) const;
//Relational and equality operators
bool operator<(const rational &rhs) const;
bool operator<=(const rational &rhs) const;
bool operator>(const rational &rhs) const;
bool operator>=(const rational &rhs) const;
bool operator==(const rational &rhs) const;
bool operator!=(const rational &rhs) const;
//Unary operators //Unary operators
const rational& operator++(); //prefix const rational& operator++(); //prefix
@@ -76,25 +91,39 @@ public:
rational operator-() const; rational operator-() const;
bool operator!() const; bool operator!() const;
// IO //Function: convert to double
friend std::ostream& operator<<(std::ostream &out, const rational& value); double toDouble() const;
friend std::istream& operator>>(std::istream &in, rational& value);
// Convert to double
double ToDouble() const;
// Specific values
const int64_t& numerator() const;
const int64_t& denominator() const;
// Produce "flipped" version
rational flipped() const; rational flipped() const;
private:
int64_t numerator_;
int64_t denominator_;
void FixSigns(); //Function: print number to cout
void Reduce(); void print(ostream &out = cout) const;
int64_t GreatestCommonDenominator(const int64_t &x, const int64_t &y);
//Function: get active instances
int getActiveInstances();
//IO
friend ostream& operator<<(ostream &out, const rational &value);
friend istream& operator>>(istream &in, rational &value);
const intType& numerator() const;
const intType& denominator() const;
private:
//number of active instances
static int activeInstances;
//numerator and denominator
intType numer;
intType denom;
//Function: ensures denom >= 0
void fixSigns();
//Function: ensures lowest form
void reduce();
//Function: finds greatest common denominator
intType gcd(intType &x, intType &y);
}; };
#endif // RATIONAL_H #endif // RATIONAL_H