Exemplo n.º 1
0
void TAP_DONNEES::Charger(QVar *variable)
{
    QIntList eff;
    modalites.clear();
    if(variable->Ordonnee())
    {
        modalites=variable->Ordre();
        int teff;
        for(int i=0;i<modalites.size();i++)
        {
            teff=0;
            for(int j=0;j<variable->NbVal();j++)
            {
                if(modalites.at(i)==variable->Row(j))
                {
                    teff++;
                }
            }
            eff+=teff;
        }
    }
    else
    {
        for(int i=0;i<variable->NbVal();i++)
        {
            if(variable->isValide(i))
            {
                    if(!modalites.contains(variable->Row(i)))
                    {
                        modalites+=variable->Row(i);
                        eff+=1;
                    }
                    else
                    {
                        int j=0;
                        for(j; j<modalites.size() and modalites.at(j)!=variable->Row(i);j++)
                        {}
                        eff.replace(j, eff.at(j)+1);
                    }
            }
        }
    }
    if(variable->Type()>=TYPES::QUANTITATIF_DISCRET)
    {
        if(modalites.size()>1)
        {Trier(&eff);}
    }
    double fcum=0;
    for(int i=0; i<eff.size();i++)
    {
        effectifs+=QString().number(eff.at(i),'f', 0);
         frequences+=QString().number(double(double(eff.at(i))/double(variable->NbValide())),'f', 3);
         if(variable->Type()>=TYPES::QUALITATIF_ORDINAL)
         {
             fcum+=double(eff.at(i))/double(variable->NbValide());
             frequencesCumulees+=QString().number(fcum, 'f', 3);
         }
     }
}
Exemplo n.º 2
0
void FuzzyUtils::getFuzzyIntegralSugeno(IplImage* H, IplImage* Delta, int n, float *MeasureG, IplImage* OutputImage)
{
  // MeasureG : est un vecteur contenant 3 mesure g (g1,g2,g3) tel que : g1+g2+g3=1
  // n : =2 cad aggreger les 2 images "H" et "Delta" 
  //	   =1 cad aggreger uniquement les valeurs des composantes couleurs de l'image "Delta"

  PixelUtils p;

  float* HTexturePixel = (float*) malloc(1*sizeof(float));   
  float* DeltaOhtaPixel = (float*) malloc(3*(sizeof(float)));
  int *Indice = (int*) malloc(3*(sizeof(int)));
  float *HI = (float*) malloc(3*(sizeof(float)));
  float *Integral = (float*) malloc(3*(sizeof(float)));
  float* X = (float*) malloc(1*sizeof(float));
  float* XiXj = (float*) malloc(1*sizeof(float));
  float IntegralFlou;

  *Indice = 0;
  *(Indice+1) = 1;
  *(Indice+2) = 2;
  *X = 1.0;

  for(int i = 0; i < H->width; i++)
  {
    for(int j = 0; j < H->height; j++)
    {	
      p.GetGrayPixel(H,i,j,HTexturePixel);
      p.GetPixel(Delta,i,j,DeltaOhtaPixel);

      *(HI+0) = *(HTexturePixel+0);
      *(HI+1) = *(DeltaOhtaPixel+0);
      *(HI+2) = *(DeltaOhtaPixel+1);

      Trier(HI,3,Indice);

      *XiXj = *(MeasureG + (*(Indice+1))) + (*(MeasureG + (*(Indice+2))));			

      *(Integral+0) = min((HI + (*(Indice+0))), X);
      *(Integral+1) = min((HI + (*(Indice+1))), XiXj);
      *(Integral+2) = min((HI + (*(Indice+2))), ((MeasureG+(*(Indice+2)))));

      IntegralFlou = max(Integral,3);
      p.PutGrayPixel(OutputImage,i,j,IntegralFlou);
    }
  }

  free(HTexturePixel);
  free(DeltaOhtaPixel);
  free(Indice);
  free(HI);
  free(X);
  free(XiXj);
  free(Integral);
}
Exemplo n.º 3
0
int CandidatUniqueColonne(Candidats_case cand,int colonne)
{
    T_Tab rep={0};
    int i;

    for(i=1;i<=9;i++)
    {
        if((NbRepetitionColonne(i,cand,colonne)==1)) rep[i-1]=i;
    }
    Trier(rep);
    if(NombreDeCazNonVides(rep)==1)
    {
        return rep[0];
    }
    else
    {
        return 0;
    }
}
Exemplo n.º 4
0
Arquivo: tri.c Projeto: iiyajid/TP_C
void Choix(ITEM items[], int nb_items)
{
  char cas[10];

    printf("*** Tri :\n");
    printf("- 1 ou A - numerique selon l'Age (croissant)\n");
    printf("- 2 ou B - numerique selon l'age (Decroissant)\n");
    printf("- 3 ou C - alphabetique croissant sur le Nom\n");
    printf("- 4 ou D - alphabetique decroissant sur le Nom\n");
    printf("- 5 ou E - alphabetique croissant sur le Prenom\n");
    printf("- 6 ou F - alphabetique decroissant sur le Prenom\n");
    printf("- 0 ou Q - sortir\n");

    scanf("%s", cas);

    switch (cas[0]) {
    case '1': case 'A': case 'a':
      Trier(items, nb_items,compareAgeCroiss); 
      break;
    case '2': case 'B': case 'b':
      Trier(items, nb_items,compareAgeDec); 
      break;
    case '3': case 'C': case 'c':
      Trier(items, nb_items,compareNomCroiss);
      break;
    case '4': case 'D': case 'd':
      Trier(items, nb_items,compareNomDec);
      break;
    case '5': case 'E': case 'e':
      Trier(items, nb_items,comparePrenomCroiss);
      break;
    case '6': case 'F': case 'f':
      Trier(items, nb_items,comparePrenomDec);
      break;
    case '0': case 'Q': case 'q':
      exit(0);

    default:
      printf("! Choix incorrect [%s] : entrer une autre valeur\n\n", cas);
    }
}
Exemplo n.º 5
0
void Regle3(Grille grille, Candidats_case cand,int pas_a_pas)
{
    int ligne,colonne,reg,num_case;
    int unique; /* variable qui serra tester si elle est differente de 0 */
    int i,j,k,num,cpt,pos;

    /* Pour chaque ligne, on met le candidat unique a la case dont les candidats contiennent le candidat unique */

    for(ligne=0;ligne<LIGNES_MAX;ligne++)
    {
        /* Le numero de la case au debut de la ligne en question */

        num_case=9*ligne; /* d'ou le retrait de la colonne dans la formule num_case = 9*ligne+colonne

        /* On trouve le candidat unique sur la ligne */

        unique=CandidatUniqueLigne(cand,ligne);

        /* Si il est different de zero i.e il existe */

        if(unique != 0)
        {
            for(i=0;i<9;i++)
            {
                /*Si le candidat unique sur la ligne est dans les candidats d'une case de la ligne, on le met a la case correspondante */

                if(EstDansTab(unique, cand[num_case+i])) /* plus i pour se deplacer en colonne a partir d'une ligne et donc atteindre le numero des case suivantes */
                {
                    grille[ligne][i]=unique;
                    /*if(pas_a_pas == 1)
                    {
                        AfficherGrille(grille,ligne,i);
                        printf("Appuyez une touche pour continuer\n");
                        getchar();
                    }*/

                    /* On reduit les candidats de la case a zero puisqu'elle est devoilee */

                    for(j=0;j<9;j++) cand[num_case+i][j]=0;

                    /* On enleve le candidat unique parmi les candidats de la colonne correspondant a sa case */

                    for(num=i;num<81;num+=9)
                    {
                        for(cpt=0;cpt<9;cpt++)
                        {
                            if(cand[num][cpt]== unique)
                            {
                                cand[num][cpt]=0;
                                Trier(cand[num]);
                            }
                        }
                    }

                    /* On enleve le candidat unique parmi les candidats de la region correspondant a sa case */

                    reg=Region(ligne,i);
                    pos=27*(reg/3)+3*(reg%3);

                    for(num=pos;num<pos+19;num+=9)
                    {
                        for(cpt=0;cpt<3;cpt++)
                        {
                            for(j=0;j<9;j++)
                            {
                                if(cand[num+cpt][j] == unique)
                                {
                                    cand[num+cpt][j]=0;
                                    Trier(cand[num+cpt]);
                                }
                            }
                        }
                    }
        /* REMARQUE : On a pas besoin de supprimer le candidat unique parmi les candidats de sa ligne parcequ'on sait deja qu'il est unique sur la ligne */
                }
            }
        }
    }

    /* Pour chaque colonne, on met le candidat unique a la case dont les candidats contiennent le candidat unique */

    for(colonne=0;colonne<COLONNES_MAX;colonne++)
    {
        /* Le numero de la case au debut de la colonne en question */

        num_case=colonne;

        /* On trouve le candidat unique sur la colonne */

        unique=CandidatUniqueColonne(cand, colonne);

        /* Si le candidat unique est different de zero i.e il existe */

        if(unique != 0 )
        {
            for(i=0;i<9;i++)
            {
                /* Si le candidat unique appartient a la liste des candidats d'une case, on met le candidat unique a la case correspondante */

                if(EstDansTab(unique, cand[num_case+(9*i)]))
                {
                    grille[i][colonne]=unique;
                    if(pas_a_pas == 1)
                    {
                        AfficherGrille(grille,i,colonne);
                        printf("Appuyez une touche pour continuer\n");
                        getchar();
                    }

                    /* On reduit les candidats de la case a zero */

                    for(j=0;j<9;j++) cand[num_case+(9*i)][j]=0;

                    /* On supprime le candidat unique parmi les candidats des autres cases de la ligne correspondante */

                    for(num=i*9;num<9*i+9;num++)
                    {
                        for(cpt=0;cpt<9;cpt++)
                        {
                            if(cand[num][cpt] == unique) cand[num][cpt]=0;Trier(cand[num]);
                        }
                    }

                    /* On supprime le candidat unique parmi les candidats des autres cases de la region correspondante */

                    reg=Region(i,colonne);
                    pos=27*(reg/3)+3*(reg%3);

                    for(num=pos;num<pos+19;num+=9)
                    {
                        for(cpt=0;cpt<3;cpt++)
                        {
                            for(j=0;j<9;j++)
                            {
                                if(cand[num+cpt][j] == unique)
                                {
                                    cand[num+cpt][j]=0;Trier(cand[num+cpt]);
                                }
                            }
                        }
                    }

                    /* REMARQUE : On a pas besoin de supprimer le candidat unique parmi les candidats de sa colonne parcequ'on sait deja qu'il est unique sur la colonne */

                }
            }
        }
    }

    /* Pour chaque region, on met le candidat unique a la case dont les candidats contiennent le candidat unique */

    for(reg=0;reg<9;reg++)
    {
        /* Le numero de la case en haut a gauche de la region en question */

        num_case=(27*(reg/3))+(3*(reg%3));

        /* On trouve le candidat unique dans la region */

        unique=CandidatUniqueRegion(cand, reg);

        /* S'il est different de zero i.e il existe */

        if(unique != 0)
        {
            for(i=0;i<3;i++)
            {
                for(j=0;j<3;j++)
                {

                    /* Si le candidat unique sur la region appartient a la liste des candidats d'une case; on le met a la case correspondante */

                    if(EstDansTab(unique, cand[(num_case+9*i+j)]))
                    {
                            ligne=(num_case+9*i+j)/9;
                            colonne=(num_case+9*i+j)%9;

                            grille[ligne][colonne]=unique;
                            if(pas_a_pas == 1)
                            {
                                AfficherGrille(grille,ligne,colonne);
                                printf("Appuyez une touche pour continuer\n");
                                getchar();
                            }

                            /* On reduit les candidats de la case a zero puisqu'elle est devoilee */

                            for(k=0;k<9;k++) cand[(num_case+9*i+j)][k]=0;

                            /* On supprime le candidat unique de la region parmi les candidats de la ligne */

                            for(num=ligne*9;num<9*ligne+9;num++)
                            {
                                for(cpt=0;cpt<9;cpt++)
                                {
                                    if(cand[num][cpt] == unique)
                                    {
                                        cand[num][cpt]=0;
                                        Trier(cand[num]);
                                    }
                                }
                            }

                            /* On supprime le candidat unique de la region parmi les candidats et de la colonne correspondant */

                            for(num=colonne;num<81;num+=9)
                            {
                                for(cpt=0;cpt<9;cpt++)
                                {
                                    if(cand[num][cpt]== unique)
                                    {
                                        cand[num][cpt]=0;
                                        Trier(cand[num]);
                                    }
                                }
                            }

                            /*REMARQUE : On a pas besoin de supprimer le candidat unique parmi les candidats de sa region parcequ'on sait deja qu'il est unique sur la region */
                    }
                }
            }
        }
    }
}
Exemplo n.º 6
0
void CandJumeauxLigne(Candidats_case cand,int reg)
{
    /* Les coordonnes en haut a gauche de la region reg */

    int lig=3*(reg/3);
    int col=3*(reg%3);

    /*Le numero de case correspondant a la case decrite precedemment */

    int num_case=9*lig+col;

    T_Tab rep={0};
    int i,j,num;

    /* On regarde pour chaque candidat de [1;9] son nombre de repetition;
    Si celui-ci est egal a 2 ou 3 i.e c'est un candidat soit jumeau ou triple;
    on le met dans le tableau rep */

    for(i=1;i<=9;i++)
    {
        if(((NbRepetitionRegion(i,cand,reg))==2)||((NbRepetitionRegion(i,cand,reg))==3))
        {
            rep[i-1]=i;
        }
    }

    Trier(rep); /*On trie le tableau contenant les jumeaux et triples

    /*Pour toutes les cases non vides du tableau rep */

    for(i=0;i<(NombreDeCazNonVides(rep));i++)
    {

        /* Si le nombre de repetion d'une valeur du tableau est egal a 2 i.e il a un jumeau parmi */

        if((NbRepetitionRegion(rep[i],cand,reg))==2)
        {

            /* On se rassure qu'il soient(son jumeau et lui) candidats a deux cases sur la meme ligne
                avant de les supprimer parmi les candidats des autres cases de la ligne; on a 3 configurations
                possible XX? ?XX X?X */

        if(((EstDansTab(rep[i],cand[num_case]))&&(EstDansTab(rep[i],cand[num_case+1])))||
        ((EstDansTab(rep[i],cand[num_case+1]))&&(EstDansTab(rep[i],cand[num_case+2])))||
        ((EstDansTab(rep[i],cand[num_case]))&&(EstDansTab(rep[i],cand[num_case+2]))))
        {

            /* On supprime rep[i](le jumeau) parmi les candidats de la ligne */

            for(num=9*lig;num<(9*lig)+9;num++)
            {

                /* On se rassure de ne pas supprimer les jumeaux parmi les candidats de leur region */

                if((Region(Ligne_of_case(num),Colonne_of_case(num))) != reg)
                {
                    for(j=0;j<9;j++)
                    {
                        if(cand[num][j] == rep[i])
                        {
                            cand[num][j]=0;
                            Trier(cand[num]);
                        }
                    }
                }
            }
        }
        else
            if(((EstDansTab(rep[i],cand[num_case+9]))&&(EstDansTab(rep[i],cand[num_case+10])))||
            ((EstDansTab(rep[i],cand[num_case+10]))&&(EstDansTab(rep[i],cand[num_case+11])))||
            ((EstDansTab(rep[i],cand[num_case+9]))&&(EstDansTab(rep[i],cand[num_case+11]))))
            {
                for(num=lig*9+9;num<9*lig+18;num++)
                {
                    if((Region(Ligne_of_case(num),Colonne_of_case(num))) != reg)
                    {
                        for(j=0;j<9;j++)
                        {
                            if(cand[num][j]==rep[i])
                            {
                                cand[num][j]=0;
                                Trier(cand[num]);
                            }
                        }
                    }
                }
            }
            else
            if(((EstDansTab(rep[i],cand[num_case+18])&&(EstDansTab(rep[i],cand[num_case+19]))))||
            ((EstDansTab(rep[i],cand[num_case+19])&&(EstDansTab(rep[i],cand[num_case+20]))))||
            ((EstDansTab(rep[i],cand[num_case+18])&&(EstDansTab(rep[i],cand[num_case+20])))))
            {
                for(num=lig*9+18;num<9*lig+27;num++)
                {
                    if((Region(Ligne_of_case(num),Colonne_of_case(num))) != reg)
                    {
                        for(j=0;j<9;j++)
                        {
                            if(cand[num][j]==rep[i])
                            {
                                cand[num][j]=0;
                                Trier(cand[num]);
                            }
                        }
                    }
                }
            }
            }
            else
            if((NbRepetitionRegion(rep[i],cand,reg))==3)
            {
                if((EstDansTab(rep[i],cand[num_case]))&&(EstDansTab(rep[i],cand[num_case+1]))&&(EstDansTab(rep[i],cand[num_case+2])))
                {
                    for(num=9*lig;num<(9*lig)+9;num++)
                    {
                        if((Region(Ligne_of_case(num),Colonne_of_case(num))) != reg)
                        {
                            for(j=0;j<9;j++)
                            {
                                if(cand[num][j] == rep[i])
                                {
                                    cand[num][j]=0;
                                    Trier(cand[num]);
                                }
                            }
                        }
                    }
                }
                else
                if((EstDansTab(rep[i],cand[num_case+9]))&&(EstDansTab(rep[i],cand[num_case+10]))&&(EstDansTab(rep[i],cand[num_case+11])))
                {
                    for(num=lig*9+9;num<9*lig+18;num++)
                    {
                        if((Region(Ligne_of_case(num),Colonne_of_case(num))) != reg)
                        {
                            for(j=0;j<9;j++)
                            {
                                if(cand[num][j]==rep[i])
                                {
                                    cand[num][j]=0;
                                    Trier(cand[num]);
                                }
                            }
                        }
                    }
                }else
                if((EstDansTab(rep[i],cand[num_case+18]))&&(EstDansTab(rep[i],cand[num_case+19]))&&(EstDansTab(rep[i],cand[num_case+20])))
                {
                    for(num=lig*9+18;num<9*lig+27;num++)
                    {
                        if((Region(Ligne_of_case(num),Colonne_of_case(num))) != reg)
                        {
                            for(j=0;j<9;j++)
                            {
                                if(cand[num][j]==rep[i])
                                {
                                    cand[num][j]=0;
                                    Trier(cand[num]);
                                }
                            }
                        }
                    }
                }
            }
    }
}
Exemplo n.º 7
0
void CandJumeauxColonne(Candidats_case cand,int reg)
{
    int lig=3*(reg/3);
    int col=3*(reg%3);
    int num,num_case=9*lig+col;

    T_Tab rep={0};
    int i,j;


    for(i=1;i<=9;i++)
    {
        if(((NbRepetitionRegion(i,cand,reg))==2)||((NbRepetitionRegion(i,cand,reg))==3))
        {
            rep[i-1]=i;
        }
    }

    Trier(rep);

    for(i=0;i<(NombreDeCazNonVides(rep));i++)
    {
        if((NbRepetitionRegion(rep[i],cand,reg))==2)
        {
            if(((EstDansTab(rep[i],cand[num_case]))&&(EstDansTab(rep[i],cand[num_case+9])))||
            ((EstDansTab(rep[i],cand[num_case+9])&&(EstDansTab(rep[i],cand[num_case+18]))))||
            ((EstDansTab(rep[i],cand[num_case]))&&(EstDansTab(rep[i],cand[num_case+18]))))
            {
                for(num=col;num<81;num+=9)
                {
                    if((Region(Ligne_of_case(num),Colonne_of_case(num))) != reg)
                    {
                        for(j=0;j<9;j++)
                        {
                            if(cand[num][j] == rep[i])
                            {
                                cand[num][j]=0;
                                Trier(cand[num]);
                            }
                        }
                    }
                }
            }
            else
            if(((EstDansTab(rep[i],cand[num_case+1]))&&(EstDansTab(rep[i],cand[num_case+10])))||
            ((EstDansTab(rep[i],cand[num_case+10]))&&(EstDansTab(rep[i],cand[num_case+19])))||
            ((EstDansTab(rep[i],cand[num_case+1]))&&(EstDansTab(rep[i],cand[num_case+19]))))
            {
                for(num=col+1;num<81;num+=9)
                {
                    if((Region(Ligne_of_case(num),Colonne_of_case(num))) != reg)
                    {
                        for(j=0;j<9;j++)
                        {
                            if(cand[num][j] == rep[i])
                            {
                                cand[num][j]=0;
                                Trier(cand[num]);
                            }
                        }
                    }
                }
            }
            else
            if((((EstDansTab(rep[i],cand[num_case+2]))&&(EstDansTab(rep[i],cand[num_case+11]))))||
            ((EstDansTab(rep[i],cand[num_case+11]))&&(EstDansTab(rep[i],cand[num_case+20])))||
            ((EstDansTab(rep[i],cand[num_case+2]))&&(EstDansTab(rep[i],cand[num_case+20]))))
            {
                for(num=col+2;num<81;num+=9)
                {
                    if((Region(Ligne_of_case(num),Colonne_of_case(num))) != reg)
                    {
                        for(j=0;j<9;j++)
                        {
                            if(cand[num][j] == rep[i])
                            {
                                cand[num][j]=0;
                                Trier(cand[num]);
                            }
                        }
                    }
                }
            }
            }else
            if((NbRepetitionRegion(rep[i],cand,reg))==3)
            {
                if((EstDansTab(rep[i],cand[num_case]))&&(EstDansTab(rep[i],cand[num_case+9]))&&(EstDansTab(rep[i],cand[num_case+18])))
                {
                    for(num=col;num<81;num+=9)
                    {
                        if((Region(Ligne_of_case(num),Colonne_of_case(num))) != reg)
                        {
                            for(j=0;j<9;j++)
                            {
                                if(cand[num][j] == rep[i])
                                {
                                    cand[num][j]=0;
                                    Trier(cand[num]);
                                }
                            }
                        }
                    }
                }
                else
                if ((EstDansTab(rep[i],cand[num_case+1]))&&(EstDansTab(rep[i],cand[num_case+10]))&&(EstDansTab(rep[i],cand[num_case+19])))
                {
                    for(num=col+1;num<81;num+=9)
                    {
                        if((Region(Ligne_of_case(num),Colonne_of_case(num))) != reg)
                        {
                            for(j=0;j<9;j++)
                            {
                                if(cand[num][j] == rep[i])
                                {
                                    cand[num][j]=0;
                                    Trier(cand[num]);
                                }
                            }
                        }
                    }
                }
                else
                if ((EstDansTab(rep[i],cand[num_case+2]))&&(EstDansTab(rep[i],cand[num_case+11]))&&(EstDansTab(rep[i],cand[num_case+20])))
                {
                    for(num=col+2;num<81;num+=9)
                    {
                        if((Region(Ligne_of_case(num),Colonne_of_case(num))) != reg)
                        {
                            for(j=0;j<9;j++)
                            {
                                if(cand[num][j] == rep[i])
                                {
                                    cand[num][j]=0;
                                    Trier(cand[num]);
                                }
                            }
                        }
                    }
                }
            }
    }
}