sábado, 10 de marzo de 2012

Multiplicación de valores de distintas bases

using System;

namespace ProgramArquitectura
{
    class Program
    {
        public static void Main(string[] args)
        {
            bool temp = true;
            string opcion;
           
            while(temp == true){
            Console.Clear();
            Console.SetCursorPosition(30,0);
            Console.WriteLine("SISTEMAS NUMERICOS ");
            Console.SetCursorPosition(30,1);
            Console.WriteLine("==================");
            Console.SetCursorPosition(20,2);
            Console.WriteLine("SISTEMA DE GESTION DE MULTIPLICACIONES ");
            Console.SetCursorPosition(20,3);
            Console.WriteLine("DE VALORES NUMERICOS EN DISTINTAS BASES ");
            Console.SetCursorPosition(20,4);
            Console.WriteLine("=======================================");
            Console.WriteLine();   
           
            Console.WriteLine("MENU DE OPCIONES ");
            Console.WriteLine("----------------");
            Console.WriteLine("[A].MULTIPLICACION EN BASES DISTINTAS ");
            Console.WriteLine("[S].ABANDONAR PROGRAMA ");
            opcion = Console.ReadLine();
           
            switch(opcion){
                case "A":{
                MultiplicacionBasesDistintas();
                Console.ReadKey(true);
                break;
                }
                case "S":{
                temp = false;
                break;
                }
                default:{
                Console.WriteLine("Opcion no existe !!");
                Console.ReadKey(true);
                break;
                }
            }
            }
            Console.ReadKey(true);
        }
       
