Added operators: -, ==, !=, <, >, <=, >=

Still working on division, needed some other operators to make it work.

1 files changed, 152 insertions, 5 deletions

diff --git a/src/number.cpp b/src/number.cpp
index ac29c61..9b6ec55 100644
--- a/src/number.cpp
+++ b/src/number.cpp
@@ -6,15 +6,15 @@
 

 Number::Number( int iOrd ) : 

     iOrd( iOrd ),

-    aInt( 4 ),

-    bPositive( true )

+    bPositive( true ),

+    aInt( 4 )

 {

 }

 

 Number::Number( const Bu::String &sData, int iOrd ) :

     iOrd( iOrd ),

-    aInt( 4 ),

-    bPositive( true )

+    bPositive( true ),

+    aInt( 4 )

 {

     set( sData );

 }

@@ -45,7 +45,6 @@ Number Number::operator*( const Number &rhs ) const
 {

     Number ret( iOrd );

 

-    int iPlaces = Bu::buMax(rhs.aInt.getSize(), aInt.getSize() );

     int iCnt = aInt.getSize()+rhs.aInt.getSize();

 

     int iCarry = 0;

@@ -86,6 +85,154 @@ Number Number::operator*( const Number &rhs ) const
     return ret;

 }

 

+Number Number::operator/( const Number &rhs ) const

+{

+    if( rhs.aInt.getSize() > aInt.getSize() )

+        return Number( iOrd );

+

+    Number q( iOrd );

+

+    int iMinWidth = rhs.aInt.getSize();

+

+    Bu::println("%1\n-----").arg( aInt.toString() );

+    for( int j = aInt.getSize(); j > iMinWidth; j-- )

+    {

+        Number sub( iOrd );

+        sub.aInt.set( aInt, j-iMinWidth, iMinWidth );

+        Bu::println("%1\n%2\n----").arg( sub.toString() ).arg( rhs.toString() );

+    }

+

+    return q;

+}

+

+Number Number::operator-() const

+{

+    Number neg( *this );

+    neg.bPositive = !neg.bPositive;

+    return neg;

+}

+

+bool Number::operator==( const Number &rhs ) const

+{

+    if( rhs.bPositive != bPositive ||

+        rhs.iOrd != iOrd || 

+        rhs.aInt.getSize() != aInt.getSize() )

+        return false;

+

+    for( int j = 0; j < aInt.getSize(); j++ )

+    {

+        if( aInt[j] != rhs.aInt[j] )

+            return false;

+    }

+

+    return true;

+}

+

+bool Number::operator!=( const Number &rhs ) const

+{

+    return !(*this == rhs);

+}

+

+bool Number::operator>( const Number &rhs ) const

+{

+    if( bPositive && !rhs.bPositive )

+        return true;

+    if( !bPositive && rhs.bPositive )

+        return false;

+

+    if( aInt.getSize() > rhs.aInt.getSize() )

+        return bPositive;

+    if( aInt.getSize() < rhs.aInt.getSize() )

+        return !bPositive;

+

+    for( int j = aInt.getSize()-1; j >= 0; j-- )

+    {

+//        Bu::println("  --> %1 > %2 -> %3").arg( aInt[j] ).arg( rhs.aInt[j] ).

+//            arg( aInt[j] > rhs.aInt[j] );

+        int iDiff = aInt[j] - rhs.aInt[j];

+        if( iDiff < 0 )

+            return !bPositive;

+        else if( iDiff > 0 )

+            return bPositive;

+    }

+    return false;

+}

+

+bool Number::operator<( const Number &rhs ) const

+{

+    if( bPositive && !rhs.bPositive )

+        return false;

+    if( !bPositive && rhs.bPositive )

+        return true;

+

+    if( aInt.getSize() < rhs.aInt.getSize() )

+        return bPositive;

+    if( aInt.getSize() > rhs.aInt.getSize() )

+        return !bPositive;

+

+    for( int j = aInt.getSize()-1; j >= 0; j-- )

+    {

+//        Bu::println("  --> %1 > %2 -> %3").arg( aInt[j] ).arg( rhs.aInt[j] ).

+//            arg( aInt[j] < rhs.aInt[j] );

+        int iDiff = aInt[j] - rhs.aInt[j];

+        if( iDiff > 0 )

+            return !bPositive;

+        else if( iDiff < 0 )

+            return bPositive;

+    }

+    return false;

+}

+

+bool Number::operator>=( const Number &rhs ) const

+{

+    if( bPositive && !rhs.bPositive )

+        return true;

+    if( !bPositive && rhs.bPositive )

+        return false;

+

+    if( aInt.getSize() > rhs.aInt.getSize() )

+        return bPositive;

+    if( aInt.getSize() < rhs.aInt.getSize() )

+        return !bPositive;

+

+    for( int j = aInt.getSize()-1; j >= 0; j-- )

+    {

+//        Bu::println("  --> %1 > %2 -> %3").arg( aInt[j] ).arg( rhs.aInt[j] ).

+//            arg( aInt[j] > rhs.aInt[j] );

+        int iDiff = aInt[j] - rhs.aInt[j];

+        if( iDiff < 0 )

+            return !bPositive;

+        else if( iDiff > 0 )

+            return bPositive;

+    }

+    return true;

+}

+

+bool Number::operator<=( const Number &rhs ) const

+{

+    if( bPositive && !rhs.bPositive )

+        return false;

+    if( !bPositive && rhs.bPositive )

+        return true;

+

+    if( aInt.getSize() < rhs.aInt.getSize() )

+        return bPositive;

+    if( aInt.getSize() > rhs.aInt.getSize() )

+        return !bPositive;

+

+    for( int j = aInt.getSize()-1; j >= 0; j-- )

+    {

+//        Bu::println("  --> %1 > %2 -> %3").arg( aInt[j] ).arg( rhs.aInt[j] ).

+//            arg( aInt[j] < rhs.aInt[j] );

+        int iDiff = aInt[j] - rhs.aInt[j];

+        if( iDiff > 0 )

+            return !bPositive;

+        else if( iDiff < 0 )

+            return bPositive;

+    }

+    return true;

+}

+

 void Number::set( const Bu::String &sNum )

 {

     aInt.clear();