Simuler des équations logiques

Bonjour :D,

Pour un de mes logiciels, j'ai besoin de simuler des équations logiques. Je dois savoir faire des opérations AND et OR (pas plus). Cela revient respectivement à faire des * et des +.

J'ai des objets "Input" qui contiennent la valeur logique d'une entrée:
Code:

1 2 3 4 5 6 7 class Input { public bool Value { return mValue_b; } }
Je dois par exemple faire: G + (A * B * C + D * E ) * F + H.

Cette formule sera stockée dans un objet s'appelant Expression. Celui-ci a une méthode Evaluate qui permet de calculer le résultat des différents opérations (donc à chaque fois en fonction de l'opération à réaliser il faut appeler GetValue):
Code:

1 2 3 4 5 6 7 class Expression { public bool Evaluate() { ... } }
J'ai essayé de partir sur une liste avec un appel récursif pour évaluer mon expression mais ce n'est pas vraiment génial :D

Pour info, les formules sont générées à partir de diagramme Ladder.

Si quelqu'un pouvait m'aider à me dépatouiller, ce serait cool :ccool:

Bonjour,

J'ai du mal à comprendre; quel est ton problème concrètement ?

je ne comprend également pas pourquoi tu as besoin de faire de la récursivité ? peux-tu nous expliqué plus en détails ?

Salut

Personelement j'ai aussi du mal a comprendre l'assertion suivante

Citation:

Je dois savoir faire des opérations AND et OR (pas plus). Cela revient respectivement à faire des * et des +.

:koi:

Le plus propre serait d'utiliser la classe Expression.

Sinon, Ceci devrait marcher:

en prenant a,b,c, ... =" 1=1 " ou " 1=0 " suivant que A,B,C,...=True ou false,
après remplacement des + et * par "AND" et "OR "

Code:

1
2
3
4
5
6
7
8
9
10
11
12
string Expression = g+"OR"+"("+a+"AND"+b+"AND"+c+
       "AND" +d+"AND"+e+")"+"AND"+f+"OR"+g ;
