operator <

[z.facultad/75.29/dale.git] / src / number.h

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 <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 };
 
 
 enum sign_type { positive, negative };
 


@@ -66,7 +72,9 @@ struct number
 
        number& operator+= (const number& n);
        number& operator*= (const number& n);
 
        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).
 
        // 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);
        }
 
                        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)
 
 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;
        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 >
 
 // 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);
        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 >
 }
 
 template < typename N, typename E >