/************************************************************************/
/*                                                                      */
/* INITIALISATION D'UN MIN_MAX_T                                        */
/*                                                                      */
/* Fonction qui alloue "suffisamment" de memoire pour stocker les       */
/* extrema locaux que l'on va rechercher dans le signal.                */
/*                                                                      */
/************************************************************************/

min_max_t initialiser_min_max(int n) {
  min_max_t mm;
  mm.x_min=(double *)malloc(n*sizeof(double));
  mm.x_max=(double *)malloc(n*sizeof(double));
  mm.y_min=(double *)malloc(n*sizeof(double));
  mm.y_max=(double *)malloc(n*sizeof(double));
  return mm;
}


/************************************************************************/
/*                                                                      */
/* DETECTION DES MAXIMA ET DES MINIMA LOCAUX                            */
/*                                                                      */
/* Fonction qui recherche dans le signal les extrema locaux que l'on va */
/* interpoler. Elle choisit egalement les valeurs a tabuler au debut et */
/* a la fin du signal.                                                  */
/*                                                                      */
/************************************************************************/

void min_max(double x[],double y[],int n,min_max_t *mm) {
  int cour;
  mm->n_min=1;
  mm->n_max=1;

  /* recherche a proprement parler des minima et des maxima */
  for(cour=1;cour<(n-1);cour++) {
    if (y[cour]<=y[cour-1] && y[cour]<=y[cour+1]) /* minimum local */ {
      mm->x_min[mm->n_min]=x[cour];
      mm->y_min[mm->n_min]=y[cour];
      mm->n_min++;
    }
    if (y[cour]>=y[cour-1] && y[cour]>=y[cour+1]) /* maximum local */ {
      mm->x_max[mm->n_max]=x[cour];
      mm->y_max[mm->n_max]=y[cour];
      mm->n_max++;
    }
  }

  /* valeurs a tabuler au debut du signal */
  mm->x_max[0]=x[0]; mm->x_min[0]=x[0];
  if (y[0]<=mm->y_max[1] && y[0]>=mm->y_min[1]) {
    mm->y_max[0]=mm->y_max[1];
    mm->y_min[0]=mm->y_min[1];
  } else {
    if (y[0]<y[1]) {
      mm->y_min[0]=y[0];
      mm->y_max[0]=mm->y_max[1];
    } else if (y[0]>y[1]) {
      mm->y_max[0]=y[0];
      mm->y_min[0]=mm->y_min[1];
    } else {
      mm->y_max[0]=y[0];
      mm->y_min[0]=y[0];
    }
  }

  /* valeurs a tabuler a la fin du signal */
  mm->x_min[mm->n_min]=x[n-1]; mm->x_max[mm->n_max]=x[n-1];
  if (y[n-1]<=mm->y_max[mm->n_max-1] && y[n-1]>=mm->y_min[mm->n_min-1]) {
    mm->y_min[mm->n_min]=mm->y_min[mm->n_min-1];
    mm->y_max[mm->n_max]=mm->y_max[mm->n_max-1];
  } else {
    if (y[n-1]<y[n-2]) {
      mm->y_min[mm->n_min]=y[n-1];
      mm->y_max[mm->n_max]=mm->y_max[mm->n_max-1];
    } else if (y[n-1]>y[n-2]) {
      mm->y_max[mm->n_max]=y[n-1];
      mm->y_min[mm->n_min]=mm->y_min[mm->n_min-1];
    } else {
      mm->y_max[mm->n_max]=y[n-1];
      mm->y_min[mm->n_min]=y[n-1];
    }
  }

  (mm->n_min)++;
  (mm->n_max)++;
}


/************************************************************************/
/*                                                                      */
/* LIBERATION D'UN MIN_MAX_T                                            */
/*                                                                      */
/* Liberation de la memoire allouee par la fonction                     */
/* "initialiser_min_max".                                               */
/*                                                                      */
/************************************************************************/

void liberer_min_max(min_max_t mm) {
  free(mm.x_max);
  free(mm.x_min);
  free(mm.y_max);
  free(mm.y_min);
}
