Changeset 1605


Ignore:
Timestamp:
Jun 8, 2010, 5:26:20 PM (12 years ago)
Author:
Sven Rech
Message:

KeyPatternPool changes:

o aubparts are now directly accessible by using this[] operator
o cleanup stuff

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/KeySearcher/KeyPatternPool.cs

    r1585 r1605  
    66using System.Collections;
    77using System.Numerics;
     8using System.Diagnostics;
    89
    910namespace KeySearcher
     
    2324        private bool end = false;
    2425
     26#region public
     27
     28        public KeyPatternPool(KeyPattern pattern, BigInteger partsize)
     29        {
     30            this.partsize = partsize;
     31            this.pattern = pattern;
     32            splittingQuotient = new int[pattern.wildcardList.Count];
     33            CalculateSplitting();
     34            splittingCounter = new int[pattern.wildcardList.Count];
     35        }
     36
     37        /// <summary>
     38        /// The KeyPatternPool divides the initial KeyPattern into several (well ordered) sub KeyPattern parts which are disjunct.
     39        /// By using the [] Operator, you can get the part at position "index".
     40        /// </summary>
     41        /// <param name="index">The index</param>
     42        /// <returns>The sub key pattern</returns>
     43        public KeyPattern this[BigInteger index]
     44        {
     45            get
     46            {
     47                return GetAtIndex(index);
     48            }
     49        }
     50
     51        /// <summary>
     52        /// Returns the amount of parts that are available.
     53        /// </summary>
     54        public BigInteger Length
     55        {
     56            get
     57            {
     58                BigInteger res = 1;
     59                for (int k = 0; k < pattern.wildcardList.Count; k++)
     60                {
     61                    Wildcard wc = ((Wildcard)pattern.wildcardList[k]);
     62                    res *= splittingQuotient[k];
     63                }
     64                return res;
     65            }
     66        }
     67
     68        /// <summary>
     69        /// Returns the size of one part.
     70        /// </summary>
     71        public BigInteger PartSize
     72        {
     73            get
     74            {
     75                BigInteger res = 1;
     76                for (int k = 0; k < pattern.wildcardList.Count; k++)
     77                {
     78                    Wildcard wc = ((Wildcard)pattern.wildcardList[k]);
     79                    res *= wc.size() / splittingQuotient[k];
     80                }
     81                return res;
     82            }
     83        }
     84
     85#endregion
     86
     87#region private
    2588        private void CalculateSplitting()
    2689        {
     
    2891                splittingQuotient[c] = 1;
    2992
    30             BigInteger bestSize = GetPartSize();
     93            BigInteger bestSize = PartSize;
    3194
    3295            for (int c = pattern.wildcardList.Count - 1; c >= 0; c--)
     
    39102                        int tmp = splittingQuotient[c];
    40103                        splittingQuotient[c] = k;
    41                         BigInteger size = GetPartSize();
     104                        BigInteger size = PartSize;
    42105                        if (BigInteger.Abs((size - partsize)) < BigInteger.Abs(bestSize - partsize))
    43106                            bestSize = size;                       
     
    49112        }
    50113               
     114        /// <summary>
     115        /// See this[]
     116        /// </summary>
     117        /// <param name="index">The index</param>
     118        /// <returns>The sub key pattern</returns>
     119        private KeyPattern GetAtIndex(BigInteger index)
     120        {
     121            //calculate the wildcard positions on which we want to split:
     122            int[] splittingPositions = new int[pattern.wildcardList.Count];
     123            for (int k = pattern.wildcardList.Count - 1; k >= 0; k--)
     124            {
     125                splittingPositions[k] = (int)(index % splittingQuotient[k]);
     126                index /= splittingQuotient[k];
     127            }
     128            Debug.Assert(index == 0);
     129
     130            //split up the sub pattern parts:
     131            KeyPattern subpart = new KeyPattern(pattern.GetPattern());
     132            subpart.wildcardList = new ArrayList();
     133            for (int k = 0; k < pattern.wildcardList.Count; k++)
     134            {
     135                Wildcard subwc = ((Wildcard)pattern.wildcardList[k]);
     136                char[] values = new char[256];
     137                int sublength = subwc.size() / splittingQuotient[k];
     138                for (int i = 0; i < sublength; i++)
     139                    values[i] = subwc.getChar(i + splittingPositions[k] * sublength);
     140                Wildcard newwc = new Wildcard(values, sublength);
     141                subpart.wildcardList.Add(newwc);
     142            }
     143
     144            return subpart;
     145        }
     146
     147#endregion
     148
     149#region TODO: Remove these methods later
     150
    51151        private bool SuccCounter()
    52152        {
    53             for (int k = pattern.wildcardList.Count-1; k >= 0; k--)
    54             {
    55                 Wildcard wc = ((Wildcard)pattern.wildcardList[k]);
     153            for (int k = pattern.wildcardList.Count - 1; k >= 0; k--)
     154            {
    56155                splittingCounter[k]++;
    57156                if (splittingCounter[k] >= splittingQuotient[k])
     
    63162        }
    64163
    65         // added by Arnie - 2010.02.04
    66164        public bool Contains(byte[] serializedJob)
    67165        {
     
    152250        }
    153251
    154         public BigInteger GetPartSize()
    155         {
    156             BigInteger res = 1;
    157             for (int k = 0; k < pattern.wildcardList.Count; k++)
    158             {
    159                 Wildcard wc = ((Wildcard)pattern.wildcardList[k]);
    160                 res *= wc.size() / splittingQuotient[k];
    161             }
    162             return res;
    163         }
    164 
    165252        public long Count()
    166253        {
    167             return (long)(TotalAmount() + stack.Count - counter);
    168         }
    169 
    170         public BigInteger TotalAmount()
    171         {
    172             BigInteger res = 1;
    173             for (int k = 0; k < pattern.wildcardList.Count; k++)
    174             {
    175                 Wildcard wc = ((Wildcard)pattern.wildcardList[k]);
    176                 res *= splittingQuotient[k];
    177             }
    178             return res;
    179         }
    180 
    181         public KeyPatternPool(KeyPattern pattern, BigInteger partsize)
    182         {
    183             this.partsize = partsize;
    184             this.pattern = pattern;
    185             splittingQuotient = new int[pattern.wildcardList.Count];
    186             CalculateSplitting();
    187             splittingCounter = new int[pattern.wildcardList.Count];
    188         }
     254            return (long)(Length + stack.Count - counter);
     255        }
     256
     257#endregion
     258
    189259    }
    190260}
Note: See TracChangeset for help on using the changeset viewer.