Dev - C++ - Evaluar en otra función

#include <iostream>

#include <cstdlib>

#include <math.h>

#include <iomanip>

#define MAXGRAD 11

using namespace std;

//----------------------------------------------------------------------------//

void Capturar_Polinomio(float [], int );

float Evaluar_Polinomio(float [], int, float);

float Evaluar_Seno(float, float, float, float);

float Evaluar_Coseno(float, float, float, float);

float Evaluar_Logaritmo(float, float, float, float);

float Evaluar_Exponencial(float, float, float, float);

int Menu();

//----------------------------------------------------------------------------//

enum{SALIR=0, POLINOMIO, SENO, COSENO, LOGARITMO, EXPONENCIAL, CONTINUAR=1};

//----------------------------------------------------------------------------//

int main()

{

    float P[MAXGRAD], x, a, b, c, ini_interv, fin_interv, cruce_con_eje, cruce_anterior, fan, fbn, fcn;

    int eleccion, grad_pol, seguir=CONTINUAR, nmax, tol;

    double error;

    system("mode con lines=42 cols=142");

    cout << "\n\tPrograma que aproxima la ra" << (char) 161 << "z de una funci" << (char) 162 << "n dada por el m" << (char) 130 << "todo \n\tde regla falsa." << endl;

    do{

        cout << endl;

        eleccion = Menu();

        if(eleccion == SALIR) break;

        //Se elige el tipo de función a utilizar.

        switch(eleccion){

                case POLINOMIO:

                    do{

                        cout << "Indique el grado del polinomio[0,10]: ";

                        cin >> grad_pol;

                        system("cls");

                        if(grad_pol<0 || grad_pol>MAXGRAD-1)

                            cout << "\aERROR: Valor invalido." << endl;

                    }while(grad_pol<0 || grad_pol>MAXGRAD-1);

                    cout << "Capturando polinomio" << endl;

                    Capturar_Polinomio( P, grad_pol );

                    break;

                ///////////////////////////////////////////////////////////////

                case SENO:

                    cout << "Tomando la forma de seno como [ aSen( bX ) + c ] (se utilizan radianes, no grados)" << endl;

                    cout << "\nIndique el valor de a: ";

                    cin >> a;

                    cout << "\nIndique el valor de b: ";

                    cin >> b;

                    cout << "\nIndique el valor de c: ";

                    cin >> c;

                    break;

                ///////////////////////////////////////////////////////////////

                case COSENO:

                    cout << "Tomando la forma de coseno como [ aCos( bX ) + c ] (se utilizan radianes, no grados)" << endl;

                    cout << "\nIndique el valor de a: ";

                    cin >> a;

                    cout << "\nIndique el valor de b: ";

                    cin >> b;

                    cout << "\nIndique el valor de c: ";

                    cin >> c;

                    break;

                ///////////////////////////////////////////////////////////////

                case LOGARITMO:

                    cout << "Tomando al logaritmo en la forma [ aLog( bX ) + c , b>0 ]" << endl;

                    cout << "\nIndique el valor de a: ";

                    cin >> a;

                    do{

                        cout << "\nIndique el valor de b: ";

                        cin >> b;

                        if(b<=0) cout << "\aERROR: Valor invalido." << endl;

                    }while(b<=0);

                    cout << "\nIndique el valor de c: ";

                    cin >> c;

                    break;

                ///////////////////////////////////////////////////////////////

                case EXPONENCIAL:

                    cout << "Tomando a la funci" << (char) 162 << "n exponencial en la forma [ a*e^bX + c ]" << endl;

                    cout << "\nIndique el valor de a: ";

                    cin >> a;

                    cout << "\nIndique el valor de b: ";

                    cin >> b;

                    cout << "\nIndique el valor de c: ";

                    cin >> c;

                    break;

        }

        //Se da y valida el intervalo.

        system("cls");

        do{

        	seguir = CONTINUAR;

            cout << "Indique el intervalo [a,b]" << endl;

            cout << "\n\ta: ";

            cin >> ini_interv;

            do{

                cout << "\n\tb: ";

                cin >> fin_interv;

                if(fin_interv<=ini_interv) cout << "\aERROR: Valor invalido (el fin del intervalo debe ser mayor al inicio)." << endl;

            }while(fin_interv<=ini_interv);

            system("cls");

            switch(eleccion){

                    case POLINOMIO:

                        fan = Evaluar_Polinomio(P, grad_pol, ini_interv);

                        fbn = Evaluar_Polinomio(P, grad_pol, fin_interv);

                        break;

                    case SENO:

                        fan = Evaluar_Seno(a,b,c,ini_interv);

                        fbn = Evaluar_Seno(a,b,c,fin_interv);

                        break;

                    case COSENO:

                        fan = Evaluar_Coseno(a,b,c,ini_interv);

                        fbn = Evaluar_Coseno(a,b,c,fin_interv);

                        break;

                    case LOGARITMO:

                        if(ini_interv*b<=0 || fin_interv*b<=0){

                            fan = 1;

                            fbn = 1;

                            break;

                        }

                        fan = Evaluar_Logaritmo(a,b,c,ini_interv);

                        fbn = Evaluar_Logaritmo(a,b,c,fin_interv);

                        break;

                    case EXPONENCIAL:

                        fan = Evaluar_Exponencial(a,b,c,ini_interv);

                        fbn = Evaluar_Exponencial(a,b,c,fin_interv);

                        break;

            }

            if(fan*fbn>0){

                do{

                    cout << "\a\a ERROR: La funci" << (char) 162 << "n evaluada en los extremos del intervalo no presenta \n cambio de signo, por lo que no se puede utilizar el algoritmo de \n regla falsa. Elija que hacer a continuaci" << (char) 162 << "n:" << endl << endl;

                    cout << "( " << SALIR << " ) Volver a elegir funci" << (char) 162 << "n." << endl;

                    cout << "( " << CONTINUAR << " ) Introducir otro intervalo." << endl;

                    cin >> seguir;

                    system("cls");

                    if(seguir<SALIR || seguir>CONTINUAR) cout << "\aERROR: Valor invalido." << endl;

                }while(seguir<SALIR || seguir>CONTINUAR);

            }

        }while(fan*fbn>0 && seguir!=SALIR);

        system("cls");

        if(seguir == SALIR) continue;

        //Se elige la cantidad máxima de iteraciones.

        do{

            cout << "Indique el numero m" << (char) 160 << "ximo de iteraciones: ";

            cin >> nmax;

            system("cls");

            if(nmax<1) cout << "\aERROR: Valor invalido." << endl;

        }while(nmax<1);

        //Se indica la tolerancia para la aproximación.

        do{

            cout << "Indique las cifras de tolerancia[0,10]: ";

            cin >> tol;

            system("cls");

            if(tol<0 || tol>10) cout << "\aERROR: Valor invalido." << endl;

        }while(tol<0 || tol>10);

        //Se tabula todo.

        cout << setw(5) << "n" << setw(16) << "an" << setw(16) << "bn" << setw(16) << "cn" << setw(20) << "f(an)" << setw(20) << "f(bn)" << setw(20) << "f(cn)" << setw(20) << "error" << endl;

        for(int i=1 ; i<=nmax ; ++i){

            error = 10;

            if(i>=2) cruce_anterior = cruce_con_eje;

            switch(eleccion){

                    case POLINOMIO:

                        fan = Evaluar_Polinomio(P, grad_pol, ini_interv);

                        fbn = Evaluar_Polinomio(P, grad_pol, fin_interv);

                        cruce_con_eje = ini_interv -((fan*(fin_interv-ini_interv))/(fbn-fan));

                        fcn = Evaluar_Polinomio(P, grad_pol, cruce_con_eje);

                        break;

                    case SENO:

                        fan = Evaluar_Seno(a,b,c,ini_interv);

                        fbn = Evaluar_Seno(a,b,c,fin_interv);

                        cruce_con_eje = ini_interv -((fan*(fin_interv-ini_interv))/(fbn-fan));

                        fcn = Evaluar_Seno(a,b,c,cruce_con_eje);

                        break;

                    case COSENO:

                        fan = Evaluar_Coseno(a,b,c,ini_interv);

                        fbn = Evaluar_Coseno(a,b,c,fin_interv);

                        cruce_con_eje = ini_interv -((fan*(fin_interv-ini_interv))/(fbn-fan));

                        fcn = Evaluar_Coseno(a,b,c,cruce_con_eje);

                        break;

                    case LOGARITMO:

                        fan = Evaluar_Logaritmo(a,b,c,ini_interv);

                        fbn = Evaluar_Logaritmo(a,b,c,fin_interv);

                        cruce_con_eje = ini_interv -((fan*(fin_interv-ini_interv))/(fbn-fan));

                        fcn = Evaluar_Logaritmo(a,b,c,cruce_con_eje);

                        break;

                    case EXPONENCIAL:

                        fan = Evaluar_Exponencial(a,b,c,ini_interv);

                        fbn = Evaluar_Exponencial(a,b,c,fin_interv);

                        cruce_con_eje = ini_interv -((fan*(fin_interv-ini_interv))/(fbn-fan));

                        fcn = Evaluar_Exponencial(a,b,c,cruce_con_eje);

                        break;

            }

            if(i>=2 && fcn!=0) error = (cruce_con_eje-cruce_anterior)/cruce_con_eje;

            cout << setw(5) << i;

            cout << setw(16) << ini_interv;

            cout << setw(16) << fin_interv;

            cout << setw(16) << cruce_con_eje;

            cout << setw(20) << fan;

            cout << setw(20) << fbn;

            cout << setw(20) << fcn;

            if(i==1) cout << setw(20) << "---" << endl;

            else if(fcn==0) cout << setw(20) << "0" << endl;

            else cout << setw(20) << error << endl;

            if(fcn==0 || error <= pow(10,-tol)){

                cout << "\nValor encontrado con la tolerancia dada antes de las iteraciones m" << (char) 160 << "ximas." << endl;

                break;

            }

            if(fan*fcn<0) fin_interv = cruce_con_eje;

            else ini_interv = cruce_con_eje;

            if(i==nmax) cout << "\nValor no encontrado con la tolerancia dada antes de las iteraciones especificadas." << endl;

        }

        cout << "\nValor aproximado:  " << cruce_con_eje << endl << endl;

    system("pause");

    system("cls");

    }while(true);

    return 0;

}