MessageBox.show(EvaluateBooleanExpression(Expression).ToString() ;
... 
public static bool EvaluateBooleanExpression(string BooleanExpression)
{
  DataTable EvaluationTable=new DataTable() ;
  // L'instruction suivante columns.Add est peut-être inutile !
  EvaluationTable.Columns.Add("DUMMYCOL",System.Type.GetType("System.String")) ;
  EvaluationTable.Rows.Add(EvaluationTable.NewRow()) ;
  return EvaluationTable.Select(BooleanExpression).Length!=0 ;
}

Salut :mrgreen:,

Je pense que je n'ai pas été assez clair. En fait je veux créer un objet qui représente un "calcul à réaliser". J'ai des variables qui n'arrêtent pas de changer dans mon système, ce sont mes entrées et à chaque cycle, il faut que je recalcule des expressions. Il s'agit tout le temps des mêmes calculs. C'est pour ça que je veux créer un objet représentant ces calculs.

Voici mon code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    //G + (A * B * C + D * E ) * F + H
    public abstract class OperationBase
    {
        public enum OperationType { UNKNOW, VALUE, GROUP };
 
        //Fonction abstraite
        public abstract bool Evaluate();
 
        //Type de l'objet: valeur ou groupe?
        public OperationType Type   {   get { return mOperationType_E; }}
 
        //Variables
        protected OperationType mOperationType_E = OperationType.UNKNOW;
    }

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
    public class OperationVALUE : OperationBase
    {
        public OperationVALUE(PLCInputInstruction PLCInputInstruction_O)
        {
            mOperationType_E = OperationType.VALUE;
            mPLCInputInstruction_O = PLCInputInstruction_O;
        }
 
        public override bool Evaluate()
        {
            return mPLCInputInstruction_O.Value;
        }
 
        PLCInputInstruction mPLCInputInstruction_O = null;
    }

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
    public class OperationGROUP : OperationBase
    {
        public enum OperationGroupType { UNKNOW, AND, OR };
 
        public OperationGROUP(OperationBase[] Operations_O)
        {
            mStructure_O = (OperationBase[])Operations_O.Clone();
            mOperationGroupType_O = OperationGroupType.UNKNOW;
        }
 
        public OperationGroupType GroupType { get { return mOperationGroupType_O; } }
 
        public override bool Evaluate()
        {
            bool Value_b;
 
            for (int i = 0; i < mStructure_O.Length; i++)
            {
                OperationBase OperationBase_O = mStructure_O[i];
                if (OperationBase_O.Type == OperationType.VALUE)
                {
                    OperationVALUE OperationValue_O = (OperationVALUE)OperationBase_O;
 
                }
                else //il s'agit d'un groupe d'opération
                {
                    OperationGROUP OperationGroup_O = (OperationGROUP)OperationBase_O;
                    switch (OperationGroup_O.GroupType)
                    {
                        case OperationGroupType.AND:
                            break;
 
                        case OperationGroupType.OR:
                            break;
                    }
                }
            }
 
            return Value_b;
        }
 
        OperationBase[] mStructure_O = null;
        OperationGroupType mOperationGroupType_O;
    }
 
    public class OperationGroupAND : OperationGROUP
    {
    }
 
    public class OperationGroupOR : OperationGROUP
    {
    }

où l'objet PLCInputInstruction représente une entrée de mon système (en simplifier):

Code:

1
2
3
4
5
6
7
8
9
10
    public class PLCInputInstruction
    {
        public bool Value   
        {   
            get { return mValue_; }
            set { mValue_b = value; }
        }
 
        bool mValue_b = false;
    }

Code:

1
2
3
4
    /* OperationBase  => OperationValue
                      => OperationGroup  => OperationGroupAND
                                         => OperatonGroupOR
    //*/

Je bloque dans la fonction Evaluate. Mettons que mon objet représente l'expression suivante: G + (A * B * C + D * E ) * F + H.
A,B,C,...,H étant des entrées de mon système: PLCInputInstruction.
*: AND
+: OR

Toutes ses entrées seront stockées dans un objet de type OperationValue qui dérive de l'objet OperationBase.
La fonction Evaluate retournera tout simplement la valeur de l'entrée (propriété Value). Donc c'est facile.

Lorsque j'ai des opérations à réaliser, j'utilise des objets OperationGroup qui dérive également de l'objet OperationBase.

Lorsqu'on a une opération AND à réaliser, il ne s'agit pas simplement de faire des AND entre mes entrées, cela peut également être des opérations AND entre d'autres groupes d'opération. Je ne sais pas si je suis clair?
C'est pour ça que je voulais utiliser la récursivité.

Tant que tu n'es pas sur un objet de type OperationValue, tu appelles la fonction Evaluate.

Voilà j'espère que c'est plus clair :calim2:

Si tu as comme expression : "G + (A * B * C + D * E ) * F + H", tu peux:

calculer séparément chacun des différents éléments A, B, C D, E, F et G
remplacer la lettre de l'élément par la valeur TRUE ou FALSE résultant du calcul,
évaluer comme indiqué dans le code de mon message précédent l'expression booléene globale en remplacant:
- TRUE par " 1=1 "
- FALSE par " 1=0 "
- "+" par "OR"
- "*" par "AND"

Et pas besoin de récursivité ;)

Salut,

J'ai trouvé :D. I'm the king of the world :ccool:

Graffito, merci pour ta réponse mais je ne souhaite pas faire un parseur (enfin après si, mon expression sera générée en parsant des programmes).
A chaque fois, j'écris mes expressions à calculer et après, je les recalcule plus ou moins 10000 fois par seconde. Ces équations seront générées à partir de Grafcet ou de Ladder ou de LIST ou de StructuredText. Tous ces langages sont dédiés aux automates programmables.

Je poste le code source.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
 
namespace AutomationLib
{
    /* OperationBase  => OperationValue
                      => OperationGroup  => OperationGroupAND
                                         => OperatonGroupOR
    //*/
 
    //G + (A * B * C + D * E ) * F + H
    public abstract class OperationBase
    {
        public enum OperationType { UNKNOW, VALUE, GROUP };
 
        //Fonctions abstraites
        public abstract bool Evaluate();
        public abstract override string ToString();
        public abstract OperationGroup AND(OperationBase[] Operations_O);
        public abstract OperationGroup OR(OperationBase[] Operations_O);
 
        public OperationGroup AND(OperationBase Operation_O)
        {
            return this.AND(new OperationBase[] { Operation_O });
        }
 
        public OperationGroup OR(OperationBase Operation_O)
        {
            return this.OR(new OperationBase[] { Operation_O });
        }
 
        //Type de l'objet: valeur ou groupe?
        public OperationType Type   {   get { return mOperationType_E; }}
 
        //Variables
        protected OperationType mOperationType_E = OperationType.UNKNOW;
 
