MANUAL
DE USUARIO BASICO (CALCULADORA EN
JAVA)
INTRODUCCIÓN.
La calculadora tiene como objetivo realizar operaciones
básicas tales como suma, resta, multiplicación y división de números en forma
binaria, obteniendo resultados de la misma forma.
El programa se
estructura de la siguiente forma: en los primeros apartados se definen algunos
conceptos básicos, luego se presentan las operaciones que permiten realizar la
manipulación de datos y variables, así como la forma de mostrar los resultados
PASOS.
1. Seleccionara del menú que operación desea realizar, oprimiendo la tecla
indicada.
Presione
tecla 1 para SUMA.
Presione
tecla 2 para RESTA.
Presione
tecla 3 para MULTIPLICACION.
Presione
tecla 4 para DIVISION.
Presione
tecla 5 para SALIR.
2. Le pedirá
ingresar los valores, estos serán de forma hexadecimal.
Ingrese
valor A.
Ingrese
valor B.
3. Una vez ingresados los valores, presionara la tecla
enter y se realizara la operación e inmediatamente se mostrara el resultado.
El
resultado de su operación es: (Resultado en binario).
4. Una vez mostrado el resultado se le preguntara si
desea realizar una nueva operación. En caso de que si presione "S" se
le mostrara nuevamente el menú de
operaciones, en caso de que sea lo contrario "N" saldrá del
programa.
Manual Técnico
DIAGRAMA
El
presente documento constituye una herramienta de ayuda para cualquier persona
interesada en el funcionamiento de la calculadora de números binarios.
El
documento está dividido en la tecnología
(software) utilizado y la codificación de cada una de las partes que
componen la calculadora.
Esperamos
que este manual cumpla con las expectativas del lector y se convierta en una
herramienta para el conocimiento del programa de la calculadora binaria.
Software utilizado
La
codificación de la calculadora se
realizó en NetBeans IDE 7.2.1.
Ejecución del código
Se
utilizara NetBeans para la ejecución del
código de la calculadora de números binarios.
Código menú
public class Calculadora_Binaria3 {
public
static void main(String[] args) {
Scanner
teclado = new Scanner(System.in);
int
opcion;
int
opcion1, opcion2;
boolean
salir = false;
do{
System.out.println("**********
BIENVENIDO A LA CALCULADORA DE OPERACIONES CON NUMEROS BINARIOS **********
\n");
System.out.println("******************** \t Que operación desea
hacer \t ********************");
System.out.println("1.- Suma");
System.out.println("2.- Resta");
System.out.println("3.- División");
System.out.println("4.- Multilicación");
System.out.println("5.- Salir \n");
System.out.print("Opcion
deseada : ");
opcion = teclado.nextInt();
System.out.println("");
switch (opcion){
case 1 :
System.out.println("***** INTRODUCE LOS VALORES *****");
System.out.print("Valor 1 : \n");
opcion1 = teclado.nextInt();
System.out.print("Valor 2 : \n");
opcion2 = teclado.nextInt();
System.out.println("\n\t\t
BINARIO \t DECIMAL");
SumaBinario sum = new SumaBinario();
sum.operacionsum(opcion1, opcion2);
System.out.println("\n
Desea otra operacion? Y/N");
String sn = teclado.next();
if (sn.equals("Y") || sn.equals("y")){
salir = true;
}
else{
salir = false;
}
break;
case 2 :
boolean restri = false;
do{
System.out.println("*****
INTRODUCE LOS VALORES *****");
System.out.println("NOTA: En este caso el valor 1 debe ser mayor
que le valor2");
System.out.print("Valor 1 : \n");
opcion1 = teclado.nextInt();
System.out.print("Valor 2 : \n");
opcion2 = teclado.nextInt();
if(opcion1 >= opcion2){
RestaBinario
rest = new RestaBinario();
rest.operacionrest(opcion1, opcion2);
restri = false;
}
else{
System.out.println("*** VALOR 2 ES MAYOR AL VALOR 1, INTENTA DE
NUEVO\n\n");
restri = true;
}
}while(restri == true);
System.out.println("\n
Desea otra operacion? Y/N");
String sm = teclado.next();
if (sm.equals("Y") || sm.equals("y")){
salir = true;
}
else{
salir = false;
}
break;
case 3 :
System.out.println("***** INTRODUCE LOS VALORES *****");
System.out.print("Valor 1
: \n");
opcion1 = teclado.nextInt();
System.out.print("Valor 2 : \n");
opcion2 = teclado.nextInt();
DivisionBinario div = new DivisionBinario();
salir = true;
break;
case 4 :
System.out.println("*****
INTRODUCE LOS VALORES *****");
System.out.print("Valor 1 : \n");
opcion1 = teclado.nextInt();
System.out.print("Valor 2 : \n");
opcion2 = teclado.nextInt();
MultiBinario multi = new MultiBinario();
salir = true;
break;
case 5 :
salir
= false;
break;
default :
System.out.println("********** Opcion no valida, Intentalo de Nuevo
********** \n\n");
salir = true;
}
}while(salir == true);
}
}
Código suma
public class SumaBinario {
public void
operacionsum (int valor1, int valor2){
int
[] arregloa = decimaltobinari(valor1);
int [] arreglob =
decimaltobinari(valor2);
System.out.print("Valor 1:
\t");//se imprime el el primer valor convertido a bianrio
for (int binario : arregloa) {
System.out.print(binario);
}
System.out.print("\t\t" +
valor1);//se imprimer el valor 1 en decimal
System.out.println();
System.out.print("Valor 2:
\t");//se imprime el el segundo valor convertido a bianrio
for (int binario : arreglob) {
System.out.print(binario);
}
System.out.print("\t\t" +
valor2);//se imprimer el valor 2 en decimal
System.out.println("\n--------------------------------------------");
int []
resultado = sumaBinyBin(arregloa, arreglob);
System.out.print("Resultado:
\t");
for(int
i = 0; i < resultado.length; i++) {
System.out.print(resultado[i]);//se
imprime la el resultado de la suma binaria
}
int resul = valor1 + valor2;
System.out.print("\t\t" +
resul);//se imprime la suma de los valores decimales
System.out.println();
}
public
static int [] decimaltobinari(int valor){
//variables
String
binariores, res="";
int
residuo;
int x =
0;
binariores = Integer.toBinaryString(valor);
int
arreglo [] = new int[15];
while
(valor > 0) {
residuo = valor % 2;//obtener el
residuo
valor = valor / 2;//realizar la
siguiente division
//En el orden natural de la
operacion los valores estan invertidos
//por eso aqui los volvemos a
invertir :)
res = residuo + res;
x++;
}
for(int
i = arreglo.length -1, j=0, k=0; i > -1; i--, j++){
if(i
>= res.length()){
arreglo[j] = 0;//llenamos los
lugares vacios con ceros
}
else{
arreglo[j] =
Integer.parseInt(res.charAt(k)+ "");//cuando llegemos al primer uno
guradamos la conversion a binarios
k++;
}
}
return arreglo;// se regresa el
arreglo
}
public
static int[] sumaBinyBin(int a[], int b[]) {
int
acarreo = 0;//variable de control.
int[] c = new int[15];//Arreglo a retornar.
//Se
recorre el arreglo a de manera inversa.
for (int i = c.length -1 ; i > 0; i--) {
int
suma = a[i] + b[i]; //Se realiza la suma
una vez por ciclo
if(suma == 2) {//Si la suma da 2
los elementos en el arreglo son 1 y 1.
c[i] = 0;//Por lo tanto debe ir
como resultado un 0
acarreo = 1;//Y se lleva un
acarreo
}
//Si por el contrario la suma es 0
quiere decir que los elementos
//eran 0 y 0.
else if(suma == 0) {
c[i] = 0;//Entonces debe ir 0
como resultado
}
//Si por el contrario la suma es 1,
entonces los elementos
//eran 0 y 1 o viceversa.
else if(suma == 1) {
c[i] = 1;//Y debe ir como
resultado un 1.
}
if(acarreo == 1) {//Si existe un
acarreo en este ciclo
//Se comprueba si la suma del
elemento siguiente del
//arreglo "a" mas el
acarreo es igual a 2.
if(a[i-1] + 1 == 2) {
a[i-1] = 0;//Si lo es, se
asigna un 0 a "a".
acarreo = 1;//Y se sigue
llevando un acarreo.
} else {//Si la suma no da 2,
solo puede dar 1.
a[i-1] = 1;//Y entonces se
asigna 1 a "a".
acarreo = 0;//Y el acarreo
desaparece.
}
}
}
return c;//Se regresa el arreglo.
}
}
Código resta
public class RestaBinario {
public void
operacionrest (int valor1, int valor2){
int
[] arregloa = decimaltobinari(valor1);
int [] arreglob =
decimaltobinari(valor2);
System.out.print("Valor 1:
\t");//se imprime el el primer valor convertido a bianrio
for (int binario : arregloa) {
System.out.print(binario);
}
System.out.print("\t\t" +
valor1);//se imprimer el valor 1 en decimal
System.out.println();
System.out.print("Valor 2:
\t");//se imprime el el segundo valor convertido a bianrio
for (int binario : arreglob) {
System.out.print(binario);
}
System.out.print("\t\t" +
valor2);//se imprimer el valor 2 en decimal
System.out.println("\n--------------------------------------------");
int []
resultado = restaBinyBin(arregloa, arreglob);
System.out.print("Resultado:
\t");
for(int
i = 0; i < resultado.length; i++) {
System.out.print(resultado[i]);//se
imprime la el resultado de la suma binaria
}
int resul = valor1 - valor2;
System.out.print("\t\t" +
resul);//se imprime la suma de los valores decimales
System.out.println();
}
public
static int [] decimaltobinari(int valor){
//variables
String
binariores, res="";
int
residuo;
int x =
0;
binariores = Integer.toBinaryString(valor);
int
arreglo [] = new int[15];
while
(valor > 0) {
residuo = valor % 2;//obtener el
residuo
valor = valor / 2;//realizar la
siguiente division
//En el orden natural de la
operacion los valores estan invertidos
//por eso aqui los volvemos a
invertir :)
res = residuo + res;
x++;
}
for(int
i = arreglo.length -1, j=0, k=0; i > -1; i--, j++){
if(i
>= res.length()){
arreglo[j] = 0;//llenamos los
lugares vacios con ceros
}
else{
arreglo[j] =
Integer.parseInt(res.charAt(k)+ "");//cuando llegemos al primer uno
guradamos la conversion a binarios
k++;
}
}
return arreglo;// se regresa el
arreglo
}
public
static int[] restaBinyBin(int a[], int b[]) {
int
acarreo = 0;//variable de control.
int[] c = new int[15];//Arreglo a retornar.
//Se
recorre el arreglo a de manera inversa.
for (int i = c.length -1 ; i > 0; i--) {
int
resta = a[i] - b[i]; //Se realiza la
resta una vez por ciclo
if(resta == -1) {//Si la resta da
-1 los elementos en el arreglo son 0 y 1.
c[i] = 1;//Por lo tanto debe ir
como resultado un 1
acarreo = 1;//Y se lleva un
acarreo
}
//Si por el contrario la resta es 0
quiere decir que los elementos
//eran 1 y 1 || 0 y 0.
else if(resta == 0) {
c[i] = 0;//Entonces debe ir 0
como resultado
}
//Si por el contrario la suma es 1,
entonces los elementos
//eran 1 y 0.
else if(resta == 1) {
c[i] = 1;//Y debe ir como
resultado un 1.
}
if(acarreo == 1) {//Si existe un
acarreo en este ciclo
//Se comprueba si la resta del
elemento siguiente del
//arreglo "a" mas el
acarreo es igual a 0.
if(a[i-1] - 1 == 0) {
a[i-1] = 0;//Si lo es, se
asigna un 0 a "a".
acarreo = 0;//Y el acarreo
desaparece.
}
}
}
return c;//Se regresa el arreglo.
}
}
Código multiplicación
Código división
No hay comentarios:
Publicar un comentario