From 2e3882b4cdc800dae7eae62c446f65ffcfbb477d Mon Sep 17 00:00:00 2001 From: Richard Braun Date: Sat, 12 Nov 2005 13:41:26 +0000 Subject: Due to my inability to get used to (and even understand) white spaces between functions and arguments, I've decided to use a lightly modified GNU coding style :-). --- main.cc | 30 ++++----- mtxinteger.cc | 210 ++++++++++++++++++++++++++++----------------------------- mtxinteger.h | 86 +++++++++++------------ mtxrational.cc | 120 ++++++++++++++++----------------- mtxrational.h | 38 +++++------ 5 files changed, 242 insertions(+), 242 deletions(-) diff --git a/main.cc b/main.cc index 843c52d..6186647 100644 --- a/main.cc +++ b/main.cc @@ -27,7 +27,7 @@ using namespace std; int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { MtxInteger a, b; MtxRational r; @@ -35,57 +35,57 @@ main (int argc, char *argv[]) if (argc != 3) { - fprintf (stderr, "usage: mtx \n"); + fprintf(stderr, "usage: mtx \n"); return 1; } a = argv[1]; b = argv[2]; - r = MtxRational (a, b); + r = MtxRational(a, b); - tmp = (a + b).toString (); + tmp = (a + b).toString(); cout << "a + b = " << tmp << endl; delete [] tmp; - tmp = (a - b).toString (); + tmp = (a - b).toString(); cout << "a - b = " << tmp << endl; delete [] tmp; - tmp = (a * b).toString (); + tmp = (a * b).toString(); cout << "a * b = " << tmp << endl; delete [] tmp; - tmp = (a / b).toString (); + tmp = (a / b).toString(); cout << "a / b = " << tmp << endl; delete [] tmp; - tmp = (a % b).toString (); + tmp = (a % b).toString(); cout << "a % b = " << tmp << endl; delete [] tmp; - tmp = r.toString (); + tmp = r.toString(); cout << "r = " << tmp << endl; delete [] tmp; - tmp = r.toFloatString (); + tmp = r.toFloatString(); cout << "r = " << tmp << endl; delete [] tmp; - r.simplify (); + r.simplify(); cout << "r has been simplified." << endl; - tmp = r.toString (); + tmp = r.toString(); cout << "r = " << tmp << endl; delete [] tmp; - tmp = r.toFloatString (); + tmp = r.toFloatString(); cout << "r = " << tmp << endl; delete [] tmp; { cout << "tests :" << endl; - r = MtxRational (-0.067); - tmp = r.toString (); + r = MtxRational(-0.067); + tmp = r.toString(); cout << "r = " << tmp << endl; delete [] tmp; } diff --git a/mtxinteger.cc b/mtxinteger.cc index 9ef036b..eb2afd2 100644 --- a/mtxinteger.cc +++ b/mtxinteger.cc @@ -25,66 +25,66 @@ #include "mtx.h" #include "mtxinteger.h" -MtxInteger::MtxInteger () +MtxInteger::MtxInteger() { digits = NULL; - setDigits ("0"); + setDigits("0"); } -MtxInteger::MtxInteger (int integer) +MtxInteger::MtxInteger(int integer) { char *tmp; digits = NULL; - tmp = parseInt (integer); - setDigits (tmp); + tmp = parseInt(integer); + setDigits(tmp); delete [] tmp; } -MtxInteger::MtxInteger (unsigned int integer) +MtxInteger::MtxInteger(unsigned int integer) { char *tmp; digits = NULL; - tmp = parseInt (integer); - setDigits (tmp); + tmp = parseInt(integer); + setDigits(tmp); delete [] tmp; } -MtxInteger::MtxInteger (double integer) +MtxInteger::MtxInteger(double integer) { char *tmp; digits = NULL; - tmp = parseDouble (integer); - setDigits (tmp); + tmp = parseDouble(integer); + setDigits(tmp); delete [] tmp; } -MtxInteger::MtxInteger (const char *digits) +MtxInteger::MtxInteger(const char *digits) { this->digits = NULL; - setDigits (digits); + setDigits(digits); } -MtxInteger::MtxInteger (const MtxInteger &integer) +MtxInteger::MtxInteger(const MtxInteger &integer) { digits = NULL; - setDigits (integer.digits); + setDigits(integer.digits); sign = integer.sign; } -MtxInteger::~MtxInteger () +MtxInteger::~MtxInteger() { delete [] digits; } MtxInteger & -MtxInteger::operator= (const MtxInteger &integer) +MtxInteger::operator=(const MtxInteger &integer) { if (this != &integer) { - setDigits (integer.digits); + setDigits(integer.digits); sign = integer.sign; } @@ -92,15 +92,15 @@ MtxInteger::operator= (const MtxInteger &integer) } MtxInteger -MtxInteger::operator+ () const +MtxInteger::operator+() const { - return MtxInteger (*this); + return MtxInteger(*this); } MtxInteger -MtxInteger::operator- () const +MtxInteger::operator-() const { - MtxInteger new_integer (*this); + MtxInteger new_integer(*this); new_integer.sign = ((new_integer.sign == MTX_POSITIVE) && (new_integer != 0)) @@ -110,7 +110,7 @@ MtxInteger::operator- () const } static int -charToInt (char c) +charToInt(char c) { switch (c) { @@ -150,7 +150,7 @@ charToInt (char c) } static char -intToChar (int n) +intToChar(int n) { switch (n) { @@ -190,9 +190,9 @@ intToChar (int n) } bool -MtxInteger::operator== (const MtxInteger &integer) const +MtxInteger::operator==(const MtxInteger &integer) const { - if (sign == integer.sign && strcmp (digits, integer.digits) == 0) + if (sign == integer.sign && strcmp(digits, integer.digits) == 0) return true; else @@ -200,13 +200,13 @@ MtxInteger::operator== (const MtxInteger &integer) const } bool -MtxInteger::operator!= (const MtxInteger &integer) const +MtxInteger::operator!=(const MtxInteger &integer) const { return !(*this == integer); } bool -MtxInteger::operator> (const MtxInteger &integer) const +MtxInteger::operator>(const MtxInteger &integer) const { if (this == &integer) return false; @@ -229,18 +229,18 @@ MtxInteger::operator> (const MtxInteger &integer) const bool result; int a, b; - length1 = strlen (digits); - length2 = strlen (integer.digits); + length1 = strlen(digits); + length2 = strlen(integer.digits); length = (length1 > length2) ? length1 : length2; for (i = 0; i < length; i++) { a = ((length - length1) > i) ? 0 - : charToInt (digits[i - (length - length1)]); + : charToInt(digits[i - (length - length1)]); b = ((length - length2) > i) ? 0 - : charToInt (integer.digits[i - (length - length2)]); + : charToInt(integer.digits[i - (length - length2)]); if (a != b) { @@ -263,25 +263,25 @@ MtxInteger::operator> (const MtxInteger &integer) const } bool -MtxInteger::operator>= (const MtxInteger &integer) const +MtxInteger::operator>=(const MtxInteger &integer) const { return (*this > integer || *this == integer); } bool -MtxInteger::operator< (const MtxInteger &integer) const +MtxInteger::operator<(const MtxInteger &integer) const { return integer > *this; } bool -MtxInteger::operator<= (const MtxInteger &integer) const +MtxInteger::operator<=(const MtxInteger &integer) const { return (*this < integer || *this == integer); } MtxInteger -MtxInteger::operator+ (const MtxInteger &integer) const +MtxInteger::operator+(const MtxInteger &integer) const { if (sign != integer.sign) return *this - (-integer); @@ -293,8 +293,8 @@ MtxInteger::operator+ (const MtxInteger &integer) const int a, b, c, tmp_int; char *tmp; - length1 = strlen (digits); - length2 = strlen (integer.digits); + length1 = strlen(digits); + length2 = strlen(integer.digits); /* * Allocate enough memory for any possible decimal addition. @@ -308,20 +308,20 @@ MtxInteger::operator+ (const MtxInteger &integer) const { a = (i >= length1) ? 0 - : charToInt (digits[length1 - 1 - i]); + : charToInt(digits[length1 - 1 - i]); b = (i >= length2) ? 0 - : charToInt (integer.digits[length2 - 1 - i]); + : charToInt(integer.digits[length2 - 1 - i]); c = a + b + tmp_int; tmp_int = c / 10; if (tmp_int) c -= 10; - tmp[length - 1 - i] = intToChar (c); + tmp[length - 1 - i] = intToChar(c); } - new_integer.setDigits (tmp); + new_integer.setDigits(tmp); delete [] tmp; @@ -334,28 +334,28 @@ MtxInteger::operator+ (const MtxInteger &integer) const } MtxInteger & -MtxInteger::operator++ () +MtxInteger::operator++() { *this = *this + 1; return *this; } MtxInteger & -MtxInteger::operator++ (int a) +MtxInteger::operator++(int a) { *this = *this + 1; return *this; } MtxInteger & -MtxInteger::operator+= (const MtxInteger &integer) +MtxInteger::operator+=(const MtxInteger &integer) { *this = *this + integer; return *this; } MtxInteger -MtxInteger::operator- (const MtxInteger &integer) const +MtxInteger::operator-(const MtxInteger &integer) const { if (sign != integer.sign) return *this + (-integer); @@ -368,7 +368,7 @@ MtxInteger::operator- (const MtxInteger &integer) const int a, b, c, tmp_int; char *tmp; - if (abs() >= integer.abs ()) + if (abs() >= integer.abs()) { i1 = this; i2 = &integer; @@ -380,8 +380,8 @@ MtxInteger::operator- (const MtxInteger &integer) const i2 = this; } - length1 = strlen (i1->digits); - length2 = strlen (i2->digits); + length1 = strlen(i1->digits); + length2 = strlen(i2->digits); length = (length1 > length2) ? length1 : length2; tmp = new char[length + 1]; tmp[length] = '\0'; @@ -391,10 +391,10 @@ MtxInteger::operator- (const MtxInteger &integer) const { a = (i >= length1) ? 0 - : charToInt (i1->digits[length1 - 1 - i]); + : charToInt(i1->digits[length1 - 1 - i]); b = (i >= length2) ? 0 - : charToInt (i2->digits[length2 - 1 - i]); + : charToInt(i2->digits[length2 - 1 - i]); c = a - (b + tmp_int); if (c < 0) @@ -406,10 +406,10 @@ MtxInteger::operator- (const MtxInteger &integer) const else tmp_int = 0; - tmp[length - 1 - i] = intToChar (c); + tmp[length - 1 - i] = intToChar(c); } - new_integer.setDigits (tmp); + new_integer.setDigits(tmp); delete [] tmp; @@ -425,28 +425,28 @@ MtxInteger::operator- (const MtxInteger &integer) const } MtxInteger & -MtxInteger::operator-- () +MtxInteger::operator--() { *this = *this - 1; return *this; } MtxInteger & -MtxInteger::operator-- (int a) +MtxInteger::operator--(int a) { *this = *this - 1; return *this; } MtxInteger & -MtxInteger::operator-= (const MtxInteger &integer) +MtxInteger::operator-=(const MtxInteger &integer) { *this = *this - integer; return *this; } MtxInteger -MtxInteger::operator* (const MtxInteger &integer) const +MtxInteger::operator*(const MtxInteger &integer) const { if (*this == 0 || integer == 0) return 0; @@ -462,13 +462,13 @@ MtxInteger::operator* (const MtxInteger &integer) const size_t i, j, length1, length2; MtxInteger new_integer; - length1 = strlen (digits); - length2 = strlen (integer.digits); + length1 = strlen(digits); + length2 = strlen(integer.digits); for (i = 1; i <= length1; i++) for(j = 1; j <= length2; j++) - new_integer += pot (charToInt (digits[length1 - i]) - * charToInt (integer.digits[length2 - j]), + new_integer += pot(charToInt(digits[length1 - i]) + * charToInt(integer.digits[length2 - j]), (i - 1) + (j - 1)); if(sign == integer.sign) @@ -480,28 +480,28 @@ MtxInteger::operator* (const MtxInteger &integer) const } MtxInteger & -MtxInteger::operator*= (const MtxInteger &integer) +MtxInteger::operator*=(const MtxInteger &integer) { *this = *this * integer; return *this; } MtxInteger -MtxInteger::divideByTwo () const +MtxInteger::divideByTwo() const { MtxInteger new_integer; int a, n, tmp_int; size_t i, length; char *tmp; - length = strlen (digits); + length = strlen(digits); tmp = new char[length + 1]; tmp[length] = '\0'; tmp_int = 0; for (i = 0; i < length; i++) { - n = charToInt (digits[i]); + n = charToInt(digits[i]); switch (tmp_int + n) { @@ -545,14 +545,14 @@ MtxInteger::divideByTwo () const tmp[i] = a; } - new_integer.setDigits (tmp); + new_integer.setDigits(tmp); delete [] tmp; new_integer.sign = sign; return new_integer; } MtxInteger -MtxInteger::divide (const MtxInteger &integer, bool modulo0) const +MtxInteger::divide(const MtxInteger &integer, bool modulo0) const { /* * TODO: When I know how to use exceptions ... :-) @@ -599,7 +599,7 @@ MtxInteger::divide (const MtxInteger &integer, bool modulo0) const return -*this; } - else if (abs () < integer.abs ()) + else if (abs() < integer.abs()) { if (modulo0) return *this; @@ -612,14 +612,14 @@ MtxInteger::divide (const MtxInteger &integer, bool modulo0) const { MtxInteger inf, sup, tmp, result, this_abs, integer_abs, modulo; - this_abs = abs (); - integer_abs = integer.abs (); + this_abs = abs(); + integer_abs = integer.abs(); inf = 0; sup = this_abs; do { - result = inf + (sup - inf).divideByTwo (); + result = inf + (sup - inf).divideByTwo(); tmp = result * integer_abs; if (tmp > this_abs) @@ -657,48 +657,48 @@ MtxInteger::divide (const MtxInteger &integer, bool modulo0) const } MtxInteger -MtxInteger::operator/ (const MtxInteger &integer) const +MtxInteger::operator/(const MtxInteger &integer) const { - return divide (integer, false); + return divide(integer, false); } MtxInteger & -MtxInteger::operator/= (const MtxInteger &integer) +MtxInteger::operator/=(const MtxInteger &integer) { *this = *this / integer; return *this; } MtxInteger -MtxInteger::operator% (const MtxInteger &integer) const +MtxInteger::operator%(const MtxInteger &integer) const { - return divide (integer, true); + return divide(integer, true); } MtxInteger & -MtxInteger::operator%= (const MtxInteger &integer) +MtxInteger::operator%=(const MtxInteger &integer) { *this = *this % integer; return *this; } int -MtxInteger::getSign () const +MtxInteger::getSign() const { return sign; } MtxInteger -MtxInteger::abs () const +MtxInteger::abs() const { - MtxInteger new_integer (*this); + MtxInteger new_integer(*this); new_integer.sign = MTX_POSITIVE; return new_integer; } void -MtxInteger::setDigits (const char *digits) +MtxInteger::setDigits(const char *digits) { size_t size; @@ -735,19 +735,19 @@ MtxInteger::setDigits (const char *digits) sign = MTX_POSITIVE; } - size = strlen (digits); + size = strlen(digits); this->digits = new char[size + 1]; - strncpy (this->digits, digits, size); + strncpy(this->digits, digits, size); this->digits[size] = '\0'; } char * -MtxInteger::toString () const +MtxInteger::toString() const { char *string, *ptr; size_t length; - length = strlen (digits); + length = strlen(digits); if (sign == MTX_NEGATIVE) length++; @@ -763,16 +763,16 @@ MtxInteger::toString () const else ptr = string; - strcpy (ptr, digits); + strcpy(ptr, digits); return string; } int -MtxInteger::toInt () const +MtxInteger::toInt() const { int integer; - integer = atoi (digits); + integer = atoi(digits); if (sign == MTX_NEGATIVE) integer = -integer; @@ -781,69 +781,69 @@ MtxInteger::toInt () const } char * -MtxInteger::parseInt (int n) +MtxInteger::parseInt(int n) { char *tmp; int size; - size = snprintf (NULL, 0, "%d", n) + 1; + size = snprintf(NULL, 0, "%d", n) + 1; tmp = new char[size]; - snprintf (tmp, size, "%d", n); + snprintf(tmp, size, "%d", n); return tmp; } char * -MtxInteger::parseInt (unsigned int n) +MtxInteger::parseInt(unsigned int n) { char *tmp; int size; - size = snprintf (NULL, 0, "%u", n) + 1; + size = snprintf(NULL, 0, "%u", n) + 1; tmp = new char[size]; - snprintf (tmp, size, "%u", n); + snprintf(tmp, size, "%u", n); return tmp; } char * -MtxInteger::parseDouble (double d) +MtxInteger::parseDouble(double d) { char *tmp; int size; - size = snprintf (NULL, 0, "%.0f", d) + 1; + size = snprintf(NULL, 0, "%.0f", d) + 1; tmp = new char[size]; - snprintf (tmp, size, "%.0f", d); + snprintf(tmp, size, "%.0f", d); return tmp; } MtxInteger -MtxInteger::pot (int integer0, unsigned int power) +MtxInteger::pot(int integer0, unsigned int power) { MtxInteger integer, new_integer; size_t length, length1; char *tmp, *ptr; integer = integer0; - length1 = strlen (integer.digits); + length1 = strlen(integer.digits); length = length1 + power; tmp = new char[length + 1]; tmp[length] = '\0'; ptr = tmp; - memcpy (ptr, integer.digits, length1); + memcpy(ptr, integer.digits, length1); ptr += length1; - memset (ptr, '0', power); - new_integer.setDigits (tmp); + memset(ptr, '0', power); + new_integer.setDigits(tmp); new_integer.sign = integer.sign; return new_integer; } MtxInteger -MtxInteger::gcd (MtxInteger a, MtxInteger b) +MtxInteger::gcd(MtxInteger a, MtxInteger b) { MtxInteger tmp; - a = a.abs (); - b = b.abs (); + a = a.abs(); + b = b.abs(); while (b != 0) { diff --git a/mtxinteger.h b/mtxinteger.h index 39ab74c..8c30b14 100644 --- a/mtxinteger.h +++ b/mtxinteger.h @@ -27,56 +27,56 @@ class MtxInteger char *digits; int sign; - void setDigits (const char *digits); - MtxInteger divideByTwo () const; - MtxInteger divide (const MtxInteger &integer, bool modulo0) const; + void setDigits(const char *digits); + MtxInteger divideByTwo() const; + MtxInteger divide(const MtxInteger &integer, bool modulo0) const; public: - MtxInteger (); - MtxInteger (int integer); - MtxInteger (unsigned int integer); - MtxInteger (double integer); - MtxInteger (const char *digits); - MtxInteger (const MtxInteger &integer); - ~MtxInteger (); - MtxInteger & operator= (const MtxInteger &integer); - MtxInteger operator+ () const; - MtxInteger operator- () const; - bool operator== (const MtxInteger &integer) const; - bool operator!= (const MtxInteger &integer) const; - bool operator> (const MtxInteger &integer) const; - bool operator>= (const MtxInteger &integer) const; - bool operator< (const MtxInteger &integer) const; - bool operator<= (const MtxInteger &integer) const; - MtxInteger operator+ (const MtxInteger &integer) const; - MtxInteger & operator++ (); - MtxInteger & operator++ (int a); - MtxInteger & operator+= (const MtxInteger &integer); - MtxInteger operator- (const MtxInteger &integer) const; - MtxInteger & operator-- (); - MtxInteger & operator-- (int a); - MtxInteger & operator-= (const MtxInteger &integer); - MtxInteger operator* (const MtxInteger &integer) const; - MtxInteger & operator*= (const MtxInteger &integer); - MtxInteger operator/ (const MtxInteger &integer) const; - MtxInteger & operator/= (const MtxInteger &integer); - MtxInteger operator% (const MtxInteger &integer) const; - MtxInteger & operator%= (const MtxInteger &integer); - int getSign () const; - MtxInteger abs () const; - void display () const; - char * toString () const; - int toInt () const; - static char * parseInt (int n); - static char * parseInt (unsigned int n); - static char * parseDouble (double d); + MtxInteger(); + MtxInteger(int integer); + MtxInteger(unsigned int integer); + MtxInteger(double integer); + MtxInteger(const char *digits); + MtxInteger(const MtxInteger &integer); + ~MtxInteger(); + MtxInteger & operator=(const MtxInteger &integer); + MtxInteger operator+() const; + MtxInteger operator-() const; + bool operator==(const MtxInteger &integer) const; + bool operator!=(const MtxInteger &integer) const; + bool operator>(const MtxInteger &integer) const; + bool operator>=(const MtxInteger &integer) const; + bool operator<(const MtxInteger &integer) const; + bool operator<=(const MtxInteger &integer) const; + MtxInteger operator+(const MtxInteger &integer) const; + MtxInteger & operator++(); + MtxInteger & operator++(int a); + MtxInteger & operator+=(const MtxInteger &integer); + MtxInteger operator-(const MtxInteger &integer) const; + MtxInteger & operator--(); + MtxInteger & operator--(int a); + MtxInteger & operator-=(const MtxInteger &integer); + MtxInteger operator*(const MtxInteger &integer) const; + MtxInteger & operator*=(const MtxInteger &integer); + MtxInteger operator/(const MtxInteger &integer) const; + MtxInteger & operator/=(const MtxInteger &integer); + MtxInteger operator%(const MtxInteger &integer) const; + MtxInteger & operator%=(const MtxInteger &integer); + int getSign() const; + MtxInteger abs() const; + void display() const; + char * toString() const; + int toInt() const; + static char * parseInt(int n); + static char * parseInt(unsigned int n); + static char * parseDouble(double d); /* * Return integer0 * 10^power. */ - static MtxInteger MtxInteger::pot (int integer0, unsigned int power); + static MtxInteger MtxInteger::pot(int integer0, unsigned int power); - static MtxInteger gcd (MtxInteger a, MtxInteger b); + static MtxInteger gcd(MtxInteger a, MtxInteger b); }; #endif /* _MTXINTEGER_H */ diff --git a/mtxrational.cc b/mtxrational.cc index d54ef3d..66d69f0 100644 --- a/mtxrational.cc +++ b/mtxrational.cc @@ -27,17 +27,17 @@ unsigned int MtxRational::precision = MTX_DEFAULT_PRECISION; -MtxRational::MtxRational () +MtxRational::MtxRational() { - setNumerator (0); - setDenominator (1); + setNumerator(0); + setDenominator(1); } /* * Return 10^power. */ static double -pot (unsigned int power) +pot(unsigned int power) { unsigned int i; double result; @@ -50,7 +50,7 @@ pot (unsigned int power) return result; } -MtxRational::MtxRational (double rational) +MtxRational::MtxRational(double rational) { unsigned int power; @@ -62,65 +62,65 @@ MtxRational::MtxRational (double rational) power++; } - setNumerator (rational); - setDenominator (pot(power)); + setNumerator(rational); + setDenominator(pot(power)); } -MtxRational::MtxRational (int numerator, int denominator) +MtxRational::MtxRational(int numerator, int denominator) { - setNumerator (numerator); - setDenominator (denominator); + setNumerator(numerator); + setDenominator(denominator); } -MtxRational::MtxRational (unsigned int numerator, unsigned int denominator) +MtxRational::MtxRational(unsigned int numerator, unsigned int denominator) { - setNumerator (numerator); - setDenominator (denominator); + setNumerator(numerator); + setDenominator(denominator); } -MtxRational::MtxRational (const char *numerator, const char *denominator) +MtxRational::MtxRational(const char *numerator, const char *denominator) { - setNumerator (numerator); - setDenominator (denominator); + setNumerator(numerator); + setDenominator(denominator); } -MtxRational::MtxRational (const MtxInteger &numerator, +MtxRational::MtxRational(const MtxInteger &numerator, const MtxInteger &denominator) { - setNumerator (numerator); - setDenominator (denominator); + setNumerator(numerator); + setDenominator(denominator); } void -MtxRational::setNumerator (const MtxInteger &numerator) +MtxRational::setNumerator(const MtxInteger &numerator) { this->numerator = numerator; } void -MtxRational::setDenominator (const MtxInteger &denominator) +MtxRational::setDenominator(const MtxInteger &denominator) { this->denominator = denominator; } MtxRational -MtxRational::operator+ () const +MtxRational::operator+() const { - return MtxRational (*this); + return MtxRational(*this); } MtxRational -MtxRational::operator- () const +MtxRational::operator-() const { - MtxRational new_rational (*this); + MtxRational new_rational(*this); - new_rational.setNumerator (-new_rational.numerator); + new_rational.setNumerator(-new_rational.numerator); return new_rational; } bool -MtxRational::operator== (const MtxRational &rational) const +MtxRational::operator==(const MtxRational &rational) const { if (numerator * rational.denominator == denominator * rational.numerator) return true; @@ -130,54 +130,54 @@ MtxRational::operator== (const MtxRational &rational) const } MtxRational -MtxRational::operator+ (const MtxRational &rational) const +MtxRational::operator+(const MtxRational &rational) const { - return MtxRational ((numerator * rational.denominator + return MtxRational((numerator * rational.denominator + rational.numerator * denominator), denominator * rational.denominator); } MtxRational -MtxRational::operator- (const MtxRational &rational) const +MtxRational::operator-(const MtxRational &rational) const { - return MtxRational ((numerator * rational.denominator + return MtxRational((numerator * rational.denominator - rational.numerator * denominator), denominator * rational.denominator); } MtxRational -MtxRational::operator* (const MtxRational &rational) const +MtxRational::operator*(const MtxRational &rational) const { - return MtxRational (numerator * rational.numerator, + return MtxRational(numerator * rational.numerator, denominator * rational.denominator); } MtxRational -MtxRational::operator/ (const MtxRational &rational) const +MtxRational::operator/(const MtxRational &rational) const { - return MtxRational (numerator * rational.denominator, + return MtxRational(numerator * rational.denominator, denominator * rational.numerator); } void -MtxRational::simplify () +MtxRational::simplify() { - if (denominator.abs () != 1) + if (denominator.abs() != 1) { MtxInteger gcd; - gcd = MtxInteger::gcd (numerator, denominator); + gcd = MtxInteger::gcd(numerator, denominator); numerator /= gcd; denominator /= gcd; } } char * -MtxRational::toString () const +MtxRational::toString() const { char *numerator; - numerator = this->numerator.toString (); + numerator = this->numerator.toString(); if (this->denominator == 1) return numerator; @@ -186,15 +186,15 @@ MtxRational::toString () const { char *rational, *denominator; - denominator = this->denominator.toString (); + denominator = this->denominator.toString(); /* * Include '/' and '\0'. */ - rational = new char[strlen (numerator) + 1 + strlen (denominator) + 1]; - strcpy (rational , numerator); - strcat (rational , "/"); - strcat (rational , denominator); + rational = new char[strlen(numerator) + 1 + strlen(denominator) + 1]; + strcpy(rational , numerator); + strcat(rational , "/"); + strcat(rational , denominator); delete [] numerator; delete [] denominator; return rational; @@ -202,7 +202,7 @@ MtxRational::toString () const } char * -MtxRational::toFloatString () const +MtxRational::toFloatString() const { MtxInteger result, remainder, divisor; char *float_string, *tmp; @@ -211,36 +211,36 @@ MtxRational::toFloatString () const * Include '.' and '\0'. Not optimal, but quite enough, and even efficient * for most cases, since there is only one allocation. */ - tmp = numerator.toString (); - float_string = new char[strlen (tmp) + 1 + precision + 1]; + tmp = numerator.toString(); + float_string = new char[strlen(tmp) + 1 + precision + 1]; delete [] tmp; - result = (numerator / denominator).abs (); - remainder = (numerator % denominator).abs (); - divisor = denominator.abs (); + result = (numerator / denominator).abs(); + remainder = (numerator % denominator).abs(); + divisor = denominator.abs(); - if (numerator.getSign () != denominator.getSign ()) - strcpy (float_string, "-"); + if (numerator.getSign() != denominator.getSign()) + strcpy(float_string, "-"); else - strcpy (float_string, ""); + strcpy(float_string, ""); - tmp = result.toString (); - strcat (float_string, tmp); + tmp = result.toString(); + strcat(float_string, tmp); delete [] tmp; if (remainder != 0) { unsigned int digits_count; - strcat (float_string, "."); + strcat(float_string, "."); digits_count = 0; do { remainder *= 10; result = remainder / divisor; - tmp = result.toString (); - strcat (float_string, tmp); + tmp = result.toString(); + strcat(float_string, tmp); delete [] tmp; remainder %= divisor; digits_count++; @@ -252,7 +252,7 @@ MtxRational::toFloatString () const } void -MtxRational::setPrecision (unsigned int new_precision) +MtxRational::setPrecision(unsigned int new_precision) { precision = new_precision; } diff --git a/mtxrational.h b/mtxrational.h index ed1ce0a..f11b6bf 100644 --- a/mtxrational.h +++ b/mtxrational.h @@ -31,26 +31,26 @@ class MtxRational static unsigned int precision; public: - MtxRational (); - MtxRational (double rational); - MtxRational (int numerator, int denominator = 1); - MtxRational (unsigned int numerator, unsigned int denominator = 1); - MtxRational (const char *numerator, const char *denominator = "1"); - MtxRational (const MtxInteger &numerator, + MtxRational(); + MtxRational(double rational); + MtxRational(int numerator, int denominator = 1); + MtxRational(unsigned int numerator, unsigned int denominator = 1); + MtxRational(const char *numerator, const char *denominator = "1"); + MtxRational(const MtxInteger &numerator, const MtxInteger &denominator = 1); - void setNumerator (const MtxInteger &numerator); - void setDenominator (const MtxInteger &denominator); - MtxRational operator+ () const; - MtxRational operator- () const; - bool operator== (const MtxRational &rational) const; - MtxRational operator+ (const MtxRational &rational) const; - MtxRational operator- (const MtxRational &rational) const; - MtxRational operator* (const MtxRational &rational) const; - MtxRational operator/ (const MtxRational &rational) const; - void simplify (); - char * toString () const; - char * toFloatString () const; - static void setPrecision (unsigned int new_precision); + void setNumerator(const MtxInteger &numerator); + void setDenominator(const MtxInteger &denominator); + MtxRational operator+() const; + MtxRational operator-() const; + bool operator==(const MtxRational &rational) const; + MtxRational operator+(const MtxRational &rational) const; + MtxRational operator-(const MtxRational &rational) const; + MtxRational operator*(const MtxRational &rational) const; + MtxRational operator/(const MtxRational &rational) const; + void simplify(); + char * toString() const; + char * toFloatString() const; + static void setPrecision(unsigned int new_precision); }; #endif /* _MTXRATIONAL_H */ -- cgit v1.2.3