        protected OperationBase[] JoinArrays(OperationBase[] FirstArray_O, OperationBase[] SecondArray_O)
        {
            /* On calcule la nouvelle taille du tableau */
            int  FirstNumberOfElements_i = FirstArray_O.Length;
            int SecondNumberOfElements_i = SecondArray_O.Length;
 
            int NewNumberOfElements_i = FirstNumberOfElements_i + SecondNumberOfElements_i;
 
            /* On crée le nouveau tableau */
            OperationBase[] mNewStructure_O = new OperationBase[NewNumberOfElements_i];
 
            /* On copie le premier tableau */
            for (int i = 0; i < FirstNumberOfElements_i; i++)
            {
                mNewStructure_O[i] = FirstArray_O[i];
            }
 
            /* On copie le second tableau */
            for (int i = 0; i < SecondNumberOfElements_i; i++)
            {
                mNewStructure_O[i + FirstNumberOfElements_i] = SecondArray_O[i];
            }
 
            return mNewStructure_O;
        }
    }
 
    public class OperationValue : OperationBase
    {
        public OperationValue(PLCInputInstruction PLCInputInstruction_O)
        {
            mOperationType_E = OperationType.VALUE;
            mPLCInputInstruction_O = PLCInputInstruction_O;
        }
 
        public override bool Evaluate()
        {
            return mPLCInputInstruction_O.Value;
        }
 
        public override string ToString()
        {
#if DEBUG
            return "OPERATIONVALUE[" + mPLCInputInstruction_O.ToString() + "]";
#else
            return mPLCInputInstruction_O.ToString();
#endif
        }
 
        public override OperationGroup AND(OperationBase[] Operations_O)
        {
            return new OperationGroupAND(JoinArrays(new OperationBase[]{this}, Operations_O));
        }
 
        public override OperationGroup OR(OperationBase[] Operations_O)
        {
            return new OperationGroupOR(JoinArrays(new OperationBase[]{this}, Operations_O));
        }
 
        PLCInputInstruction mPLCInputInstruction_O = null;
    }
 
    public abstract class OperationGroup : OperationBase
    {
        public enum OperationGroupType { UNKNOW, AND, OR };
 
        public OperationGroup(OperationBase[] Operations_O)
        {
            mStructure_O = (OperationBase[])Operations_O.Clone();
            mOperationType_E = OperationType.GROUP;
            mOperationGroupType_O = OperationGroupType.UNKNOW;
        }
 
        public OperationGroupType GroupType { get { return mOperationGroupType_O; } }
 
        protected OperationBase[] mStructure_O = null;
        protected OperationGroupType mOperationGroupType_O;
    }
 
    public class OperationGroupAND : OperationGroup
    {
        public OperationGroupAND(OperationBase[] Operations_O) 
            : base(Operations_O)
        {
            mOperationGroupType_O = OperationGroupType.AND;
        }
 
        public override bool Evaluate()
        {
            bool Value_b = true;
 
            for (int i = 0; i < mStructure_O.Length; i++)
            {
                OperationBase OperationBase_O = (OperationBase)mStructure_O[i];
                Value_b = Value_b && OperationBase_O.Evaluate();
            }
 
            return Value_b;
        }
 
        public override string ToString()
        {
            String Value_Str = "";
 
            int NumberItems_L = mStructure_O.Length;
 
            for (int i = 0; i < NumberItems_L - 1; i++)
            {
                Value_Str = Value_Str + mStructure_O[i].ToString() + " * ";
            }
 
            Value_Str += mStructure_O[NumberItems_L - 1].ToString();// + ")";
 
            return Value_Str;
        }
 
        public override OperationGroup OR(OperationBase[] NewOperations_O)
        {
            /* on a un groupe d'opération AND et on veut lui ajouter un OR
             * on va donc créer un groupe OR*/
            OperationBase[] OperationBase_O = new OperationBase[2];
            OperationBase_O[0] = new OperationGroupAND(mStructure_O);
            OperationBase_O[1] = new OperationGroupOR(NewOperations_O);
 
            return new OperationGroupOR(OperationBase_O);
        }
 
        public override OperationGroup AND(OperationBase[] NewOperations_O)
        {
            /* on a déjà un groupe d'opération AND et on veut lui en ajouter
             * on va donc étendre notre tableau de NewOperations_O.Length
             * */
            return new OperationGroupAND(JoinArrays(mStructure_O, NewOperations_O));
        }
    }
 
    public class OperationGroupOR : OperationGroup
    {
        public OperationGroupOR(OperationBase[] Operations_O) 
            : base(Operations_O)
        {
            mOperationGroupType_O = OperationGroupType.OR;
        }
 
