source: trunk/CrypPlugins/ComputeXZ/ComputeXZ.cs @ 2392

Last change on this file since 2392 was 2334, checked in by Matthäus Wander, 11 years ago

removed 1006 occurences of DisplayLevel in 218 files (see #122)

File size: 40.2 KB
Line 
1using System;
2using System.Collections;
3using System.Collections.Generic;
4using System.Linq;
5using System.Text;
6using Cryptool.PluginBase;
7using Cryptool.PluginBase.Analysis;
8using Cryptool.PluginBase.Cryptography;
9using Cryptool.PluginBase.Miscellaneous;
10using System.Text.RegularExpressions;
11using System.IO;
12using System.ComponentModel;
13using Cryptool.PluginBase.IO;
14using System.Windows.Controls;
15
16namespace Cryptool.ComputeXZ
17{
18    [Author("Abdeljalil Bourbahh", "bourbahh@yahoo.de", "Ruhr-Universitaet Bochum, Chair for System Security", "http://www.trust.rub.de/")]
19    [PluginInfo(false, "Alg. attack: Compute XZ", "compute the sets XZ for a Combiner of streamcipher", "ComputeXZ/DetailedDescription/Description.xaml", "ComputeXZ/Images/xzz.png")]
20    public class ComputeXZ : IAnalysisMisc
21    {
22        #region Private variables
23        private Hashtable outputXZ;
24        private Hashtable XZ;
25        private string outputString;
26        private ComputeXZSettings settings;
27        private string outputfunction;
28        private string memoryupdatefunction;
29        private int k;// Anzahl der LFSRSs-Ausgänge bei (k,l)-Combiner
30        private int startX = 0;
31        private bool isXZloaded = false;
32        private bool stop = false;
33        #endregion
34        #region Public interface
35        public ComputeXZ()
36        {
37            this.settings = new ComputeXZSettings();
38            ((ComputeXZSettings)(this.settings)).LogMessage += ComputeXZ_LogMessage;
39        }
40        public ISettings Settings
41        {
42            get { return (ISettings)this.settings; }
43            set { this.settings = (ComputeXZSettings)value; }
44        }
45        [PropertyInfo(Direction.InputData, "outputfunction", "outputfunction of Combiner", "", true, false, QuickWatchFormat.Text, null)]
46        public string Outputfunction
47        {
48            get { return this.outputfunction; }
49            set
50            {
51                if (value != outputfunction)
52                {
53                    this.outputfunction = value;
54                    OnPropertyChanged("Outputfunction");
55                }
56            }
57        }
58        [PropertyInfo(Direction.InputData, "memoryupdatefunction of combiner", " to input if combiner has memory ", "", false, false, QuickWatchFormat.Text, null)]
59        public string Memoryupdatefunction
60        {
61            get { return this.memoryupdatefunction; }
62            set
63            {
64                if (value != memoryupdatefunction)
65                {
66                    this.memoryupdatefunction = value;
67                    OnPropertyChanged("Memoryupdatefunction");
68                }
69            }
70        }
71        [PropertyInfo(Direction.OutputData, "the stes XZ as string", "to display XZ in Textoutput", "", false, false, QuickWatchFormat.Text, null)]
72        public string OutputString
73        {
74            get { return this.outputString; }
75            set
76            {
77                outputString = value;
78                OnPropertyChanged("OutputString");
79            }
80
81        }
82        [PropertyInfo(Direction.OutputData, " the sets XZ as (Hashtable(Z,XZ))", " to use as Input of Pugin compute Annihiators", "", false, false, QuickWatchFormat.Text, null)]
83        public Hashtable OutputXZ
84        {
85            get { return this.outputXZ; }
86            set
87            {
88                outputXZ = value;
89                OnPropertyChanged("OutputXZ");
90            }
91        }
92        #endregion
93        #region IPlugin members
94        public void Initialize()
95        {
96        }
97        public void Dispose()
98        {
99        }
100        public bool HasChanges
101        {
102            get { return settings.HasChanges; }
103            set { settings.HasChanges = value; }
104        }
105        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
106        private void GuiLogMessage(string message, NotificationLevel logLevel)
107        {
108            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(message, this, logLevel));
109        }
110        public UserControl Presentation
111        {
112            get { return null; }
113        }
114        public UserControl QuickWatchPresentation
115        {
116            get { return null; }
117        }
118        public void Stop()
119        {
120            try
121            {
122                if (!settings.IsXZcomputed) stop = true;
123            }
124            catch (Exception exception)
125            {
126                GuiLogMessage(exception.Message, NotificationLevel.Error);
127            }
128        }
129        public void PostExecution()
130        {
131        }
132        public void Pause()
133        {
134        }
135        public void PreExecution()
136        {
137        }
138        #endregion
139        #region INotifyPropertyChanged Members
140        public event PropertyChangedEventHandler PropertyChanged;
141        public void OnPropertyChanged(string name)
142        {
143            if (PropertyChanged != null)
144            {
145                PropertyChanged(this, new PropertyChangedEventArgs(name));
146            }
147        }
148        private void ComputeXZ_LogMessage(string msg, NotificationLevel logLevel)
149        {
150            if (OnGuiLogNotificationOccured != null)
151            {
152                OnGuiLogNotificationOccured(this, new GuiLogEventArgs(msg, this, logLevel));
153            }
154        }
155        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
156        private void ProgressChanged(double value, double max)
157        {
158            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
159        }
160        #endregion
161
162
163#pragma warning disable 67
164        public event StatusChangedEventHandler OnPluginStatusChanged;
165#pragma warning restore
166        #region private functions
167        public void Execute()
168        {
169            try
170            {
171                if (outputfunction != null && settings.SetOfOutputs != null)
172                {
173                    if (IsFunctionsExpValid() && (IsOutputsExpValid(settings.SetOfOutputs)))
174                    {
175                        stop = false;
176                        if (IsParameterNew() || !settings.IsXZcomputed)
177                        {
178                            if (memoryupdatefunction == null) ComputeSimpleXZ();
179                            else ComputeSetXZ();
180                        }
181                        else
182                        {
183                            if (!isXZloaded)
184                            {
185                                outputXZ = settings.SavedXZ;
186                                isXZloaded = true;
187                            }
188                        }
189                        if (!stop)
190                        {
191                            switch (settings.OutputSetting)
192                            {
193                                case 0:
194                                    DisplayXZ();
195                                    break;
196                                case 1:
197                                    PassXZ();
198                                    break;
199                                case 2:
200                                    DisplayXZ();
201                                    PassXZ();
202                                    break;
203                            }
204                        }
205                    }
206                }
207                else
208                {
209                    GuiLogMessage("not all mandatory parameters are provided", NotificationLevel.Error);
210                }
211            }
212            catch (Exception exception)
213            {
214                GuiLogMessage(exception.Message, NotificationLevel.Error);
215            }
216            finally
217            {
218                ProgressChanged(1, 1);
219            }
220        }
221        public void ComputeSetXZ()
222        {
223            int run = settings.SetOfOutputs.Length;
224            string simplef = SimplifyFunction(outputfunction);
225            string[] initY = memoryupdatefunction.Split(';');
226            int l = initY.Length;//l=memorysize
227            int Xlength = k * run;
228            ArrayList f = ConvertCombinerFunction(simplef, k, l);
229            ArrayList[] Y = new ArrayList[l];
230            for (int q = 0; q < l; q++)
231            {
232                string simpleY_k = SimplifyFunction(initY[q]);
233                Y[q] = ConvertCombinerFunction(simpleY_k, k, l);
234            }
235            InitializeXZ();
236            int Z;
237            for (int x = startX; x < exp(2, Xlength); x++)
238            {
239                if (stop)
240                {
241                    settings.SavedstartX = x;
242                    settings.SavedXZ = XZ;
243                    break;
244                }
245                bool[] X = ConstructBitsequence(x, Xlength);
246                for (int m = 0; m < exp(2, l); m++)
247                {
248                    Z = 0;
249                    bool[] M_i = ConstructBitsequence(m, l);
250                    bool[] savemi = new bool[l];
251                    for (int r = 0; r < run; r++)
252                    {// r
253                        bool z_i = EvaluateCombinerFunction(f, X, r, M_i);
254                        if (z_i) Z = Z + exp(2, run - r - 1);
255                        for (int i = 0; i < l; i++)
256                        {
257                            savemi[i] = M_i[i];
258                        }
259                        for (int j = 0; j < l; j++)
260                        {
261                            M_i[j] = EvaluateCombinerFunction(Y[j], X, r, savemi);
262                        }
263                    }
264                    ((ArrayList)XZ[Z]).Add(X);
265                }
266            }
267            if (!stop)
268            {
269                settings.IsXZcomputed = true;
270                outputXZ = new Hashtable();
271                foreach (DictionaryEntry dicEntry in XZ)
272                {
273                    int z = (int)dicEntry.Key;
274                    ArrayList xz = ReduceXZ((ArrayList)dicEntry.Value);
275                    outputXZ.Add(z, xz);
276                }
277                settings.SavedXZ = outputXZ;
278            }
279        }
280        public void ComputeSimpleXZ()
281        {
282            int run = settings.SetOfOutputs.Length;
283            string simplef = SimplifyFunction(outputfunction);
284            int Xlength = k * run;
285            ArrayList f = ConvertSimpleFunction(simplef, k);
286            InitializeXZ();
287            int Z;
288            for (int x = startX; x < exp(2, Xlength); x++)// für alle X
289            {
290                if (stop)
291                {
292                    settings.SavedstartX = x;
293                    settings.SavedXZ = XZ;
294                    break;
295                }
296                bool[] X = ConstructBitsequence(x, Xlength);
297                Z = 0;
298                for (int r = 0; r < run; r++)
299                {// r
300                    bool z = EvaluateOutputFunction(f, X, r);
301                    if (z) Z = Z + exp(2, run - r - 1);
302                }
303                ((ArrayList)XZ[Z]).Add(X);
304            }
305            if (!stop)
306            {
307                settings.IsXZcomputed = true;
308                outputXZ = new Hashtable();
309                foreach (DictionaryEntry dicEntry in XZ)
310                {
311                    int z = (int)dicEntry.Key;
312                    ArrayList xz = ReduceXZ((ArrayList)dicEntry.Value);
313                    outputXZ.Add(z, xz);
314                }
315                settings.SavedXZ = outputXZ;
316            }
317        }
318        public bool IsParameterNew()
319        {
320            if (memoryupdatefunction != null)
321            {
322                if (settings.Saveoutputfunction == outputfunction && settings.Savedmemoryupdatefunction == memoryupdatefunction && settings.Savedrunlength == settings.SetOfOutputs.Length)
323                    return false;
324            }
325            else
326            {
327                if (settings.Saveoutputfunction == outputfunction && settings.Savedrunlength == settings.SetOfOutputs.Length)
328                    return false;
329            }
330            return true;
331        }
332        public void DisplayXZ()
333        {
334            int[] outputsZ = GetOutputs(settings.SetOfOutputs);
335            StringBuilder b = new StringBuilder();
336            for (int i = 0; i < outputsZ.Length; i++)
337            {
338                int Z = outputsZ[i];
339                ArrayList XZ = (ArrayList)outputXZ[Z];
340                b.AppendLine("X_" + Bitpresentation(Z, settings.SetOfOutputs.Length));
341                b.AppendLine(TostringXZ(XZ));
342            }
343            outputString = b.ToString();
344            OnPropertyChanged("OutputString");
345        }
346        public void PassXZ()
347        {
348            int index = exp(2, settings.SetOfOutputs.Length);
349            ArrayList parameter = new ArrayList();
350            parameter.Add(settings.Saveoutputfunction);
351            if (memoryupdatefunction != null)
352                parameter.Add(settings.Savedmemoryupdatefunction);
353            else parameter.Add("");
354            parameter.Add(settings.SetOfOutputs.Length);
355            if (outputXZ.Contains(index)) outputXZ.Remove(index);
356            outputXZ.Add(index, parameter);
357            OnPropertyChanged("OutputXZ");
358        }
359        public int[] GetOutputs(string outputsexp)
360        {
361            char[] c = outputsexp.ToCharArray();
362            int[] Z;
363            int Zlength = 0;
364            int sum = 0;
365            ArrayList sumlist = new ArrayList();
366            for (int i = 0; i < c.Length; i++)
367            {
368                if (c[i] == '*')
369                {
370                    Zlength++;
371                    sumlist.Add(exp(2, c.Length - 1 - i));
372                }
373                else
374                {
375                    if (c[i] == '1') sum = sum + exp(2, c.Length - 1 - i);
376                }
377            }
378            Z = new int[exp(2, Zlength)];
379            for (int i = 0; i < exp(2, Zlength); i++)
380            {
381                bool[] bitseq = ConstructBitsequence(i, Zlength);
382                int dez_v = 0;
383                for (int j = 0; j < bitseq.Length; j++)
384                {
385                    if (bitseq[j]) dez_v = dez_v + (int)sumlist[j];
386                }
387                Z[i] = dez_v + sum;
388            }
389            return Z;
390        }
391        public void InitializeXZ()
392        {
393            int run = settings.SetOfOutputs.Length;
394            XZ = new Hashtable();
395            if (IsParameterNew())
396            {
397                startX = 0;
398                settings.IsXZcomputed = false;
399                for (int k = 0; k < exp(2, run); k++)
400                {
401                    ArrayList list = new ArrayList();
402                    XZ.Add(k, list);
403                }
404                settings.Saveoutputfunction = outputfunction;
405                settings.Savedmemoryupdatefunction = memoryupdatefunction;
406                settings.Savedrunlength = settings.SetOfOutputs.Length;
407            }
408            else
409            {
410                startX = settings.SavedstartX;
411                foreach (DictionaryEntry dicEntry in settings.SavedXZ)
412                {
413                    ArrayList list = (ArrayList)dicEntry.Value;
414                    XZ.Add((int)dicEntry.Key, list);
415                }
416            }
417        }
418        public ArrayList ReduceXZ(ArrayList primXZ)
419        {
420            ArrayList reducedXZ = new ArrayList();
421            int i = 0;
422            bool[] X = (bool[])primXZ[0];
423            while (i < primXZ.Count)
424            {
425                if (X.Equals((bool[])primXZ[i])) i++;
426                else
427                {
428                    reducedXZ.Add(X);
429                    X = (bool[])primXZ[i];
430                    i++;
431                }
432            }
433            reducedXZ.Add((bool[])primXZ[i - 1]);
434            return reducedXZ;
435        }
436        private bool EvaluateCombinerMonomial(bool[] monom, bool[] X, int i, bool[] M)
437        {
438            int Xindex = i * k;
439            for (int j = 0; j < k; j++)
440            {
441                if (monom[j] && !X[Xindex])
442                { return false; }
443                Xindex++;
444            }
445            for (int j = 0; j < M.Length; j++)
446            {
447                if (monom[k + j] && !M[j]) return false;
448            }
449            return true;
450        }
451        public bool EvaluateCombinerFunction(ArrayList function, bool[] X, int i, bool[] M)
452        {
453            bool erg = EvaluateCombinerMonomial((bool[])function[0], X, i, M);
454            for (int j = 1; j < function.Count; j++)
455            {
456                erg = erg ^ (EvaluateCombinerMonomial((bool[])function[j], X, i, M));
457            }
458            return erg;
459        }
460        private bool EvaluateSimpleMonomial(bool[] monom, bool[] X, int i)
461        {
462            int Xindex = i * k;
463            for (int j = 0; j < k; j++)
464            {
465                if (monom[j] && !X[Xindex])
466                { return false; }
467                Xindex++;
468            }
469            return true;
470        }
471        public bool EvaluateOutputFunction(ArrayList function, bool[] X, int i)
472        {
473            bool erg = EvaluateSimpleMonomial((bool[])function[0], X, i);
474            for (int j = 1; j < function.Count; j++)
475            {
476                erg = erg ^ (EvaluateSimpleMonomial((bool[])function[j], X, i));
477            }
478            return erg;
479        }
480        private ArrayList ConvertCombinerFunction(string function, int p, int q)
481        {
482            ArrayList convertfunction = new ArrayList();
483            int totalinput = p + q;
484            string[] monmials = function.Split('+');
485            for (int i = 0; i < monmials.Length; i++)
486            {
487                string[] literals = monmials[i].Split('*');
488                bool[] monom = new bool[totalinput];
489                for (int j = 0; j < monom.Length; j++)
490                {
491                    monom[j] = false;
492                }
493                for (int j = 0; j < literals.Length; j++)
494                {
495                    string literal = literals[j];
496                    if (literal.StartsWith("x"))
497                    {
498                        int index = Convert.ToInt16(literal.Substring(1, literal.Length - 1));
499                        if (index <= p) monom[index - 1] = true;
500                        else
501                        {
502                            GuiLogMessage("the indexes of variable must begin  from 1 and to be successiv ", NotificationLevel.Error);
503
504                        }
505                    }
506                    else
507                    {
508                        if (literal.StartsWith("m"))
509                        {
510                            int index = Convert.ToInt16(literal.Substring(1, literal.Length - 1));
511                            if (index <= p) monom[p + index - 1] = true;
512                            else
513                            {
514                                GuiLogMessage("the indexes of variable must begin  from 1 and to be successiv ", NotificationLevel.Error);
515
516                            }
517
518                        }
519                    }
520                }
521                bool containmonom = false;
522                for (int j = 0; j < convertfunction.Count; j++)
523                {
524                    if (monom.SequenceEqual((bool[])convertfunction[j]))
525                    {
526                        convertfunction.RemoveAt(j);
527                        containmonom = true;
528                        break;
529                    }
530                }
531                if (!containmonom)
532                {
533                    convertfunction.Add(monom);
534                }
535            }
536            return convertfunction;
537        }
538        private ArrayList ConvertSimpleFunction(string function, int p)
539        {
540            ArrayList convertfunction = new ArrayList();
541            string[] monomials = function.Split('+');
542            for (int i = 0; i < monomials.Length; i++)
543            {
544                string[] literals = monomials[i].Split('*');
545                bool[] monom = new bool[p];
546                for (int j = 0; j < monom.Length; j++)
547                {
548                    monom[j] = false;
549                }
550                for (int j = 0; j < literals.Length; j++)
551                {
552                    string literal = literals[j];
553                    if (literal.StartsWith("x"))
554                    {
555                        int index = Convert.ToInt16(literal.Substring(1, literal.Length - 1));
556                        if (index <= p) monom[index - 1] = true;
557                        else
558                        {
559                            GuiLogMessage("the indexes of variable must begin  from 1 and to be successiv ", NotificationLevel.Error);
560
561                        }
562                    }
563
564                }
565                convertfunction.Add(monom);
566            }
567            return convertfunction;
568        }
569        public bool IsFunctionsExpValid()// eingegebene Funktionen
570        {
571            if (memoryupdatefunction == null) return IsFunctionExpValid(outputfunction);
572            else return IsCombinerFunctionsExpvalid();
573        }
574        public bool IsFunctionExpValid(string f)//einfache combiner
575        {
576            Regex validExpression = new Regex("^(([\\!]?[\\(])*(((\\!?)(x))(\\d+)|1)[\\)]*(\\*|\\+))*(((\\!?)(x))(\\d+)|1)[\\)]*$");
577            f = f.Replace(" ", "");
578            if (!IsParenthesesvalid(f))
579            {
580                GuiLogMessage("the  Parentheses in " + f + "are not valid", NotificationLevel.Error);
581                return false;
582
583            }
584            if (!validExpression.IsMatch(f))
585            {
586                GuiLogMessage(f + "is not a legal  function expression", NotificationLevel.Error);
587                return false;
588            }
589            if (!IsSimpleIndicesValid(f)) return false;
590            return true;
591        }
592        public bool IsCombinerFunctionsExpvalid()//alle Combinerfunktionen
593        {
594            if (!IsCombinerFunctionExpValid(outputfunction))
595            {
596                return false;
597            }
598            memoryupdatefunction = memoryupdatefunction.Replace("\r\n", "");
599            if (memoryupdatefunction.EndsWith(";"))
600            { memoryupdatefunction = memoryupdatefunction.Remove(memoryupdatefunction.Length - 1, 1); }
601            string[] memoryupdatefunctionArray = memoryupdatefunction.Split(';');
602            for (int i = 0; i < memoryupdatefunctionArray.Length; i++)
603            {
604                if (!IsCombinerFunctionExpValid(memoryupdatefunctionArray[i])) return false;
605            }
606            if (!IsIndicesValid()) return false;
607            return true;
608
609        }
610        private bool IsOutputsExpValid(string expression)
611        {
612            Regex regExpression1 = new Regex("^(1|[\\*]|0)+$");
613            if (!regExpression1.IsMatch(expression))
614            {
615                GuiLogMessage("The expression of Set of output" + expression + "is not legal", NotificationLevel.Error);
616                return false;
617            }
618            return true;
619        }
620        public bool IsCombinerFunctionExpValid(string function)//eine Combinerfunktion
621        {
622            function = function.Replace(" ", "");
623            Regex validExpression = new Regex("^(([\\!]?[\\(])*(((\\!?)(x|m))(\\d+)|1)[\\)]*(\\*|\\+))*(((\\!?)(x|m))(\\d+)|1)[\\)]*$");
624            if (!IsParenthesesvalid(function))
625            {
626                GuiLogMessage("the  Parentheses in " + function + "is not valid", NotificationLevel.Error);
627                return false;
628            }
629            if (!validExpression.IsMatch(function))
630            {
631                GuiLogMessage(function + "is not a legal  function expression", NotificationLevel.Error);
632                return false;
633            }
634            return true;
635        }
636        private bool IsParenthesesvalid(string s)
637        {
638            CharEnumerator cn = s.GetEnumerator();
639            int overt = 0;
640            int closed = 0;
641            while (cn.MoveNext())
642            {
643                char c = cn.Current;
644                if (c == '(') overt++;
645                else
646                {
647                    if (c == ')') closed++;
648                    if (closed > overt) return false;
649                }
650            }
651            if (closed < overt) return false;
652            return true;
653        }
654        private bool IsIndicesValid()
655        {
656            string[] memoryupdatefunctionArray = memoryupdatefunction.Split(';');
657            int q = memoryupdatefunctionArray.Length;
658            string[] functions = new string[q + 1];
659            Array.Copy(memoryupdatefunctionArray, functions, q);
660            functions[q] = outputfunction;
661            ArrayList lfsrvar = new ArrayList();
662            ArrayList memvar = new ArrayList();
663            for (int n = 0; n < functions.Length; n++)
664            {
665                string[] monomials = Splitfunction(functions[n]);
666                for (int i = 0; i < monomials.Length; i++)
667                {
668                    string[] literals = monomials[i].Split('*');
669                    for (int j = 0; j < literals.Length; j++)
670                    {
671                        string literal = literals[j];
672                        if (literal.StartsWith("x"))
673                        {
674                            if (!lfsrvar.Contains(literal)) lfsrvar.Add(literal);
675                        }
676                        else
677                        {
678                            if (literal.StartsWith("m"))
679                            {
680                                if (!memvar.Contains(literal)) memvar.Add(literal);
681                            }
682                        }
683                    }
684
685                }
686            }
687            k = lfsrvar.Count;
688            foreach (string lit in lfsrvar)
689            {
690                int index = Convert.ToInt16(lit.Substring(1, lit.Length - 1));
691                if (!(1 <= index && index <= k))
692                {
693                    GuiLogMessage("the indexes of variable x_i must begin  from 1 and to be successiv ", NotificationLevel.Error);
694                    return false;
695                }
696            }
697            foreach (string mlit in memvar)
698            {
699                int index = Convert.ToInt16(mlit.Substring(1, mlit.Length - 1));
700                if (!(1 <= index && index <= q))
701                {
702                    GuiLogMessage("the indexes of variable m_i must begin  from 1 and to be successiv ", NotificationLevel.Error);
703                    return false;
704                }
705            }
706            return true;
707        }
708        private bool IsSimpleIndicesValid(string function)
709        {
710            ArrayList lfsrvar = new ArrayList();
711            string[] monomials = Splitfunction(function);
712            for (int i = 0; i < monomials.Length; i++)
713            {
714                string[] literals = monomials[i].Split('*');
715                for (int j = 0; j < literals.Length; j++)
716                {
717                    string literal = literals[j];
718                    if (literal.StartsWith("x"))
719                    {
720                        if (!lfsrvar.Contains(literal)) lfsrvar.Add(literal);
721
722                    }
723                }
724            }
725            k = lfsrvar.Count;
726            foreach (string lit in lfsrvar)
727            {
728                int index = Convert.ToInt16(lit.Substring(1, lit.Length - 1));
729                if (!(1 <= index && index <= k))
730                {
731                    GuiLogMessage("the indexes of variable x_i must begin  from 1 and to be successiv ", NotificationLevel.Error);
732                    return false;
733                }
734            }
735            return true;
736        }
737        public string TostringXZ(ArrayList xzset)
738        {
739            StringBuilder xzstring = new StringBuilder();
740            int Xlength = ((bool[])xzset[0]).Length;
741            foreach (bool[] X in xzset)
742            {
743                for (int j = 0; j < Xlength; j++)
744                {
745                    if (X[j]) xzstring.Append("1");
746                    else xzstring.Append("0");
747                }
748                xzstring.Append(",");
749            }
750            xzstring.Remove(xzstring.Length - 1, 1);
751            return xzstring.ToString();
752        }
753        #region functionparser
754        private string SimplifyFunction(string function)
755        {
756            return ReduceFunction(SimplifyParentheses(NegateTerms(function)));
757        }
758        public string SimplifyParentheses(string f)
759        {
760            CharEnumerator fchar = f.GetEnumerator();
761            int overt = 0;
762            int closed = 0;
763            int firstovert = 0;
764            int lastclosed = 0;
765            int index = 0;
766            if (!IsParenthesesNested(f)) return Expandproducts(f);
767            else
768            {
769                while (fchar.MoveNext())
770                {
771                    char c = fchar.Current;
772                    if (c == '(')
773                    {
774                        if (overt == 0)
775                        {
776                            firstovert = index;
777                            overt++;
778                        }
779                        else { overt++; }
780                    }
781                    if (c == ')')
782                    {
783                        if (overt == 1) overt = 0;
784                        else
785                        {
786                            closed++;
787                            if (closed == overt)
788                            {
789                                overt = 0;
790                                closed = 0;
791                                lastclosed = index;
792                                string toexpand = f.Substring(firstovert + 1, lastclosed - firstovert - 1);
793                                f = f.Remove(firstovert + 1, lastclosed - firstovert - 1);
794                                f = f.Insert(firstovert + 1, SimplifyParentheses(toexpand));
795                                f = SimplifyParentheses(f);
796                            }
797                        }
798                    }
799                    index++;
800                }
801                return f;
802            }
803        }
804        public bool IsParenthesesNested(string f)
805        {
806            CharEnumerator fchar = f.GetEnumerator();
807            bool overt = false;
808            while (fchar.MoveNext())
809            {
810                char c = fchar.Current;
811                if (c == '(')
812                {
813                    if (overt) return true;
814                    else overt = true;
815                }
816                if (c == ')' && overt) overt = false;
817            }
818            return false;
819
820        }
821        private string NegateTerms(string f)
822        {
823            int notindex = f.IndexOf("!");
824            while (notindex != -1)
825            {
826                string tonegate = f.Substring(notindex + 1, 1);
827                if (tonegate == "(")
828                {
829                    f = f.Remove(notindex, 1);
830                    f = f.Insert(notindex + 1, "1+");
831                }
832                else
833                {
834                    string subf = f.Substring(notindex + 1);
835                    string[] subterms = subf.Split('+');
836                    string[] subliterals = subterms[0].Split('*');
837                    string tonegatliteral = subliterals[0];
838                    f = f.Remove(notindex, 1 + tonegatliteral.Length);
839                    f = f.Insert(notindex, "(1+" + tonegatliteral + ")");
840                }
841                notindex = f.IndexOf("!");
842            }
843            return f;
844        }
845        private string Expandproducts(string f)
846        {
847            while (f.IndexOf("(") != -1)
848            {
849                int p1 = f.IndexOf("(");
850                int p2 = f.IndexOf(")");
851                if (!f.Substring(p1, p2 - p1 + 1).Contains('+'))
852                {
853                    f = f.Remove(p1, 1);
854                    f = f.Remove(p2 - 1, 1);
855                }
856                else
857                {
858                    string topar = f.Substring(0, p1);
859                    int begin = topar.LastIndexOf("+") + 1;
860                    int end = p1 + FindEndOfTerm(f.Substring(p1));
861                    string Term = f.Substring(begin, end - begin);
862                    f = f.Remove(begin, Term.Length);
863                    Term = ExpandOneTerm(Term);
864                    f = f.Insert(begin, Term);
865                }
866            }
867            return f;
868        }
869        public int FindEndOfTerm(string f)
870        {
871            CharEnumerator f_char = f.GetEnumerator();
872            int index = 0;
873            bool overt = false;
874            while (f_char.MoveNext())
875            {
876                char c = f_char.Current;
877                if (c == '(') overt = true;
878                if (c == ')') overt = false;
879                if (c == '+' && !overt) return index;
880                index++;
881            }
882            return f.Length;
883        }
884        public string ExpandOneTerm(string term)
885        {
886            int p1 = term.IndexOf('(');
887            int p2 = term.IndexOf(')');
888            ArrayList terms = new ArrayList();
889            while (p1 != -1)
890            {
891                string factor = term.Substring(p1, p2 - p1 + 1);
892                if (p2 != term.Length - 1) { term = term.Remove(p1, p2 - p1 + 2); }
893                else { term = term.Remove(p1, p2 - p1 + 1); }
894                terms.Add(factor);
895                p1 = term.IndexOf('(');
896                p2 = term.IndexOf(')');
897            }
898            string res = "";
899            if (terms.Count == 1) res = (string)terms[0];
900            else
901            {
902                res = "(" + LiftRightExpand(terms[0] + "*" + terms[1]) + ")";
903                for (int i = 2; i < terms.Count; i++)
904                {
905                    res = "(" + LiftRightExpand(res + "*" + terms[i]) + ")";
906                }
907            }
908            if (term != "")
909            {
910                if (term.EndsWith("*")) res = RightExpand(term + res);
911                else res = RightExpand(term + "*" + res);
912            }
913            else
914            {
915                res = res.Remove(0, 1);
916                res = res.Remove(res.Length - 1, 1);
917            }
918            return res;
919        }
920        public string RightExpand(string term)
921        {
922            int p1 = term.IndexOf("(");
923            int p2 = term.IndexOf(")");
924            string fact1 = term.Substring(0, p1);
925            string fact2 = term.Substring(p1 + 1, p2 - p1 - 1);
926            string[] sumands = fact2.Split('+');
927            string s = "";
928            for (int i = 0; i < sumands.Length; i++)
929            {
930                s = s + fact1 + sumands[i] + "+";
931            }
932            s = s.Remove(s.Length - 1);
933            return s;
934        }
935        public string LiftExpand(string term)
936        {
937            int p1 = term.IndexOf("(");
938            int p2 = term.IndexOf(")");
939            string fac1 = term.Substring(p2 + 1, term.Length - p2 - 1);
940            string fac2 = term.Substring(p1 + 1, p2 - p1 - 1);
941            string[] sumands = fac2.Split('+');
942            string s = "";
943            for (int i = 0; i < sumands.Length; i++)
944            {
945                s = s + sumands[i] + fac1 + "+";
946            }
947            s = s.Remove(s.Length - 1);
948            return s;
949        }
950        public string LiftRightExpand(string term)
951        {
952            int p1 = term.IndexOf("(");
953            int p2 = term.IndexOf(")");
954            string fac1 = term.Substring(0, p2 + 2);
955            string fac2 = term.Substring(p2 + 3, term.Length - p2 - 4);
956            string[] sumands = fac2.Split('+');
957            string s = "";
958            for (int i = 0; i < sumands.Length; i++)
959            {
960                s = s + LiftExpand(fac1 + sumands[i]) + "+";
961            }
962            s = s.Remove(s.Length - 1);
963            return s;
964        }
965        public string ReduceFunction(string function)
966        {
967            int index = function.IndexOf("+1*");
968            while (index != -1)
969            {
970                function = function.Remove(index + 1, 2);
971                index = function.IndexOf("+1*");
972            }
973            index = function.IndexOf("1*");
974            if (index == 0) function = function.Remove(index + 1, 2);
975            index = function.IndexOf("*1");
976            while (index != -1)
977            {
978                function = function.Remove(index, 2);
979                index = function.IndexOf("*1");
980            }
981            string[] monomials = function.Split('+');
982            string s = "";
983            for (int i = 0; i < monomials.Length; i++)
984            {
985                s = s + ReduceTerm(monomials[i]) + "+";
986            }
987            s = s.Remove(s.LastIndexOf("+"));
988            return s;
989        }
990        private string ReduceTerm(string term)
991        {
992            string[] literals = term.Split('*');
993            string s = "";
994            for (int i = 0; i < literals.Length - 1; i++)
995            {
996                if (literals[i] != "")
997                {
998                    for (int j = i + 1; j < literals.Length; j++)
999                    {
1000                        if (literals[i] == literals[j])
1001                        {
1002                            literals[j] = "";
1003                        }
1004                    }
1005                    s = s + literals[i] + "*";
1006                }
1007            }
1008            s = s + literals[literals.Length - 1];
1009            return s;
1010        }
1011        #endregion
1012        public int exp(int b, int e)
1013        {
1014            int res = 1;
1015            for (int i = 1; i <= e; i++)
1016            {
1017                res = res * b;
1018            }
1019            return res;
1020        }
1021        public bool[] ConstructBitsequence(int value, int length)
1022        {
1023            bool[] bitseq = new bool[length];
1024            if (value == 0)
1025            {
1026                for (int j = 0; j < length; j++)
1027                {
1028                    bitseq[j] = false;
1029                }
1030            }
1031            else
1032            {
1033                int i = length;
1034                while (value != 0)
1035                {
1036                    int div = value % 2;
1037                    if (div == 0) bitseq[i - 1] = false;
1038                    else bitseq[i - 1] = true;
1039                    i = i - 1;
1040                    value = value / 2;
1041                }
1042                if (i > 0)
1043                {
1044                    for (int j = 0; j < i; j++)
1045                    {
1046                        bitseq[j] = false;
1047                    }
1048                }
1049            }
1050            return bitseq;
1051        }
1052        public string Bitpresentation(int value, int length)
1053        {
1054            string s = "";
1055            int i = length;
1056            if (value == 0)
1057            {
1058                for (int j = 0; j < length; j++)
1059                {
1060                    s = s + "0";
1061                }
1062            }
1063            else
1064            {
1065                while (value != 0)
1066                {
1067                    int div = value % 2;
1068                    if (div == 0) s = "0" + s;
1069                    else s = "1" + s;
1070                    i = i - 1;
1071                    value = value / 2;
1072                }
1073                if (i > 0)
1074                {
1075                    for (int j = 0; j < i; j++)
1076                    {
1077                        s = "0" + s;
1078                    }
1079                }
1080            }
1081            return s;
1082        }
1083        private string[] Splitfunction(string function)
1084        {
1085            string s = function;
1086            int index = s.IndexOf('(');
1087            while (index != -1)
1088            {
1089                s = s.Remove(index, 1);
1090                index = s.IndexOf('(');
1091            }
1092            index = s.IndexOf(')');
1093            while (index != -1)
1094            {
1095                s = s.Remove(index, 1);
1096                index = s.IndexOf(')');
1097            }
1098            index = s.IndexOf('!');
1099            while (index != -1)
1100            {
1101                s = s.Remove(index, 1);
1102                index = s.IndexOf('!');
1103            }
1104            string[] monom = function.Split('+');
1105            return monom;
1106        }
1107
1108        #endregion
1109    }
1110}
Note: See TracBrowser for help on using the repository browser.