test

/*!
\file simplexe.c
\author x
\brief Ce programme résoud un problème linéaire par la méthode du simplexe
\remarks On demande à l'utilisateur d'entrer dans un fichier les données nécessaires (contraintes, etc.).
__________________
Maximiser               Z = f(x(1),x(2)) = 3x(1) + 2x(2)
sous les contraintes:   2x(1) + x(2) ≤ 18
                        2x(1) + 3x(2) ≤ 42
                        3x(1) + x(2) ≤ 24
                        x(1) ≥ 0 , x(2) ≥ 0
__________________
*/


/*Saisie des librairies que l'on a besoin*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

#define TAILLE_MAX 3



/*
\fn
\author x
\version 0.1
\brief
\param argv valeurs des arguments en entrée du programme
\param argc nombre d'arguments en entrée du programme
\return 0 si tout s'est bien passe
*/



 void afficher(float **A) {
       int i, j ;

       for (i = 0 ; i != TAILLE_MAX ; i++) {
        for (j = 0 ; j != TAILLE_MAX ; j++) {
           printf("%8.2f |", A[i][j]);
         }
         printf("\n" );
       }

 }

float** lire(float **A, int choix_taille) {
     int int_retour;
     int i, j;

    for(i=0; i!=choix_taille; i++) {
        for(j=0; j!=choix_taille; j++) {
            A[i][j]=0;
        }
    }

    for(i=0; i!=choix_taille; i++) {
        for(j=0; j!=choix_taille; j++) {
            printf("A[%d][%d]=", i, j );
            int_retour=scanf("%f", &A[i][j]);
            if(int_retour==0) { exit(-1); }
        }
    }

  return(A);
}

