Due to my inability to get used to (and even understand) white spacesmtx-20060126

between functions and arguments, I've decided to use a lightly modified
GNU coding style :-).

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 <int1> <int2>\n");
+      fprintf(stderr, "usage: mtx <int1> <int2>\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 */