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



/* --------------------------------------------------- */
/*  Declarations des fonctions et procédures utilisees */
/*  (a lire mais ne rien ajouter dans cette partie)    */
/* --------------------------------------------------- */


void creeFichierReels(const char * nomFichier, const double lesElements[], int nb);
/* Preconditions : nomFichier est une chaine de caracteres designant le nom du fichier 
   a creer, lesElements est un tableau contenant nb reels
   Postconditions : le fichier nomFichier contient les nb reels, ecrits en binaire
   comme ils sont representes en memoire vive. Si le fichier existait déjà, son 
   ancien contenu est écrasé. */


void litFichierReels(const char * nomFichier);
/* Preconditions : nomFichier est le nom d'un fichier produit par une machine de meme
   architecture, contenant des reels ecrits en binaire comme ils sont representes en
   memoire vive. 
   Postcondition : affichage du contenu du fichier sur la sortie standard (un reel
   par ligne, ecrit en notation scientifique).*/



void triFusion(const char * nomFic); 
/* Precondition : le fichier appele nomFic contient des double codes en binaire et a 
   ete produit par une machine de meme architecture que celle qui va executer la
   procedure de tri.
   Postcondition : le fichier appele nomFic contient les memes elements, mais tries.*/  




void eclatement(const char * nomFicX, int lg, \
                const char * nomFicA, const char * nomFicB); 
/* Precondition : le fichier appele nomFicX contient des monotonies de longueur lg, 
   sauf peut-etre la derniere qui peut etre plus courte
   Postcondition : Les monotonies de nomFicX sont reparties dans des fichiers appeles 
   nomFicA et nomFicB : la premiere monotonie est copiee dans le fichier A, la seconde 
   dans le fichier B, la troisieme dans le A, etc. Si ces fichiers existaient deja, 
   leur contenu est ecrase. Le fichier A peut recueillir une monotonie de plus que le 
   fichier B, et cette derniere monotonie peut etre de longueur inferieure a lg. 
   Si au contraire ficA et ficB recueillent le meme nombre de monotonies, la derniere
   monotonie ecrite dans ficB peut etre de longueur inferieure a lg. */



void fusion(const char * nomFicA, const char * nomFicB, int lg,\
            const char * nomFicX, int * nbMonoDansX); 
/* Preconditions : les fichiers appeles nomFicA et nomFicB contiennent des monotonies 
   de longueur lg. FicA peut contenir une monotonie de plus (eventuellement incomplete) 
   que FicB. Si au contraire FicA et FicB contiennent le meme nombre de monotonies, 
   alors la derniere monotonie de FicB peut etre incomplete.
   Postconditions : le fichier appele nomFicX contient nbMonoApres monotonies de 
   longueur 2*lg, la derniere pouvant etre plus courte. Ces monotonies resultent de 
   la fusion 2 a 2 des monotonies de FicA et de FicB. Si FicX existait deja, son ancien 
   contenu est ecrase. */  





/* -------------------------------------------------------------- */
/*  Definitions des fonctions et procédures = partie A COMPLETER  */ 
/* -------------------------------------------------------------- */


int main()
{
  double mesReels[] = {9.5, -0.00033, 56.1, -2.0, 695.84, 5e10, -13.7};

  creeFichierReels("mesReels.bin", mesReels, 7);
  printf("Fichier avant le tri : \n");
  litFichierReels("mesReels.bin");

  /*  triFusion("mesReels.bin");
  printf("Fichier apres le tri : \n");
  litFichierReels("mesReels.bin"); */


  return 0;
}





void creeFichierReels(const char * nomFichier, const double lesElements[], int nb)
{
  /* a completer (exercice 1) */
}



void litFichierReels(const char * nomFichier)
{
  /* a completer (exercice 1) */
} 





 void triFusion(const char * nomFic)
{
  /* a completer (exercice 2, cf TD) */

} 



void eclatement(const char * nomFicX, int lg, \
		const char * nomFicA, const char * nomFicB)
{
  /* a completer (exercice 2, cf TD) */

} 






void fusion(const char * nomFicA, const char * nomFicB, int lg,\
		   const char * nomFicX, int * nbMonoDansX)
{
  /* Completer en suivant le squelette ci-dessous */

  FILE * ficA, * ficB, * ficX;
  int nbAtraites, nbBtraites; 
  double e1, e2;

  /* Ouverture de trois fichiers : ficA et ficB en lecture, ficX en ecriture */
  /* (penser a faire quitter le programme si l'ouverture echoue */
  







  /* Boucle tant qu'il reste quelque chose dans le fichier 2 (= tant qu'il
     reste des monotonies a fusionner 2 a 2) */
  /* (Rmq : s'il reste des monotonies dans le fichier 2, alors il en reste 
     dans le fichier 1, et celle dans le fichier 1 est de longueur lg) */

  while( 1 < 2 /* a remplacer par la vraie condition !! */ ) 
    {

      /* initialiser les compteurs nbAtraites et nbTraites */
 

      /* lire l'element suivant dans ficA pour initialiser e1*/


      /* boucle de fusion des deux monotonies courantes */
      do
	{	

          /* si e1 <= e2, on ecrit e1 dans ficX, on incremente nbAtraites,
             et, si c'est nécessaire (si on n'a pas traite toute la 
             monotonie A), on met a jour e1 */




          /* sinon, on ecrit e2 dans ficX, on incremente nbBtraites, et,
             si necessaire, on met a jour e2. Attention au cas d'une 
             monotonie finale incomplete dans ficB. */






	} while ( 1 < 2 /* a remplacer par la vraie condition !! */ ); 
      /* (tant qu'il reste des elements a traiter dans la monotonie A et
         dans la monotonie B) */
                                 


      /* si la monotonie A a ete completement traitee, il reste a ecrire
         telle quelle dans ficX la fin eventuelle de la monotonie B. Attention,
         au cas d'une monotonie finale incomplete dans ficB. */


      
      /* sinon, c'est que c'est l'inverse : B a ete completement traitee, 
         il reste a ecrire telle quelle dans ficX la fin eventuelle de la
         monotonie A. */



      /* avant de passer aux 2 monotonies suivantes, on incremente nbMonoDansX */


    }


  /* Enfin, n'oublions pas l'eventuelle monotonie supplementaire de ficA,
     qui est a recopier telle quelle dans ficX */



  /* Fermeture des trois fichiers */



} 