        public static void MultiplicacionBasesDistintas ()
        {
            Console.Clear();
           
            int valor = 0, baseE1 = 0, baseE2 = 0, valor2 = 0;
           
            Console.SetCursorPosition(30,0);
            Console.WriteLine("SISTEMAS NUMERICOS ");
            Console.SetCursorPosition(30,1);
            Console.WriteLine("==================");
            Console.SetCursorPosition(20,2);
            Console.WriteLine("SISTEMA DE GESTION DE MULTIPLICACIONES ");
            Console.SetCursorPosition(20,3);
            Console.WriteLine("DE VALORES NUMERICOS EN DISTINTAS BASES ");
            Console.SetCursorPosition(20,4);
            Console.WriteLine("=======================================");
            Console.WriteLine();
            Console.SetCursorPosition(23,6);
            Console.WriteLine("MULTIPLICACION EN BASES DISTINTAS ");
            Console.SetCursorPosition(23,7);
            Console.WriteLine("=================================");
           
            int u = 11;//Validacion base 1
            bool tmp = true;
            while(tmp == true){
            Console.SetCursorPosition(0,u);
            Console.Write("INGRESE LA BASE DEL PRIMER VALOR ");
            baseE1 = int.Parse(Console.ReadLine());
            if(baseE1>=10||baseE1<=1){
            tmp = true;
            u++;
            }
            else
            tmp = false;
            }//Validacion base 1
           
            Console.Clear();
           
            Console.SetCursorPosition(30,0);
            Console.WriteLine("SISTEMAS NUMERICOS ");
            Console.SetCursorPosition(30,1);
            Console.WriteLine("==================");
            Console.SetCursorPosition(20,2);
            Console.WriteLine("SISTEMA DE GESTION DE MULTIPLICACIONES ");
            Console.SetCursorPosition(20,3);
            Console.WriteLine("DE VALORES NUMERICOS EN DISTINTAS BASES ");
            Console.SetCursorPosition(20,4);
            Console.WriteLine("=======================================");
            Console.WriteLine();
            Console.SetCursorPosition(23,6);
            Console.WriteLine("MULTIPLICACION EN BASES DISTINTAS ");
            Console.SetCursorPosition(23,7);
            Console.WriteLine("=================================");
           
            Console.SetCursorPosition(0,11);
            Console.WriteLine("INGRESE EL PRIMER VALOR . . ");
            valor = int.Parse(Console.ReadLine());
            int valoraux1 = valor;
            int valoraux1val = valor;
           
           
            //primer valor
            bool var = false;
            while (var == false){//Todo el proceso de validacion***
            while(valoraux1val!=0){
            int num = valoraux1val%10;
            valoraux1val = valoraux1val/10;
            if (num >= baseE1){
            Console.WriteLine("Error de ingreso !! ");
            Console.WriteLine("INGRESE NUEVAMENTE POR FAVOR ");
            valor = int.Parse (Console.ReadLine());
            valoraux1 = valor;
            valoraux1val = valor;
            var = false;
            }else
            var = true;
            }
            }
           
            Console.Clear();
           
            Console.SetCursorPosition(30,0);
            Console.WriteLine("SISTEMAS NUMERICOS ");
            Console.SetCursorPosition(30,1);
            Console.WriteLine("==================");
            Console.SetCursorPosition(20,2);
            Console.WriteLine("SISTEMA DE GESTION DE MULTIPLICACIONES ");
            Console.SetCursorPosition(20,3);
            Console.WriteLine("DE VALORES NUMERICOS EN DISTINTAS BASES ");
            Console.SetCursorPosition(20,4);
            Console.WriteLine("=======================================");
            Console.WriteLine();
            Console.SetCursorPosition(23,6);
            Console.WriteLine("MULTIPLICACION EN BASES DISTINTAS ");
            Console.SetCursorPosition(23,7);
            Console.WriteLine("=================================");
           
           
            u = 11;//Validacion base 2
            tmp = true;
            while(tmp == true){
            Console.SetCursorPosition(0,u);
            Console.Write("INGRESE LA BASE DEL SEGUNDO VALOR  ");
            baseE2 = int.Parse(Console.ReadLine());
            Console.WriteLine();
            if(baseE2>=10||baseE1<=1){
            tmp = true;
            u++;
            }
            else
            tmp = false;
            }//Validacion base 2
           
           
           
            Console.Clear();
           
            Console.SetCursorPosition(30,0);
            Console.WriteLine("SISTEMAS NUMERICOS ");
            Console.SetCursorPosition(30,1);
            Console.WriteLine("==================");
            Console.SetCursorPosition(20,2);
            Console.WriteLine("SISTEMA DE GESTION DE MULTIPLICACIONES ");
            Console.SetCursorPosition(20,3);
            Console.WriteLine("DE VALORES NUMERICOS EN DISTINTAS BASES ");
            Console.SetCursorPosition(20,4);
            Console.WriteLine("=======================================");
            Console.WriteLine();
            Console.SetCursorPosition(23,6);
            Console.WriteLine("MULTIPLICACION EN BASES DISTINTAS ");
            Console.SetCursorPosition(23,7);
            Console.WriteLine("=================================");
           
           
            Console.SetCursorPosition(0,11);
            Console.WriteLine("INGRESE EL SEGUNDO VALOR . . ");
            valor2 = int.Parse(Console.ReadLine());
            int valoraux2 = valor2;
            int valoraux2val = valor2;
           
            //segundo valor
            var = false;
            while (var == false){//Todo el proceso de validacion***
            while(valoraux2val!=0){
            int num2 = valoraux2val%10;
            valoraux2val = valoraux2val/10;
            if (num2 >= baseE2){
            Console.WriteLine("Error de ingreso !! ");
            Console.WriteLine("INGRESE NUEVAMENTE POR FAVOR ");
            valor2 = int.Parse (Console.ReadLine());
            valoraux2 = valor2;
            valoraux2val = valor2;
            var = false;
            }else
            var = true;
            }
            }
            Console.WriteLine();//Solo algo de estetica
            Console.WriteLine("*** Se ha ingresado correctamente *** ");
            Console.WriteLine("Continuar . . ");
            Console.ReadLine();//
           
            int j=0;
            while(valoraux1!=0){
            int numaux = valoraux1%10;   
            valoraux1 = valoraux1/10;   
            j++;//Indicando la dimension del vector
            }
           
            int [] vector = new int[j];
           
            int i = j - 1;// Sacando cada uno de los valores
            while(valor!=0){
            int num = valor%10;   
            valor = valor/10;   
            vector[i] = num;
            i--;//Ingresando los valores dentro del vector
            }
           
            Console.Clear();
           
            int r = 0;
            Console.WriteLine();
            Console.WriteLine("Primer Valor Ingresado en base ({0})",baseE1);
            for(int m = 0; m<j; m++){
            Console.SetCursorPosition(r,4);
            Console.WriteLine(vector[m]);
            r+=3;//Mostrando el valor que ingreso el usuario
            }
           
            r = 0;//lineas
            for(int e = 0; e<25; e++){
            Console.SetCursorPosition(r,6);
            Console.WriteLine("==");
            r+=2;
            }//lineas
           
            Console.WriteLine();
            Console.WriteLine("Proceso de conversion a b10 . . . ");
           
            int mostrarbase = j-1;//MP
            r = 0;
            for(int m = 0; m<j; m++){
            Console.SetCursorPosition(r,11);
            Console.WriteLine("[{0}]x{1}^{2}" ,vector[m],baseE1,mostrarbase);
            r+=12;
            mostrarbase--;//Simplemente mostrar el proceso
            }
           
            double [] product1 = new double[j];
            double con1 = 0;
           
            int t = 0, n = j - 1;//PC
            while(t<j){
            product1[t] = vector[t]*(Math.Pow(baseE1,n));
            con1 += product1[t];
            t++;
            n--;//Proceso de conversion
            }
            r = 0;//lineas
            for(int e = 0; e<25; e++){
            Console.SetCursorPosition(r,15);
            Console.WriteLine("==");
            r+=2;
            }//lineas
           
            Console.WriteLine();
            r = 0;
            for(int m = 0; m<j; m++){
            Console.SetCursorPosition(r,13);
            Console.WriteLine(product1[m]);
            r+=13;//Visualizando el producto
            }
            r = 8;// SIgnos +
           
            for(int m = 0; m<j-1; m++){
            Console.SetCursorPosition(r,13);
            Console.WriteLine("+");
            r+=14;//Mostrando el proceso de las sumas
            }
            Console.SetCursorPosition(0,17);
            Console.WriteLine("Valor en base 10 ==> [{0}]",con1);
            Console.SetCursorPosition(0,20);
            Console.WriteLine("Presionar ENTER para ver el segundo valor . .");
            Console.ReadLine();
           
            Proceso2(con1,valor2,valoraux2,baseE2);
           
        }   
               