        public override bool Evaluate()
        {
            bool Value_b = false;
 
            for (int i = 0; i < mStructure_O.Length; i++)
            {
                OperationBase OperationBase_O = (OperationBase)mStructure_O[i];
                Value_b = Value_b || OperationBase_O.Evaluate();
            }
 
            return Value_b;
        }
 
        public override string ToString()
        {
            String Value_Str = "";
 
            int NumberItems_L = mStructure_O.Length;
 
            if (NumberItems_L > 1)
                Value_Str = "(";
 
            for (int i = 0; i < NumberItems_L - 1; i++)
            {
                Value_Str = Value_Str + mStructure_O[i].ToString() + " + ";
            }
 
            Value_Str += mStructure_O[NumberItems_L - 1].ToString();
 
            if (NumberItems_L > 1)
                Value_Str += ")";
 
            return Value_Str;
        }
 
        public override OperationGroup AND(OperationBase[] NewOperations_O)
        {
            /* on a un groupe d'opération OR et on veut lui ajouter un AND
             * on va donc créer un groupe AND*/
            OperationBase[] OperationBase_O = new OperationBase[2];
            OperationBase_O[0] = new OperationGroupOR(mStructure_O);
            OperationBase_O[1] = new OperationGroupAND(NewOperations_O);
 
            return new OperationGroupAND(OperationBase_O);
        }
 
        public override OperationGroup OR(OperationBase[] NewOperations_O)
        {
            /* on a déjà un groupe d'opération OR et on veut lui en ajouter
             * on va donc étendre notre tableau de NewOperations_O.Length
             * */
            return new OperationGroupOR(JoinArrays(mStructure_O, NewOperations_O));
        }
    }
}

