Publicidad

Resultados 1 al 3 de 3
  1. #1
    [IG] Aprendiz Avatar de relicsoft
    Ingreso
    13 feb, 14
    Ubicación
    Planeta Soft
    Mensajes
    20
    País
    Gracias
    3
    17 gracias en 7 Posts

    Smile Programa para resolver complejos y matrices.

    Buenos días. Hace tiempo que tenía ideas para plasmarlas en código. Ideas más grandes de lo que naturalmente podía realizar así que las empezaba para luego dejarlas, y cuando mis conocimientos llegaran al punto de poder completar esos trabajos quería llevarlos, sin éxito, a otros sistemas operativos. Estar en 5º año de secundaria me vino bastante bien, ya que empecé a ver más ayá de Microsoft, para ver la programación en Linux, y demás cosas. Desde ese momento empecé a programar en C++, y la diferencia es totalmente notoria. Obviamente, cuando digo programar, me refiero a EMPEZAR a programar.
    Llendo al tema, empecé con proyectos bastante sencillos (los que me daba mi profesor de programación que, como yo, programó mucho en vb6, entre sus muchas anécdotas, ¡me contó que uno de sus programas le tomó 500,000 líneas!) hasta que uno de mis profesores pidió que resolvamos 60 ejercicios de Mayas y demás sistemas de resolución de circuitos en corriente alterna que tomaban aproximadamente 30 minutos cada uno. Entonces se me ocurrió hacer un programa que los calcule, ya que como es corriente alterna, son números complejos


    Bueno... para cerrar el tema, les dejo el código por si a alguien le sirve. Está programado sin debuguear, ya que lo escribí en bloc de notas. Verán muchos disparates xd:


    Código:
    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    #include <cmath>
    #include <string>
    #include <windows.h>
    using namespace std;
    
        float BP_Modulo_CD;
        float BP_Angulo_CD;
    
    
    int Inicio()
    {
        printf("---------------------------------------- \n");
        printf("--     Calculador de electronica      -- \n");
        printf("---------------------------------------- \n");
        printf("\n");
        printf("\n");
        printf("\n");
        return 0;
    }
    
    int Menu_Matrices()
    {
    
        system("cls");
        printf("---------------------------------------- \n");
        printf("--              Matrices              -- \n");
        printf("---------------------------------------- \n");
        printf("\n");
        printf("\n");
        printf("\n");
        printf("Ingrese los datos solicitados: \n \n");
    
    }
    
    int Binomico_Polar_CD(float P_Real, float P_Imaginaria)
    {
        double Cuadrado_X;
        double Cuadrado_Y;
        double Cuadrado_XY;
    
    
        double Angulo_Temporal;
    
    
    
    
        Cuadrado_X = P_Real * P_Real;
        Cuadrado_Y = P_Imaginaria * P_Imaginaria;
        Cuadrado_XY = Cuadrado_X + Cuadrado_Y;
        BP_Modulo_CD = sqrt(Cuadrado_XY);
    
        // Arreglar lo del ángulo, para el cuadrante I, II, III, IV.... ARREGLADO
    
        BP_Angulo_CD = atan2(P_Imaginaria,P_Real);
    
    
    
    }
    
    
    int Binomico_O_Polar()
    {
    
        int Seleccionado;
        printf("\n El numero complejo que quiere ingresar esta en:  \n");
        printf("\n 0. Forma Cuadratica/Binomica");
        printf("\n 1. Forma Polar");
        printf("\n \n Seleccione '0' o '1':  \n \n ");
        cin >> Seleccionado;
        if (Seleccionado == 0)
        {
            return Seleccionado;
        }
        else if (Seleccionado == 1)
        {
            return Seleccionado;
        }
        else
        {
            system("cls");
            printf("Incorrecto. Seleccione una opcion valida. \n");
            system("pause");
            Binomico_O_Polar();
        }
    }
    
    
    int Matrices()
    {
    
        int Variable_Binomico_O_Polar_Z11;
        int Variable_Binomico_O_Polar_Z12;
        int Variable_Binomico_O_Polar_Z13;
        int Variable_Binomico_O_Polar_Z21;
        int Variable_Binomico_O_Polar_Z22;
        int Variable_Binomico_O_Polar_Z23;
        int Variable_Binomico_O_Polar_Z31;
        int Variable_Binomico_O_Polar_Z32;
        int Variable_Binomico_O_Polar_Z33;
    
        double Z11_Imaginario,Z12_Imaginario,Z13_Imaginario,Z21_Imaginario,Z22_Imaginario,Z23_Imaginario,Z31_Imaginario,Z32_Imaginario,Z33_Imaginario;
        double Z11_Real,Z12_Real,Z13_Real,Z21_Real,Z22_Real,Z23_Real,Z31_Real,Z32_Real,Z33_Real;
        double Primera_Parte_Ida;
        double Segunda_Parte_Vuelta;
        double Delta_X;
    
        Menu_Matrices();
    
    
        printf("\n Datos para:   Z11 \n");
    
        Variable_Binomico_O_Polar_Z11 = Binomico_O_Polar();
    
        if (Variable_Binomico_O_Polar_Z11==0)
        {
    
            //Si se elige que se va a ingresar un numero en forma Binómica, se procede
            //así.
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z11 Real: \n");
            cin >> Z11_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z11 Imaginario: \n");
            cin >> Z11_Imaginario;
            Menu_Matrices();
        }
        else if (Variable_Binomico_O_Polar_Z11==1)
        {
    
            //Si se elige que se va a ingresar un numero en forma Polar, se procede
            //así.
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z11 Modulo: \n");
            cin >> Z11_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z11 Angulo: \n");
            cin >> Z11_Imaginario;
            Menu_Matrices();
    
        }
    
    // ------------------------------------------------------
    // ------------------------------------------------------
    
        printf("\n Datos para:   Z12 \n");
    
        Variable_Binomico_O_Polar_Z12 = Binomico_O_Polar();
    
        if (Variable_Binomico_O_Polar_Z12==0)
        {
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z12 Real: \n");
            cin >> Z12_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z12 Imaginario: \n");
            cin >> Z12_Imaginario;
            Menu_Matrices();
        }
        else if (Variable_Binomico_O_Polar_Z12==1)
        {
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z12 Modulo: \n");
            cin >> Z12_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z12 Angulo: \n");
            cin >> Z12_Imaginario;
            Menu_Matrices();
    
        }
    
    // ------------------------------------------------------
    // ------------------------------------------------------
        printf("\n Datos para:   Z13 \n");
        Variable_Binomico_O_Polar_Z13 = Binomico_O_Polar();
    
        if (Variable_Binomico_O_Polar_Z13==0)
        {
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z13 Real: \n");
            cin >> Z13_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z13 Imaginario: \n");
            cin >> Z13_Imaginario;
            Menu_Matrices();
        }
        else if (Variable_Binomico_O_Polar_Z13==1)
        {
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z13 Modulo: \n");
            cin >> Z13_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z13 Angulo: \n");
            cin >> Z13_Imaginario;
            Menu_Matrices();
        }
    
    // ------------------------------------------------------
    // ------------------------------------------------------
        printf("\n Datos para:   Z21 \n");
        Variable_Binomico_O_Polar_Z21 = Binomico_O_Polar();
    
        if (Variable_Binomico_O_Polar_Z21==0)
        {
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z21 Real: \n");
            cin >> Z21_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z21 Imaginario: \n");
            cin >> Z21_Imaginario;
            Menu_Matrices();
        }
        else if (Variable_Binomico_O_Polar_Z21==1)
        {
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z21 Modulo: \n");
            cin >> Z21_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z21 Angulo: \n");
            cin >> Z21_Imaginario;
            Menu_Matrices();
        }
    
    // ------------------------------------------------------
    // ------------------------------------------------------
        printf("\n Datos para:   Z22 \n");
        Variable_Binomico_O_Polar_Z22 = Binomico_O_Polar();
    
        if (Variable_Binomico_O_Polar_Z22==0)
        {
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z22 Real: \n");
            cin >> Z22_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z22 Imaginario: \n");
            cin >> Z22_Imaginario;
            Menu_Matrices();
        }
        else if (Variable_Binomico_O_Polar_Z22==1)
        {
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z22 Modulo: \n");
            cin >> Z22_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z22 Angulo: \n");
            cin >> Z22_Imaginario;
            Menu_Matrices();
        }
    
    // ------------------------------------------------------
    // ------------------------------------------------------
        printf("\n Datos para:   Z23 \n");
        Variable_Binomico_O_Polar_Z23 = Binomico_O_Polar();
    
        if (Variable_Binomico_O_Polar_Z23==0)
        {
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z23 Real: \n");
            cin >> Z23_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z23 Imaginario: \n");
            cin >> Z23_Imaginario;
            Menu_Matrices();
        }
        else if (Variable_Binomico_O_Polar_Z23==1)
        {
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z23 Modulo: \n");
            cin >> Z23_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z23 Angulo: \n");
            cin >> Z23_Imaginario;
            Menu_Matrices();
        }
    // ------------------------------------------------------
    // ------------------------------------------------------
        printf("\n Datos para:   Z31 \n");
        Variable_Binomico_O_Polar_Z31 = Binomico_O_Polar();
    
        if (Variable_Binomico_O_Polar_Z31==0)
        {
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z31 Real: \n");
            cin >> Z31_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z31 Imaginario: \n");
            cin >> Z31_Imaginario;
            Menu_Matrices();
        }
        else if (Variable_Binomico_O_Polar_Z31==1)
        {
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z31 Modulo: \n");
            cin >> Z31_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z31 Angulo: \n");
            cin >> Z31_Imaginario;
            Menu_Matrices();
        }
    // ------------------------------------------------------
    // ------------------------------------------------------
        printf("\n Datos para:   Z32 \n");
        Variable_Binomico_O_Polar_Z32 = Binomico_O_Polar();
    
        if (Variable_Binomico_O_Polar_Z32==0)
        {
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z32 Real: \n");
            cin >> Z32_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z32 Imaginario: \n");
            cin >> Z32_Imaginario;
            Menu_Matrices();
        }
        else if (Variable_Binomico_O_Polar_Z32==1)
        {
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z32 Modulo: \n");
            cin >> Z32_Real;
            Menu_Matrices();
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z32 Angulo: \n");
            cin >> Z32_Imaginario;
            Menu_Matrices();
        }
    
    // ------------------------------------------------------
    // ------------------------------------------------------
        printf("\n Datos para:   Z33 \n");
        Variable_Binomico_O_Polar_Z33 = Binomico_O_Polar();
    
        if (Variable_Binomico_O_Polar_Z33==0)
        {
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z33 Real: \n");
            cin >> Z33_Real;
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z33 Imaginario: \n");
            cin >> Z33_Imaginario;
        }
        else if (Variable_Binomico_O_Polar_Z33==1)
        {
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z33 Modulo: \n");
            cin >> Z33_Real;
    
            system("cls");
            Menu_Matrices();
            printf("Ingrese el valor de Z33 Angulo: \n");
            cin >> Z33_Imaginario;
        }
    
    // ------------------------------------------------------
    // ------------------------------------------------------
    
    
        if (Variable_Binomico_O_Polar_Z11==0)
        {
            Binomico_Polar_CD(Z11_Real,Z11_Imaginario);
            Z11_Real=BP_Modulo_CD;
            Z11_Imaginario=BP_Angulo_CD;
        }
    
        if (Variable_Binomico_O_Polar_Z12==0)
        {
            Binomico_Polar_CD(Z12_Real,Z12_Imaginario);
            Z12_Real=BP_Modulo_CD;
            Z12_Imaginario=BP_Angulo_CD;
        }
    
        if (Variable_Binomico_O_Polar_Z13==0)
        {
            Binomico_Polar_CD(Z13_Real,Z13_Imaginario);
            Z13_Real=BP_Modulo_CD;
            Z13_Imaginario=BP_Angulo_CD;
        }
        if (Variable_Binomico_O_Polar_Z21==0)
        {
            Binomico_Polar_CD(Z21_Real,Z21_Imaginario);
            Z21_Real=BP_Modulo_CD;
            Z21_Imaginario=BP_Angulo_CD;
        }
        if (Variable_Binomico_O_Polar_Z22==0)
        {
            Binomico_Polar_CD(Z22_Real,Z22_Imaginario);
            Z22_Real=BP_Modulo_CD;
            Z22_Imaginario=BP_Angulo_CD;
        }
        if (Variable_Binomico_O_Polar_Z23==0)
        {
            Binomico_Polar_CD(Z23_Real,Z23_Imaginario);
            Z23_Real=BP_Modulo_CD;
            Z23_Imaginario=BP_Angulo_CD;
        }
        if (Variable_Binomico_O_Polar_Z12==0)
        {
            Binomico_Polar_CD(Z31_Real,Z31_Imaginario);
            Z31_Real=BP_Modulo_CD;
            Z31_Imaginario=BP_Angulo_CD;
        }
        if (Variable_Binomico_O_Polar_Z32==0)
        {
            Binomico_Polar_CD(Z32_Real,Z32_Imaginario);
            Z32_Real=BP_Modulo_CD;
            Z32_Imaginario=BP_Angulo_CD;
        }
        if (Variable_Binomico_O_Polar_Z33==0)
        {
            Binomico_Polar_CD(Z33_Real,Z33_Imaginario);
            Z33_Real=BP_Modulo_CD;
            Z33_Imaginario=BP_Angulo_CD;
        }
    
        double Primera_Parte_Ida_Angulo_1;
        double Primera_Parte_Ida_Angulo_2;
        double Primera_Parte_Ida_Angulo_3;
        double Primera_Parte_Ida_Angulo_T;
    
        double Segunda_Parte_Vuelta_Angulo_1;
        double Segunda_Parte_Vuelta_Angulo_2;
        double Segunda_Parte_Vuelta_Angulo_3;
        double Segunda_Parte_Vuelta_Angulo_T;
    
        double Ambas_Vueltas_Angulo_T;
    
        double Primera_Parte_Ida_Bin_X;
        double Primera_Parte_Ida_Bin_Y;
    
        double Segunda_Parte_Vuelta_Bin_X;
        double Segunda_Parte_Vuelta_Bin_Y;
    
        double Total_X;
        double Total_Y;
    
        double Primera_Parte_Ida_X;
        double Primera_Parte_Ida_Y;
    
        double Segunda_Parte_Vuelta_X;
        double Segunda_Parte_Vuelta_Y;
        //Saca el angulo de los tres parentesis
    
        Primera_Parte_Ida_Angulo_1 = (Z11_Imaginario + Z22_Imaginario + Z33_Imaginario);
        Primera_Parte_Ida_Angulo_2 = (Z21_Imaginario + Z32_Imaginario + Z13_Imaginario);
        Primera_Parte_Ida_Angulo_3 = (Z31_Imaginario + Z12_Imaginario + Z23_Imaginario);
    
        //Suma los angulos de los tres paréntesis sin antes pasarlos a binomico.
    
    
    
    
    
        //Primera_Parte_Ida_Angulo_T = Primera_Parte_Ida_Angulo_1 + Primera_Parte_Ida_Angulo_2 + Primera_Parte_Ida_Angulo_3;
    
        //Lo mismo, pero para el otro lado (cosa de matrices :D)
    
        Segunda_Parte_Vuelta_Angulo_1 = (Z13_Imaginario + Z22_Imaginario + Z31_Imaginario);
        Segunda_Parte_Vuelta_Angulo_2 = (Z23_Imaginario + Z32_Imaginario + Z11_Imaginario);
        Segunda_Parte_Vuelta_Angulo_3 = (Z33_Imaginario + Z12_Imaginario + Z21_Imaginario);
    
        //Segunda_Parte_Vuelta_Angulo_T = Segunda_Parte_Vuelta_Angulo_1 + Segunda_Parte_Vuelta_Angulo_2 + Segunda_Parte_Vuelta_Angulo_3;
    
        //Suma ambas vueltas
    
        //Ambas_Vueltas_Angulo_T = Primera_Parte_Ida_Angulo_T + Segunda_Parte_Vuelta_Angulo_T;
    
    
        Primera_Parte_Ida_X = ((Z11_Real * Z22_Real * Z33_Real) * cos(Primera_Parte_Ida_Angulo_1)) + ((Z21_Real * Z32_Real * Z13_Real) * cos(Primera_Parte_Ida_Angulo_2)) + ((Z31_Real * Z12_Real * Z23_Real) * cos(Primera_Parte_Ida_Angulo_3));
        Segunda_Parte_Vuelta_X = ((Z13_Real * Z22_Real * Z31_Real) * cos(Segunda_Parte_Vuelta_Angulo_1)) + ((Z23_Real * Z32_Real * Z11_Real) * cos(Segunda_Parte_Vuelta_Angulo_2)) + ((Z33_Real * Z12_Real * Z21_Real) * cos(Segunda_Parte_Vuelta_Angulo_3));
    
        Primera_Parte_Ida_Y = ((Z11_Real * Z22_Real * Z33_Real) * sin(Primera_Parte_Ida_Angulo_1)) + ((Z21_Real * Z32_Real * Z13_Real) * sin(Primera_Parte_Ida_Angulo_2)) + ((Z31_Real * Z12_Real * Z23_Real) * sin(Primera_Parte_Ida_Angulo_3));
        Segunda_Parte_Vuelta_Y = ((Z13_Real * Z22_Real * Z31_Real) * sin(Segunda_Parte_Vuelta_Angulo_1)) + ((Z23_Real * Z32_Real * Z11_Real) * sin(Segunda_Parte_Vuelta_Angulo_2)) + ((Z33_Real * Z12_Real * Z21_Real) * sin(Segunda_Parte_Vuelta_Angulo_3));
    
    
    
    
        Total_X = Primera_Parte_Ida_X - Segunda_Parte_Vuelta_X;
        Total_Y = Primera_Parte_Ida_Y - Segunda_Parte_Vuelta_Y;
    
        system("cls");
        printf("---------------------------------------- \n");
        printf("--              Matrices              -- \n");
        printf("---------------------------------------- \n");
        printf("\n");
        printf("\n");
        printf("\n");
    
    //    cout << "Primera Polar:   " << Primera_Parte_Ida << "/" << Primera_Parte_Ida_Angulo_T << "\n";
    //
    //    if (Primera_Parte_Ida_Bin_Y<0)
    //    {
    //        cout << "Primera [Binomico]:   " << Primera_Parte_Ida_Bin_X << " -j" << Primera_Parte_Ida_Bin_Y << "\n";
    //    }
    //    else if (Primera_Parte_Ida_Bin_Y>=0)
    //    {
    //        cout << "Primera [Binomico]:   " << Primera_Parte_Ida_Bin_X << " +j" << Primera_Parte_Ida_Bin_Y << "\n";
    //    }
    //
    //    cout << "Segunda [Polar]:   " << Segunda_Parte_Vuelta << "/" << Segunda_Parte_Vuelta_Angulo_T << "\n";
    
    
    
    //    if (Segunda_Parte_Vuelta_Bin_Y<0)
    //    {
    //        Segunda_Parte_Vuelta_Bin_Y = Segunda_Parte_Vuelta_Bin_Y * (-1);
    //        cout << "Segunda [Binomico]:   " << Segunda_Parte_Vuelta_Bin_X << " -j" << Segunda_Parte_Vuelta_Bin_Y << "\n";
    //    }
    //    else if (Segunda_Parte_Vuelta_Bin_Y>=0)
    //    {
    //        cout << "Segunda [Binomico]:   " << Segunda_Parte_Vuelta_Bin_X << " +j" << Segunda_Parte_Vuelta_Bin_Y << "\n";
    //    }
    //
    
        Binomico_Polar_CD(Total_X,Total_Y);
    
    
        cout << "Delta X [Polar] es igual a:      " << BP_Modulo_CD << "/" << BP_Angulo_CD << "\n \n";
    
        if (Total_Y<0)
        {
            Total_Y = Total_Y * (-1);
            cout << "Delta X [Binomico] es igual a:   " << Total_X << " -j" << Total_Y;
        }
        else if (Total_Y>=0)
        {
            cout << "Delta X [Binomico] es igual a:   " << Total_X << " +j" << Total_Y;
        }
    
        printf("\n \n");
        system("pause");
    }
    
    int Polar_Binomico_SD()
    {
        double Parte_Real;
        double Parte_Imaginaria;
        double PB_Modulo_SD;
        double PB_Angulo_SD;
    
        system("cls");
        printf("---------------------------------------- \n");
        printf("--       Pasaje Polar-Binomico        -- \n");
        printf("---------------------------------------- \n");
        printf("\n");
        printf("\n");
        printf("\n");
        printf("Ingrese el modulo: \n");
        cin >> PB_Modulo_SD;
        system("cls");
        printf("---------------------------------------- \n");
        printf("--       Pasaje Polar-Binomico        -- \n");
        printf("---------------------------------------- \n");
        printf("\n");
        printf("\n");
        printf("\n");
        printf("Ingrese el angulo: \n");
        cin >> PB_Angulo_SD;
        printf("\n");
        Parte_Real = PB_Modulo_SD * cos(PB_Angulo_SD);
        Parte_Imaginaria = PB_Modulo_SD * sin(PB_Angulo_SD);
    
        if (Parte_Imaginaria >= 0)
        {
            cout << "El resultado es:    " << Parte_Real << " +j" << Parte_Imaginaria;
        }
        else
        {
            cout << "El resultado es:    " << Parte_Real << " -j" << Parte_Imaginaria;
        }
        printf("\n \n");
        system("pause");
        Polar_Binomico_SD();
    }
    int Binomico_Polar_SD()
    {
        double PI_Valor;
        double PB_Real_SD;
        double PB_Imag_SD;
        double Cuadrado_X;
        double Cuadrado_Y;
        double Cuadrado_XY;
        double Modulo_SD;
        double Angulo_SD;
        int Nuevo_Calculo;
        system("cls");
        printf("---------------------------------------- \n");
        printf("--       Pasaje Binomico-Polar        -- \n");
        printf("---------------------------------------- \n");
        printf("\n");
        printf("\n");
        printf("\n");
        printf("Ingrese la parte REAL: \n");
        cin >> PB_Real_SD;
        system ("cls");
        printf("---------------------------------------- \n");
        printf("--       Pasaje Binomico-Polar        -- \n");
        printf("---------------------------------------- \n");
        printf("\n");
        printf("\n");
        printf("\n");
        printf("Ingrese la parte IMAGINARIA: \n");
        cin >> PB_Imag_SD;
        Cuadrado_X = PB_Real_SD * PB_Real_SD;
        Cuadrado_Y = PB_Imag_SD * PB_Imag_SD;
        Cuadrado_XY = Cuadrado_X + Cuadrado_Y;
        Modulo_SD = sqrt(Cuadrado_XY);
        Angulo_SD = atan2(PB_Imag_SD,PB_Real_SD);
    
        cout << "El resultado es:    " << Modulo_SD << "/" << Angulo_SD << "\n \n";
        system("pause");
        system("cls");
        Binomico_Polar_SD();
    }
    
    int Menu()
    {
        double Destino_Picon;
        printf("Menu:");
        printf("\n");
        printf("\n");
        printf("\n");
        printf("    A. Pasaje Polar-Binomico y viceversa. \n");
        printf("        1. De Polar a Binomico. \n");
        printf("        2. De Binomico a Polar. \n");
        printf("    B. Matrices. \n");
        printf("        3. Matices. \n");
        printf("    C. Tension en los nodos. \n");
        printf("\n");
        printf("Ingrese la accion deseada segun las opciones. \n");
        cin >> Destino_Picon;
    
    
        if (Destino_Picon == 1)
        {
            Polar_Binomico_SD();
        }
        else
        {
            if (Destino_Picon == 2)
            {
                 Binomico_Polar_SD();
            }
            else
            {
                if (Destino_Picon == 3)
                {
                    Matrices();
                }
                else
                {
                    system("cls");
                    printf("Opcion invalida. Seleccione una existente.");
                    system("pause");
                    //Reemplazamos estas líneas por una función universal.
                    system("cls");
                    Menu();
                }
            }
        }
    }
    
    int Error_De_Numero()
    {
        system("cls");
        printf("Opcion invalida. Seleccione una existente.");
        system("pause");
    }
    
    int main()
    {
        SetConsoleTitle("Calculador de electronica  -  C++ Relic Soft");
        Inicio();
        Menu();
    
    }


    Saludos, disculpen por la larga introducción xd.
    Valentín Andrada, 15 años, programador en VB6."¿Quieren conocer a un hombre? Revestidle de riquezas."

  2.    Publicidad


  3. The Following User Says Thank You to relicsoft For This Useful Post:


  4. #2
    [IG] [email protected] Avatar de AURIC
    Ingreso
    02 oct, 11
    Mensajes
    88
    País
    Gracias
    6
    8 gracias en 8 Posts

    Re: Programa para resolver complejos y matrices.

    Tenes un par de errores con los operadores pero ta bueno. De todas maneras este tipo de material deberias de aportarlo en alguna Comunidad mas enfocada a la programacion, aca casi nadie sabe programación y este tipo de aportes no les dan bola. En otro foro seguramente al aportar este tipo de cosas te den sugerencias o te enseñen otras cosas. asludos

  5. #3
    [IG] Aprendiz Avatar de relicsoft
    Ingreso
    13 feb, 14
    Ubicación
    Planeta Soft
    Mensajes
    20
    País
    Gracias
    3
    17 gracias en 7 Posts

    Re: Programa para resolver complejos y matrices.

    Sip. De todos modos lo hice para poner algo en la sección xd. Gracias por tu respuesta Auric!

    Saludos desde Argentina.
    Valentín Andrada, 15 años, programador en VB6."¿Quieren conocer a un hombre? Revestidle de riquezas."


 

Marcadores

Permisos de publicación

  • No puedes crear nuevos temas
  • No puedes responder temas
  • No puedes subir archivos adjuntos
  • No puedes editar tus mensajes
  •