        public static void Proceso2 (double con1, int valor2, int valoraux2, int baseE2)
        {
            Console.Clear();
           
            int t=0;
            while(valoraux2!=0){
            int numaux = valoraux2%10;   
            valoraux2 = valoraux2/10;   
            t++;//Indicando la dimension del vector numero 2
            }
            int [] vector = new int[t];
           
            int i = t - 1;// Sacando cada uno de los valores
            while(valor2!=0){
            int num = valor2%10;   
            valor2 = valor2/10;   
            vector[i] = num;
            i--;//Ingresando los valores dentro del vector 2
            }
            Console.Clear();
            int r = 0;
            Console.WriteLine();
            Console.WriteLine("Segundo Valor Ingresado en base ({0})",baseE2);
            for(int m = 0; m<t; m++){
            Console.SetCursorPosition(r,4);
            Console.WriteLine(vector[m]);
            r+=3;//Mostrando el valor que ingreso el usuario
            }
            r = 0;//lineas
            for(int e = 0; e<25; e++){
            Console.SetCursorPosition(r,6);
            Console.WriteLine("==");
            r+=2;
            }//lineas
           
            Console.WriteLine();
            Console.WriteLine("Proceso de conversion a b10 . . . ");
           
            int mostrarbase = t-1;//MP
            r = 0;
            for(int m = 0; m<t; m++){
            Console.SetCursorPosition(r,11);
            Console.WriteLine("[{0}]x{1}^{2}" ,vector[m],baseE2,mostrarbase);
            r+=12;
            mostrarbase--;//Simplemente mostrar el proceso
            }
            double [] product2 = new double[t];
            double con2 = 0;
            int p = 0, n = t - 1;//PC//
            while(p<t){
            product2[p] = vector[p]*(Math.Pow(baseE2,n));
            con2 += product2[p];
            p++;
            n--;//Proceso de conversion
            }
            r = 0;//lineas
            for(int e = 0; e<25; e++){
            Console.SetCursorPosition(r,15);
            Console.WriteLine("==");
            r+=2;
            }//lineas
            Console.WriteLine();
           
            r = 0;
            for(int m = 0; m<t; m++){
            Console.SetCursorPosition(r,13);
            Console.WriteLine(product2[m]);
            r+=13;//Visualizando el producto
            }
            r = 8;// SIgnos +
           
            for(int m = 0; m<t-1; m++){
            Console.SetCursorPosition(r,13);
            Console.WriteLine("+");
            r+=14;//Mostrando el proceso de las sumas
            }
            Console.SetCursorPosition(0,17);
            Console.WriteLine("Valor en base 10 ==> [{0}]",con2);
            Console.SetCursorPosition(0,20);
            Console.WriteLine("Presionar ENTER para Realizar la multiplicacion . .");
            Console.ReadLine();
            MultiplicacionBase(con1, con2);
           
           
            }
       