et un petit code pour l'utiliser:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
static void TestOperation()
        {
            PLCInputMemory A = new PLCInputMemory(new PLCRegister()); A.Name = "A"; Console.WriteLine(A.ToString()); Console.WriteLine("A = " + A.GetValue().ToString());
            PLCInputMemory B = new PLCInputMemory(new PLCRegister()); B.Name = "B"; Console.WriteLine(B.ToString()); Console.WriteLine("B = " + B.GetValue().ToString());
            PLCInputMemory C = new PLCInputMemory(new PLCRegister()); C.Name = "C"; Console.WriteLine(C.ToString()); Console.WriteLine("C = " + C.GetValue().ToString());
            PLCInputMemory D = new PLCInputMemory(new PLCRegister()); D.Name = "D"; Console.WriteLine(D.ToString()); Console.WriteLine("D = " + D.GetValue().ToString());
 
            PLCInputInstructionLD IA  = new PLCInputInstructionLD(A); Console.WriteLine(IA.ToString());
            PLCInputInstructionLD IB = new PLCInputInstructionLD(B); Console.WriteLine(IB.ToString());
            PLCInputInstructionLD IC = new PLCInputInstructionLD(C); Console.WriteLine(IC.ToString());
            PLCInputInstructionLD ID = new PLCInputInstructionLD(D); Console.WriteLine(ID.ToString());
            //Autres instructions...
            //PLCInputInstructionLDN IB = new PLCInputInstructionLDN(B); Console.WriteLine(IB.ToString());
            //PLCInputInstructionLDR IC = new PLCInputInstructionLDR(C); Console.WriteLine(IC.ToString());
            //PLCInputInstructionLDF ID = new PLCInputInstructionLDF(D); Console.WriteLine(ID.ToString());
 
            OperationValue OpA = new OperationValue(IA); Console.WriteLine(OpA.ToString()); Console.WriteLine("A = " + OpA.Evaluate().ToString());
            OperationValue OpB = new OperationValue(IB); Console.WriteLine(OpB.ToString()); Console.WriteLine("B = " + OpB.Evaluate().ToString());
            OperationValue OpC = new OperationValue(IC); Console.WriteLine(OpC.ToString()); Console.WriteLine("C = " + OpC.Evaluate().ToString());
            OperationValue OpD = new OperationValue(ID); Console.WriteLine(OpD.ToString()); Console.WriteLine("D = " + OpD.Evaluate().ToString());
 
            /* (A*B*D + C) * B * D + C */
            Console.WriteLine("Test opération");
            string dbgstr;
 
            //A
            OperationBase expression = OpA; dbgstr = expression.ToString() + " = " + expression.Evaluate().ToString(); Console.WriteLine(dbgstr);
            //A*B
            expression = expression.AND(OpB); dbgstr = expression.ToString() + " = " + expression.Evaluate().ToString(); Console.WriteLine(dbgstr);
            //A*B*D
            expression = expression.AND(OpD); dbgstr = expression.ToString() + " = " + expression.Evaluate().ToString(); Console.WriteLine(dbgstr);
            //A*B*D+C
            expression = expression.OR(OpC); dbgstr = expression.ToString() + " = " + expression.Evaluate().ToString(); Console.WriteLine(dbgstr);
            //(A*D*D+C)*B
            expression = expression.AND(OpB); dbgstr = expression.ToString() + " = " + expression.Evaluate().ToString(); Console.WriteLine(dbgstr);
            //(A*D*D+C)*B*D
            expression = expression.AND(OpD); dbgstr = expression.ToString() + " = " + expression.Evaluate().ToString(); Console.WriteLine(dbgstr);
            //(A*D*D+C)*B*D+C
            expression = expression.OR(OpC); dbgstr = expression.ToString() + " = " + expression.Evaluate().ToString(); Console.WriteLine(dbgstr);
 
 
            /* générer table de vérité */
            Console.WriteLine("(A*D*D+C)*B*D+C");
            GenererTableVerite(new PLCInputMemory[]{A,B,C,D}, expression);
 
            //(A*D*D+C)*B*D+C = A*B*D+C
            Console.WriteLine("(A*D*D+C)*B*D+C = A*B*D+C");
            expression = OpA.AND(OpB).AND(OpD).OR(OpC);
            GenererTableVerite(new PLCInputMemory[] { A, B, C, D }, expression);
 
            //A*D
            Console.WriteLine("A*D");
            expression = OpA.AND(OpD);
            GenererTableVerite(new PLCInputMemory[] { A, D }, expression);
 
            //A+C
            Console.WriteLine("A+C");
            expression = OpA.OR(OpC);
            GenererTableVerite(new PLCInputMemory[] { A, C }, expression);
 
            Pause();
        }
 
        static void GenererTableVerite(PLCInputMemory[] Inputs_O, OperationBase Expression_O)
        {
            int NbBits = Inputs_O.Length;
            int NbPossibilities = 1 << Inputs_O.Length;
 
            Console.WriteLine("Table de vérité:");
            Console.WriteLine("Equation: " + Expression_O.ToString());
            Console.WriteLine("Nombre d'entrées: " + NbBits);
            Console.WriteLine("Nombre de possibilités: " + NbPossibilities);
 
            /* génération de toutes les possibilités */
            bool[][] Possibilities_b = new bool[NbPossibilities][];
 
            for (int i = 0; i < NbPossibilities; i++)
            {
                Possibilities_b[i] = new bool[NbBits];
            }
 
            /* On remplit le tableau */
            bool value_b = false;
            int count_i = 0;
            int base_i = 2; //2,4,8,16, etc.
            int column_i = NbBits - 1;
            for (int j = 0; j < NbBits; j++)
            {
                count_i = 0;
                base_i = 1 << j;
 
                for (int i = 0; i < NbPossibilities; i++)
                {
                    Possibilities_b[i][column_i] = value_b;
                    count_i++;
 
                    if (count_i == base_i)
                    {
                        count_i = 0;
                        value_b = !value_b;
                    }
                }
 
                column_i--;
            }
 
            for (int i = 0; i < NbPossibilities; i++)
            {
                for (int j = 0; j < NbBits; j++)
                {
                    bool v = Possibilities_b[i][j];
                    if (v) Console.Write("1");
                    else Console.Write("0");
                }
 
                Console.Write(" = ");
 
                for (int j = 0; j < NbBits; j++)
                {
                    Inputs_O[j].SetValue(Possibilities_b[i][j]);
                }
 
                if (Expression_O.Evaluate())
                    Console.Write("1");
                else
                    Console.Write("0");
 
                Console.Write("\n");
            }
            Console.WriteLine();
        }

Voilà, j'espère que ce n'est pas trop sur-compliqué...

Pour simplifier, on peut créer des expressions de cette manière:

Code:

1
2
3
4
5
6
7
8
9
10
11
            //A*C + B*D
            Console.WriteLine("A*C + B*D");
            OperationBase op1 = OpA.AND(OpC);
            OperationBase op2 = OpB.AND(OpD);
            expression = op2.OR(op1);
            GenererTableVerite(new PLCInputMemory[] { A, B, C, D }, expression);
 
            //A*B + C*D
            Console.WriteLine("A*C + B*D");
            expression = (OpA.AND(OpB)).OR(OpC.AND(OpD));
            GenererTableVerite(new PLCInputMemory[] { A, B, C, D }, expression);

Comme on peut le voir, il y a 2 méthodes.