Programmer une fonction en C

Sur ce coup je ne vois pas comment t'aider. Ce n'est pas mon domaine, je ne comprends pas les notations de ton fichier pdf etc... Je peux juste te débloquer sur des questions précises.

Est-ce que tu as au moins codé une structure de graphe ? Et est-ce que tu comprends les algorithmes qu'il y a dans ton document pdf ? Est-ce que tu as compris comment utiliser le code que je t'ai donné ?

Quelle est la question ?

ma question est comment puisse-je programmer cette fonction en langage C

Ben il faut commencer à l'écrire dans un fichier (par exemple main.c) et compiler le tout par exemple avec code::blocks si tu es sous windows, et enfin l'exécuter.

Pour moi qui programme en C tes notations ne me parlent pas trop. Notamment
- comment sont notées les variables associées aux entrées de F, G,?
- quels sont les types des variables d'entrées ?
- quel est le type de retour de leur réponse ?
- que signifie ta notation T[F,G] ?
- que signifie ta notation "Fr F" ?

Je pense que dans un premier temps tu devrais t'exercer à faire quelques programme simples en langage C pour apprendre la syntaxe, apprendre à compiler etc... Et ensuite dans un second temps, tu pourras traduire ton programme.

Voici par exemple pour commencer à découvrir la syntaxe avec les fonctions :

#include <stdio.h> // permet d'appeler printf 

// Cette fonction reçoit un paramètre entier 
// (noté x dans le code de la fonction valeur_absolue 
// et retourne un entier x 
int valeur_absolue(int x){ 
  if (x < 0){ 
    return -x; 
  }else{ 
    return x; 
  } 
} 

// La fonction main est celle dans laquelle démarre 
// le programme 
int main(){ 
  // Début du programme 
  int y = -7; 
  printf("Coucou je vais calculer la valeur absolue de y = %d\n", y); 
  int val_abs_y = valeur_absolue(y); 
  printf("|y| = %d\n", val_abs_y); 
  printf("Et maintenant je quitte !\n"); 

  // Ceci met le programme en pause ce qui est utile sous windows 
  // quand on lance le programme depuis l'explorateur 
  // (sinon il quitte directement la console !) 
  getchar(); 

  // Le programme s'est terminé correctement 
  // Par convention on retourne 0 si tout va bien 
  return 0; 
}

Bonne chance

merci bien pour les remarques et les conseilles, moi c'est pas la première fois car j'ai déjà exercé sur programme simples
revenant à la fonction et pour vous dire que cette fonction fait parti de mon programme globale c'est une fonction intermédiaire car moi je veux faire un programme qui fait la lecture d'un fichier de données (données logique par exemples: portes logiques et leur entrées ...) et recupérer les données puis les traduire en un Diagramme Binaire et ansi de suite

pouvez vous m'aider???
merci de votre reponse

Bah ce que je ne comprends pas c'est comment t'aider en fait. Personnellement je n'ai pas compris le pseudo code que tu avais donné (cf les points que j'ai énuméré) et je n'ai pas compris ce qui te bloquait à ce stade si tu sais développer en C.

Pour lire un fichier il faut utiliser les fonctions fopen, fscanf et fclose. Parfois des outils comme getline peuvent être pratiques (mais pas forcément standard). Avant de parler de diagramme binaire il faudrait définir la structure de données associée en langage C (personnellement je ne sais pas ce que tu appelles un diagramme binaire, si tu as un lien à me faire parvenir...).

voila une doc sur les DDB
http://www.lirmm.fr/users/utilisateurs-lirmm/serge-pravossoudovitch

Ok je vois ce que c'est. Mais ça ne m'explique pas ce qui te bloque à ce stade et comment je peux t'aider.

Pour moi tu dois commencer par faire un module (ddb.h et ddb.c) qui permettra de gérer une structure de graphe de décision binaire. En C++ tu pourrais même exploiter la librairie boost pour éviter d'avoir à recoder une structure de graphe.

Ensuite pour l'algorithme en lui même vu que certaines notations ne sont pas claires je ne les comprends toujours pas trop.

Enfin vu que tu ne parles pas trop des formats de fichiers que tu as à traiter c'est difficile de te guider. Afin que tu ne te fasses pas de faux espoirs, je n'aurai clairement pas le temps de coder ce genre de chose pour toi. Je peux juste te débloquer si tu cales sur un point précis.

Il faut donc que tu m'indiques clairement un problème concret qui te gêne. Est-ce comment architecturer ton code ? Un problème de compilation ? Une erreur à l'exécution ? Etc...

