Ignore:
Timestamp:
Nov 26, 2008, 1:28:11 PM (13 years ago)
Author:
Danail Vazov
Message:

Added a beta version Presentation.

Location:
trunk/CrypPlugins/KasiskiTest
Files:
2 added
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/KasiskiTest/KasiskiTest.cs

    r4 r71  
    77using Cryptool.PluginBase.Analysis;
    88using System.ComponentModel;
     9using System.Collections.ObjectModel;
     10using System.Windows.Controls;
    911
    1012namespace KasiskiTest
     
    1719    public class KasiskiTest : IStatistic
    1820    {
    19         public KasiskiTest()
    20         {
    21             settings = new KasiskiTestSettings();
    22            
    23         }
    24 
     21       
    2522        #region Private Variables
    2623        private int integerValue;
    2724        private string stringOutput;
    2825        private string stringInput;
     26        public static DataSource Data = new DataSource();
    2927        #endregion
    3028
     
    8987            set { settings = (KasiskiTestSettings)value; }
    9088        }
    91 
    92         public System.Windows.Controls.UserControl Presentation
    93         {
    94             get {  return null; }
    95         }
     89        private KasiskiTestPresentation presentation;
     90        public KasiskiTest()
     91        {
     92        settings = new KasiskiTestSettings();
     93        presentation = new KasiskiTestPresentation(this);
     94        Presentation = presentation;
     95        }
     96        public UserControl Presentation { get; private set; }
    9697
    9798        public System.Windows.Controls.UserControl QuickWatchPresentation
     
    109110            if (stringInput != null)
    110111            {
    111                
     112
    112113                // BEGIN PREWORK TO INPUT STRING DEPENDING ON USER CHOICE IN SETTINGS PANEL
    113                
     114
    114115                string workString = stringInput; //Copy the input string to a work string in order to make changes to it if neccessary
    115116                string workstring2 = "";
    116                
    117                   //UNKNOWN SYMBOL HANDLING
    118                                
    119                
     117
     118                //UNKNOWN SYMBOL HANDLING
     119
     120
    120121                if (settings.unknownSymbolHandling == 1) //Determine (via setting in Settings Panel) if unknown symbols (e.g. , : \ /) should be discarded from the text which is to be analysed
    121122                {
     
    133134                    workstring2 = workstring1.ToString(); // Now copy workstring1 to workstring2. Needed because workstring1 can not be altered once its built
    134135                }
    135                 else 
     136                else
    136137                {
    137138                    workstring2 = workString; // In case unknown symbols are to be ignored copy workString to workstring2, and proceed with analysis of workstring2
    138139                }
    139140
    140                    //CASE SENSITIVITY
    141 
    142                 if (settings.caseSensitivity == 0) { workstring2=workstring2.ToUpper(); }                         
    143                
    144                
    145                
    146                
     141                //CASE SENSITIVITY
     142
     143                if (settings.caseSensitivity == 0) { workstring2 = workstring2.ToUpper(); }
     144
     145
     146
     147
    147148                //int grammLength = 3; - Setting for maximum gramm length now avaliable in Settings Panel
    148149                ArrayList checkedGramms = new ArrayList();
     
    152153                string grammToSearch;
    153154
    154                  
    155                              
     155
     156
    156157
    157158                //TODO "add functionality that allows the user to choose grammLength - Done" , "add another for loop which starts from 3 until gramLength is reached" - array size of checkedGramms[],factors[] and distances[] needs tweaking, otherwise done
    158159
    159                
     160
    160161                //BEGIN TO SEARCH FOR EQUAL SUBSTRINGS AND TO COUNT DISTANCES BETWEEN THEM
    161162
    162                
     163
    163164                for (int d = 3; d <= settings.grammLength; d++)
    164165                {
     
    171172                        //{
    172173
    173                            
    174                             for (int n = i + settings.grammLength; n <= workstring2.Length - settings.grammLength; n++)  //go through workString starting after the end of the taken grammToSearch
     174
     175                        for (int n = i + settings.grammLength; n <= workstring2.Length - settings.grammLength; n++)  //go through workString starting after the end of the taken grammToSearch
     176                        {
     177                            if (grammToSearch == workstring2.Substring(n, d)) //if grammToSearch in workString
    175178                            {
    176                                 if (grammToSearch == workstring2.Substring(n, d)) //if grammToSearch in workString
    177                                 {
    178                                     distances.Add(n-i);               //save the distance in index 'g' of distances exactly where gramToSearch in checkedGramms is placed 
    179                                     checkedGramms.Add(grammToSearch);                     //put in unused space of checkedGramms
    180                                    
    181 break;
    182                                 }
    183 
    184 
     179                                distances.Add(n - i);               //save the distance in index 'g' of distances exactly where gramToSearch in checkedGramms is placed 
     180                                checkedGramms.Add(grammToSearch);                     //put in unused space of checkedGramms
     181
     182                                break;
    185183                            }
     184
     185
     186                        }
    186187                        //}
    187                        
     188
    188189                    }
    189190                }
     
    192193
    193194
    194                
     195
    195196
    196197                //TODO: SPEED !@#$%^& !!!
    197198
    198                              
    199                
    200                
     199
     200
     201
    201202                //int[] copyOfDistances = distances.GetType(); //Copy distances to find largest member
    202203                //Array.Copy(distances, copyOfDistances, distances.Length);
    203204                //Array.Sort(copyOfDistances);
    204205                //int sqrtOfLargestDist = Convert.ToInt32(Math.Sqrt(copyOfDistances[copyOfDistances.Length - 1])); //sqrtOf largest distance will give the maximum number of prime factors of the distance for example if the distance is a power of 2 which is the worst case
    205                 int x=0;
     206                int x = 0;
    206207
    207208
    208209                int[,] factors = new int[distances.Count, settings.factorSize /*sqrtOfLargestDist */];    //Rectangular array factors     
    209210
    210                 int[] factorCounter = new int[(settings.factorSize+1) /*sqrtOfLargestDist */];                //Vector array each factor is the index of the array, the element at this index illustrates how many times the factor is met
    211                
     211                int[] factorCounter = new int[(settings.factorSize + 1) /*sqrtOfLargestDist */];                //Vector array each factor is the index of the array, the element at this index illustrates how many times the factor is met
     212
    212213                for (int z = 0; z <= distances.Count - 1; z++)       //for each distance
    213214                {
    214                     int numberToFactorize = Convert.ToInt32( distances[z]);             //assign variable
     215                    int numberToFactorize = Convert.ToInt32(distances[z]);             //assign variable
    215216                    x = 0;
    216217
    217218                    for (int y = 2; y <= settings.factorSize/*Math.Sqrt(numberToFactorize)*/; y++) // for each number starting from 2 until sqrt(number to factorize)
    218219                    {
    219                         if (numberToFactorize == 0) { break;}
     220                        if (numberToFactorize == 0) { break; }
    220221                        if (numberToFactorize % y == 0 /*& numberToFactorize!=0*/)     // if devisibe without rest
    221222                        {
     
    223224                            x++;
    224225                            factorCounter[y]++;
    225                            
    226                            // while (numberToFactorize % y == 0)  //if a factor is found numberToFactorize is divided by it until division without rest is not possible anymore
    227                            // {
    228                            //     numberToFactorize = numberToFactorize / y;
    229                            // }
     226
     227                            // while (numberToFactorize % y == 0)  //if a factor is found numberToFactorize is divided by it until division without rest is not possible anymore
     228                            // {
     229                            //     numberToFactorize = numberToFactorize / y;
     230                            // }
    230231                        }
    231232                    }
     
    233234
    234235                }
    235  
    236 
    237                 //BEGIN OUTPUT
    238 
    239                
    240                
    241                
    242                 StringOutput = "";
    243 
    244                 for (int k = 0; k <= checkedGramms.Count - 1; k++)
    245                 {
    246                     if (Convert.ToInt32(distances[k] )!= 0)
    247                     { StringOutput += checkedGramms[k] + "/" + Convert.ToString(distances[k]);
    248                       for (int l = 0; l <= settings.factorSize /*sqrtOfLargestDist */ - 1; l++)
    249                         {
    250                             if (factors[k, l] != 0) { StringOutput += "/" + Convert.ToString(factors[k, l]); }
    251 
    252                         }
    253                         StringOutput += '\n';
    254                     }
    255                    
    256                 }
    257                
     236                Data.ValueCollection.Clear();
     237                for (int z = 2; z <= factorCounter.Count(); z++)
     238                {
     239                    CollectionElement row = new CollectionElement(z,factorCounter[z]);
     240                    Data.ValueCollection.Add(row);
     241                }
     242                presentation.InitializeComponent();
     243                    //BEGIN OUTPUT
     244                    stringOutput = "";
     245                for (int i = 2; i <= factorCounter.Count() - 1; i++)
     246                {
     247                    stringOutput += i + ":" + Convert.ToString(factorCounter[i]) + Environment.NewLine;
     248                }
     249               
     250                //   for (int k = 0; k <= checkedGramms.Count - 1; k++)
     251                //   {
     252                //       if (Convert.ToInt32(distances[k] )!= 0)
     253                //       { StringOutput += checkedGramms[k] + "/" + Convert.ToString(distances[k]);
     254                //         for (int l = 0; l <= settings.factorSize /*sqrtOfLargestDist */ - 1; l++)
     255                //           {
     256                //               if (factors[k, l] != 0) { StringOutput += "/" + Convert.ToString(factors[k, l]); }
     257                ///
     258                //              }
     259                //              StringOutput += '\n';
     260                //          }
     261                //         
     262                //     }   
     263                //     
    258264                //find the most frequent factor
    259                 int biggestSoFar=0;
    260                 int biggestSoFarIndex=0;
    261                
    262                 for (int j = 0; j <= factorCounter.Length - 1; j++)
    263                 {
    264                     if (factorCounter[j] > biggestSoFar)
    265                     {
    266                        
    267                         biggestSoFar = factorCounter[j];
    268                         biggestSoFarIndex = j;
    269                     }
    270                    
    271                 }
    272                 if (biggestSoFarIndex % 2 == 0)
    273                 {
    274                     StringOutput += '\n' + "The probable keylength is a multiple of: " + biggestSoFarIndex ;
    275                 }
    276                 else
    277                 {
    278            
    279                     StringOutput += '\n' + "most frequent factor is:" + biggestSoFarIndex + '\n' + "with: " + biggestSoFar + " hits";
    280                 }
    281                 integerValue = biggestSoFarIndex;
    282             }
    283 
    284         }
    285 
    286          //P.S. The arrays used in the solution are:
    287         //checkedGramms -the array contains all checked gramms :) 
    288         //distances - The same size as checkedGramms, if the gramm doesn't repeat itself the value of distances[k] corresponding to checkedGramms[k] equals 0
    289         //factors - same size as checkedGramms and distances on one side ,and 20 (for now)on the other side for the factors , if the corresponding distance is 0 all the factors are also 0
    290        
     265                //  int biggestSoFar=0;
     266                //  int biggestSoFarIndex=0;
     267                // 
     268                //   for (int j = 0; j <= factorCounter.Length - 1; j++)
     269                //  {
     270                //      if (factorCounter[j] > biggestSoFar)
     271                //     {
     272                //       
     273                //        biggestSoFar = factorCounter[j];
     274                //        biggestSoFarIndex = j;
     275                //    }
     276                //     
     277                // }
     278                // if (biggestSoFarIndex % 2 == 0)
     279                // {
     280                //     StringOutput += '\n' + "The probable keylength is a multiple of: " + biggestSoFarIndex ;
     281                /// }
     282                // else
     283                // {
     284                //
     285                //      StringOutput += '\n' + "most frequent factor is:" + biggestSoFarIndex + '\n' + "with: " + biggestSoFar + " hits";
     286                //   }
     287                //   integerValue = biggestSoFarIndex;
     288            }
     289
     290        }
    291291       
    292292       
     
    333333        #endregion
    334334    }
     335    public class CollectionElement
     336    {
     337
     338
     339       
     340        private int m_factor;
     341        private int m_count;
     342
     343
     344
     345        public CollectionElement(int factor, int count)
     346        {
     347            m_factor = factor;
     348            m_count = count;
     349        }
     350
     351        public int Count
     352        {
     353            get { return m_count; }
     354            set
     355            {
     356                m_count = value;
     357            }
     358        }
     359        public int Factor
     360        {
     361            get { return m_factor; }
     362            set
     363            {
     364                m_factor = value;
     365            }
     366        }
     367
     368    }
     369    public class DataSource
     370    {
     371
     372        private ObservableCollection<CollectionElement> valueCollection;
     373
     374        public ObservableCollection<CollectionElement> ValueCollection
     375        {
     376            get { return valueCollection; }
     377            set { valueCollection = value; }
     378        }
     379
     380        //public void AddtoCollection(int i, double d, string s)
     381       // {
     382        //    CollectionElement z = new CollectionElement(i, d, s);
     383        //    valueCollection.Add(z);
     384       // }
     385
     386        public DataSource()
     387        {
     388           // CollectionElement z= new CollectionElement(30,30.5,"qqq");
     389            valueCollection = new ObservableCollection<CollectionElement>();
     390           // valueCollection.Add(z);
     391           // CollectionElement y = new CollectionElement(30, 30.5, "qqq");
     392            //CollectionElement s = new CollectionElement(30, 30.5, "qqq");
     393           // valueCollection.Add(s);
     394           // valueCollection.Add(y);
     395           // CollectionElement q = new CollectionElement(30, 30.5, "qqq");
     396           // valueCollection.Add(q);
     397        }
     398    }
     399
    335400}
  • trunk/CrypPlugins/KasiskiTest/KasiskiTest.csproj

    r4 r71  
    6363    <Compile Include="KasiskiTestSettings.cs" />
    6464    <Compile Include="Properties\AssemblyInfo.cs" />
     65    <Compile Include="KasiskiTestPresentation.xaml.cs">
     66      <DependentUpon>KasiskiTestPresentation.xaml</DependentUpon>
     67    </Compile>
    6568  </ItemGroup>
    6669  <ItemGroup>
     
    7578  <ItemGroup>
    7679    <Resource Include="icon.png" />
     80  </ItemGroup>
     81  <ItemGroup>
     82    <Page Include="KasiskiTestPresentation.xaml">
     83      <SubType>Designer</SubType>
     84      <Generator>MSBuild:Compile</Generator>
     85    </Page>
    7786  </ItemGroup>
    7887  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
Note: See TracChangeset for help on using the changeset viewer.