test

/*!
\file simplexe.c
\author Romain Guilloux & Hugo Sainte-Cluque
\version 0.1
\date 13 decembre 2014
\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 10



/*
\fn
\author Romain Guilloux & Hugo Sainte-Cluque
\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("\nA[%d][%d] : %f\n", i, j, A);
         }
       }
       printf("\n" );
 }

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


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

    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);
    }

 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*/
    float addition; /*Coeffcient résultant d'addition*/
    int nb_variables_ecart=0; /*Nombre de variables d'écart : y(i)*/

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");


/*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 erreure lors de l'allocation   de mémoire*/
if( A == NULL ){
     printf("Allocation impossible.");
     exit(-1);  /*on quitte*/
}

/*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 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*/
} else if (int_choix==0) {  }


/*
//--------------
//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(vecteur_c[j]<0){ } else { 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 = vecteur_c[0];

for (j=0; j!=nb_variables; j++) { /*j = colonne*/
    if (min > vecteur_c[j]){
        min = vecteur_c[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=vecteur_b[0]/matrice_A[0][position]; /*initialisation du min*/
for(i=0; i!=nb_contraintes-1; i++) { /*i=ligne,  si i>nb_contraintes alors min=0 */
    if(matrice_A[i][position]==0){
        printf("Erreure : division par zero.");
        exit(-1);
    }

    temp=vecteur_b[i]/matrice_A[i][position];

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

    temp=vecteur_b[i+1]/matrice_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);

vecteur_Base[place]=vecteur_x[position]; /*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", nb_contraintes);
for(k=0; k!=nb_contraintes; 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!=nb_variables; i++){
            for(j=0; j!=nb_variables; j++){
                matrice_T[i][j]=matrice_A[i][j];
                if(j==position){
                    matrice_T[i][j]=0;
                }
            }
        }
        matrice_T[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!=nb_variables; i++){
            for(j=0; j!=nb_variables; j++){
                matrice_T[i][j]=matrice_A[i][j];
                if(j==position){
                    matrice_T[i][j]=0;
                }
            }
        }
        matrice_T[place][position]=-1;
    break;

    case 3 :
         continue;
    break;

    }
}

/*On vérifie que (0, ..., 0) est solution du problème et que les y(i) sont bien positifs, sinon on ajoute des variables de pénalité*/
for(i=0; i!=nb_contraintes; i++){
    for(j=0; j!=nb_variables-nb_variables_ecart; j++){
        matrice_A[i][j]=0;
        if(matrice_A[i][j]<0) {
            /*ajout des variables de pénalité*/

        }
    }
}


/*
//----------------------
//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<nb_contraintes; i++){
       if(matrice_A[i][i]==0){
         for(j=0; j<nb_contraintes; j++){
            if(matrice_A[j][i] !=0 && matrice_A[i][j]!=0){
              for(k=0; k<nb_contraintes; k++){
                  temp = matrice_A[j][k];
                  matrice_A[j][k] = matrice_A[i][k];
                  matrice_A[i][k] = temp;
              }
                temp = vecteur_b[j];
                vecteur_b[j] = vecteur_b[i];
                vecteur_b[i] = temp;
             }
         }
      }
    }


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

    for(i=nb_contraintes-1; i>=0; i--){
         addition = 0;
          for(j = i; j<nb_contraintes; j++){
               addition = addition + matrice_A[i][j]*vecteur_x[j];
          }
         vecteur_x[i] = (vecteur_b[i] - addition) / matrice_A[i][i];
    }


/*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!=nb_variables; j++){
    if(vecteur_c[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!=nb_contraintes; i++){
      free(matrice_A[i]);
}
free(matrice_A);
free(vecteur_c);
free(vecteur_b);
free(vecteur_x);
free(vecteur_Base);

return(0);
}