Mes données sont dans un fichier txt qui représentent un Arbre de la manière suivante avec des portes logiques (OU par p*1,ET par p+2) et leurs entrées sur chaque ligne , en faite chaque ligne presente une porte logique ( portes ou des événements simple ou leurs complément (e+1 ou e-1) c'est des appellations)

Exemple :

p+0 e+1 e+2 e+3 p*1 p*2

p*1 p+4 p*5

p*2 p+6 p+7

p*3 p+8 p*9

p+4 e+16 e+18 g+10

p*5 e+4 e+5e+6 e+10 e+12 e+14

p+7 e+7 e+8 e+9 e+11 e+13 e+15

p+8 e+17 e+19 g+13

p*9 e+4 e+5

p+10 e+4 e+5 e+6 e+10 e+12 e+14

p*11 e-4 e-5 e-6

mon but est de faire le traitement pour transformer cette arbre à un arbre binaire et d'extraire les coupes minimales selon des algorithmes bien défini.
j'ai un algorithme qui fait ça: mais j'arrive pas à l'implementer

AdD-to-BDD(node)
Start
If (node is a basic event)
then
R := ite(node, 1, 0)
If not /* node is an operator*/
op := the operator associated with node
j := ?rst children of node
R := AdD-to-BDD(j )
For (for all the threads i of node and i is not egal to j)
Make
F := AdD-to-BDD(i )
R := BDD-OP(R,F,op) /* fonction qui définie*/
End for
End if
Return(R)
End

NB:la fonction qui définie BDD-OP(R,F,op) est définie en haut

merci bien

c'est très gentil de votre part,

svp comment je dois commencer la lecture et comment la je câble dans ma

structure de graphe les extraits que j'ai fait.

car j'ai reussi à faire la lecture mais pas le traitement car ce qui je fais est fopen mais reelement moi je veux le traitement et l'extraction de mes données

merci bien pour vos information

Bah c'est là que scanf entre en action pour extraire les triplets (lettre, opérateur, nombre). Arrives-tu déjà à extraire ces triplets ? Ensuite comme je ne sais pas comment se construit le graphe je ne peux pas trop te dire.

l'algorithme ci dessous explique la transformation;
pendant la lecture cmt puisse je faire cette extraction des triplets .
example svp

Ci-dessous le parseur, maintenant à toi de jouer :

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

int main(){
    FILE *fp = fopen("toto.txt","r");
    size_t n = 255;
    char *buffer  = malloc(n * sizeof(char));
    char *triplet = malloc(n * sizeof(char));
    char *pos;
    char lettre;
    char operande;
    int  valeur;
    unsigned no_ligne;

    for(no_ligne = 0; getline(&buffer, &n, fp) != -1; ++no_ligne){
        printf("Ligne %d: %s", no_ligne, buffer);
        pos = buffer;
        while(sscanf(pos, "%s ", triplet) == 1){
            if(sscanf(triplet,  "%c%c%d", &lettre, &operande, &valeur) == 3){
                printf("(%c, %c, %d)\n", lettre, operande, valeur);
            }
            pos += strlen(triplet) + 1;
        }   
    }

    free(buffer);
    free(triplet);
    return 0;
}

toto.txt

p+0 e+1 e+2 e+3 p*1 p*2
p*1 p+4 p*5

Résultat :

Ligne 0: p+0 e+1 e+2 e+3 p*1 p*2
(p, +, 0)
(e, +, 1)
(e, +, 2)
(e, +, 3)
(p, *, 1)
(p, *, 2)
Ligne 1: p*1 p+4 p*5 
(p, *, 1)
(p, +, 4)
(p, *, 5)

Bonne chance

bonjour,
merci pour votre aide,
qd je compile sous DevC++ il me rend des erreur suivantes:

cannot convert 'int*' to 'const char*' for argument '1' to 'int sscanf(const char*, const char*, ...)'
invalid conversion from 'void*' to 'int*'
'getline' undeclared (first use this function)

merci bien une autre fois

Pour getline elle n'est pas vraiment standard tu peux avoir un #define à faire ou devoir recoder la fonction.

https://linux.die.net/man/3/getline

#define _GNU_SOURCE
#include <stdio.h>

...

Pour le sscanf à mon avis tu t'es trompé en recopiant.

bonsoir et merci bien ,

pour les premières erreurs il fallait mettre :

char *buffer =(char*) malloc(n * sizeof(char));

char *triplet = (char*)malloc(n * sizeof(char));

mais pour la fonction :

getline(&buffer, &n, fp) != -1 j'arrive pas ;

je pense que mon compilateur Dev C++ ne l'accepte pas.

quel'elle est son equivalence ou bien comment on peut la remplacer.

Mr mamiemando ,

j'ai eu un code en C via un ami (cet ami je l'ai perdu)qui est plein de fonctions de

genre expliquer en haut et je veux bien le compiler mais malheureusement ça

