#include <stdlib.h>     // GAUTHEY MATHIS P1704971
#include <stdio.h>
#include <math.h>

double const PI=3.14159265359;

double toSolve(double x) //Fonction qui pour un reel x renvoie la valeur de f(x) selon la regle 1.9
{
    double res = -x*x + pow(x+PI,1.0/2.0);
    return res;
}

double toSolveDerivee(double x) //Fonction qui pour un reel x renvoie la valeur de f'(x) selon la regle 1.9
{
    double res = -2.0*x + (1.0/2.0) * pow(x+PI,-1.0/2.0);
    return res;
}

int securite(double x0) /*Fonction qui verifie si l'avion est dans une phase d'atterrissage.
                        Courbe de vol: Parabole avec un maxima. Si on choisis un xo avant ce maxima (donc une derivee positive),
                        la methode de Newton converge vers une valeur negative. Si on choisit le x0 au maxima, la méthode diverge car f'(x)=0. */
{
    if(toSolveDerivee(x0)>=0.0 || x0<-3)  /*Pour traiter uniquemnt probleme au maxima de la pente nulle (atteint en 0.1380469902324), on aurait mit une condition fabs(x0-maxima)<epsilon
                                        avec un epsilon choisi habilement permettant d'etre sur d'éviter ce cas limite. De plus f n'est pas défini en x < -PI */
    {
        return 0;
    }
    else
    {
        return 1;   /*Le return 0 et 1 permettent d'etablir une condition pour la fonction resolution qui executera l'algorithme (si 1)
                    ou redemandera un x0 (si 0) en cas de comportement singulier.*/
    }

}

double resolution(double x0,double eps,int *iteration,double *erreur,double *ecart)  /*Fonction qui trouve la racine de f(x) par la methode de Newton. x0 le point de depart de l'algorithme,
                                                                        eps l'erreur maximale associee a la racine, iteration un pointeur pour "recuperer" le nombres
                                                                        d'iterations requises pour realiser l'algorithme, erreur un pointeur pour obtenir l'erreur finale de la mesure,
                                                                        et ecart un pointeur donnant la difference entre notre x0 et la solution.
                                                                        Passer par un pointeur permet de ne pas utiliser d'affichage dans la fonction.*/
{
    while(securite(x0)==0) //Si securite renvoie 0, le x0 n'est pas défini ou est inferieur au maxima. On demande donc une valeur superieure.
    {
        printf("Erreur: L'avion n'est pas dans une phase d'atterrissage mais est actuellement en phase de decollage. Veuillez choisir une valeur de x0 superieure. \n");
        scanf("%lf",&x0);
    }
    if (securite(x0))   //Si la fonction securite retourne 1, on execute l'algorithme.
    {
        double xn_1,xn=x0;   //xn_1 correspond a xn+1.
        *iteration=0;   //On initialise notre compteur a 0.
        do
        {
            xn_1 = xn - toSolve(xn) / toSolveDerivee(xn);   //Algorithme de la methode de Newton
            *erreur = fabs((xn_1-xn)/xn_1);                 //Calcul de l'erreur a cette iteration de la methode
            xn = xn_1;                                      //Preparation de xn pour la prochaine boucle.
            *iteration += 1;                                //Incrementation du compteur d'iterations.
        }while(*erreur>eps);                                //Condition de la boucle: Si l'erreur est plus grande que l'erreur max voulu, on recommence.
        *ecart=fabs(x0-xn_1);                               //L'ecart est calcule dans resolution car en cas de probleme on change le x0 dans resolution, et c'est
        return xn_1;                                        //l'ecart avec ce dernier x0 qui nous interesse, pas le premier choisi dans le main.
    }
}

int main (int argc, char*argv[])
{
    double x0,erreurmax=pow(10,-10),solution,erreur,ecart;
    int iteration;
    printf("Objectif du programme: Trouver la position x de l'avion lorsqu'il touchera le sol a partir de la phase d'atterrissage donnee par y = -x^2 + (x+pi)^(1/2).\n");
    printf("Veuillez choisir un x0, point projete au sol de la position de l'avion dans sa phase d'atterrissage: \n");
    scanf("%lf",&x0);
    //printf("Veuillez selectionner une erreur maximum sur la valeur de x0 attendue: \n");      //A activer pour choisir l'erreur.
    //scanf("%lf",&erreurmax);
    solution=resolution(x0,erreurmax,&iteration,&erreur,&ecart);
    printf("La solution par la methode de Newton est %.16lf \nLa methode a necessite %d iteration(s) pour atteindre la precision voulue de %.16lf\n",solution,iteration,erreurmax);
    printf("L'erreur finale de la mesure est de %.16lf \nL'ecart entre le x0 utilise et la solution est de %lf",erreur,ecart);
    //Le %.16 permet d'afficher autant de chiffres apres la virgule que la precision machine ne le permet.
    return 0;
}