/******************************************************************************
 *                                                                            *
 *   WANG Haichen                                                             *
 *   Deuxieme candidatue en informatique                                      *
 *   Introduction a l'analyse numerique                                       *
 *   Projet de l'examen                                                       *
 *   Modele simplifie proie-predateur                                         *
 *                                                                            *
 *****************************************************************************/

//BIBLIOTHEQUES:

#include<rung.h>
#include<stdio.h>
#include<stdlib.h>
#include<gnuplot.h>

//VARIABLES GLOBALES:

double A,B,C,D,EP,CMP;

double* Fonc (double temp,double *v)
{
    double *vf;
    vf=(double*)malloc(2*sizeof(double));
    vf[0]=A*v[0]-B*v[1]*v[0]-EP*v[0];
    vf[1]=-C*v[1]+D*v[0]*v[1]-EP*v[1]-CMP*v[1]*v[1];
    return vf;
}

/******************************************************************************
*                                                                             *
*Routine de Tracage                                                           *
*                                                                             *
*IN:le nombre d'iteration nbr_iteration  int nbr                              *
*   le tableau contenant les iterations donnees par la routine Runge-kutta    *
*                                                       double **val          *
*OUT:fontion void                                                             *
*                                                                             *
*Remarque:                                                                    *
*         val est le tableau contenant les iterations donnees par la          *
*         routine Runge-kutta donc c'est un tableau a 2 dimensions dont une   *
*         ligne presente les nombres de petits poissons et gros poissons a une*
*         tranche de temps,chaque colone presente une espece.Pour pouvoir pre-*
*         senter separement les mouvements des 2 especes on a introduit 2     *
*         variables locales qui sont x,y dont x est la copie de la colone de  *
*         petits poissons et y est la copie de la colone de gros poissons.    *
*                                                                             *
******************************************************************************/

void trace (int nbr,double** val)
{
    int i=nbr;
    double *x,*y;
    gnuplot_t d=NULL;
    x=(double*)malloc(nbr*sizeof(double));
    y=(double*)malloc(nbr*sizeof(double));

    while (nbr>0)
    {
        x[nbr-1]=val[nbr-1][0];
        y[nbr-1]=val[nbr-1][1];
        nbr--;
    }
    d=gnuplot_init(GNUPLOT_X);
    gnuplot_title
     (d,"NOMBRE DE PETITES POISSONS ET DE GROS POISSONS.");
    gnuplot_xlabel(d,"Nombre de petits poissons (en milliers)");
    gnuplot_ylabel(d,"Nombre de gros poissons (en milliers)");
    gnuplot_xy(d,x,y,i,"lines 3","Orbite de v(t)");
    gnuplot_pen_width(d,2);
    gnuplot_xy(d,x,y,1,"points 1","POINT DE DEPART");
    gnuplot_xy(d,x+(i-1),y+(i-1),1,"points 2","POINT FINAL");
    gnuplot_close(d);
    free(x);
    free(y);
}
/******************************************************************************
*                                                                             *
*Routine de Tracage en fonction du temps                                      *
*                                                                             *
*IN:le nombre d'iteration nbr_iteration  int nbr                              *
*   le tableau contenant les iterations donnees par la routine Runge-kutta    *
*                                                       double **val          *
*OUT:fontion void                                                             *
*                                                                             *
*Remarque:                                                                    *
*         La seule difference entre void trace et void tracetmps est que la   *
*         void tracetmps trace les x et y en fonction du temps.               *
*                                                                             *
******************************************************************************/

void tracetmps(int nbr,double** val)
{
    int i=nbr;
    double *x,*y;
    gnuplot_t d=NULL;
    x=(double*)malloc(nbr*sizeof(double));
    y=(double*)malloc(nbr*sizeof(double));
    while (nbr>0)
    {
        x[nbr-1]=val[nbr-1][0];
        y[nbr-1]=val[nbr-1][1];
        nbr--;
    }
    d=gnuplot_init(GNUPLOT_X);
    gnuplot_title
     (d,"NOMBRE DE PETITES POISSONS ET DE GROS POISSONS EN FONCTION DU TEMPS;");
    gnuplot_xlabel(d,"Temps (en *temps/nombre d'iterations)");
    gnuplot_ylabel(d,"Nombre de poissons (en milliers)");
    gnuplot_x(d,0,x,i,"lines 1","Nombre de petits poissons.");
    gnuplot_x(d,0,y,i,"lines 2","Nombre de gros poissons");
    gnuplot_close(d);
    free(x);
    free(y);
}

/******************************************************************************
*                                                                             *
*Routine d'estimation de la periode                                           *
*                                                                             *
*IN:l'intervalle de temps [temps0,temp1]                                      *
*   point de depart v0                                                        *
*   une reference de niveau precision a                                       *
*                                                                             *
*OUT:la periode estimee                                                       *
*                                                                             *
*Remarque:                                                                    *
*        celle-ci est une fontion recurcive dediee pour trouver la periode    *
*        bien precise.L'idee est qu'on s'arrete au premier point qui franchit *
*        le point du depart(car ceci peut garantir que l'estimation grossiere *
*        est superieure que la periode exacte),voila,une estimation grossiere *
*        de la periode (i*unite de temps) en suite on rappelle cette fonction *
*        en lui donnant l'intervalle de temps [temp0,(temp0+estimation gross- *
*        iere)] et ainsi de suite jusqu'a a eme fois (a=niveau de precision). *
*        Car a chaque recursion on diminue l'intervalle du temps mais le      *
*        nombre d'iteration reste toujours le meme alors ca nous permet de    *
*        calculer la periode plus precise deja avec a=2(une estimation et une *
*        amelioration!!!),si a=4 ceci veut dire 1 estimation et 3 fois d'     *
*        amelioration!!!                                                      *
*                                                                             *
******************************************************************************/

double estim_periode(double temp0 ,double temp1,double *v0,int a)
{
    int i;
    double **rung;
    if (a!=0)
    {
        rung=Rung_kutta(&Fonc,v0,3000,temp0,temp1);
        for (i=1;i<3000;i++)
            if (((rung[i][0]-v0[0])*(rung[i-1][0]-v0[0])<0)
              &&((rung[i][1]-v0[1])*(rung[i-1][1]-v0[1])<0))
              {
                  temp1=i*(temp1-temp0)/3000+temp0;break;
              }
        free (rung);
        return estim_periode(temp0,temp1,v0,(a-1));
    }
    else
    return (temp1-temp0);
}

/******************************************************************************
*                                                                             *
*Routine de Moyenne                                                           *
*                                                                             *
*IN:le tableau contenant les iterations donnees par la routine Runge-kutta    *
*       double **val                                                          *
*   le nombre d'iteration nbr_iteration int iter                              *
*   l'indice de colone int col                                                *
*                                                                             *
*OUT:la moyenne calculee par cette routine                                    *