marche pas car il manque quelques déclarations.(comme la struct de file à lire ....)

est ce que il y a une possibilité de vous l'envoyer pour me le corriger si c'est

possible votre email, car je vous trouve que vous pouvez bien m'aider.

merci d'avance

bonjour;

Est-ce que tu as au moins codé une structure de graphe ? Et est-ce que tu comprends les algorithmes qu'il y a dans ton document pdf ? Est-ce que tu as compris comment utiliser le code que je t'ai donné ?

mais bien sur j'ai compris les algorithme , mon probleme est comment je

l'implemente;

je vous explique:

Algorithm 1. Construction of the BDD from the FT

il fait la transformation d'un arbre (ici appelé FT or c'est Fault Tree =arbre de

défaillance) à un arbre binaire donc moi je dois introduire mon arbre sous form

txt par example puis mon algorithme test le type des données exemple les

triplets (node dans l'algorithme) ,si un triplet est une n'est pas une porte faire

ceci et cela sinon le triplet est une porte donc fais ceci et cela

et ansi de suite

por le deuxieme algorithme : c'est une fonction utilisée dans le premier

moi ce qui me bloque c'est comment commencer

c'est tout pas d'autre chose

merci bien

Il faut que tu commences par implémenter une structures d'arbre. Dans le cas d'un arbre binaire. On va faire deux fichiers pour ce faire : binary_tree.h et binary_tree.c par exemple. Notons l le fils gauche (left) et r le fils droit (right). Voici à quoi ressemblerait tree.h :

#ifndef BINARY_TREE_H
#define BINARY_TREE_H

typedef struct _binary_tree_node_t{
  struct _binary_tree_node_t *l; /// Fils gauche
  struct _binary_tree_node_t *r; /// Fils droit
  void *data; /// Adresse de la donnée stockée dans le noeud
} binary_tree_node_t;

typedef struct _binary_tree_t{
  binary_tree_node_t * root; /// Racine de l'arbre
} binary_tree_t;

// Noeuds
void free_binary_tree_node(binary_tree_node_t *node);
binary_tree_node_t * alloc_binary_tree_node();

// Arbre
binary_tree_t * alloc_binary_tree();
void free_binary_tree(binary_tree_t *tree);

// Alloue un noeud fils
binary_tree_node_t * add_child_node(
  binary_tree_node_t *node,
  char where /// 'r' ou 'l'
);

// Alloue un noeud parent de l et r
binary_tree_node_t * add_parent_node(
  binary_tree_node_t *l,
  binary_tree_node_t *r
);

#endif

Et le binary_tree.c :

#include "binary_tree.h"
#include <stdlib.h>

binary_tree_node_t * alloc_binary_tree_node(){
  return calloc(1, sizeof(binary_tree_node_t));
}

binary_tree_t * alloc_binary_tree(){
  return calloc(1, sizeof(binary_tree_t));
}

void free_binary_tree_node(binary_tree_node_t *node){
  if(node->r) free_binary_tree_node(node->r);
  if(node->l) free_binary_tree_node(node->l);
  free(node);
}

void free_binary_tree(binary_tree_t *tree){
  if(tree){
    if(tree->root){
      free_binary_tree_node(tree->root);
      free(tree->root);
    }
    free(tree);
  }
}

binary_tree_node_t * add_child_node(
  binary_tree_node_t *node, /// Le noeud sur lequel on greffe child
  char where /// 'l' ou 'r'
){
  binary_tree_node_t *child = NULL;
  if(node){
    binary_tree_node_t *p = NULL;
    switch(where){
      case 'l': p = node->l; break;
      case 'r': p = node->r; break;
    }
    if(p){
      child = alloc_binary_tree_node();
      p = child;
    }
  }
  return child;
}

binary_tree_node_t * add_parent_node(
  binary_tree_node_t *l,
  binary_tree_node_t *r
){
  binary_tree_node_t *parent = alloc_binary_tree_node();
  if(parent){
    parent->l = l;
    parent->r = r;
  }
  return parent;
}

Je n'ai pas testé le code c'est juste pour te donner de quoi démarrer mais dans l'idée ça ressemble à ça.

Ensuite quand tu parses ton fichier tu dois en déduire un morceau de l'arbre. Tu peux le construire en partant des feuilles en appelant comme il faut add_parent_node ou en partant de la racine en appelant add_child_node.

Bonne chance

merci pour le code mais ou est le main
je le voix pas

Il n'y en a pas pour la bonne et simple raison que ceci est un module. Un projet écrit en C comporte un fichier ".c" avec un main et à côté de ça des couples de fichiers ".h" et ".c" qu'on appelle module.

Je crois qu'il faut vraiment que tu lises un cours de langage C avant de commencer sinon tu vas bloquer toutes les 5min.