Xwork's Blog

Recientemente publiqué un par de programas que se encargaban de convertir un número decimal a cualquier base en el rango 2-35, todo parecía funcionar bien, eso al menos hasta el número 2,147,483,647, intentar convertir el número 2,147,483,648 produce un fallo que causa que la aplicación se detenga.

Al inspeccionar la imagen, podemos ver que el error es: OverflowException (en el caso de C#, pero te aseguro que es el mismo para java). Este tipo de errores/excepciones, se producen cuando intentamos asignar un valor más grande del que la variable puede manejar. hay que recordar que para almacenar el valor de entrada en la función que convierte el numero, usamos una variable del tipo "int" y si buscamos el valor máximo que este tipo de variable puede almacenar tenemos que es 2,147,483,647 y el mínimo es -2,147,483,648, eso quiere decir que se intentamos guardar un numero por arriba (o por abajo), simplemente no podremos hacerlo.

El tipo int es uno de los más comunes que usaremos, en la vida real hay muy pocas cosas que requieran un numero tan grande, pero porque solo puede almacenar ese numero? Bueno, la razón es porque utiliza un espacio de 32 bits, pero no todos están disponibles para almacenar el valor del número, el primer byte (de izquierda a derecha), se usará para almacenar el signo, cuando este byte tenga 1, indicará que es un número negativo, para el caso contrario, será positivo.

Para solucionar el error, debemos de escoger una variable que pueda contener un valor más grande, pero que tenga características similares a la que usamos actualmente y la más parecida es "long" que puede almacenar un valor de -922337203685477508 a 922337203685477507, más que suficiente para nosotros. Por ahora queda de tarea ajustar el programa en C#.

Y bien, por ahora es todo, en el transcurso de la semana actualizaré los programas.

Por ahora es todo, los leo luego.

La interfaz principal está compuesta por 4 componentes:

• 1 TextView.
• 1 EditText (Numérico).
• 1 Button.
• 1 ListView.

Todos los componentes se pueden crear con el siguiente código:

 <?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
	xmlns:app="http://schemas.android.com/apk/res-auto"
	xmlns:tools="http://schemas.android.com/tools"
	android:layout_width="match_parent"
	android:layout_height="match_parent"
	tools:context="com.mdev.com.dectoany.MainActivity">

	<LinearLayout
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"
		android:orientation="vertical"
		tools:layout_editor_absoluteX="8dp"
		tools:layout_editor_absoluteY="8dp">

		<TextView
			android:id="@+id/lblNumberIn"
			android:layout_width="match_parent"
			android:layout_height="wrap_content"
			android:text="Número a convertir" />

		<EditText
			android:id="@+id/TXTNumberIn"
			android:layout_width="match_parent"
			android:layout_height="wrap_content"
			android:ems="10"
			android:inputType="number" />

		<Button
			android:id="@+id/BtnConvert"
			android:layout_width="match_parent"
			android:layout_height="wrap_content"
			android:text="Convertir" />

		<ListView
			android:id="@+id/LVResults"
			android:layout_width="match_parent"
			android:layout_height="match_parent" />
	</LinearLayout>
</android.support.constraint.ConstraintLayout>

Con esto, tendremos todos los controles necesarios para que el usuario interactue con la aplicación, ahora solo queda implementar el código que hace funcionar las cosas.

El Código que hace funcionar las cosas.

El código es muy parecido al que usamos para la versión de C#. Solo que en este caso, vamos a usar el control ListView para mostrar los resultados de las conversiones.

El código java de DecToAny es el siguiente:

package com.mdev.com.dectoany;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;
import android.widget.TextView;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class MainActivity extends Activity {

	Button BtnConvert;
	ListView LVResults;
	TextView TxtNumberIn;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);

		BtnConvert = (Button) findViewById(R.id.BtnConvert);
		TxtNumberIn = (TextView) findViewById(R.id.TXTNumberIn);
		LVResults = (ListView) findViewById(R.id.LVResults);

		BtnConvert.setOnClickListener(new View.OnClickListener() {
			@Override
			public void onClick(View view) {
				DoConvert();
			}
		});
	}

	private void DoConvert(){
		ArrayList Items = new ArrayList();
		String CurrentNumber = TxtNumberIn.getText().toString();
		int MyNumber = Integer.parseInt(CurrentNumber);
		for (int I = 2; I < 30; I++){
			Items.add(ListToString(NumbersList(MyNumber, I))+"\n"+"Base "+ I);
		}
		final ArrayAdapter adapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1,Items);
		LVResults.setAdapter(adapter);
	}
	private String ListToString(List<Integer> Numbers)
	{
		Collections.reverse(Numbers);
		String Result = "";
		for (int i = 0; i < Numbers.size(); i++){
			int CurrentNumber = Numbers.get(i);
			if (CurrentNumber < 10)
				Result += CurrentNumber;
			else
				Result += NumberToChar(Numbers.get(i));
		}
		return Result;
	}
	private char NumberToChar(int Number){
			return (char)(Number + 55);
	}

	private List<Integer> NumbersList(Integer InNumber, int Base) {
		Integer LastNumber = InNumber;
		Integer Garbage;
		List<Integer> result = new ArrayList<Integer>();
		if (LastNumber < Base) {
			result.add(LastNumber);
		}
		else         {
			if (LastNumber >= Base) {
				do {
					Garbage = LastNumber % Base;
					LastNumber = LastNumber / Base;
					if (LastNumber < Base) {
						result.add(Garbage);
						result.add(LastNumber);
					} else {
						result.add(Garbage);
					}
				} while (LastNumber >= Base);
			}
		}
		return result;
	}
}

