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

Tareas Comunes con Números en C# - Parte 2/5 | Clase Math

Índice

1. Introducción
2. Palabras Clave
3. Clase static Math
4. Conclusiones
5. Literatura & Enlaces

1. Introducción

La clase static Math permite realizar interesantes tareas comunes con números. La segunda parte de esta serie de Tareas Comunes con Números en C# describe, grosso modo, varios de métodos para ejecutar funciones matemáticas: redondeo, valor absoluto, mínimo y máximo, logaritmos, trigonométricas, entre otras útiles operaciones.

2. Palabras Clave

• Clase static
• Función
• Método static

3. Clase static Math

Math es una clase static [Clases Estáticas en C#] que contiene miembros para funciones matemáticas como: 

• Trigonometría, 
• Logaritmos, 
• Redondeo, 
• Potenciación

La Tabla 1 (Albahari, 2012) representa la agrupación de los métodos static de esta clase. 

Tabla 1. Categorías y métodos de la clase Math (Albahari, 2012).

Varios de estos métodos, como Max y Min, poseen diferentes versiones sobrecargadas para los distintos tipos de datos primitivos -e.g., int, float, double-; mientras otras como las trigonométricas -Sin, Cos, Tan- sólo reciben como argumento valores de tipo double.

Además de funciones método, la clase Math también posee funciones a modo de propiedad para la representación de las constantes 𝞹 y ℯ: 

• Math.PI 
• Math.E

Por otra parte, con Round el programador puede especificar el número de cifras decimales a las cuales redondear el valor numérico; además, gestiona los puntos medios (e.g., redondeo de banquero) (Albahari, 2012).

Los métodos de máximo y mínimo -Max y Min- aceptan sólo dos argumentos; si el requerimiento involucra más argumento los métodos de extensión Max y Min -definidos en System.Linq.Enumerable- aceptan arreglos o secuencias (código de ejemplo en LINQPad):

int[] nums = { 13, 1, 23, 29, 2, 0, 43};

Enumerable.Min(nums).Dump("Mínimo"); // 0

Enumerable.Max(nums).Dump("Máximo"); // 43

Figura 1. Ejemplo de Enumerable.Max Enumerable.Min.

5. Conclusiones

Se ha demostrado que la clase static Math tiene definidos miembros para el cómputo de operaciones matemáticas interesantes: trigonometría, redondeo, exponenciación, etc.

La tercera parte de esta serie presentará las características de la estructura BigInteger.

6. Literatura & Enlaces

Albahari, J., Albahari, B. (2012). C# 5.0 in a Nutshell. United States: O'Reilly Media.
Math Class (System) (2016, julio 21). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.math(v=vs.110).aspx
Clases Estáticas en C# (2016, julio 21). Recuperado desde: https://ortizol.blogspot.com.co/2013/10/clases-estaticas-en-c.html

O

Otros Mecanismos de Conversión en C# - Parte 1/4: Clase Convert

Índice

1. Introducción
2. Palabras Clave
3. Clase Convert
4. Redondeo en Conversiones de Valores Reales a Enteros
5. Conversión de Números a Base Binaria, Octal, y Hexadecimal
6. Conversiones Dinámicas
7. Conversiones sobre el Sistema de Codificación Base 64
8. Conclusiones
9. Literatura & Enlaces

1. Introducción

En la serie anterior -Cadenas de Caracteres de Formato Estándar y Flags de Parseo en C#- se estudiaron los conceptos fundamentales acerca de los proveedores de formato -mecanismo de conversión y formateo integrado en .NET Framework-; a parte estos mecanismos, en .NET se cuentan con elementos de programa -clases- adicionales para suplementar la conversión para otros tipos de datos. Esta nueva serie Otros Mecanismos de Conversión en C# está divida en 4 partes; a saber: 

1. Clase Convert
2. Clase XmlConvert
3. Convertidores de Tipos
4. Clase BitConverter

En cada una de estas partes se estudia los elementos de programa que soportan otros tipos de conversiones.

Esta primera parte describe la clase Convert. Clase útil para la conversión de los datos de un tipo de dato base a otro tipo de dato base. Todos los miembros, como se muestra en los ejemplos, son static: accesibles sin requerir al programador declarar una instancia. Incluso se explora las conversiones entre tipos de datos integrales (entero a real), cambio de base numérica, conversiones dinámicas, y conversiones Base 64.

2. Palabras Clave

• .NET
• Clase
• Conversión
• Mecanismo de conversión
• Miembro static
• Tipo de dato
• Tipo de dato base

3. Clase Convert

La clase Convert de .NET Framework cuanta con miembros static para realizar operaciones de conversión entre tipos de datos base. En .NET se considera a los siguientes tipo de dato como base: 

• bool, 
• char, 
• string, 
• System.DateTime, 
• System.DateTimeOffset, 
• Todos los tipos de datos numéricos -short, int, double, etc.

Entre las características de las funciones sobresalientes de este elemento de programa se hallan: 

• La conversión de un valor real a uno entero en lugar de truncarse es redondeada.
• Conversión entre base, i.e., 2 (binario), 8 (octal), y 16 (hexadecimal).
• Conversiones dinámicas.
• Conversiones Base 64.

Los métodos definidos en esta clase, lo cuales son static, permiten al programador convertir cada tipo de dato base a cada tipo de dato base. En la Figura 1 ("Convert Class", 2016) se enumeran algunos de estos miembros. 

Figura 1. Métodos static clase Convert ("Convert Class", 2016).

En Albahari (2012) se afirma que la mayoría de estos métodos son inútiles; dado que muchos pueden resultar redundantes en conversiones implícitas o recurren al uso constante de excepciones. Sin embargo, otros métodos, aunque pocos, sí que son de bastante utilidad.

4. Redondeo en Conversiones de Valores Reales a Enteros

En el artículo Tipos de Datos Numéricos en C# se comprendió que valores de tipos de datos numéricos, la conversión implícita y explícita está permitida. En general (Albahari, 2012): 

• Las conversiones implícitas funciona para conversiones sin pérdida (.e.g., int a double).
• Las conversiones implícitas como double a int conllevan a pérdidas de precisión.

Debido a que las conversiones -casts- han sido diseñadas y optimizadas considerando la eficiencia, los datos que no se ajustan a la conversión entre los tipos de datos base son truncados. Para cubrir esta limitación, la clase System.Convert provee métodos que redondean los valores de los tipos de datos base a su objetivo; por ejemplo: 

double d = 4.9;

int i = Convert.ToInt32(d);

Console.WriteLine(i); // 5

Vale agregar que la clase Convert efectúa esta operación usando el algoritmo de redondeo del banquero ("Rounding", 2016); por ejemplo:

double d1 = 23.5;

double d2 = 24.5;

int i1 = Convert.ToInt32(d1);

int i2 = Convert.ToInt32(d2);

Console.WriteLine(i1); // 24

Console.WriteLine(i2); // 24

de modo análogo 

double d1 = -23.5;

double d2 = -24.5;

int i1 = Convert.ToInt32(d1);

int i2 = Convert.ToInt32(d2);

Console.WriteLine(i1); // -24

Console.WriteLine(i2); // -24

5. Conversión de Números a Base Binaria, Octal y Hexadecimal

Entre los métodos útiles que se encuentran en Convert están los de cambio de base numérica; e.g., Convert.ToInt32(String, Int32) y Convert.ToUInt32(String, Int32).

Ejemplos de uso: 

// Conversión a hexadecimal:

int treinta = Convert.ToInt32("1E", 16); // 30

// Conversión a octal:

int nueve = Convert.ToInt32("11", 8); // 9

// Conversión a binario:

uint siete = Convert.ToUInt32("111", 2); // 7

6. Conversiones Dinámicas

Otro método interesante que provee Convert, es el que permite convertir de un tipo de dato a otro; se trata de ChangeType(object, Type). Esta es su firma: 

public static object ChangeType(object value, Type conversionType);

Ejemplo de uso: 

Type tipoDestino = typeof (int);

object tipoFuente = "42";

object resultado = Convert.ChangeType (tipoFuente, tipoDestino);

Console.WriteLine(resultado); // 42

Console.WriteLine(resultado.GetType()); // system.Int32

El programador debe tener en cuenta que tanto el tipo de dato fuente como el tipo de dato destino deben ser compatibles (Albahari, 2012).

Este tipo de conversión puede resultar útil cuando se está implementando un deserializador que emplee múltiples tipos de datos (Albahari, 2012).

Finalmente, hay que considerar la nota respecto a cadenas de caracteres de formato apuntada en Albahari (2012): 

A limitation of ChangeType is that you cannot specify a format string or parsing flag.

7. Conversiones sobre el Sistema de Codificación Base 64

La transferencia de datos sobre un estándar como XML facilita intercambiar datos de diferentes tipos entre aplicaciones; entre ellos datos binarios: como podría ser una imagen o datos equivalentes. El sistema de codificación Base 64 provee los medios para codificar datos binarios en una representación binaria legible; esto lo logra a través de 64 caracteres de la codificación ASCII (Albahari, 2012).

[Nota: En Receta No. 2-4 en C#: Codificación de Datos Binarios a través de Base64 se explica a través de una receta C# este tipo de proceso de conversión con mayor grado de detalle.]

8. Conclusiones

El programador ha comprendido los fundamentos básicos acerca de la funcionalidad que provee la clase Convert por medio de sus métodos static. Se estudiaron en esencia: el mecanismo de redondeo basado en el algoritmo del banquero, cambios de base, conversión dinámica (en tiempo de ejecución), y al final, conversión bajo sistema de codificación Base 64.

La segunda parte de esta serie explica la utilidad de la clase XmlConvert.

9. Literatura & Enlaces

Albahari, J., Albahari, B. (2012). C# 5.0 in a Nutshell. United States: O'Reilly Media.
Convert Class (System) (2016, julio 19). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.convert.aspx
Tipos de Datos Numéricos en C# (2016, julio 19). Recuperado desde: https://ortizol.blogspot.com.co/2013/07/tipos-numericos-en-c-parte-2.html
Rounding (2016, julio 19). Recuperado desde: https://en.wikipedia.org/wiki/Rounding#Round_half_to_even
Receta No. 2-4 en C#: Codificación de Datos Binarios a través de Base64 (2016, julio 19). Recuperado desde: https://ortizol.blogspot.com.co/2014/05/receta-no-2-4-en-c-codificacion-de.html

O