float** allocation_mem(void) {
int i;
float **A;

/*Allocation de l'espace nécessaire au tableau dynamique.*/
A=malloc(sizeof(float*)*TAILLE_MAX);

for(i=0; i!=TAILLE_MAX;i++){
    A[i]=malloc(sizeof(float)*TAILLE_MAX);
}

/*Si il y a eu une erreur lors de l'allocation  de mémoire*/
if(A == NULL ){
     printf("Allocation impossible.");
     exit(-1);  /*on quitte*/
}
return(A);
}

 int main (int argc, char** argv) {
    int int_retour; /*Valeur de retour*/
    float **A;  /*Matrice contenant les contraintes*/
    int int_choix; /*Valeur choisie par l'utilisateur*/
    int i; /*indice ligne*/
    int j; /*indice colonne*/
    float min; /*Valeur duu minimum*/
    int position; /*Position colonne du minimum*/
    float temp; /*Valeur temporaire*/
    int place; /*Position ligne du minimum*/
    int k;  /**/
    float M; /*Coeficient multiplicateur*/
    int nb_variables_ecart=0; /*Nombre de variables d'écart : y(i)*/
    int choix_taille;
    int verif=0;

printf("\n\t\t\t     _________________________________");
printf("\n\t\t\t    /                                 /");
printf("\n\t\t\t   /      -                    -     / ");
printf("\n\t\t\t  /             Symplexe            /  ");
printf("\n\t\t\t /      -                    -     /   ");
printf("\n\t\t\t/_________________________________/\n\n\n\n\n");


A = allocation_mem();

printf("Quelle est la dimenssion choisie inferieur a %d ?", TAILLE_MAX);
int_retour=scanf("%d", &choix_taille);
if((int_retour==0) || (choix_taille>TAILLE_MAX)) { exit(-1); }

A=lire(A, choix_taille);
afficher(A);

/*demande maximisation ou minimisation*/
printf("Maximiser (0) ou minimiser (1) ?");
int_retour=scanf("%d", &int_choix);

/*on vérifie que l'utilisateur a bien entré un entier, 1 ou 0*/
if ((int_retour==0) || ((int_choix!=1) && (int_choix!=0))) {
    printf("Mauvaise saisie.\n");
    exit(-1);
}


printf("---------------Mise sous forme standard.-----------------\n");

/*si c'est un probleme de maximisation, on le rend en minimisation.*/
if (int_choix==0) {
    for(j=0; j!=TAILLE_MAX; j++) {A[0][j]= -A[0][j]; } /*on modifie l'objectif de telle sorte que les coeeficient soient négatifs*/
}


/*
//--------------
//initialisation
//--------------
*/

/*on regarde s'il exite un coeficient dans l'objectif qui est négatif pour lancer le programme, sinon on stop l'algorithme*/
for(j=0; j!=TAILLE_MAX; j++){
    if(A[0][j]<0){ verif=1;} else { verif=0;}
}
if(verif==0){ printf("Il n'existe pas de coefficient ci<0 donc l'agorithme s'arrete");  }


debut:

/*on prend le coefficient le plus petit dans la fonction objectif
initialisation du min de vecteur_c*/
min = A[0][0];

for (j=0; j!=TAILLE_MAX; j++) { /*j = colonne*/
    if (min > A[0][j]){
        min = A[0][j];
        position = j; /*colonne correspondant au min*/
    }
}
printf("minimum vecteur_objectif en position %d = %f\n", position, min);

/*on prend le minimum des b(i)/a(i)(position)*/
min=A[TAILLE_MAX-1][0]/A[0][position]; /*initialisation du min*/
for(i=0; i!=TAILLE_MAX-1; i++) { /*i=ligne,  si i>nb_contraintes alors min=0 */
    if(A[i][position]==0){
        printf("Erreure : division par zero.");
        exit(-1);
    }

    temp=A[TAILLE_MAX-1][i]/A[i][position];

    if(temp<0){ /*si b(i)/a(i)(position) est négatif, on l'ignore*/
        continue;
    }

    temp = ((A[TAILLE_MAX-1][i+1]) / (A[i+1][position])); /*on passe à la ligne suivante*/
    if (min > temp){ /*on compare*/
            min = temp;
            place = i; /*position du min*/
     }
}
printf("minimum des b(i)/a(i)(position) en position %d = %f \n", place, min);

printf("x%d entre en base et x%d en sort.\n", position, place); /*changement des base, place devient une variable "hors-base"*/

/*Demande des types de contraintes  < : 1, > : 2, = : 3*/
printf("Saisie des types de vos  %d contraintes : 1 pour <; 2 pour > et 3 pour =\n", choix_taille);
for(k=0; k!=choix_taille-1; k++) {
    printf("\nType de la contrainte n°%d : ", k+1);
    int_retour=scanf("%d", &int_choix);

    /*on vérifie que l'utilisateur a bien entré un entier, 1 2 ou 3*/
    if ((int_retour==0) || ((int_choix!=1) && (int_choix!=2) && (int_choix!=3))) {
        printf("Mauvaise saisie.\n");
        exit(-1);
    }

    switch (int_choix) {
    case 1 :/* on ajoute une dimenssion à matrice_A
         ajout +y,  on ajoute un vecteur (0,.., 1, 0,..,0)*/
        nb_variables_ecart=nb_variables_ecart+1;
        for(i=0; i!=TAILLE_MAX-1; i++){
            for(j=0; j!=TAILLE_MAX-1; j++){
                if(j==position){
                    A[i][j]=0;
                }
            }
        }
        A[place][position]=1;
    break;

    case 2 :/* on ajoute une dimenssion à Tableau_donnees
         ajout -y,  on ajoute un vecteur (0,.., -1, 0,..,0)*/
        nb_variables_ecart=nb_variables_ecart+1;
        for(i=0; i!=TAILLE_MAX-1; i++){
            for(j=0; j!=TAILLE_MAX-1; j++){
                if(j==position){
                    A[i][j]=0;
                }
            }
        }
        A[place][position]=-1;
    break;

    case 3 :
         continue;
    break;

    }
}


/*
//----------------------
//PIVOT DE GAUSS
//----------------------
*/
    /*On regarde s'il est nécessaire de faire des permutations à cause des 0 sur la diagonale.*/
    temp = 0;
    for(i=0; i<TAILLE_MAX-1; i++){
       if(A[i][i]==0){
         for(j=0; j<TAILLE_MAX-1; j++){
            if(A[j][i] !=0 && A[i][j]!=0){
              for(k=0; k<TAILLE_MAX-1; k++){
                  temp = A[j][k];
                  A[j][k] = A[i][k];
                  A[i][k] = temp;
              }
                temp = A[j][TAILLE_MAX];
                A[j][TAILLE_MAX] = A[i][TAILLE_MAX];
                A[i][TAILLE_MAX] = temp;
             }
         }
      }
    }


    /*Méthode de gauss : On calcule les solutions*/
    for(k=0; k<TAILLE_MAX-1; k++){
       for(i=k+1; i<TAILLE_MAX-1; i++){
          if(A[k][k]==0){
             printf("Il n'y a pas de solution.\n");
             exit(-1);
          }
           M = A[i][k] / A[k][k];
             for(j=k; j<TAILLE_MAX-1; j++){
                 A[i][j] -= M * A[k][j];
             }
              A[i][TAILLE_MAX] -= M*A[k][TAILLE_MAX];
       }
    }

afficher(A);
/*on regarde s'il exite un coeficient dans l'objectif qui est négatif pour relancer le programme, sinon on stop l'algorithme*/
for(j=0; j!=TAILLE_MAX; j++){
    if(A[0][j]<0){ goto debut; } else { printf("Il n'existe pas de coefficient ci<0 donc l'agorithme s'arrete"); }
}


/*Libération de l'espace mémoire.*/
for (i=0 ; i!=TAILLE_MAX; i++){
      free(A[i]);
}
free(A);

return(0);
}