Para esta aplicación vamos usar 4 funciones, la primera de ellas en orden de uso (no de aparicion) es "NumberList", esta es la función que va a realizar los cálculos; cómo parámetros de entrada, recibirá un parámetro del tipo "Integer" llamado "InNumber" que es el número decimal que queremos convertir; seguido de una valor del tipo "int" llamado "Base", este; cómo su nombre lo indica; es la base de destino a la cual queremos convertir nuestro número decimal. La función regresa una lista del tipo "List<Integer>" con los valores de los dígitos para formar el número, pero en orden inverso.
Después tenemos la función "ListToString" que será la encargada de formar un número y devolverlo en forma de "String". Esta función recibe cómo parámetro un lista del tipo "List<Integer>". Esta función se encarga primero; en invertir el orden de la lista que se ingresa cómo parámetro. Después comprueba si el valor es menor a 10 (decimal), si es así, simplemente agrega al string "Result" (variable interna de la función) el valor actual, en caso contrario, manda a llamar a la función "NumberToChar" que se encargara de asignar una letra de la A a la Z a los valores mayores a 10. Finalmente devuelve un "string" que contiene la representación de los resultados de la función "NumberToList" en el formato adecuado para que cualquier persona lo pueda entender.
La función "NumberToChar" simplemente devuelve el numero que se ingresa cómo parámetro + 55.
Para la aplicación de Android también usamos un procedimiento llamado "DoConvert"; en el cual se manda a llamar a las otras funciones dentro de un bucle que va del 2 al 29. En este procedimiento se crea un "ArrayAdapter" que se llenará con los valores que se crean en el ciclo "for" y finalmente se asignan al "ListView".
Con esto podemos obtener de forma fácil el valor de un numero decimal en 27 bases diferentes. En todas las aplicaciones (Android, Windows, Web)no he revisado los errores que puedan haber, no porque sea perezoso o algo similar), pero un error critico existe en la version Web, en esta al poder escoger cual es la base a la que queremos convertir nuestro numero, podemos introducir base 1, pero esta base es imposible de usar, ya que solo disponemos del numero 0, entonces al hacer las divisiones, entramos al bucle "while", pero nunca podremos salir de el, y en algún momento la memoria se acabará hasta que finalmente el navegador en el cual se usa falle. Aunque el sentido común dice que no se debe de hacer lo antes descrito, nunca falta aquel que lo haga solo para saber que pasa. Para evitarlo basta con comprobar las base de destino, si es menor a 2, simplemente hay que informarle al usuario y terminar la ejecución.
Y bien, por ahora es todo, la aplicación compilada la puedes descargar de mi dropbox, el código lo subiré un poco después, primero voy a corregir un error minusculo en el proyecto. (Debería de ser com.mdev.dectoany, en su lugar puse com.mdev.com.dectoany ).

Los leo luego

El código en javascript que convierte de decimal a otras bases es el siguiente:

<html>
	<head>
	<title>Convertidor de decimal a otras bases</title>
	<style type="text/css">
	.h1Cal
	{
	   font-size: 14px;
	}
	.formDecToAny{
		font: 95% Arial, Helvetica, sans-serif;
		max-width: 400px;
		margin: 10px auto;
		padding: 16px;
		background: #F9F9F9;
	}
	.TextCal
	{
		width: 100%;
		box-sizing: border-box;
		border: 2px solid #999;
		border-radius: 4px;
	}

	.ButtonCal
	{
	width: 100%;
		background-color: #26c6da;
		border: none;
		color: white;
		padding: 15px 32px;
		text-align: center;
		text-decoration: none;
		display: inline-block;
		-webkit-transition-duration: 0.4s; /* Safari */
		transition-duration: 0.4s;
	}

	.ButtonCal:hover
	{
	width: 100%;
		background-color: #35d5e5;
		border: none;
		color: white;
		padding: 15px 32px;
		text-align: center;
		text-decoration: none;
		display: inline-block;
	}
	</style>
	<script type="text/javascript">

	function DecToAny(Number, Base){
		var LastNumber = parseInt(Number, 10);
		var Garbage;
		var result = []
		debugger;
		if (LastNumber < Base)
		{
			result.push(LastNumber);
		}
		else
		{
			while (LastNumber >= Base) {
				Garbage = LastNumber % Base;
				LastNumber = Math.floor(LastNumber / Base);
				if (LastNumber < Base)
				{
					result.push(Garbage.toString());
					result.push(LastNumber.toString());
				}
				else
				{
					result.push(Garbage.toString());
				}
			}
		}
		return result;
	}

	function NumberToChar(Number){
		if(Number < 10)
			return Number;
		else
			return String.fromCharCode(parseInt(Number, 10) + 55);
	}

	function ArrayToString(){
		var GetNumber = document.getElementById('InputNumber').value;
		var GetBase = document.getElementById('InputBase').value;
		if(GetNumber.length < 1 || GetBase.length < 1)
		{
			alert('El numero/base no puede estar en blanco');
			return;
		}
		var Convert = DecToAny(GetNumber,GetBase);
		var Out = "";
		Convert.reverse()
		for(var i = 0; i < Convert.length; i++)
		{
			Out = Out + NumberToChar(Convert[i])
		}
		document.getElementById('Result').value = Out;
	}
	</script>
	</head>
	<body>
		<form class="formDecToAny">
			<span class="h1Cal">Numero decimal a convertir:</span>
			<input class="TextCal" id="InputNumber" type="text"></input><br />
			<span class="h1Cal">Base a la cual convertir:</span>
			<input class="TextCal" id="InputBase" type="text"></input><br />
			<br />
			<input class="ButtonCal" id="ToAny" onclick="ArrayToString()" type="button" value="Convertir" /><br />
			<br />
			<span class="h1Cal">Resultado:</span>
			<input class="TextCal" id="Result" type="text"></input><br />
			<br />
		</form>
	</body>
</html>

El código esta formado por 3 funciones. La priera es "DecToAny", esta será la encargada de hacer los cálculos, hay que recordar que todo el proceso se lleva a cabo por una sucesión de divisiones. Esta función recibe dos parámetros, el primero es el número que queremos convertir, el segundo es la base objetivo. Devuelve una matriz que contiene los valores en orden inverso.

La segunda función es "NumberToChar", esta recibe un número cómo parámetro y lo único que hace es comprobar si el número es menor a 10, si es así, entonces solo devuelve el número que se ingreso, en caso contrario, convertirá el número ingresado cómo parámetro y lo devolverá con el valor correcto, hay que recordar que cuando usamos el décimo dígito en una base 12; por ejemplo; no podemos poner 0,2,3,4,5,6,7,8,9,10,11,12 (que serian los doce dígitos necesarios para representar todos los números simples hasta la base), en su lugar, debemos de recurrir a letras: 0,1,2,3,4,5,6,7,8,9,0,A,B. Con está función tenemos disponible hasta el dígito Z (base 35).
Finalmente tenemos la función "ArrayToString" que se encarga de convertir todos los datos de la matriz devuelta por la función "DecToAny" a un formato legible para las personas, internamente también llama a la función "NumberToChar" para que el resultado contenga letras cuando se hace uso del décimo o más. Cuando se quiera convertir un número, esta es la función que se debe mandar a llamar.

Para el formulario, solamente se hace uso de tres Textbox(text), uno servirá para introducir el número a convertir, otro recibirá la base de destino y el tercero mostrará el resultado. Ademas se hace el uso de un boton(button) que al hacer clic sobre el, mandará a llamar a la función "ArrayToString".