        public static void MultiplicacionBase (double con1, double con2)
        {
            Console.Clear();
           
            Console.SetCursorPosition(33,1);
            Console.WriteLine("MULTIPLICACION ");
            Console.SetCursorPosition(33,2);
            Console.WriteLine("==============");
           
            double multip = con1*con2;
            int mul = (int)multip;
           
            Console.SetCursorPosition(0,4);
            Console.WriteLine("[{0}] x [{1}] ==> [{2}]",con1,con2,multip);
            Console.WriteLine();
            int opcion = 0;
           
            Console.WriteLine("Selecciona una opcion de salida . . ");
            Console.WriteLine();
            Console.WriteLine("[2]. Salida en b2");
            Console.WriteLine("[3]. Salida en b3");
            Console.WriteLine("[4]. Salida en b4");
            Console.WriteLine("[5]. Salida en b5");
            Console.WriteLine("[6]. Salida en b6");
            Console.WriteLine("[7]. Salida en b7");
            Console.WriteLine("[8]. Salida en b8");
            Console.WriteLine("[9]. Salida en b9");
            Console.WriteLine("[0]. Salida en b10");
            opcion = int.Parse(Console.ReadLine());
           
            if(opcion == 2){//Primera condicion/binario
            Console.Clear();
            Console.SetCursorPosition(29,0);
            Console.WriteLine("CONVERSION A BASE 2");
            Console.SetCursorPosition(29,1);
            Console.WriteLine("===================");
            Console.WriteLine("VALOR EN BASE 10 ==> {0}",mul);
            Console.WriteLine("=========================");
            Console.WriteLine();
            int aux1 = mul, i = 0;
            while(aux1!=0){
            int numaux1 = aux1%2;
            aux1 = aux1/2;
            i++;           
            }
            int [] vector = new int[i];
            int p = i-1;
            while(mul!=0){
            int num1 = mul%2;
            mul = mul/2;
            vector[p] = num1;
            p--;           
            }
            Console.WriteLine("RESPUESTA DE LA MULTIPLICACION EN BASE 2");
            Console.WriteLine();
            for(int r = 0; r<i; r++)
            Console.Write(vector[r]);
            Console.ReadLine();
            }//Fin primera condicion
            //====================================================================
           
            else if (opcion == 3){//segunda condicion base 3
            Console.Clear();
            Console.SetCursorPosition(29,0);
            Console.WriteLine("CONVERSION A BASE 3");
            Console.SetCursorPosition(29,1);
            Console.WriteLine("===================");
            Console.WriteLine("VALOR EN BASE 10 ==> {0}",mul);
            Console.WriteLine("=========================");
            Console.WriteLine();
            int aux2 = mul, i = 0;
            while(aux2!=0){
            int numaux2 = aux2%3;
            aux2 = aux2/3;
            i++;           
            }
            int [] vector = new int[i];
            int p = i-1;
            while(mul!=0){
            int num2 = mul%3;
            mul = mul/3;
            vector[p] = num2;
            p--;           
            }
            Console.WriteLine("RESPUESTA DE LA MULTIPLICACION EN BASE 3 ");
            Console.WriteLine();
            for(int r = 0; r<i; r++)
            Console.Write(vector[r]);
            Console.ReadLine();       
            }//fin de la segunda condicion
            //====================================================================
           
            else if (opcion == 4){//Tercera condicion base 4
            Console.Clear();
            Console.SetCursorPosition(29,0);
            Console.WriteLine("CONVERSION A BASE 4");
            Console.SetCursorPosition(29,1);
            Console.WriteLine("===================");
            Console.WriteLine("VALOR EN BASE 10 ==> {0}",mul);
            Console.WriteLine("=========================");
            Console.WriteLine();
            int aux3 = mul, i = 0;
            while(aux3!=0){
            int numaux3 = aux3%4;
            aux3 = aux3/4;
            i++;           
            }
            int [] vector = new int[i];
            int p = i-1;
            while(mul!=0){
            int num3 = mul%4;
            mul = mul/4;
            vector[p] = num3;
            p--;           
            }
            Console.WriteLine("RESPUESTA DE LA MULTIPLICACION EN BASE 4");
            Console.WriteLine();
            for(int r = 0; r<i; r++)
            Console.Write(vector[r]);
            Console.ReadLine();       
            }//Fin de la tercera condicion
            //====================================================================
           
            else if (opcion == 5){//CUARTA condicion base 5
            Console.Clear();
            Console.SetCursorPosition(29,0);
            Console.WriteLine("CONVERSION A BASE 5");
            Console.SetCursorPosition(29,1);
            Console.WriteLine("===================");
            Console.WriteLine("VALOR EN BASE 10 ==> {0}",mul);
            Console.WriteLine("=========================");
            Console.WriteLine();
            int aux4 = mul, i = 0;
            while(aux4!=0){
            int numaux4 = aux4%5;
            aux4 = aux4/5;
            i++;           
            }
            int [] vector = new int[i];
            int p = i-1;
            while(mul!=0){
            int num4 = mul%5;
            mul = mul/5;
            vector[p] = num4;
            p--;           
            }
            Console.WriteLine("RESPUESTA DE LA MULTIPLICACION EN BASE 5");
            Console.WriteLine();
            for(int r = 0; r<i; r++)
            Console.Write(vector[r]);
            Console.ReadLine();       
            }//Fin de cuarta condicion
            //====================================================================
           
            else if (opcion == 6){//quinta condicion base 6
            Console.Clear();
            Console.SetCursorPosition(29,0);
            Console.WriteLine("CONVERSION A BASE 6");
            Console.SetCursorPosition(29,1);
            Console.WriteLine("===================");
            Console.WriteLine("VALOR EN BASE 10 ==> {0}",mul);
            Console.WriteLine("=========================");
            Console.WriteLine();
            int aux5 = mul, i = 0;
            while(aux5!=0){
            int numaux5 = aux5%6;
            aux5 = aux5/6;
            i++;           
            }
            int [] vector = new int[i];
            int p = i-1;
            while(mul!=0){
            int num5 = mul%6;
            mul = mul/6;
            vector[p] = num5;
            p--;           
            }
            Console.WriteLine("RESPUESTA DE LA MULTIPLICACION EN BASE 6");
            Console.WriteLine();
            for(int r = 0; r<i; r++)
            Console.Write(vector[r]);
            Console.ReadLine();       
            }//Fin de la quinta condicion
            //====================================================================
           
            else if (opcion == 7){//sexta condicion base 7
            Console.Clear();
            Console.SetCursorPosition(29,0);
            Console.WriteLine("CONVERSION A BASE 7");
            Console.SetCursorPosition(29,1);
            Console.WriteLine("===================");
            Console.WriteLine("VALOR EN BASE 10 ==> {0}",mul);
            Console.WriteLine("=========================");
            Console.WriteLine();
            int aux6 = mul, i = 0;
            while(aux6!=0){
            int numaux6 = aux6%7;
            aux6 = aux6/7;
            i++;           
            }
            int [] vector = new int[i];
            int p = i-1;
            while(mul!=0){
            int num6 = mul%7;
            mul = mul/7;
            vector[p] = num6;
            p--;           
            }
            Console.WriteLine("RESPUESTA DE LA MULTIPLICACION EN BASE 7");
            Console.WriteLine();
            for(int r = 0; r<i; r++)
            Console.Write(vector[r]);
            Console.ReadLine();       
            }//Fin de la sexta condicion
            //====================================================================
           
            else if (opcion == 8){//septima condicion base 8
            Console.Clear();
            Console.SetCursorPosition(29,0);
            Console.WriteLine("CONVERSION A BASE 8");
            Console.SetCursorPosition(29,1);
            Console.WriteLine("===================");
            Console.WriteLine("VALOR EN BASE 10 ==> {0}",mul);
            Console.WriteLine("=========================");
            Console.WriteLine();
            int aux7 = mul, i = 0;
            while(aux7!=0){
            int numaux7 = aux7%8;
            aux7 = aux7/8;
            i++;           
            }
            int [] vector = new int[i];
            int p = i-1;
            while(mul!=0){
            int num7 = mul%8;
            mul = mul/8;
            vector[p] = num7;
            p--;           
            }
            Console.WriteLine("RESPUESTA DE LA MULTIPLICACION EN BASE 8");
            Console.WriteLine();
            for(int r = 0; r<i; r++)
            Console.Write(vector[r]);
            Console.ReadLine();       
            }//Fin de la sptima condicion
            //====================================================================
           
            else if (opcion == 9){//octaba condicion base 9
            Console.Clear();
            Console.SetCursorPosition(29,0);
            Console.WriteLine("CONVERSION A BASE 9");
            Console.SetCursorPosition(29,1);
            Console.WriteLine("===================");
            Console.WriteLine("VALOR EN BASE 10 ==> {0}",mul);
            Console.WriteLine("=========================");
            Console.WriteLine();
            int aux8 = mul, i = 0;
            while(aux8!=0){
            int numaux8 = aux8%9;
            aux8 = aux8/9;
            i++;           
            }
            int [] vector = new int[i];
            int p = i-1;
            while(mul!=0){
            int num8 = mul%9;
            mul = mul/9;
            vector[p] = num8;
            p--;           
            }
            Console.WriteLine("RESPUESTA DE LA MULTIPLICACION EN BASE 9");
            Console.WriteLine();
            for(int r = 0; r<i; r++)
            Console.Write(vector[r]);
            Console.ReadLine();       
            }//Fin de la octaba condicion
            //====================================================================
           
            else{
            Console.Clear();
            Console.WriteLine("VALOR EN BASE 10 ==> {0}",mul);
            Console.WriteLine("=========================");
            Console.WriteLine();
            }   
        }
    }
}