stdc - Representando números de 128 bits en C++
libreria bits stdc++ h (11)
Aquí hay una biblioteca que encontré en google.
¿Cuál es la mejor manera de representar un número de 128 bits en C ++? Debe comportarse lo más cerca posible de los tipos numéricos incorporados (es decir, admitir todos los operadores aritméticos, etc.).
Estaba pensando en construir una clase que tuviera 2 números de 64 bits o 4 de 32 bits. O posiblemente solo creando un bloque de memoria de 128 bits y haciendo todo yo mismo.
¿Hay alguna manera más fácil / más estándar, o algo que sea menos probable que arruine cuando lo implemente yo mismo? :)
También sería bueno si pudiera extenderse a 256 bits, 512 bits, etc.
Boost tiene tipos de datos en la biblioteca de multiprecision para tipos que van de 128 a 1024 bits.
#include <boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;
int128_t mySignedInt128 = -1;
uint128_t myUnsignedInt128 = 2;
int256_t mySignedInt256 = -3;
uint256_t myUnsignedInt256 = 4;
int512_t mySignedInt512 = -5;
uint512_t myUnsignedInt512 = 6;
int1024_t mySignedInt1024 = -7;
uint1024_t myUnsignedInt1024 = 8;
En Visual Studio C ++ hay un tipo FLOAT128 que se utiliza para representar enteros de 128 bits. Se implementa como:
#if defined(_M_IA64) && !defined(MIDL_PASS)
__declspec(align(16))
#endif
typedef struct _FLOAT128 {
__int64 LowPart;
__int64 HighPart;
} FLOAT128;
así que no estoy seguro de qué operaciones matemáticas se implementan para él
Es posible que desee probar GMP
Este es un caso especial, especialmente porque no especificó qué plataforma (s) está buscando, pero con GCC puede usar lo que se llama modo (TI) para obtener (sintetizar) operaciones de 128 bits, para ejemplo:
typedef unsigned int uint128_t __attribute__((mode(TI)));
uint64_t x = 0xABCDEF01234568;
uint64_t y = ~x;
uint128_t result = ((uint128_t) x * y);
printf("%016llX * %016llX -> ", x, y);
uint64_t r1 = (result >> 64);
uint64_t r2 = result;
printf("%016llX %016llX/n", r1, r2);
Sin embargo, esto solo funciona en procesadores de 64 bits.
De una manera u otra, estás buscando una aritmética de precisión múltiple para resolver esto. mode (TI) hará que el compilador genere las operaciones por usted, de lo contrario, deben escribirse explícitamente.
Puede usar un paquete general bigint; Los que conozco en C ++ incluyen los paquetes de teoría de números LiDIA y NTL , y los paquetes bigint utilizados para el código criptográfico en Crypto ++ y Botan . Además, por supuesto, está GMP , que es la biblioteca C MPI canónica (y también tiene un contenedor C ++, aunque parecía poco documentada la última vez que lo analicé). Todos estos están diseñados para ser rápidos, pero probablemente también estén ajustados para números más grandes (más de 1000 bits), por lo que a 128 bits puede estar teniendo que lidiar con una gran sobrecarga. (Por otro lado, no dices si eso importa o no). Y todos ellos (a diferencia del paquete bigint-cpp, que es GPL, son BSD o LGPL), no estoy seguro si es importante, pero podría importar mucho.
También podría escribir un tipo de tipo uint128_t personalizado; Por lo general, una clase de este tipo implementaría los mismos algoritmos que una clase regular de MPI, solo codificada para tener solo 2 o 4 elementos. Si tiene curiosidad sobre cómo implementar dichos algoritmos, una buena referencia es el Capítulo 14 del Manual de Criptografía Aplicada
Por supuesto, hacerlo a mano es más fácil si no se necesitan todas las operaciones aritméticas (la división y el módulo, en particular, son bastante complicados). Por ejemplo, si solo necesita realizar un seguimiento de un contador que hipotéticamente podría desbordar 64 bits, podría representarlo como un par de largos de 64 bits y realizar el acarreo a mano:
unsigned long long ctrs[2] = { 0 };
void increment() {
++ctrs[0];
if(!ctrs[0]) // overflow
++ctrs[1];
}
Por supuesto, será mucho más fácil de tratar que un paquete general de MPI o una clase uint128_t personalizada.
GCC supports un tipo de entero de 128 bits para los procesadores que lo soportan. Puedes acceder utilizando:
__int128 a;
unsigned __int128 b;
La biblioteca de gráficos de cairo tiene dos archivos que implementan la aritmética de enteros de 128 bits portátil: cairo-wideint-private.h, cairo-wideint.c. Incluimos solo estos dos en nuestro proyecto para obtener 128 bits.
Mire en otras bibliotecas que se han desarrollado. Mucha gente ha querido hacer esto antes que tú. :RE
Prueba bigint C ++
No reinvente la rueda: estoy seguro de que otras personas ya han resuelto este problema, aunque no puedo nombrar ninguna solución en mi cabeza. GMP seguramente puede resolver su problema, aunque es excesivo para enteros de tamaño fijo, y también es un poco engorroso de usar (es una biblioteca C, no C ++).
Puede que estés mejor con una clase entera de precisión infinita, en lugar de una secuencia de tamaño creciente. Algunos lenguajes (como Common Lisp y IIRC Python) los tienen de forma nativa. No estoy seguro de lo que está disponible para C ++; La última vez que miré no había una versión de Boost.
EDITAR: cuando escribí por primera vez este boost::multiprecision::uint128_t aún no era una cosa. Manteniendo esta respuesta por razones históricas.
Ya hice una clase de uint128, puedes verla en: http://www.codef00.com/code/uint128.h .
Depende de impulsar para proporcionar automáticamente todas las variantes de los operadores matemáticos, por lo que debe ser compatible con todo lo que hace un tipo unsigned int nativo unsigned int .
Hay algunas extensiones menores para tipos incorporados, como inicializarlo con una cadena como esta:
uint128_t x("12345678901234567890");
Hay una macro de conveniencia que funciona de manera similar a las de C99 que puede usar de esta manera:
uint128_t x = U128_C(12345678901234567890);