Cómo podrás ver, el código es realmente similar al de la versión C# que hicimos en el post anterior, con esto quiero demostrar que resulta relativamente fácil portar un programa de un lenguaje a otro, ahora solo queda pendiente la versión para android, pero eso será la semana que viene. Cómo siempre, el código completo lo puedes descargar de mi dropbox, pero además la versión online también esta disponible para su ejecución en este blog.

Por ahora es todo. Los leo luego.

Para empezar recordemos que las conversión de un número decimal a un número en otra base, se realiza mediante divisiones sucesivas de el numero resultante de la división anterior entre la base. Si tenemos el numero X decimal y lo queremos pasar a la base B, debemos de dividir X/B y al resultado R, en la siguiente división lo dividiremos entre la base (B), este proceso se repite mientras que el resultado R sea mayor que la base.

Sabiendo lo anterior, podemos crear una funcion cómo la que sigue:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace DecToAny
{
 public partial class FrmMain : Form
 {
  private List<TextBox> TextBoxes = new List<TextBox>();
  private List<int> DecToAny(int Number, int Base)
  {
   int LastNumber = Number;
   int Garbage;
   List<int> result = new List<int>();
   if (LastNumber < Base)
   {
    result.Add(LastNumber);
   }
   else
   {
   while (LastNumber >= Base) {
    Garbage = LastNumber % Base;
    LastNumber = LastNumber / Base;
    if (LastNumber < Base)
    {
     result.Add(Garbage);
     result.Add(LastNumber);
    }
    else
    {
     result.Add(Garbage);
    }
   }
   }

   return result;
  }
  private string ListToString(List<int> Lista)
  {
   string Out = "";
   Lista.Reverse();
   foreach (int Numero in Lista) {
    if (Numero < 10)
    {
     Out += Numero.ToString();
    }
    else
    {
     Out += NumberToLetra(Numero);
    }
   }
   return Out;
  }
  public FrmMain()
  {
   InitializeComponent();
  }
  private char NumberToLetra(int Number)
  {
   return (char)(Number + 55);
  }
  private void FrmMain_Load(object sender, EventArgs e)
  {
   TextBoxes.Add(txtBase2);
   TextBoxes.Add(txtBase3);
   TextBoxes.Add(txtBase4);
   TextBoxes.Add(txtBase5);
   TextBoxes.Add(txtBase6);
   TextBoxes.Add(txtBase7);
   TextBoxes.Add(txtBase8);
   TextBoxes.Add(txtBase9);
   TextBoxes.Add(txtBase10);
   TextBoxes.Add(txtBase11);
   TextBoxes.Add(txtBase12);
   TextBoxes.Add(txtBase13);
   TextBoxes.Add(txtBase14);
   TextBoxes.Add(txtBase15);
   TextBoxes.Add(txtBase16);
   TextBoxes.Add(txtBase17);
   TextBoxes.Add(txtBase18);
   TextBoxes.Add(txtBase19);
   TextBoxes.Add(txtBase20);

  }

  private void BtnConvert_Click(object sender, EventArgs e)
  {
   for (int T = 0; T < TextBoxes.Count; T++)
   {
    TextBoxes[T].Text = ListToString(DecToAny(int.Parse(TxtNIn.Text), (T + 2)));
   }
  }
 }
}

El código anterior consta de 3 funciones. La función que hace gran parte del trabajo es "DecToAny", en ella se crean dos variables. La variable "LastNumber" será la encargada de almacenar el resultado de las divisiones anteriores. La variable "Garbage" será utilizada para guardar los "residuos" de las divisiones, estos son usados para formar el número final. Antes de siquiera empezar con el ciclo while, se hace una comprobación; si el número es menor que la base, simplemente se regresa una lista del tipo "int" con un solo elemento, en este caso, el mismo numero que se ingreso cómo parámetro para "Number". Si por el contrario el numero es igual o mayor que la base; se entra en el bucle while y  se comienzan a hacer las divisiones. En el bucle, se comprueba que el resultado de la división que esta almacenado en "LastNumber" sea mayor que la base. Cuando la base es mayor que el resultado de la división, el residuo de esta se agrega a la lista "result", pero cuando la condición ya no se cumple, entonces agrega a la misma lista el valor residual de la división y además el resultado de la misma. Finalmente devuelve una lista del tipo "int" con todos los valores.
La funcion "ListToString" se usa para convertir la lista del tipo "int" en un string (valga la redundancia). Para empezar, primero se invierte el orden en el cual están los elementos, hay que recordar que el resultado de las divisiones se usa en orden inverso en donde el primer digito, sera el residuo de la ultima division seguido del resultado entero de la misma seguido de los residuos del resto de las otras divisiones. Para devolver el resultado final, tambien se hace uso interno de la funcion "NumberToLetra", hay que recordar que para el decimo digito se usa la letra A.
Una vez que se ejecuta la función "DecToAny" hay que pasársela cómo parámetro a la función "ListToString" y el resultado será un string con una cadena equivalente al numero en la base especificada.

