source: trunk/CrypPlugins/SystemOfEquations/SystemOfEquations.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: 26.9 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.SystemOfEquations
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: System of equations", "generate a System of equation for algebric attack against Combiner of streamcipher", "SystemOfEquations/DetailedDescription/Description.xaml",
20 "SystemOfEquations/Images/soe.png")]
21    public class SystemOfEquations : IAnalysisMisc
22    {
23        #region Private variables
24        private SystemOfEquationsSettings settings;
25        private Hashtable inputZfunctions;// Input
26        private string[] keystreams;
27        private string[] feedbackpolynomials;
28        private string[] lfsrsoutputs;
29        private string outputString;
30        #endregion
31        public SystemOfEquations()
32        {
33            this.settings = new SystemOfEquationsSettings();
34            ((SystemOfEquationsSettings)(this.settings)).LogMessage += SystemOfEquations_LogMessage;
35        }
36        public ISettings Settings
37        {
38            get { return (ISettings)this.settings; }
39            set { this.settings = (SystemOfEquationsSettings)value; }
40        }
41        [PropertyInfo(Direction.InputData, "Z-functions ", "Z-functions as  Hashtable(Z ,FZ) delivred from plugin compute annihilators", "", true, false, QuickWatchFormat.Text, null)]
42        public Hashtable InputAhnilators
43        {
44            get { return this.inputZfunctions; }
45            set
46            {
47                if (value != inputZfunctions)
48                {
49                    this.inputZfunctions = value;
50                    OnPropertyChanged("InputAhnilators");
51                }
52            }
53        }
54        [PropertyInfo(Direction.OutputData, "System of equation function", " the variables are die Keys Bits (k1,k2..kn)=initial statue of LFSRs", "", false, false, QuickWatchFormat.Text, null)]
55        public string OutputString
56        {
57            get { return this.outputString; }
58            set
59            {
60                outputString = value;
61                OnPropertyChanged("OutputString");
62            }
63        }
64        #region IPlugin members
65        public void Initialize()
66        {
67        }
68        public void Dispose()
69        {
70        }
71        public bool HasChanges
72        {
73            get { return settings.HasChanges; }
74            set { settings.HasChanges = value; }
75        }
76        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
77
78        private void GuiLogMessage(string message, NotificationLevel logLevel)
79        {
80            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(message, this, logLevel));
81        }
82        public UserControl Presentation
83        {
84            get { return null; }
85        }
86
87        public UserControl QuickWatchPresentation
88        {
89            get { return null; }
90        }
91        public void Stop()
92        {
93        }
94        public void Pause()
95        {
96        }
97        public void PostExecution()
98        {
99            Dispose();
100        }
101
102        public void PreExecution()
103        {
104            Dispose();
105        }
106        #endregion
107        #region INotifyPropertyChanged Members
108        public void OnPropertyChanged(string name)
109        {
110            if (PropertyChanged != null)
111            {
112                PropertyChanged(this, new PropertyChangedEventArgs(name));
113            }
114        }
115        public event PropertyChangedEventHandler PropertyChanged;
116
117        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
118        private void ProgressChanged(double value, double max)
119        {
120            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
121        }
122        private void SystemOfEquations_LogMessage(string msg, NotificationLevel logLevel)
123        {
124            if (OnGuiLogNotificationOccured != null)
125            {
126                OnGuiLogNotificationOccured(this, new GuiLogEventArgs(msg, this, logLevel));
127            }
128        }
129        #endregion
130        #region IPlugin Members
131#pragma warning disable 67
132        public event StatusChangedEventHandler OnPluginStatusChanged;
133#pragma warning restore
134        public void Execute()
135        {
136            try
137            {
138                if (inputZfunctions != null && settings.Feedbackpolynomials != null && settings.Lfsrsoutputs != null && settings.Keystream != null)
139                {
140                    if (IsLFSRsParameterlvalid() && IsKeyStreamValid())
141                    {
142                        int runlength = GetRunlength(inputZfunctions, lfsrsoutputs);
143                        if (runlength != 0)
144                        {
145                            Combiner combiner = new Combiner(feedbackpolynomials, lfsrsoutputs);
146                            String output = "";
147                            ArrayList[] keystream = StructureKeyStream(runlength);
148                            int begintime = 1;
149                            ArrayList ts = keystream[0];
150                            ArrayList keys = keystream[1];
151                            for (int j = 0; j < ts.Count; j++)
152                            {
153                                int t = (int)ts[j];
154                                int time = t - begintime;
155                                combiner.Clock(time);
156                                int[] Zset = (int[])keys[j];
157                                begintime = t + Zset.Length * runlength;
158                                for (int i = 0; i < Zset.Length; i++)
159                                {
160                                    ArrayList[][] Kt = combiner.Outputs(runlength);
161                                    ArrayList Ktstring = combiner.SortOutput(Kt);
162                                    int outpusize = Ktstring.Count / runlength;
163                                    if (inputZfunctions[Zset[i]] != null)
164                                    {
165                                        string s = ReplaceVariables((ArrayList)inputZfunctions[Zset[i]], Ktstring);
166                                        output = output + s;
167                                    }
168                                    else
169                                    {
170                                        output = output + "ahnilators correspond to Z= " + Bitpresentation(Zset[i], runlength) + "is not provided" + "\r\n";
171                                    }
172                                }
173                            }
174                            outputString = output;
175                            OnPropertyChanged("OutputString");
176                        }
177                        else
178                        {
179                            GuiLogMessage("No Z-function is provided", NotificationLevel.Error);
180                        }
181                    }
182                }
183                else
184                {
185                    GuiLogMessage("not all mandatory Input is provided", NotificationLevel.Error);
186                }
187            }
188            catch (Exception exception)
189            {
190                GuiLogMessage(exception.Message, NotificationLevel.Error);
191            }
192            finally
193            {
194                ProgressChanged(1, 1);
195            }
196        }
197        public string ReplaceVariables(ArrayList Zfunctions, ArrayList lfsroutput)
198        {
199            StringBuilder outputstring = new StringBuilder();
200            foreach (ArrayList Zfunction in Zfunctions)
201            {
202                string equation = "";
203                foreach (bool[] monomial in Zfunction)
204                {
205                    string s = "";
206                    for (int i = 0; i < monomial.Length; i++)
207                    {
208                        if (monomial[i]) s = s + (string)lfsroutput[i] + "*";
209                    }
210                    if (s == "") { s = "" + 1; }
211                    else { s = s.Remove(s.LastIndexOf("*")); }
212                    equation = equation + s + "+";
213                }
214                equation = SimplifyFunction(equation.Remove(equation.LastIndexOf("+")));
215                outputstring.AppendLine(equation + "=0");
216            }
217            return outputstring.ToString();
218        }
219        public ArrayList[] StructureKeyStream(int run)
220        {
221            ArrayList timeseq = new ArrayList();
222            ArrayList Zseq = new ArrayList();
223            for (int j = 0; j < keystreams.Length; j++)
224            {
225                string[] streami = keystreams[j].Split(',');
226                int t_i = Convert.ToInt16(streami[0]);
227                timeseq.Add(t_i);
228                string streamseq = streami[1];
229                int index = 0;
230                int seqlength = streamseq.Length;
231                int Zcount = seqlength / run;
232                int[] Z = new int[Zcount];
233                for (int i = 0; i < Zcount; i++)
234                {
235                    string Zstring = streamseq.Substring(index, run);
236                    int Zi = IntValue(Zstring);
237                    Z[i] = Zi;
238                    index = index + run;
239                }
240                Zseq.Add(Z);
241            }
242            ArrayList[] KeyStream = new ArrayList[2];
243            KeyStream[0] = timeseq;
244            KeyStream[1] = Zseq;
245            return KeyStream;
246        }
247        public bool IsLFSRsParameterlvalid()
248        {
249            feedbackpolynomials = settings.Feedbackpolynomials.Replace(" ", "").Split(';');
250            lfsrsoutputs = settings.Lfsrsoutputs.Replace(" ", "").Split(';');
251            Regex objBoolExpression = new Regex("^(1|0)+$");
252            if (feedbackpolynomials.Length != feedbackpolynomials.Length)
253            {
254                GuiLogMessage("The count of feedbackpolynomials and LSFRsoutputs is not equal ", NotificationLevel.Error);
255                return false;
256
257            }
258            for (int i = 0; i < feedbackpolynomials.Length; i++)
259            {
260                if (feedbackpolynomials[i].Length != lfsrsoutputs[i].Length)
261                {
262                    GuiLogMessage("the length of feedbackpolynomial and LSFRsoutput of " + (i + 1) + "th LFSR  is not equal", NotificationLevel.Error);
263                    return false;
264                }
265                if (!objBoolExpression.IsMatch(feedbackpolynomials[i]))
266                {
267                    GuiLogMessage("the feedbackpolynomial" + feedbackpolynomials[i] + "is not a legal ", NotificationLevel.Error);
268                    return false;
269                }
270                if (!objBoolExpression.IsMatch(lfsrsoutputs[i]))
271                {
272                    GuiLogMessage("the LSFRsoutput" + lfsrsoutputs[i] + " is not a legal ", NotificationLevel.Error);
273                    return false;
274                }
275            }
276            return true;
277        }
278        public bool IsKeyStreamValid()
279        {
280            keystreams = settings.Keystream.Replace(" ", "").Split(';');
281            Regex objBoolExpression = new Regex("^(1|0)+$");
282            int lasttime = 1;
283            for (int i = 0; i < keystreams.Length; i++)
284            {
285                string[] keyseq = keystreams[i].Split(',');
286                char[] dig = keyseq[0].ToCharArray();
287                for (int j = 0; j < dig.Length; j++)
288                {
289                    if (!Char.IsDigit(dig[j]))
290                    {
291                        GuiLogMessage("time in" + (i + 1) + "th keytreamsequence number is not a dezimal number", NotificationLevel.Error);
292                        return false;
293                    }
294                }
295                if (!objBoolExpression.IsMatch(keyseq[1]))
296                {
297                    GuiLogMessage("keystream in " + (i + 1) + "the keytreamsequence number  is not a not ligal", NotificationLevel.Error);
298                    return false;
299                }
300                if (Convert.ToInt16(keyseq[0]) < lasttime)
301                {
302                    GuiLogMessage("the time t_(i+1) must > t_i + length of ith keystreamsequence ", NotificationLevel.Error);
303                    return false;
304                }
305                lasttime = Convert.ToInt16(keyseq[0]) + keyseq[1].Length;
306            }
307            return true;
308        }
309        private int GetRunlength(Hashtable zfunctions, string[] outputcells)
310        {
311            int lfsroutputcount = 0;
312            int Xsize = 0;
313            for (int i = 0; i < zfunctions.Count; i++)
314            {
315                ArrayList l2 = (ArrayList)zfunctions[i];
316                if (l2.Count != 0)
317                {
318                    ArrayList l = (ArrayList)l2[0];
319                    bool[] monom0 = (bool[])l[0];
320                    Xsize = monom0.Length;
321                    break;
322                }
323            }
324            for (int i = 0; i < outputcells.Length; i++)
325            {
326                char[] C = outputcells[i].ToCharArray();
327                for (int j = 0; j < C.Length; j++)
328                {
329                    if (C[j] == '1') lfsroutputcount++;
330                }
331            }
332            return Xsize / lfsroutputcount;
333        }
334        private int IntValue(string bitsequence)
335        {
336            int value = 0;
337            int index = bitsequence.Length - 1;
338            for (int i = 0; i < bitsequence.Length; i++)
339            {
340                index = index - i;
341                char bit = bitsequence[i];
342                if (bit == '1') value = value + exp(2, index);
343            }
344            return value;
345        }
346        private string SimplifyFunction(string function)
347        {
348            while (function.IndexOf("(") != -1)
349            {
350                int z1 = function.IndexOf("(");
351                int z2 = function.IndexOf(")");
352                string bispar = function.Substring(0, z1);
353                int plus1 = bispar.LastIndexOf("+") + 1;
354                int plus2 = z1 + FindEndOfTerm(function.Substring(z1));
355                string Term = function.Substring(plus1, plus2 - plus1);
356                function = function.Remove(plus1, Term.Length);
357                Term = ExpandOneTerm(Term);
358                function = function.Insert(plus1, Term);
359            }
360            return ReduceEquation(function);
361        }
362        public int FindEndOfTerm(string f)
363        {
364            CharEnumerator f_char = f.GetEnumerator();
365            int index = 0;
366            bool overt = false;
367            while (f_char.MoveNext())
368            {
369                char c = f_char.Current;
370                if (c == '(') overt = true;
371                if (c == ')') overt = false;
372                if (c == '+' && !overt) return index;
373                index++;
374            }
375            return f.Length;
376        }
377        private string ReduceEquation(string function)
378        {
379            string[] monomials = function.Split('+');
380            for (int i = 0; i < monomials.Length; i++)
381            {
382                string monomial = OrderMonomial(monomials[i]);
383                monomials[i] = monomial;
384            }
385            for (int i = 0; i < monomials.Length - 1; i++)
386            {
387                if (monomials[i] != null)
388                {
389                    bool delete = false;
390                    for (int j = i + 1; j < monomials.Length; j++)
391                    {
392                        if (monomials[i] == monomials[j])
393                        {
394                            monomials[j] = null;
395                            delete = !delete;
396                        }
397
398                    }
399                    if (delete) monomials[i] = null;
400                }
401            }
402            string equation = "";
403            for (int i = 0; i < monomials.Length; i++)
404            {
405                if (monomials[i] != null)
406                    equation = equation + monomials[i] + "+";
407            }
408            equation = equation.Remove(equation.LastIndexOf("+"));
409            return equation;
410        }
411        private string OrderMonomial(string monomial)
412        {
413            string[] literals = monomial.Split('*');
414            int i = 0;
415            while (i < literals.Length && literals[i] != null)
416            {
417                for (int j = i + 1; j < literals.Length; j++)
418                {
419                    if (String.Compare(literals[j], literals[i]) < 0)
420                    {
421                        string temp = literals[j];
422                        literals[j] = literals[i];
423                        literals[i] = temp;
424                    }
425                    else
426                    {
427                        if (String.Compare(literals[j], literals[i]) == 0) literals[j] = null;
428                    }
429                }
430                i++;
431            }
432            string s = "";
433            for (int k = 0; k < literals.Length; k++)
434            {
435                if (literals[k] != null) s = s + literals[k] + "*";
436            }
437            s = s.Remove(s.LastIndexOf("*"));
438            return s;
439        }
440
441
442
443
444
445
446
447        public string Bitpresentation(int value, int length)
448        {
449            string s = "";
450            int i = length;
451            if (value == 0)
452            {
453                for (int j = 0; j < length; j++)
454                {
455                    s = s + "0";
456                }
457            }
458            else
459            {
460                while (value != 0)
461                {
462                    int div = value % 2;
463                    if (div == 0) s = "0" + s;
464                    else s = "1" + s;
465                    i = i - 1;
466                    value = value / 2;
467                }
468                if (i > 0)
469                {
470                    for (int j = 0; j < i; j++)
471                    {
472                        s = "0" + s;
473                    }
474                }
475            }
476            return s;
477        }
478        public string ExpandOneTerm(string term)//devlopet ein Term, das zwei oder mehr als zwei Faktoren enthält
479        {//func besteht aus Terme mit * verknüpft die Terme nur die Operator+ beinhalten (k+k+k)*(k+..+k)*..*(k+k+k)*(k+..+k)
480            int p1 = term.IndexOf('(');
481            int p2 = term.IndexOf(')');
482            ArrayList terms = new ArrayList();
483            while (p1 != -1)
484            {
485                string factor = term.Substring(p1, p2 - p1 + 1);
486                if (p2 != term.Length - 1) { term = term.Remove(p1, p2 - p1 + 2); }
487                else { term = term.Remove(p1, p2 - p1 + 1); }
488                terms.Add(factor);
489                p1 = term.IndexOf('(');
490                p2 = term.IndexOf(')');
491            }
492            string res = "";
493            if (terms.Count == 1) res = (string)terms[0];//mit ()
494            else
495            {
496                res = "(" + LiftRightExpand(terms[0] + "*" + terms[1]) + ")";//mit ()
497                for (int i = 2; i < terms.Count; i++)
498                {
499                    res = "(" + LiftRightExpand(res + "*" + terms[i]) + ")";
500                }
501            }
502            if (term != "")
503            {
504                if (term.EndsWith("*")) res = RightExpand(term + res);
505                else res = RightExpand(term + "*" + res);
506            }
507            else//(res)
508            {
509                res = res.Remove(0, 1);
510                res = res.Remove(res.Length - 1, 1);
511            }
512            return res;
513        }
514        public string RightExpand(string term)
515        {//k1*k2*(k1+..+k8)=>k1*k2*k1+..+k1*k2*k8
516            int p1 = term.IndexOf("(");
517            int p2 = term.IndexOf(")");
518            string fact1 = term.Substring(0, p1);
519            string fact2 = term.Substring(p1 + 1, p2 - p1 - 1);
520            string[] sumands = fact2.Split('+');
521            string s = "";
522            for (int i = 0; i < sumands.Length; i++)
523            {
524                s = s + fact1 + sumands[i] + "+";
525            }
526            s = s.Remove(s.Length - 1);
527            return s;
528        }
529        public string LiftExpand(string term)
530        {//(k1+..+k8)*k7*k8=>k1*k7*k8+..+k8*k7*k8
531            int p1 = term.IndexOf("(");
532            int p2 = term.IndexOf(")");
533            string fac1 = term.Substring(p2 + 1, term.Length - p2 - 1);//factor zu multipluzieren
534            string fac2 = term.Substring(p1 + 1, p2 - p1 - 1);
535            string[] sumands = fac2.Split('+');
536            string s = "";
537            for (int i = 0; i < sumands.Length; i++)
538            {
539                s = s + sumands[i] + fac1 + "+";
540            }
541            s = s.Remove(s.Length - 1);
542            return s;
543        }
544        public string LiftRightExpand(string term)
545        {// (k1..k6)*(k1...k12)=>(k1..k6)*k1+..+(k1..k6)*k12
546            int p1 = term.IndexOf("(");
547            int p2 = term.IndexOf(")");
548            string fac1 = term.Substring(0, p2 + 2);
549            string fac2 = term.Substring(p2 + 3, term.Length - p2 - 4);
550            string[] sumands = fac2.Split('+');
551            string s = "";
552            for (int i = 0; i < sumands.Length; i++)
553            {
554                s = s + LiftExpand(fac1 + sumands[i]) + "+";
555            }
556            s = s.Remove(s.Length - 1);
557            return s;
558        }
559        //xor durchführen zwei gleiche Terme reduzieren ( das wird nicht gemacht im XZ compute)
560
561        #endregion
562
563        public int exp(int b, int e)
564        {
565            int erg = 1;
566            for (int i = 1; i <= e; i++)
567            {
568                erg = erg * b;
569            }
570            return erg;
571        }
572    }// class System ofequation
573
574    // Class Combiner
575
576    //public class Combiner2
577    //{
578    //    public LFSR[] lfsrs;
579    //    public Combiner(string[] caracpolynoms, string[] outputcells)
580    //    {
581    //        lfsrs = new LFSR[caracpolynoms.Length];
582    //        for (int i = 0; i < caracpolynoms.Length; i++)
583    //        {
584    //            LFSR lfsr = new LFSR(caracpolynoms[i]);
585    //            lfsr.outputcells = outputcells[i].ToCharArray();
586    //            lfsrs[i] = lfsr;
587    //        }
588    //    }
589    //    public ArrayList[] OneClockOutput()
590    //    {
591    //        ArrayList[] Xi = new ArrayList[lfsrs.Length];
592    //        for (int i = 0; i < lfsrs.Length; i++)
593    //        {
594    //            Xi[i] = lfsrs[i].Output();
595    //        }
596    //        return Xi;
597    //    }
598    //    public void Clock(int time)
599    //    {
600    //       for (int i = 0; i < lfsrs.Length; i++)
601    //       {
602    //           lfsrs[i].Clock(time);
603
604    //       }           
605    //    }
606    //    public void OneClock()
607    //    {
608    //        for (int i = 0; i < lfsrs.Length; i++)
609    //        {
610    //                lfsrs[i].OneClock();
611    //        }             
612    //    }
613    //    public ArrayList[][] RunClockOutput(int run)
614    //    {
615    //        ArrayList[][] runoutput= new ArrayList[run][];
616    //        for (int i = 0; i < run; i++)
617    //        {
618    //            ArrayList[] Xi = OneClockOutput();
619    //            runoutput[i] = Xi;
620    //            OneClock();
621    //        }
622    //        return runoutput;
623    //    }
624    //    public ArrayList SortOutput(ArrayList[][] outputs)
625    //    {
626    //        ArrayList sortedoutput = new ArrayList();
627    //        for (int i = 0; i < outputs.Length; i++)
628    //        {
629    //            int startindex = 1;
630    //            for (int j = 0; j < outputs[i].Length; j++)
631    //            {
632    //                ArrayList lsfroutput = outputs[i][j];
633    //                int lfsrlength = lfsrs[j].length;
634    //                foreach (bool[] cell in lsfroutput)
635    //                {
636    //                    string cellstring= SubstituteOutput(cell,startindex);
637    //                    sortedoutput.Add(cellstring);                   
638    //                }
639    //                startindex = startindex + lfsrlength;
640    //            }
641    //        }
642    //        return sortedoutput;
643    //    }
644    //   public string SubstituteOutput(bool[] celloutput, int index)
645    //   {
646    //       string s = "";
647    //       for (int j = 0; j < celloutput.Length; j++)
648    //       {
649    //           if (celloutput[j]) s =s+"k"+(j+index)+"+";
650    //       }
651    //       s = s.Remove(s.Length - 1);
652    //       if (s.Contains("+")) s = "(" + s + ")";   
653    //       return s;
654    //   }
655    //}
656
657    //Class LfSR
658
659    //public class LfSR
660    //{
661    //    public int length;
662    //    string characteristicpolynom;
663    //    public bool[][] internalstate;
664    //    public char[] outputcells;       
665    //    public LfSR(string charpolynom)
666    //    {
667    //        characteristicpolynom = charpolynom;
668    //        length = charpolynom.Length;
669    //        internalstate = new bool[length][];
670    //        for (int i = 0; i < internalstate.Length; i++)
671    //        {
672    //            internalstate[i] = new bool[length];
673    //            for (int j = 0; j < internalstate.Length; j++)
674    //            {
675    //                if (i == j) internalstate[i][j] = true;
676    //                else internalstate[i][j] = false;
677    //            }
678    //        }
679    //    }
680    //    public bool[] XorCells(bool[] cell1, bool[] cell2)
681    //    {
682    //        bool[] res = new bool[cell2.Length];
683    //        for (int i = 0; i < cell2.Length; i++)
684    //        {
685    //            res[i] = cell1[i] ^ cell2[i];
686    //        }
687    //        return res;
688    //    }
689    //    public void OneClock()
690    //    {
691    //        char[] c = characteristicpolynom.ToCharArray();
692    //        bool[] res = new bool[length];
693    //        res = internalstate[0];
694    //        for (int k =1;  k<length; k++)
695    //        {
696    //            if (c[k] == '1') res = XorCells(res,internalstate[k]);
697    //        }
698    //        for (int j = 0; j<internalstate.Length-1; j++)
699    //        {
700    //            internalstate[j] = internalstate[j + 1];
701    //        }
702    //        internalstate[length-1] = res;
703    //    }
704    //    public void Clock(int time)
705    //    {
706    //        for (int i = 0; i < time; i++)
707    //        {
708    //            OneClock();
709    //        }
710    //    }
711    //    public ArrayList Output()
712    //    {
713    //        ArrayList lfsroutput = new ArrayList();
714    //        for (int i = 0; i < outputcells.Length; i++)
715    //        {
716    //            if (outputcells[i] == '1')
717    //            lfsroutput.Add(internalstate[i]);
718    //        }
719    //        return lfsroutput;
720    //    }
721    //}
722
723
724
725
726}
727
Note: See TracBrowser for help on using the repository browser.