//----------------------------------------------------------------------------//

int Menu()

{

    int opc;

     do{

           cout << "Seleccione el tipo de funci" << (char) 162 << "n:" << endl;

           cout << "(" << POLINOMIO << ") Polinomial." << endl;

           cout << "(" << SENO << ") Senoidal." << endl;

           cout << "(" << COSENO << ") Coseno." << endl;

           cout << "(" << LOGARITMO << ") Logaritmica." << endl;

           cout << "(" << EXPONENCIAL << ") Exponencial." << endl;

           cout << "(" << SALIR << ") Salir." << endl;

           cin >> opc;

           system("cls");

           if( opc<SALIR || opc>EXPONENCIAL )

               cout << "\aERROR: Acci" << (char) 162 << "n no definida." << endl;

     }while( opc<SALIR || opc>EXPONENCIAL);

     system("cls");

     return opc;

}

//----------------------------------------------------------------------------//

void Capturar_Polinomio(float Poli[], int TamPoli)

{

	Poli[TamPoli]=1;

    for ( int i = 0; i <= TamPoli; ++i){

        do{

           cout << "X^" << i << ": ";

           cin >> Poli[i];

        }while( Poli[TamPoli]==0 && TamPoli!=0);

    }

}

//----------------------------------------------------------------------------//

float Evaluar_Polinomio(float Poli[], int TamPoli, float x)

{

    float valor_evaluado = 0;

    for ( int i = 0; i <= TamPoli; ++i){

           valor_evaluado += Poli[i]*pow(x,i);

    }

    return valor_evaluado;

}

//----------------------------------------------------------------------------//

float Evaluar_Seno(float a, float b, float c, float x)

{

    float seno;

    seno = sin(x*b);

    return (a*seno)+c;

}

//----------------------------------------------------------------------------//

float Evaluar_Coseno(float a, float b, float c, float x)

{

    float coseno;

    coseno = cos(x*b);

    return (a*coseno)+c;

}

//----------------------------------------------------------------------------//

float Evaluar_Logaritmo(float a, float b, float c, float x)

{

    float logaritmo;

    logaritmo = log(x*b);

    return (a*logaritmo)+c;

}

//----------------------------------------------------------------------------//

float Evaluar_Exponencial(float a, float b, float c, float x)

{

    float exponencial;

    exponencial = exp(x*b);

    return (a*exponencial)+c;

}