A tomar en cuenta.

En compactan hay que recordar que internamente se usan solo dos números: el 1 y el 0, que son la cantidad mínima representable (encendido o apagado). Para trabajar en la computadora se usan Bytes y cada Byte esta compuesto de ocho bits, entonces el numero máximo que se puede representar usando ocho bits es 11111111 (hay que tener algunas consideraciones con respecto a como se interpretan los datos en una computadora, pero por ahora solo convertiremos ese numero en "crudo").

La computadora entenderá perfectamente esos numero, pero que pasa si un humano quiere saber cual es el numero que representa 10010001? Para eso es necesario convertirlo a una base con la que ya estemos familiarizados.

Los números se pueden representar en cualquier base a partir de 2, puede ser base 3, base 5, incluso base 20. La base con la que estamos familiarizados es la base 10, pero antes de seguir, de seguro te preguntas: que es una base? Bien, la explicación mas sencilla es, la cantidad de números disponibles para representar un valor mas grande. Por ejemplo, en un numero de base dos, solo se dispone de los números 0 y 1. En un numero de base diez, se disponen de los números 1,2,3,4,5,6,7,9,0. Para representar un número más grande que diez, se empiezan a usar las potencias de diez y para el caso de la base dos, para representar un numero más grande que dos se usaran potencias de dos.

Para continuar con el meollo del asunto, ahora sabemos que ocho bits pueden representar el numero 11111111 en base dos, para convertirlo, solo vamos a multiplicar el valor de cada numero por su potencia correspondiente empezando de izquierda hacia la derecha y se empezara por la base elevada a la potencia cero.

2^7 (128)	2^6 (64)	2^5 (32)	2^4 (16)	2^3 (8)	2^2 (4)	2^1 (2)	2^0 (1)
1	1	1	1	1	1	1	1

Mirando la tabla anterior tenemos que el valor de 11111111 en base dos es igual a la suma de 2^0 hasta 2^7, haciendo la cuenta esto resulta en 255 decimal. Para convertir el numero 10010001 de base dos a base 10, debemos de hacer lo mismo que hicimos antes, debemos de multiplicar el valor del dígito por si potencia y tendriamos algo cómo lo que sigue:

2^7 (128)	2^6 (64)	2^5 (32)	2^4 (16)	2^3 (8)	2^2 (4)	2^1 (2)	2^0 (1)
1	0	0	1	0	0	0	1

Al hacer las sumas obtenemos que el número 10010001 de base dos es igual a 145 en base 10.

Y ahora la pregunta del millon, por que usar la base 16? La base 16 es muy comun usarla para representar los numero en computacion, si recuerdas los post: "Cómo extraer una imagen embebida en un mp3", usabamos un visor hexadecimal para ver la informacion dentro del mp3.
Esto es así debido a que el número 11111111 (255) es equivalente a FF en hexadecimal. Antes de seguir hay que saber esto. Para evita confusiones, cuando usamos una base que tiene digitos más alla de nuestro 9, debemos de usar símbolos, asi evitamos confundir números, en el caso del hexadecimal, se deben de usar 16 caracteres para representar, entonces empezamos desde el 0 hasta la F, despues del 9 seguiría el 10, para evitar confusiones usamos la letra A(10), B(11), C(12), D(13), E(14) y F(15).
Al igual que con la base dos, se usaran potencias, pero en este caso serán potencia del número 16

16^1 (16)	16^0 (1)
F	F

entonces para representar el el numero 11111111 solo debemos de usar dos dígitos en base 16, basta con usar FF para representar cada valor posible de un byte. para valores hexadecimales más grandes, bastará con usar la siguientes potencias.
Y bien, por ahora es todo, en el siguiente post vamos a hacer el proceso inverso y más adelante una aplicación para android que convierta entre cualquier base.

Los leo luego.