operator <

diff --git a/src/number.h b/src/number.h
index 99eec8c22534d6815c8177fda66e77a58d97a4e9..d4593bcb543730b351e4c3f46c5ddaa7429f98ff 100644 (file)
--- a/src/number.h
+++ b/src/number.h
@@ -7,8 +7,14 @@
 #include <deque>
 #include <utility>
 #include <algorithm>
-#include <iomanip>
-#include <stdint.h>
+#include <iomanip>\r
+\r
+#ifdef _WIN32\r
+// VC++ no tiene la stdint.h, se agrega a mano
+#include "stdint.h"\r
+#else\r
+#include <stdint.h>\r
+#endif
 
 enum sign_type { positive, negative };
 
@@ -66,7 +72,9 @@ struct number
 
        number& operator+= (const number& n);
        number& operator*= (const number& n);
-       number& operator<<= (const size_type n);
+       number& operator<<= (const size_type n);\r
+       number& operator-= (const number& n);\r
+       bool    operator< (const number& n);
 
        // Devuelve referencia a 'átomo' i del chunk (no debería ser necesario
        // si la multiplicación es un método de este objeto).
@@ -118,7 +126,34 @@ struct number
                        chunk.push_back(1);
        }
 
-};
+};\r
+\r
+template < typename N, typename E >\r
+number< N, E >::number(const std::string& str)\r
+{\r
+       const N MAX_N = (~( (N)0 ) );\r
+       E increment = 0;\r
+       E acum = 0;\r
+\r
+       unsigned length = origen.length();\r
+       unsigned number_offset = 0;\r
+\r
+       while (number_offset<length)\r
+       {\r
+               // si encuentro un signo + ó - corto\r
+               if (!isdigit(origen[length-number_offset-1]))\r
+                       break;\r
+\r
+               increment = (10*number_offset)*(origen[length-number_offset-1]-'0');\r
+               if ((acum + increment) > MAX_N)\r
+               {\r
+                       chunk.push_back(acum);\r
+               }\r
+\r
+       }\r
+\r
+\r
+}
 
 template < typename N, typename E >
 number< N, E >& number< N, E >::operator+= (const number< N, E >& n)
@@ -193,7 +228,54 @@ number< N, E > operator+ (const number< N, E >& n1, const number< N, E >& n2)
        number< N, E > tmp = n1;
        tmp += n2;
        return tmp;
-}
+}\r
+\r
+template < typename N, typename E >\r
+number< N, E >& number< N, E >::operator-= (const number< N, E >& n)\r
+{\r
+       //TODO IMPLEMENTAR\r
+       return *this;
+}\r
+\r
+template < typename N, typename E >\r
+number< N, E > operator- (const number< N, E >& n1, const number< N, E >& n2)\r
+{\r
+       number< N, E > tmp = n1;\r
+       tmp -= n2;\r
+       return tmp;\r
+}\r
+\r
+\r
+template < typename N, typename E >\r
+bool number< N, E >::operator< (const number< N, E >& n)\r
+{\r
+       number< N, E > n1 = *this;\r
+       number< N, E > n2 = n;\r
+\r
+       // igualo los largos\r
+       n1.normalize_length(n2);\r
+       n2.normalize_length(n1);\r
+\r
+       // obtengo el largo \r
+       size_type length = n1.chunk.size();\r
+       size_type i = length - 1;\r
+\r
+       // me voy fijando desde "la cifra" más significativa si alguno es menor que el otro\r
+       // sigo iterando si son iguales hasta recorrer todo el número hasta la parte menos significativa\r
+       while (i > 0)\r
+       {\r
+               if (n1[i]<n2[i])\r
+                       return true;\r
+               if (n1[i]>n2[i])\r
+                       return false;\r
+\r
+               i--;\r
+       }\r
+\r
+       // si llegué hasta acá es porque son iguales, por lo tanto no es menor estricto\r
+       return false;\r
+\r
+}\r
 
 // efectúa un shifteo a izquierda del chunk, agregando 0s en los casilleros menos significativos
 template < typename N, typename E >
@@ -250,14 +332,10 @@ number< N, E >& number< N, E >::normalize_length(const number< N, E >& n)
        while (chunk.size() < n.chunk.size())
        {
                chunk.push_back(0);
-       }
-
-       // si no tiene cantidad par de números le agrego un atomic_type 0 a la
-       // izquierda para no tener que contemplar splits de chunks impares
-       if ((chunk.size() % 2) != 0)
-       {
-               chunk.push_back(0);
-       }
+       }\r
+\r
+       return *this;\r
+\r
 }
 
 template < typename N, typename E >

diff --git a/tests/number.cpp b/tests/number.cpp
index 44e56ab80af874aabf88cab602f415b882c96708..c0d7bd11e4393ce1cb9794318b4288f866d33fad 100644 (file)
--- a/tests/number.cpp
+++ b/tests/number.cpp
@@ -3,7 +3,7 @@
 
 int main()
 {
-#if 1
+#if 0
        unsigned buf[5] = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0 };
        //unsigned buf[3] = { 0xffffffff, 0x1, 0 };
        number<> nu(buf, 4);
@@ -21,7 +21,24 @@ int main()
 
        nu << 5;
        std::cout << "nu = " << nu << "\n\n";
-#endif
+#endif\r
+\r
+       number<> n1 = 0xffff00f0;\r
+       number<> n2 = 0xffff00f0;\r
+\r
+       n1 += 1;\r
+\r
+       n1 <<= 4;\r
+       n2 <<= 4;\r
+\r
+       if (n1 < n2)\r
+               std::cout << "n1 es menor que n2\n";\r
+       else if (n2 < n1)\r
+               std::cout << "n1 es mayor que n2\n";\r
+       else \r
+               std::cout << "n1 es igual que n2\n";\r
+               \r
+       number<> n3 = n1 - n2;
 
        return 0;