Tareas Comunes con Números en C# - Parte 3/5 | Estructura BigInteger

Índice

1. Introducción
2. Palabras Clave
3. Estructura BigInteger
3.1 Generalidades
3.2 Pérdida de precisión
3.3 Sobrecarga de operadores
3.4 Criptografía
4. Conclusiones
5. Literatura & Enlaces

1. Introducción

Esta tercera parte de la serie Tareas Comunes con Números en C# ilustra al programador C# acerca de la funcionalidad que ofrece la estructura BigInteger. Este tipo de dato está especializado en el manejo de valores numéricos enteros grandes. Se demuestra los básicos para representación, manipulación, y los casos de pérdida de precisión en operaciones de casting. Al final introduce la generación de valores pseudoaleatorios representados en un arreglo de bytes.

2. Palabras Clave

• BigInteger
• Casting
• Estructura
• Pérdida precisión
• Pseudoaleatorios

3. Estructura BigInteger

3.1 Generalidades

BigInteger es una estructura para la representación de valores enteros grandes con signo ("BigInteger Structure", 2016). Esta estructura reside en el namespace System.Numerics sobre el assembly System.Numerics.dll y fue introducida en la versión 4.0 de Microsoft .NET Framework (Albahari, 2012).

El programador debe saber que C# no provee soporte nativo para la representación de literales para BigInteger, en su lugar se opta por la conversión explícita de otros tipos de datos numéricos o el uso de funciones static definidas en esta estructura; como por ejemplo BigInteger.Pow. Ejemplos de estas dos operaciones permitidas podría ser: 

// Casting explícito:

BigInteger bi = 42;

Console.WriteLine(bi.ToString());

Salida: 

42

o a través de métodos static: 

// Uso de métodos static de BigInteger:

BigInteger googol = BigInteger.Pow(10, 100);

Console.WriteLine(googol.ToString());

Este código produce como resultado 

10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Incluse también con el método BigInteger.Parse se puede obtener el mismo resultado: 

// Uso de Parse:

googol = BigInteger.Parse("1".PadRight(101, '0'));

Console.WriteLine(googol.ToString());

que también produce 

10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

3.2 Pérdida de precisión

Sin embargo, hay que tener en cuenta que los casting explícitos a instancias de BigInteger desde otros tipos de datos numéricos conducen a la pérdida de precisión; como en 

// Périda de precisión:

double googol2 = (double) googol; // Cast explícito

BigInteger googol3 = (BigInteger) googol2; // Cast explícito

Console.WriteLine(googol3);

9999999999999998216360018871870109548898901740426374747374488505608317520357971321909184780648316928

3.3 Sobrecarga de operadores

La estructura BigInteger sobrecarga todos los operadores aritméticos [Sobrecarga de Operadores en C#], inclusive los operadores de módulo (o residuo) % y los operadores de igualdad o comparación (Albahari, 2012).

3.4 Criptografía

Para aplicaciones de criptografía, la estructura BigInteger soporta la creación de objetos a partir de un arreglo de números de 32 bytes; por ejemplo con las siguientes líneas de código se genera un número pseudoaleatorio, se crea un arreglo de bytes, y se instancia un objeto BigInteger: 

// Demostración creación valores pseudoaleatorios para criptografía:

RandomNumberGenerator aleatorio = RandomNumberGenerator.Create();

byte[] bytes = new byte[32];

aleatorio.GetBytes(bytes);

// Conversión a BigInteger:

var bigRandomNumber = new BigInteger(bytes);

Salidas de ejemplo de valores pseudoaleatorios de este código: 

-27997898345474982808272022673837133576728275777263776236111952592197235214127

11925147538907159540278407492089922528204657461881251350711774059443551062475

4. Conclusiones

Se ha estudiado las capacidades de manejo de números enteros arbitrariamente grandes a través de la estructura BigInteger. Se comprendió que resulta útil para aplicaciones de criptografía.

La siguiente parte de esta serie se enfoca en el estudio de operaciones con números complejos a través de la estructura Complex.

5. Literatura & Enlaces

Albahari, J., Albahari, B. (2012). C# 5.0 in a Nutshell. United States: O'Reilly Media.
BigInteger Structure (System.Numerics) (2016, julio 22). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.numerics.biginteger(v=vs.110).aspx
Sobrecarga de Operadores en C# (2016, julio 22). Recuperado desde: https://ortizol.blogspot.com.co/2014/09/sobrecarga-de-operadores-en-csharp.html

O