Changeset 808


Ignore:
Timestamp:
Nov 1, 2009, 11:03:21 AM (12 years ago)
Author:
Timo Eckhardt
Message:

switched from GmpBigInteger to PrimesBigInteger based on BouncyCastle BigInteger

Location:
trunk/CrypPlugins/Primes
Files:
2 added
4 deleted
86 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/Primes/Primes/CalculatorLib/CalcParser.cs

    r4 r808  
    206206using System.Text;
    207207using System.Text.RegularExpressions;
    208 using LibGmpWrapper;
     208
     209using Primes.Bignum;
    209210
    210211namespace SevenZ.Calculator
    211212{
    212    public partial class Calculator
    213    {
    214       Stack<GmpBigInteger> operands;
    215       Stack<string> operators;
    216 
    217       string token;
    218       int tokenPos;
    219       string expression;
    220 
    221       public Calculator()
    222       {
    223          Reset();
    224       }
    225 
    226       public void Reset()
    227       {
    228          LoadConstants();
    229          Clear();
    230       }
    231 
    232       public void Clear()
    233       {
    234           operands = new Stack<GmpBigInteger>();
    235          operators = new Stack<string>();
    236 
    237          operators.Push(Token.Sentinel);
    238          token = Token.None;
    239          tokenPos = -1;
    240       }
    241 
    242       /// <summary>
    243       /// Evaluates mathematical expression
    244       /// </summary>
    245       /// <param name="expr">Input expression</param>
    246       /// <returns>Result in double format</returns>
    247        public GmpBigInteger Evaluate(string expr)
    248       {
    249          Clear();
    250          expression = expr;
    251          if (Normalize(ref expression))
    252          {
    253              GmpBigInteger result = Parse();
    254             SetVariable(AnswerVar, result);
    255             return result;
    256          }
    257          else
    258          {
    259             ThrowException("Blank input expression");
    260             return GmpBigInteger.Zero;
    261          }
    262       }
    263 
    264        private GmpBigInteger Parse()
    265       {
    266          ParseBinary();
    267          Expect(Token.End);
    268          return operands.Peek();
    269       }
    270 
    271       /// <summary>
    272       /// Parse binary operations
    273       /// </summary>
    274       private void ParseBinary()
    275       {
    276          ParsePrimary();
    277 
    278          while (Token.IsBinary(token))
    279          {
    280             PushOperator(token);
    281             NextToken();
     213    public partial class Calculator
     214    {
     215        Stack<PrimesBigInteger> operands;
     216        Stack<string> operators;
     217
     218        string token;
     219        int tokenPos;
     220        string expression;
     221
     222        public Calculator()
     223        {
     224            Reset();
     225        }
     226
     227        public void Reset()
     228        {
     229            LoadConstants();
     230            Clear();
     231        }
     232
     233        public void Clear()
     234        {
     235            operands = new Stack<PrimesBigInteger>();
     236            operators = new Stack<string>();
     237
     238            operators.Push(Token.Sentinel);
     239            token = Token.None;
     240            tokenPos = -1;
     241        }
     242
     243        /// <summary>
     244        /// Evaluates mathematical expression
     245        /// </summary>
     246        /// <param name="expr">Input expression</param>
     247        /// <returns>Result in double format</returns>
     248        public PrimesBigInteger Evaluate(string expr)
     249        {
     250            Clear();
     251            expression = expr;
     252            if (Normalize(ref expression))
     253            {
     254                PrimesBigInteger result = Parse();
     255                SetVariable(AnswerVar, result);
     256                return result;
     257            }
     258            else
     259            {
     260                ThrowException("Blank input expression");
     261                return PrimesBigInteger.Zero;
     262            }
     263        }
     264
     265        private PrimesBigInteger Parse()
     266        {
     267            ParseBinary();
     268            Expect(Token.End);
     269            return operands.Peek();
     270        }
     271
     272        /// <summary>
     273        /// Parse binary operations
     274        /// </summary>
     275        private void ParseBinary()
     276        {
    282277            ParsePrimary();
    283          }
    284 
    285          while (operators.Peek() != Token.Sentinel)
    286             PopOperator();
    287       }
    288 
    289       /// <summary>
    290       /// Parse primary tokens: digits, variables, functions, parentheses
    291       /// </summary>
    292       private void ParsePrimary()
    293       {
    294          if (Token.IsDigit(token)) // reading numbers
    295          {
    296             ParseDigit();
    297          }
    298          else if (Token.IsName(token)) // variable or function (both binary and unary)
    299          {
    300             ParseName();
    301          }
    302          else if (Token.IsUnary(token)) // unary operator (unary minus)
    303          {
    304             PushOperator(Token.ConvertOperator(token));
    305             NextToken();
    306             ParsePrimary();
    307          }
    308          else if (token == Token.PLeft) // parentheses
    309          {
    310             NextToken();
    311             operators.Push(Token.Sentinel); // add sentinel to operators stack
    312             ParseBinary();
    313             Expect(Token.PRight, Token.Separator);
    314             operators.Pop(); // pop sentinel from the stack
    315 
     278
     279            while (Token.IsBinary(token))
     280            {
     281                PushOperator(token);
     282                NextToken();
     283                ParsePrimary();
     284            }
     285
     286            while (operators.Peek() != Token.Sentinel)
     287                PopOperator();
     288        }
     289
     290        /// <summary>
     291        /// Parse primary tokens: digits, variables, functions, parentheses
     292        /// </summary>
     293        private void ParsePrimary()
     294        {
     295            if (Token.IsDigit(token)) // reading numbers
     296            {
     297                ParseDigit();
     298            }
     299            else if (Token.IsName(token)) // variable or function (both binary and unary)
     300            {
     301                ParseName();
     302            }
     303            else if (Token.IsUnary(token)) // unary operator (unary minus)
     304            {
     305                PushOperator(Token.ConvertOperator(token));
     306                NextToken();
     307                ParsePrimary();
     308            }
     309            else if (token == Token.PLeft) // parentheses
     310            {
     311                NextToken();
     312                operators.Push(Token.Sentinel); // add sentinel to operators stack
     313                ParseBinary();
     314                Expect(Token.PRight, Token.Separator);
     315                operators.Pop(); // pop sentinel from the stack
     316
     317                TryInsertMultiply();
     318                TryRightSideOperator();
     319            }
     320            else if (token == Token.Separator) // arguments separator in funtions (',')
     321            {
     322                NextToken();
     323                ParsePrimary();
     324            }
     325            else
     326                ThrowException("Syntax error");
     327        }
     328
     329
     330
     331        private void ParseDigit()
     332        {
     333            StringBuilder tmpNumber = new StringBuilder();
     334
     335            while (Token.IsDigit(token))
     336            {
     337                CollectToken(ref tmpNumber);
     338            }
     339
     340            operands.Push(new PrimesBigInteger(tmpNumber.ToString()));
    316341            TryInsertMultiply();
    317342            TryRightSideOperator();
    318          }
    319          else if (token == Token.Separator) // arguments separator in funtions (',')
    320          {
     343        }
     344
     345        /// <summary>
     346        /// Turn name into a variable or a function
     347        /// </summary>
     348        private void ParseName()
     349        {
     350            StringBuilder tmpName = new StringBuilder();
     351
     352            while (Token.IsName(token))
     353            {
     354                CollectToken(ref tmpName);
     355            }
     356
     357            string name = tmpName.ToString();
     358
     359            if (Token.IsFunction(name)) // Execute operand in case of driver's function (Sin, Cos e.t.c)
     360            {
     361                PushOperator(name);
     362                ParsePrimary();
     363            }
     364            else //Variable: char (one or more) and digit (zero or more). Ex: v, a1, bb, c3d
     365            {
     366                if (token == Token.Store) // in case of var=Expression
     367                {
     368                    NextToken();
     369                    SetVariable(name, Parse());
     370                }
     371                else
     372                {
     373                    operands.Push(GetVariable(name));
     374                    TryInsertMultiply();
     375                    TryRightSideOperator();
     376
     377                }
     378            }
     379        }
     380
     381        /// <summary>
     382        /// Check x(...), make it equal to x*(...)
     383        /// numberFunc(..) or numberVar, change to -> number*Func(..) or number*Var
     384        /// Check (...)(...), make it equal to (...)*(...)
     385        /// </summary>
     386        private void TryInsertMultiply()
     387        {
     388            if (!Token.IsBinary(token) && !Token.IsSpecial(token) && !Token.IsRightSide(token))
     389            {
     390                PushOperator(Token.Multiply);
     391                ParsePrimary();
     392            }
     393        }
     394
     395        /// <summary>
     396        /// Check for right-side operators (Factorial) and for arguments separator
     397        /// </summary>
     398        private void TryRightSideOperator()
     399        {
     400            switch (token)
     401            {
     402                case Token.Factorial:
     403                    {
     404                        PushOperator(Token.Factorial);
     405                        NextToken();
     406                        TryInsertMultiply();
     407                        break;
     408                    }
     409                case Token.Separator:
     410                    ParsePrimary(); // arguments separator in functions F(x1, x2 ... xn)
     411                    break;
     412            }
     413        }
     414
     415        private void PushOperator(string op)
     416        {
     417            while (Token.Compare(operators.Peek(), op) > 0) //Token.Precedence(operators.Peek()) >= Token.Precedence(op))
     418                PopOperator();
     419
     420            operators.Push(op);
     421        }
     422
     423        private void PopOperator()
     424        {
     425            if (Token.IsBinary(operators.Peek()))
     426            {
     427                PrimesBigInteger o2 = operands.Pop();
     428                PrimesBigInteger o1 = operands.Pop();
     429                Calculate(operators.Pop(), o1, o2);
     430            }
     431            else // unary operator
     432            {
     433                Calculate(operators.Pop(), operands.Pop());
     434            }
     435        }
     436
     437        /// <summary>
     438        /// Get next token from the expression
     439        /// </summary>
     440        private void NextToken()
     441        {
     442            if (token != Token.End)
     443            {
     444                token = expression[++tokenPos].ToString();
     445            }
     446        }
     447
     448        /// <summary>
     449        /// Read token character by character
     450        /// </summary>
     451        /// <param name="sb">Temporary buffer</param>
     452        private void CollectToken(ref StringBuilder sb)
     453        {
     454            sb.Append(token);
    321455            NextToken();
    322             ParsePrimary();
    323          }
    324          else
    325             ThrowException("Syntax error");
    326       }
    327 
    328 
    329 
    330       private void ParseDigit()
    331       {
    332          StringBuilder tmpNumber = new StringBuilder();
    333 
    334          while (Token.IsDigit(token))
    335          {
    336             CollectToken(ref tmpNumber);
    337          }
    338 
    339          operands.Push(new GmpBigInteger(tmpNumber.ToString()));
    340          TryInsertMultiply();
    341          TryRightSideOperator();
    342       }
    343 
    344       /// <summary>
    345       /// Turn name into a variable or a function
    346       /// </summary>
    347       private void ParseName()
    348       {
    349          StringBuilder tmpName = new StringBuilder();
    350          
    351          while (Token.IsName(token))
    352          {
    353             CollectToken(ref tmpName);
    354          }
    355 
    356          string name = tmpName.ToString();
    357 
    358          if (Token.IsFunction(name)) // Execute operand in case of driver's function (Sin, Cos e.t.c)
    359          {
    360             PushOperator(name);
    361             ParsePrimary();
    362          }
    363          else //Variable: char (one or more) and digit (zero or more). Ex: v, a1, bb, c3d
    364          {
    365             if (token == Token.Store) // in case of var=Expression
    366             {
    367                NextToken();
    368                SetVariable(name, Parse());
    369             }
    370             else
    371             {
    372                operands.Push(GetVariable(name));
    373                TryInsertMultiply();
    374                TryRightSideOperator();
    375                
    376             }
    377          }
    378       }
    379 
    380       /// <summary>
    381       /// Check x(...), make it equal to x*(...)
    382       /// numberFunc(..) or numberVar, change to -> number*Func(..) or number*Var
    383       /// Check (...)(...), make it equal to (...)*(...)
    384       /// </summary>
    385       private void TryInsertMultiply()
    386       {
    387          if (!Token.IsBinary(token) && !Token.IsSpecial(token) && !Token.IsRightSide(token))
    388          {
    389             PushOperator(Token.Multiply);
    390             ParsePrimary();
    391          }
    392       }
    393 
    394       /// <summary>
    395       /// Check for right-side operators (Factorial) and for arguments separator
    396       /// </summary>
    397       private void TryRightSideOperator()
    398       {
    399          switch(token)
    400          {
    401             case Token.Factorial :
    402             {
    403                PushOperator(Token.Factorial);
    404                NextToken();
    405                TryInsertMultiply();
    406                break;
    407             }
    408             case Token.Separator:
    409                ParsePrimary(); // arguments separator in functions F(x1, x2 ... xn)
    410                break;
    411          }   
    412       }
    413 
    414       private void PushOperator(string op)
    415       {
    416          while ( Token.Compare(operators.Peek(),op) > 0) //Token.Precedence(operators.Peek()) >= Token.Precedence(op))
    417             PopOperator();
    418 
    419          operators.Push(op);
    420       }
    421 
    422       private void PopOperator()
    423       {
    424          if (Token.IsBinary(operators.Peek()))
    425          {
    426             GmpBigInteger o2 = operands.Pop();
    427             GmpBigInteger o1 = operands.Pop();
    428             Calculate(operators.Pop(), o1, o2);
    429          }
    430          else // unary operator
    431          {
    432             Calculate(operators.Pop(), operands.Pop());
    433          }
    434       }
    435 
    436       /// <summary>
    437       /// Get next token from the expression
    438       /// </summary>
    439       private void NextToken()
    440       {
    441          if (token != Token.End)
    442          {
    443             token = expression[++tokenPos].ToString();
    444          }
    445       }
    446 
    447       /// <summary>
    448       /// Read token character by character
    449       /// </summary>
    450       /// <param name="sb">Temporary buffer</param>
    451       private void CollectToken(ref StringBuilder sb)
    452       {
    453          sb.Append(token);
    454          NextToken();
    455       }
    456      
    457       private void Expect(params string[] expectedTokens)
    458       {
    459          for (int i = 0; i < expectedTokens.Length; i++)
    460             if (token == expectedTokens[i])
    461             {
    462                NextToken();
    463                return;
    464             }
    465          
    466          ThrowException("Syntax error: " + Token.ToString(expectedTokens[0]) + "  expected");
    467       }
    468 
    469       /// <summary>
    470       /// Normalizes expression.
    471       /// </summary>
    472       /// <param name="s">Expression string</param>
    473       /// <returns>Returns true, if expression is suitable for evaluating.</returns>
    474       private bool Normalize(ref string s)
    475       {
    476          s = s.Replace(" ", "").Replace("\t", " ").ToLower() + Token.End;
    477 
    478          if (s.Length >= 2) // any character and End token
    479          {
    480             //if (Token.IsBinary(s[0].ToString()) && !Token.IsName(
    481             NextToken();
    482             return true;
    483          }
    484 
    485          return false;
    486       }
    487 
    488       private void ThrowException(string message)
    489       {
    490          throw new CalculateException(message, tokenPos);
    491       }
    492 
    493    }
    494 
    495    public class CalculateException : Exception
    496    {
    497       int position;
    498 
    499       public CalculateException(string message, int position)
    500          : base("Error at position " + position.ToString() + "\r\n" + message)
    501       {
    502          this.position = position;
    503       }
    504 
    505       public int TokenPosition
    506       {
    507         get { return position; }
    508       }
    509    }
     456        }
     457
     458        private void Expect(params string[] expectedTokens)
     459        {
     460            for (int i = 0; i < expectedTokens.Length; i++)
     461                if (token == expectedTokens[i])
     462                {
     463                    NextToken();
     464                    return;
     465                }
     466
     467            ThrowException("Syntax error: " + Token.ToString(expectedTokens[0]) + "  expected");
     468        }
     469
     470        /// <summary>
     471        /// Normalizes expression.
     472        /// </summary>
     473        /// <param name="s">Expression string</param>
     474        /// <returns>Returns true, if expression is suitable for evaluating.</returns>
     475        private bool Normalize(ref string s)
     476        {
     477            s = s.Replace(" ", "").Replace("\t", " ").ToLower() + Token.End;
     478
     479            if (s.Length >= 2) // any character and End token
     480            {
     481                //if (Token.IsBinary(s[0].ToString()) && !Token.IsName(
     482                NextToken();
     483                return true;
     484            }
     485
     486            return false;
     487        }
     488
     489        private void ThrowException(string message)
     490        {
     491            throw new CalculateException(message, tokenPos);
     492        }
     493
     494    }
     495
     496    public class CalculateException : Exception
     497    {
     498        int position;
     499
     500        public CalculateException(string message, int position)
     501            : base("Error at position " + position.ToString() + "\r\n" + message)
     502        {
     503            this.position = position;
     504        }
     505
     506        public int TokenPosition
     507        {
     508            get { return position; }
     509        }
     510    }
    510511}
  • trunk/CrypPlugins/Primes/Primes/CalculatorLib/CalcProcessor.cs

    r4 r808  
    205205using System.Collections.Generic;
    206206using System.Text;
    207 using LibGmpWrapper;
     207using Primes.Bignum;
     208
    208209
    209210namespace SevenZ.Calculator
     
    217218      /// <param name="operand1">First operand</param>
    218219      /// <param name="operand2">Second operand</param>
    219        private void Calculate(string op, GmpBigInteger operand1, GmpBigInteger operand2)
     220       private void Calculate(string op, PrimesBigInteger operand1, PrimesBigInteger operand2)
    220221      {
    221           GmpBigInteger res = GmpBigInteger.Zero;
     222          PrimesBigInteger res = PrimesBigInteger.Zero;
    222223         try
    223224         {
     
    230231               case Token.Mod:        res = operand1.Mod(operand2); break;
    231232               case Token.Power:      res = operand1.Pow(operand2.IntValue); break;
    232                case Token.Log: res = GmpBigInteger.Zero; break;
    233                case Token.Root: res = GmpBigInteger.Zero; break;
     233               case Token.Log: res = PrimesBigInteger.Zero; break;
     234               case Token.Root: res = PrimesBigInteger.Zero; break;
    234235            }
    235236
     
    248249      /// <param name="op">Unary operator</param>
    249250      /// <param name="operand">Operand</param>
    250        private void Calculate(string op, GmpBigInteger operand)
     251       private void Calculate(string op, PrimesBigInteger operand)
    251252      {
    252           GmpBigInteger res = GmpBigInteger.One;
     253          PrimesBigInteger res = PrimesBigInteger.One;
    253254
    254255         try
     
    256257            switch (op)
    257258            {
    258                case Token.UnaryMinus: res = operand.Multiply(GmpBigInteger.NegativeOne); break;
     259                case Token.UnaryMinus: res = operand.Multiply(PrimesBigInteger.NegativeOne); break;
    259260               //case Token.Abs:        res = Math.Abs(operand); break;
    260261               //case Token.ACosine:    res = Math.Acos(operand); break;
     
    284285      /// Result post-processing
    285286      /// </summary>
    286        private GmpBigInteger PostProcess(GmpBigInteger result)
     287       private PrimesBigInteger PostProcess(PrimesBigInteger result)
    287288      {
    288289          return result;
  • trunk/CrypPlugins/Primes/Primes/CalculatorLib/CalcVariables.cs

    r4 r808  
    205205using System.Collections.Generic;
    206206using System.Text;
    207 using LibGmpWrapper;
     207using Primes.Bignum;
     208
    208209
    209210namespace SevenZ.Calculator
     
    214215      public event CalcVariableDelegate OnVariableStore;
    215216
    216        Dictionary<string, GmpBigInteger> variables;
     217      Dictionary<string, PrimesBigInteger> variables;
    217218
    218219      public const string AnswerVar = "r";
     
    220221      private void LoadConstants()
    221222      {
    222           variables = new Dictionary<string, GmpBigInteger>();
     223          variables = new Dictionary<string, PrimesBigInteger>();
    223224         //variables.Add("pi", Math.PI);
    224225         //variables.Add("e", Math.E);
     
    229230      }
    230231
    231        public Dictionary<string, GmpBigInteger> Variables
     232      public Dictionary<string, PrimesBigInteger> Variables
    232233      {
    233234         get { return variables; }
    234235      }
    235236
    236        public void SetVariable(string name, GmpBigInteger val)
     237       public void SetVariable(string name, PrimesBigInteger val)
    237238      {
    238239         if (variables.ContainsKey(name))
     
    245246      }
    246247
    247        public GmpBigInteger GetVariable(string name)
     248       public PrimesBigInteger GetVariable(string name)
    248249      {  // return variable's value // if variable ha push default value, 0
    249          return variables.ContainsKey(name) ? variables[name] : GmpBigInteger.Zero;                   
     250          return variables.ContainsKey(name) ? variables[name] : PrimesBigInteger.Zero;                   
    250251      }
    251252   }
  • trunk/CrypPlugins/Primes/Primes/Library/Delegates.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    205205using System.Collections.Generic;
    206206using System.Text;
    207 using LibGmpWrapper;
     207using Primes.Bignum;
    208208using System.Windows;
    209209
    210210namespace Primes.Library
    211211{
    212   public delegate void GmpBigIntegerParameterDelegate(GmpBigInteger value);
     212  public delegate void GmpBigIntegerParameterDelegate(PrimesBigInteger value);
    213213  public delegate void MessageDelegate(string message);
    214214  public delegate void ObjectParameterDelegate(object obj);
     
    216216  public delegate void CallBackDelegate(GmpBigIntegerParameterDelegate del);
    217217  public delegate void Navigate(NavigationCommandType type);
    218   public delegate void ExecuteIntegerDelegate(GmpBigInteger value);
    219   public delegate void ExecuteIntegerIntervalDelegate(GmpBigInteger from, GmpBigInteger to);
     218  public delegate void ExecuteIntegerDelegate(PrimesBigInteger value);
     219  public delegate void ExecuteIntegerIntervalDelegate(PrimesBigInteger from, PrimesBigInteger to);
    220220  public delegate void CallbackDelegateGetInteger(ExecuteIntegerDelegate ExecuteDelegate);
    221221  public delegate void CallbackDelegateGetIntegerInterval(ExecuteIntegerIntervalDelegate ExecuteIntervalDelegate);
  • trunk/CrypPlugins/Primes/Primes/Library/FactorTree/Exceptions/FactorizingException.cs

    r4 r808  
    205205using System.Collections.Generic;
    206206using System.Text;
    207 using LibGmpWrapper;
     207using Primes.Bignum;
     208
    208209
    209210
     
    218219    }
    219220
    220     public FactorizingException(GmpBigInteger value, GmpBigInteger maxValue)
     221    public FactorizingException(PrimesBigInteger value, PrimesBigInteger maxValue)
    221222      : base()
    222223    {
  • trunk/CrypPlugins/Primes/Primes/Library/FactorTree/GmpFactorTree.cs

    r4 r808  
    208208using Primes.Library.FactorTree.Exceptions;
    209209using System.Threading;
    210 using LibGmpWrapper;
     210using Primes.Bignum;
     211using Primes.Bignum;
    211212
    212213namespace Primes.Library.FactorTree
     
    219220    private GmpFactorTreeNode m_Root;
    220221    private object m_LockObject = null;
    221                 private IDictionary<string, GmpBigInteger> m_Factors;
     222                private IDictionary<string, PrimesBigInteger> m_Factors;
    222223
    223224   
    224     private GmpBigInteger m_Remainder;
     225    private PrimesBigInteger m_Remainder;
    225226
    226227    public GmpFactorTreeNode Root
     
    234235    }
    235236
    236                 public GmpBigInteger GetFactorCount(string factor)
     237                public PrimesBigInteger GetFactorCount(string factor)
    237238                {
    238239                        if (m_Factors.ContainsKey(factor))
     
    247248                }
    248249
    249     public GmpBigInteger Remainder
     250    public PrimesBigInteger Remainder
    250251    {
    251252      get { return m_Remainder; }
     
    260261    public event GmpBigIntegerParameterDelegate OnActualDivisorChanged;
    261262
    262     public void FireOnActualDivisorChanged(GmpBigInteger i)
     263    public void FireOnActualDivisorChanged(PrimesBigInteger i)
    263264    {
    264265      if (OnActualDivisorChanged != null)
     
    268269    }
    269270    #endregion
    270     public void Factorize(GmpBigInteger value)
    271     {
    272                         m_Factors = new Dictionary<string, GmpBigInteger>();
     271    public void Factorize(PrimesBigInteger value)
     272    {
     273                        m_Factors = new Dictionary<string, PrimesBigInteger>();
    273274                        m_FactorThread = new Thread(new ParameterizedThreadStart(DoFactorize));
    274275      this.m_Root = new GmpFactorTreeNode(value);
     
    317318                {
    318319      m_Height = 0;
    319       GmpBigInteger divisor = new GmpBigInteger(GmpBigInteger.Two);
     320      PrimesBigInteger divisor = PrimesBigInteger.Two;
    320321      FireOnActualDivisorChanged(divisor);
    321       GmpBigInteger value = new GmpBigInteger(this.m_Root.Value);
     322      PrimesBigInteger value = new PrimesBigInteger(this.m_Root.Value);
    322323      GmpFactorTreeNode node = this.m_Root;
    323324      while (!value.IsProbablePrime(10))
    324325      {
    325326          //int counter = 0;
    326           while (value.Mod(divisor).CompareTo(GmpBigInteger.Zero) != 0)
     327          while (value.Mod(divisor).CompareTo(PrimesBigInteger.Zero) != 0)
    327328          {
    328329            divisor = divisor.NextProbablePrime();
     
    359360    }
    360361
    361                 private void FastTrialDivision()
    362                 {
    363                         m_Height = 0;
    364                 GmpBigInteger m_factor = GmpBigInteger.Two;
    365                         int mod30 = m_factor.Mod(GmpBigInteger.ValueOf(30)).IntValue;
    366                         GmpBigInteger value = new GmpBigInteger(this.m_Root.Value);
    367                         GmpBigInteger max = value.SquareRoot();
    368                         GmpFactorTreeNode node = this.m_Root;
    369       bool run = true;
    370       if (value.IsProbablePrime(10))
    371         run = false;
     362      //  private void FastTrialDivision()
     363      //  {
     364      //      m_Height = 0;
     365      //  PrimesBigInteger m_factor = PrimesBigInteger.Two;
     366      //      int mod30 = m_factor.Mod(PrimesBigInteger.ValueOf(30)).IntValue;
     367      //      PrimesBigInteger value = new PrimesBigInteger(this.m_Root.Value);
     368      //      PrimesBigInteger max = value.SquareRoot();
     369      //      GmpFactorTreeNode node = this.m_Root;
     370      //bool run = true;
     371      //if (value.IsProbablePrime(10))
     372      //  run = false;
    372373     
    373                         while (run)
    374                         {
    375                                 while (m_factor.CompareTo(max) <= 0)
    376                                 {
    377                                         if (!(mod30 == 1 ||
    378                                         mod30 == 7 ||
    379                                         mod30 == 11 ||
    380                                         mod30 == 13 ||
    381                                         mod30 == 17 ||
    382                                         mod30 == 19 ||
    383                                         mod30 == 23 ||
    384                                         mod30 == 29 ||
    385                                          m_factor.CompareTo(GmpBigInteger.Two) == 0 ||
    386                                          m_factor.CompareTo(GmpBigInteger.ValueOf(3)) == 0 ||
    387                                          m_factor.CompareTo(GmpBigInteger.ValueOf(5)) == 0))
    388                                         {
    389                                                 m_factor = m_factor.Add(GmpBigInteger.One);
    390                                                 mod30++;
    391                                                 (mod30) %= 30;
    392                                                 continue;
    393                                         }
    394                                         if (value.Mod(m_factor).CompareTo(GmpBigInteger.Zero)==0)
    395                                         {
    396                                                 value = value.Divide(m_factor);
    397             m_Remainder = value;
    398 
    399                                                 max = value.SquareRoot();
    400                                                 GmpFactorTreeNode primeNodeTmp = new GmpFactorTreeNode(m_factor);
    401             primeNodeTmp.IsPrime = m_factor.IsPrime(10);
    402             m_Height++;
    403             AddFactor(m_factor);
    404             node.AddChild(primeNodeTmp);
    405                                                 node = node.AddChild(new GmpFactorTreeNode(value));
    406                                                 continue;
    407                                         }
    408                                         m_factor = m_factor.Add(GmpBigInteger.One);
    409                                         mod30++;
    410                                         (mod30) %= 30;
    411                                         run = false;
    412                                 }
    413                                 run = false;
    414                         }
    415       m_Remainder = null;
    416                         node.IsPrime = true;
    417                         AddFactor(value);
    418                 }
    419 
    420                 private void AddFactor(GmpBigInteger value)
     374      //      while (run)
     375      //      {
     376      //          while (m_factor.CompareTo(max) <= 0)
     377      //          {
     378      //              if (!(mod30 == 1 ||
     379      //              mod30 == 7 ||
     380      //              mod30 == 11 ||
     381      //              mod30 == 13 ||
     382      //              mod30 == 17 ||
     383      //              mod30 == 19 ||
     384      //              mod30 == 23 ||
     385      //              mod30 == 29 ||
     386      //               m_factor.CompareTo(PrimesBigInteger.Two) == 0 ||
     387      //               m_factor.CompareTo(PrimesBigInteger.ValueOf(3)) == 0 ||
     388      //               m_factor.CompareTo(PrimesBigInteger.ValueOf(5)) == 0))
     389      //              {
     390      //                  m_factor = m_factor.Add(PrimesBigInteger.One);
     391      //                  mod30++;
     392      //                  (mod30) %= 30;
     393      //                  continue;
     394      //              }
     395      //              if (value.Mod(m_factor).CompareTo(PrimesBigInteger.Zero)==0)
     396      //              {
     397      //                  value = value.Divide(m_factor);
     398      //      m_Remainder = value;
     399
     400      //                  max = value.SquareRoot();
     401      //                  GmpFactorTreeNode primeNodeTmp = new GmpFactorTreeNode(m_factor);
     402      //      primeNodeTmp.IsPrime = m_factor.IsPrime(10);
     403      //      m_Height++;
     404      //      AddFactor(m_factor);
     405      //      node.AddChild(primeNodeTmp);
     406      //                  node = node.AddChild(new GmpFactorTreeNode(value));
     407      //                  continue;
     408      //              }
     409      //              m_factor = m_factor.Add(PrimesBigInteger.One);
     410      //              mod30++;
     411      //              (mod30) %= 30;
     412      //              run = false;
     413      //          }
     414      //          run = false;
     415      //      }
     416      //m_Remainder = null;
     417      //      node.IsPrime = true;
     418      //      AddFactor(value);
     419      //  }
     420
     421                private void AddFactor(PrimesBigInteger value)
    421422                {
    422423                        if (m_Factors.ContainsKey(value.ToString()))
    423                                 m_Factors[value.ToString()] = m_Factors[value.ToString()].Add(GmpBigInteger.One);
     424                                m_Factors[value.ToString()] = m_Factors[value.ToString()].Add(PrimesBigInteger.One);
    424425                        else
    425                                 m_Factors.Add(value.ToString(), GmpBigInteger.One);
     426                                m_Factors.Add(value.ToString(), PrimesBigInteger.One);
    426427                        if (OnFactorFound != null)
    427428                                OnFactorFound();
     
    459460  {
    460461
    461     public GmpFactorTreeNode(GmpBigInteger value)
    462     {
    463       this.m_Value = new GmpBigInteger(value);
     462    public GmpFactorTreeNode(PrimesBigInteger value)
     463    {
     464      this.m_Value = new PrimesBigInteger(value);
    464465    }
    465466
     
    471472      set { m_IsPrime = value; }
    472473    }
    473     private GmpBigInteger m_Value = null;
    474 
    475     public GmpBigInteger Value
     474    private PrimesBigInteger m_Value = null;
     475
     476    public PrimesBigInteger Value
    476477    {
    477478      get { return m_Value; }
  • trunk/CrypPlugins/Primes/Primes/Library/Function/FunctionPiX.cs

    r4 r808  
    206206using System.Text;
    207207using Primes.Library;
    208 using LibGmpWrapper;
     208using Primes.Bignum;
    209209
    210210
     
    269269      }
    270270
    271       if (GmpBigInteger.ValueOf(m_LastNumber).IsPrime(10)) m_LastNumber++;
     271      if (PrimesBigInteger.ValueOf(m_LastNumber).IsPrime(10)) m_LastNumber++;
    272272      while (m_LastNumber < value)
    273273      {
    274         if (GmpBigInteger.ValueOf(m_LastNumber).IsPrime(10))
     274        if (PrimesBigInteger.ValueOf(m_LastNumber).IsPrime(10))
    275275        {
    276276          m_Counter++;
     
    279279        m_LastNumber++;
    280280      }
    281       if (GmpBigInteger.ValueOf(value).IsPrime(10)&&!usePrimesCountList)
     281      if (PrimesBigInteger.ValueOf(value).IsPrime(10)&&!usePrimesCountList)
    282282      {
    283283        m_FormerValue = m_Counter;
  • trunk/CrypPlugins/Primes/Primes/Library/Function/Range.cs

    r4 r808  
    205205using System.Collections.Generic;
    206206using System.Text;
    207 using LibGmpWrapper;
     207using Primes.Bignum;
    208208
    209209namespace Primes.Library
     
    211211  public class Range
    212212  {
    213     private GmpBigInteger m_From;
    214 
    215     public GmpBigInteger From
     213    private PrimesBigInteger m_From;
     214
     215    public PrimesBigInteger From
    216216    {
    217217      get { return m_From; }
     
    219219    }
    220220
    221     private GmpBigInteger m_To;
    222 
    223     public GmpBigInteger To
     221    private PrimesBigInteger m_To;
     222
     223    public PrimesBigInteger To
    224224    {
    225225      get { return m_To; }
     
    227227    }
    228228
    229     public Range(GmpBigInteger from, GmpBigInteger to)
     229    public Range(PrimesBigInteger from, PrimesBigInteger to)
    230230    {
    231231      this.From = from;
    232232      this.To = to;
    233233    }
    234     public Range(int from, int to):this(GmpBigInteger.ValueOf(from),GmpBigInteger.ValueOf(to))
    235     {
    236     }
    237 
    238     public GmpBigInteger RangeAmount
     234    public Range(int from, int to):this(PrimesBigInteger.ValueOf(from),PrimesBigInteger.ValueOf(to))
     235    {
     236    }
     237
     238    public PrimesBigInteger RangeAmount
    239239    {
    240240      get
    241241      {
    242242
    243         return this.To.Add((this.From.Multiply(GmpBigInteger.ValueOf(-1))));
     243        return this.To.Add((this.From.Multiply(PrimesBigInteger.ValueOf(-1))));
    244244      }
    245245    }
    246246
    247     public virtual GmpBigInteger GetZeroPosition()
     247    public virtual PrimesBigInteger GetZeroPosition()
    248248    {
    249249      throw new NotImplementedException("GetZeroPosition is only implmented in Primes.Library.RangeX and Primes.Library.RangeY");
  • trunk/CrypPlugins/Primes/Primes/Library/Function/RangeX.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    205205using System.Collections.Generic;
    206206using System.Text;
    207 using LibGmpWrapper;
     207using Primes.Bignum;
    208208
    209209namespace Primes.Library
     
    211211  public class RangeX:Range
    212212  {
    213     public RangeX(GmpBigInteger from, GmpBigInteger to)
     213    public RangeX(PrimesBigInteger from, PrimesBigInteger to)
    214214      : base(from,to)
    215215    {
    216216    }
    217217
    218     public override GmpBigInteger GetZeroPosition()
     218    public override PrimesBigInteger GetZeroPosition()
    219219    {
    220       GmpBigInteger result = GmpBigInteger.Zero;
    221       if (this.From.CompareTo(GmpBigInteger.Zero) < 0)
     220      PrimesBigInteger result = PrimesBigInteger.Zero;
     221      if (this.From.CompareTo(PrimesBigInteger.Zero) < 0)
    222222      {
    223         result = this.From.Multiply(GmpBigInteger.ValueOf(-1));
     223        result = this.From.Multiply(PrimesBigInteger.ValueOf(-1));
    224224      }
    225225      return result;
  • trunk/CrypPlugins/Primes/Primes/Library/Function/RangeY.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    205205using System.Collections.Generic;
    206206using System.Text;
    207 using LibGmpWrapper;
     207using Primes.Bignum;
    208208
    209209namespace Primes.Library
     
    211211  public class RangeY : Range
    212212  {
    213     public RangeY(GmpBigInteger from, GmpBigInteger to)
     213    public RangeY(PrimesBigInteger from, PrimesBigInteger to)
    214214      : base(from,to)
    215215    {
    216216    }
    217     public override GmpBigInteger GetZeroPosition()
     217    public override PrimesBigInteger GetZeroPosition()
    218218    {
    219       GmpBigInteger result = RangeAmount;
    220       if (this.From.CompareTo(GmpBigInteger.Zero) < 0)
     219      PrimesBigInteger result = RangeAmount;
     220      if (this.From.CompareTo(PrimesBigInteger.Zero) < 0)
    221221      {
    222222          result = RangeAmount.Add(this.From);
  • trunk/CrypPlugins/Primes/Primes/Primes.csproj

    r234 r808  
    3232  </PropertyGroup>
    3333  <ItemGroup>
    34     <Reference Include="LibGmpWrapper, Version=1.0.2987.28787, Culture=neutral, processorArchitecture=x86">
     34    <Reference Include="BouncyCastle.Crypto, Version=1.5.0.0, Culture=neutral, PublicKeyToken=0e99375e54769942">
    3535      <SpecificVersion>False</SpecificVersion>
    36       <HintPath>..\Primes.References\LibGmpWrapper.dll</HintPath>
     36      <HintPath>..\Primes.References\BouncyCastle.Crypto.dll</HintPath>
    3737    </Reference>
    3838    <Reference Include="Microsoft.Windows.Design, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
     
    7171  </ItemGroup>
    7272  <ItemGroup>
     73    <Compile Include="Bignum\PrimesBigInteger.cs" />
    7374    <Compile Include="CalculatorLib\CalcParser.cs" />
    7475    <Compile Include="CalculatorLib\CalcProcessor.cs" />
  • trunk/CrypPlugins/Primes/Primes/WpfControls.Validation/Advisors/LargeNumberAdvisor.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    205205using System.Collections.Generic;
    206206using System.Text;
    207 using LibGmpWrapper;
     207using Primes.Bignum;
    208208
    209209namespace Primes.WpfControls.Validation.Advisers
    210210{
    211   public class LargeNumberAdvisor:IValidator<GmpBigInteger>
     211  public class LargeNumberAdvisor:IValidator<PrimesBigInteger>
    212212  {
    213213    #region Properties
    214     private GmpBigInteger m_Limit;
     214    private PrimesBigInteger m_Limit;
    215215    private OnlineHelp.OnlineHelpActions m_HelpLink;
    216     private GmpBigInteger m_Value;
     216    private PrimesBigInteger m_Value;
    217217    #endregion
    218     public LargeNumberAdvisor(GmpBigInteger limit, OnlineHelp.OnlineHelpActions helplink)
     218    public LargeNumberAdvisor(PrimesBigInteger limit, OnlineHelp.OnlineHelpActions helplink)
    219219    {
    220220      m_Limit = limit;
    221221      m_HelpLink = helplink;
    222222    }
    223     #region IValidator<GmpBigInteger> Members
     223    #region IValidator<PrimesBigInteger> Members
    224224
    225225    public object Value
     
    231231      set
    232232      {
    233         m_Value = value as GmpBigInteger ;
     233        m_Value = value as PrimesBigInteger ;
    234234      }
    235235    }
    236236
    237     public ValidationResult Validate(ref GmpBigInteger t)
     237    public ValidationResult Validate(ref PrimesBigInteger t)
    238238    {
    239239      m_Value = t;
  • trunk/CrypPlugins/Primes/Primes/WpfControls.Validation/Validator/BigIntegerMinValueMaxValueValidator.cs

    r4 r808  
    206206using System.Text;
    207207
    208 using LibGmpWrapper;
     208using Primes.Bignum;
    209209
    210210namespace Primes.WpfControls.Validation.Validator
     
    214214
    215215    #region Properties
    216     private GmpBigInteger m_MaxValue;
     216    private PrimesBigInteger m_MaxValue;
    217217    private string m_Message;
    218218    public override string Message
     
    245245
    246246    #region Constructors
    247     public BigIntegerMinValueMaxValueValidator(object value, GmpBigInteger minValue, GmpBigInteger maxValue)
     247    public BigIntegerMinValueMaxValueValidator(object value, PrimesBigInteger minValue, PrimesBigInteger maxValue)
    248248      : base(value, minValue)
    249249    {
     
    253253    #endregion
    254254
    255     public override ValidationResult Validate(ref GmpBigInteger bi)
     255    public override ValidationResult Validate(ref PrimesBigInteger bi)
    256256    {
    257257      ValidationResult result = base.Validate(ref bi);
  • trunk/CrypPlugins/Primes/Primes/WpfControls.Validation/Validator/BigIntegerMinValueValidator.cs

    r4 r808  
    206206using System.Text;
    207207
    208 using LibGmpWrapper;
     208using Primes.Bignum;
    209209
    210210namespace Primes.WpfControls.Validation.Validator
     
    212212  public class BigIntegerMinValueValidator : BigIntegerValidator
    213213  {
    214     public BigIntegerMinValueValidator(object value, GmpBigInteger minValue)
     214    public BigIntegerMinValueValidator(object value, PrimesBigInteger minValue)
    215215      : base(value)
    216216    {
     
    219219
    220220    public BigIntegerMinValueValidator() : base() { }
    221     private GmpBigInteger m_MinValue;
    222 
    223     public GmpBigInteger MinValue
     221    private PrimesBigInteger m_MinValue;
     222
     223    public PrimesBigInteger MinValue
    224224    {
    225225      get { return m_MinValue; }
    226226      set { m_MinValue = value; }
    227227    }
    228     public override ValidationResult Validate(ref GmpBigInteger bi)
     228    public override ValidationResult Validate(ref PrimesBigInteger bi)
    229229    {
    230230      ValidationResult result = base.Validate(ref bi);
  • trunk/CrypPlugins/Primes/Primes/WpfControls.Validation/Validator/BigIntegerValidator.cs

    r4 r808  
    206206using System.Text;
    207207using System.Text.RegularExpressions;
    208 using LibGmpWrapper;
     208using Primes.Bignum;
    209209
    210210namespace Primes.WpfControls.Validation
    211211{
    212212
    213   public class BigIntegerValidator : IValidator<GmpBigInteger>
     213  public class BigIntegerValidator : IValidator<PrimesBigInteger>
    214214  {
    215215
     
    229229    #region IValidator Members
    230230
    231     public virtual ValidationResult Validate(ref GmpBigInteger bi)
     231    public virtual ValidationResult Validate(ref PrimesBigInteger bi)
    232232    {
    233233      if (m_Value != null)
     
    249249        else
    250250        {
    251           if (m_Value.GetType() == typeof(GmpBigInteger))
     251          if (m_Value.GetType() == typeof(PrimesBigInteger))
    252252          {
    253             bi = m_Value as GmpBigInteger;
     253            bi = m_Value as PrimesBigInteger;
    254254            return ValidationResult.OK;
    255255          }
     
    295295    #endregion
    296296
    297     #region IValidator<GmpBigInteger> Members
     297    #region IValidator<PrimesBigInteger> Members
    298298
    299299
  • trunk/CrypPlugins/Primes/Primes/WpfControls.Validation/Validator/PositiveBigIntegerValidator.cs

    r4 r808  
    206206using System.Text;
    207207
    208 using LibGmpWrapper;
     208using Primes.Bignum;
    209209
    210210namespace Primes.WpfControls.Validation.Validator
     
    212212  public class PositiveBigIntegerValidator : BigIntegerMinValueValidator
    213213  {
    214     public PositiveBigIntegerValidator(object value) : base(value, GmpBigInteger.ValueOf(0)) { }
    215     public PositiveBigIntegerValidator() : base(null, GmpBigInteger.ValueOf(0)) { }
     214    public PositiveBigIntegerValidator(object value) : base(value, PrimesBigInteger.ValueOf(0)) { }
     215    public PositiveBigIntegerValidator() : base(null, PrimesBigInteger.ValueOf(0)) { }
    216216  }
    217217}
  • trunk/CrypPlugins/Primes/Primes/WpfControls.Validation/Validator/PositiveMaxValueBigIntegerValidator.cs

    r4 r808  
    206206using System.Text;
    207207
    208 using LibGmpWrapper;
     208using Primes.Bignum;
    209209
    210210namespace Primes.WpfControls.Validation.Validator
     
    212212  public class PositiveMaxValueBigIntegerValidator:PositiveBigIntegerValidator
    213213  {
    214     protected GmpBigInteger m_MaxValue;
     214    protected PrimesBigInteger m_MaxValue;
    215215    public PositiveMaxValueBigIntegerValidator() : base() { }
    216     public PositiveMaxValueBigIntegerValidator(GmpBigInteger maxvalue) : this("", maxvalue) { }
    217 
    218     public PositiveMaxValueBigIntegerValidator(object value, GmpBigInteger maxValue)
     216    public PositiveMaxValueBigIntegerValidator(PrimesBigInteger maxvalue) : this("", maxvalue) { }
     217
     218    public PositiveMaxValueBigIntegerValidator(object value, PrimesBigInteger maxValue)
    219219      : base(value)
    220220    {
     
    222222    }
    223223
    224     public override ValidationResult Validate(ref GmpBigInteger bi)
     224    public override ValidationResult Validate(ref PrimesBigInteger bi)
    225225    {
    226226      ValidationResult result = base.Validate(ref bi);
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Components/GenerateRandomControl.xaml.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    214214using System.Windows.Navigation;
    215215using System.Windows.Shapes;
    216 using LibGmpWrapper;
     216using Primes.Bignum;
    217217using Primes.Library;
    218218
     
    232232
    233233
    234     private void FireOnRandomNumberGenerated(GmpBigInteger value)
     234    private void FireOnRandomNumberGenerated(PrimesBigInteger value)
    235235    {
    236236      if (OnRandomNumberGenerated != null)
     
    273273    private void miIntegerManyFactors_Click(object sender, RoutedEventArgs e)
    274274    {
    275       GmpBigInteger value = null;
     275      PrimesBigInteger value = null;
    276276      if (sender == miBigInteger)
    277277      {
    278         value = GmpBigInteger.Random(100);
     278        value = PrimesBigInteger.Random(100);
    279279        while (value.IsProbablePrime(20))
    280           value = GmpBigInteger.Random(100);
    281         if (value.Mod(GmpBigInteger.Two).Equals(GmpBigInteger.Zero)) value = value.Add(GmpBigInteger.One);
     280          value = PrimesBigInteger.Random(100);
     281        if (value.Mod(PrimesBigInteger.Two).Equals(PrimesBigInteger.Zero)) value = value.Add(PrimesBigInteger.One);
    282282      }
    283283      else if (sender == miIntegerManyFactors)
    284284      {
    285285        Random r = new Random();
    286         value = GmpBigInteger.ValueOf(r.Next(999)).NextProbablePrime();
     286        value = PrimesBigInteger.ValueOf(r.Next(999)).NextProbablePrime();
    287287        for (int i = 0; i < 19; i++)
    288288        {
    289           value = value.Multiply(GmpBigInteger.ValueOf(r.Next(999)).NextProbablePrime());
     289          value = value.Multiply(PrimesBigInteger.ValueOf(r.Next(999)).NextProbablePrime());
    290290        }
    291291      }
    292292      else if (sender == miTowBigFactors)
    293293      {
    294         value = GmpBigInteger.Random(15).NextProbablePrime().Multiply(GmpBigInteger.Random(15).NextProbablePrime());
     294        value = PrimesBigInteger.Random(15).NextProbablePrime().Multiply(PrimesBigInteger.Random(15).NextProbablePrime());
    295295      }
    296296      if (value != null)
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Components/IExpression.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    205205using System.Collections.Generic;
    206206using System.Text;
    207 using LibGmpWrapper;
     207using Primes.Bignum;
    208208
    209209namespace Primes.WpfControls.Components
     
    211211  public interface IExpression
    212212  {
    213     GmpBigInteger Execute(GmpBigInteger input);
    214     void SetParameter(string name, GmpBigInteger value);
     213    PrimesBigInteger Execute(PrimesBigInteger input);
     214    void SetParameter(string name, PrimesBigInteger value);
    215215    void Reset();
    216216  }
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Components/IPolynom.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    206206using System.Text;
    207207using System.Windows.Controls;
    208 using LibGmpWrapper;
     208using Primes.Bignum;
    209209using Primes.Library;
    210210
     
    222222  public interface IPolynomRange:IFormular<RangePolynomFactor>
    223223    {
    224     GmpBigInteger Execute(GmpBigInteger input);
     224    PrimesBigInteger Execute(PrimesBigInteger input);
    225225
    226226  }
     
    228228  public class PolynomFactor
    229229  {
    230     public PolynomFactor(string name, GmpBigInteger value)
     230    public PolynomFactor(string name, PrimesBigInteger value)
    231231    {
    232232      this.Name = name;
    233233      this.Value = value;
    234234    }
    235     public PolynomFactor(string name, GmpBigInteger value, bool isReadOnly)
     235    public PolynomFactor(string name, PrimesBigInteger value, bool isReadOnly)
    236236    {
    237237      this.Name = name;
     
    247247      set { m_Name = value; }
    248248    }
    249     private GmpBigInteger m_Value;
    250 
    251     public GmpBigInteger Value
     249    private PrimesBigInteger m_Value;
     250
     251    public PrimesBigInteger Value
    252252    {
    253253      get { return m_Value; }
     
    266266  public class RangePolynomFactor
    267267  {
    268     public RangePolynomFactor(string name, GmpBigInteger from, GmpBigInteger to):this(name,new RangeX(from, to))
     268    public RangePolynomFactor(string name, PrimesBigInteger from, PrimesBigInteger to):this(name,new RangeX(from, to))
    269269    {
    270270    }
     
    290290    private Range m_Range;
    291291
    292     public GmpBigInteger From
     292    public PrimesBigInteger From
    293293    {
    294294      get { return m_Range.From; }
    295295    }
    296     public GmpBigInteger To
     296    public PrimesBigInteger To
    297297    {
    298298      get { return m_Range.To; }
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Components/InputRangeControl.xaml.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    214214using System.Windows.Navigation;
    215215using System.Windows.Shapes;
    216 using LibGmpWrapper;
     216using Primes.Bignum;
    217217using Primes.WpfControls.Validation;
    218218using Primes.WpfControls.Validation.ControlValidator.Exceptions;
     
    225225  /// Interaction logic for InputRangeControl.xaml
    226226  /// </summary>
    227   public delegate void ExecuteDelegate(GmpBigInteger from, GmpBigInteger to);
     227  public delegate void ExecuteDelegate(PrimesBigInteger from, PrimesBigInteger to);
    228228  public partial class InputRangeControl : UserControl
    229229  {
     
    252252    {
    253253      InitializeComponent();
    254       m_Validators = new Dictionary<string, InputValidator<GmpBigInteger>>();
    255       m_ValueValidators = new Dictionary<string, IValidator<GmpBigInteger>>();
    256       m_SingleAdvisors = new Dictionary<string, IList<IValidator<GmpBigInteger>>>();
    257       m_SingleAdvisors.Add(From,new List<IValidator<GmpBigInteger>>());
    258       m_SingleAdvisors.Add(To, new List<IValidator<GmpBigInteger>>());
     254      m_Validators = new Dictionary<string, InputValidator<PrimesBigInteger>>();
     255      m_ValueValidators = new Dictionary<string, IValidator<PrimesBigInteger>>();
     256      m_SingleAdvisors = new Dictionary<string, IList<IValidator<PrimesBigInteger>>>();
     257      m_SingleAdvisors.Add(From,new List<IValidator<PrimesBigInteger>>());
     258      m_SingleAdvisors.Add(To, new List<IValidator<PrimesBigInteger>>());
    259259
    260260    }
     
    455455    }
    456456
    457     private IDictionary<string, InputValidator<GmpBigInteger>> m_Validators;
    458     public void AddInputValidator(string key, InputValidator<GmpBigInteger> validator)
     457    private IDictionary<string, InputValidator<PrimesBigInteger>> m_Validators;
     458    public void AddInputValidator(string key, InputValidator<PrimesBigInteger> validator)
    459459    {
    460460      if (this.m_Validators.ContainsKey(key))
     
    470470
    471471
    472     private IDictionary<string, IValidator<GmpBigInteger>> m_ValueValidators;
    473     public void AddValueValidator(string key, IValidator<GmpBigInteger> validator)
     472    private IDictionary<string, IValidator<PrimesBigInteger>> m_ValueValidators;
     473    public void AddValueValidator(string key, IValidator<PrimesBigInteger> validator)
    474474    {
    475475      if (this.m_ValueValidators.ContainsKey(key))
     
    483483    }
    484484
    485     private IValidator<GmpBigInteger> m_RangeValueValidator;
    486 
    487     public IValidator<GmpBigInteger> RangeValueValidator
     485    private IValidator<PrimesBigInteger> m_RangeValueValidator;
     486
     487    public IValidator<PrimesBigInteger> RangeValueValidator
    488488    {
    489489      get { return m_RangeValueValidator; }
     
    538538      }
    539539    }
    540     private IDictionary<string, IList<IValidator<GmpBigInteger>>> m_SingleAdvisors;
    541     public void AddSingleAdisors(string key, IValidator<GmpBigInteger> advisor)
     540    private IDictionary<string, IList<IValidator<PrimesBigInteger>>> m_SingleAdvisors;
     541    public void AddSingleAdisors(string key, IValidator<PrimesBigInteger> advisor)
    542542    {
    543543      if (m_SingleAdvisors.ContainsKey(key))
     
    673673    #region Buttons
    674674
    675     public bool GetValue(ref GmpBigInteger from, ref GmpBigInteger to)
     675    public bool GetValue(ref PrimesBigInteger from, ref PrimesBigInteger to)
    676676    {
    677677      from = null;
     
    691691        if (this.m_ValueValidators.ContainsKey(From))
    692692        {
    693           IValidator<GmpBigInteger> validator = this.m_ValueValidators[From];
     693          IValidator<PrimesBigInteger> validator = this.m_ValueValidators[From];
    694694          validator.Value = from;
    695695          if (validator.Validate(ref from) != Primes.WpfControls.Validation.ValidationResult.OK)
     
    710710        if (this.m_ValueValidators.ContainsKey(To))
    711711        {
    712           IValidator<GmpBigInteger> validator = this.m_ValueValidators[To];
     712          IValidator<PrimesBigInteger> validator = this.m_ValueValidators[To];
    713713          validator.Value = to;
    714714          if (validator.Validate(ref to) != Primes.WpfControls.Validation.ValidationResult.OK)
     
    729729        {
    730730          m_RangeValueValidator.Value = to.Subtract(from);
    731           GmpBigInteger range = null;
     731          PrimesBigInteger range = null;
    732732          if (m_RangeValueValidator.Validate(ref range) != Primes.WpfControls.Validation.ValidationResult.OK)
    733733          {
     
    745745
    746746        }
    747         foreach (IValidator<GmpBigInteger> validator in this.m_SingleAdvisors[From])
     747        foreach (IValidator<PrimesBigInteger> validator in this.m_SingleAdvisors[From])
    748748        {
    749749          if (validator.Validate(ref from) != Primes.WpfControls.Validation.ValidationResult.OK)
     
    760760          }
    761761        }
    762         foreach (IValidator<GmpBigInteger> validator in this.m_SingleAdvisors[To])
     762        foreach (IValidator<PrimesBigInteger> validator in this.m_SingleAdvisors[To])
    763763        {
    764764          if (validator.Validate(ref to) != Primes.WpfControls.Validation.ValidationResult.OK)
     
    789789    private void DoExecute(bool doExecute)
    790790    {
    791       GmpBigInteger from = null;
    792       GmpBigInteger to = null;
     791      PrimesBigInteger from = null;
     792      PrimesBigInteger to = null;
    793793      GetValue(ref from, ref to);
    794794      if (Execute != null && doExecute && from != null && to != null) {
     
    814814
    815815    #region Validation of Free Input
    816     public void ValidateFreeInput(ref GmpBigInteger from, ref GmpBigInteger to)
     816    public void ValidateFreeInput(ref PrimesBigInteger from, ref PrimesBigInteger to)
    817817    {
    818818      try
     
    855855    }
    856856
    857     public GmpBigInteger ValidateInput(TextBox tbSource)
    858     {
    859       GmpBigInteger result = GmpBigInteger.Zero;
    860       InputValidator<GmpBigInteger> m_Validator;
     857    public PrimesBigInteger ValidateInput(TextBox tbSource)
     858    {
     859      PrimesBigInteger result = PrimesBigInteger.Zero;
     860      InputValidator<PrimesBigInteger> m_Validator;
    861861      if (m_Validators.ContainsKey(tbSource.Tag.ToString()))
    862862      {
     
    865865      else
    866866      {
    867         m_Validator = new InputValidator<GmpBigInteger>();
     867        m_Validator = new InputValidator<PrimesBigInteger>();
    868868        m_Validator.Validator = new BigIntegerValidator(tbSource.Text);
    869869      }
    870870      try
    871871      {
    872         TextBoxValidator<GmpBigInteger> tbvalidator = new TextBoxValidator<GmpBigInteger>(m_Validator.Validator, tbSource,m_Validator.DefaultValue);
     872        TextBoxValidator<PrimesBigInteger> tbvalidator = new TextBoxValidator<PrimesBigInteger>(m_Validator.Validator, tbSource,m_Validator.DefaultValue);
    873873        tbvalidator.Validate(ref result);
    874874      }
     
    884884
    885885    #region Validation of Calculate Input
    886     public void ValidateCalcInput(ref GmpBigInteger from, ref GmpBigInteger to)
     886    public void ValidateCalcInput(ref PrimesBigInteger from, ref PrimesBigInteger to)
    887887    {
    888888      try
    889889      {
    890         GmpBigInteger fromFactor = ValidateInput(m_tbFromCalcFactor);
    891         GmpBigInteger fromBase = ValidateInput(m_tbFromCalcBase);
    892         GmpBigInteger fromExp = ValidateInput(m_tbFromCalcExp);
    893         GmpBigInteger fromSum = ValidateInput(m_tbFromCalcSum);
    894         GmpBigInteger toFactor = ValidateInput(m_tbToCalcFactor);
    895         GmpBigInteger toBase = ValidateInput(m_tbToCalcBase);
    896         GmpBigInteger toExp = ValidateInput(m_tbToCalcExp);
    897         GmpBigInteger toSum = ValidateInput(m_tbToCalcSum);
     890        PrimesBigInteger fromFactor = ValidateInput(m_tbFromCalcFactor);
     891        PrimesBigInteger fromBase = ValidateInput(m_tbFromCalcBase);
     892        PrimesBigInteger fromExp = ValidateInput(m_tbFromCalcExp);
     893        PrimesBigInteger fromSum = ValidateInput(m_tbFromCalcSum);
     894        PrimesBigInteger toFactor = ValidateInput(m_tbToCalcFactor);
     895        PrimesBigInteger toBase = ValidateInput(m_tbToCalcBase);
     896        PrimesBigInteger toExp = ValidateInput(m_tbToCalcExp);
     897        PrimesBigInteger toSum = ValidateInput(m_tbToCalcSum);
    898898        from = fromBase.Pow(fromExp.IntValue).Multiply(fromFactor).Add(fromSum);
    899899        to = toBase.Pow(toExp.IntValue).Multiply(toFactor).Add(toSum);
     
    10321032    private void tb_KeyDown(object sender, KeyEventArgs e)
    10331033    {
    1034       GmpBigInteger from = null;
    1035       GmpBigInteger to = null;
     1034      PrimesBigInteger from = null;
     1035      PrimesBigInteger to = null;
    10361036      GetValue(ref from, ref to);
    10371037      if (from != null && to != null)
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Components/InputSingleControl.xaml.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    214214using System.Windows.Navigation;
    215215using System.Windows.Shapes;
    216 using LibGmpWrapper;
     216using Primes.Bignum;
    217217using Primes.WpfControls.Validation;
    218218using Primes.WpfControls.Validation.ControlValidator.Exceptions;
     
    225225  /// Interaction logic for InputRangeControl.xaml
    226226  /// </summary>
    227   public delegate void ExecuteSingleDelegate(GmpBigInteger value);
     227  public delegate void ExecuteSingleDelegate(PrimesBigInteger value);
    228228  public partial class InputSingleControl : UserControl
    229229  {
     
    249249      {
    250250        InitializeComponent();
    251         m_Validators = new Dictionary<string, InputValidator<GmpBigInteger>>();
    252         m_SingleAdvisors = new Dictionary<string, IList<IValidator<GmpBigInteger>>>();
    253         m_SingleAdvisors.Add(Value, new List<IValidator<GmpBigInteger>>());
    254         m_ValueValidators = new Dictionary<string, IValidator<GmpBigInteger>>();
     251        m_Validators = new Dictionary<string, InputValidator<PrimesBigInteger>>();
     252        m_SingleAdvisors = new Dictionary<string, IList<IValidator<PrimesBigInteger>>>();
     253        m_SingleAdvisors.Add(Value, new List<IValidator<PrimesBigInteger>>());
     254        m_ValueValidators = new Dictionary<string, IValidator<PrimesBigInteger>>();
    255255        this.Title = "";
    256256        generateNumberControlVertFree.OnRandomNumberGenerated += new GmpBigIntegerParameterDelegate(generateNumberControlVertFree_OnRandomNumberGenerated);
     
    270270    }
    271271
    272     void generateNumberControlVertFree_OnRandomNumberGenerated(GmpBigInteger value)
     272    void generateNumberControlVertFree_OnRandomNumberGenerated(PrimesBigInteger value)
    273273    {
    274274      tbVertFree.Text = value.ToString();
     
    467467    }
    468468
    469     private IDictionary<string, InputValidator<GmpBigInteger>> m_Validators;
    470     public void AddInputValidator(string key, InputValidator<GmpBigInteger> validator)
     469    private IDictionary<string, InputValidator<PrimesBigInteger>> m_Validators;
     470    public void AddInputValidator(string key, InputValidator<PrimesBigInteger> validator)
    471471    {
    472472      if (this.m_Validators.ContainsKey(key))
     
    481481    }
    482482
    483     private IDictionary<string, IList<IValidator<GmpBigInteger>>> m_SingleAdvisors;
    484     public void AddSingleAdisors(string key, IValidator<GmpBigInteger> advisor)
     483    private IDictionary<string, IList<IValidator<PrimesBigInteger>>> m_SingleAdvisors;
     484    public void AddSingleAdisors(string key, IValidator<PrimesBigInteger> advisor)
    485485    {
    486486      if (m_SingleAdvisors.ContainsKey(key))
     
    493493      }
    494494    }
    495     private IDictionary<string, IValidator<GmpBigInteger>> m_ValueValidators;
    496     public void SetValueValidator(string key, IValidator<GmpBigInteger> validator)
     495    private IDictionary<string, IValidator<PrimesBigInteger>> m_ValueValidators;
     496    public void SetValueValidator(string key, IValidator<PrimesBigInteger> validator)
    497497    {
    498498      if (m_ValueValidators.ContainsKey(key))
     
    696696    }
    697697
    698     public GmpBigInteger GetValue()
    699     {
    700         GmpBigInteger value = null;
     698    public PrimesBigInteger GetValue()
     699    {
     700        PrimesBigInteger value = null;
    701701        ResetMessages();
    702702        if (m_RbSelection == Selection.Free)
     
    713713          if (m_ValueValidators.ContainsKey(Value))
    714714          {
    715             IValidator<GmpBigInteger> validator = m_ValueValidators[Value];
     715            IValidator<PrimesBigInteger> validator = m_ValueValidators[Value];
    716716            validator.Value = value.ToString();
    717717            Primes.WpfControls.Validation.ValidationResult result = validator.Validate(ref value);
     
    749749            }
    750750          }
    751           foreach (IValidator<GmpBigInteger> validator in this.m_SingleAdvisors[Value])
     751          foreach (IValidator<PrimesBigInteger> validator in this.m_SingleAdvisors[Value])
    752752          {
    753753            if (validator.Validate(ref value) != Primes.WpfControls.Validation.ValidationResult.OK)
     
    773773    private void DoExecute(bool doExecute)
    774774    {
    775       GmpBigInteger value = GetValue();
     775      PrimesBigInteger value = GetValue();
    776776
    777777      if (Execute != null && doExecute && value != null)
     
    827827
    828828    #region Validation of Free Input
    829     public void ValidateFreeInput(ref GmpBigInteger value)
     829    public void ValidateFreeInput(ref PrimesBigInteger value)
    830830    {
    831831      try
     
    848848    }
    849849
    850     public GmpBigInteger ValidateInput(TextBox tbSource)
    851     {
    852       GmpBigInteger result = GmpBigInteger.Zero;
    853       InputValidator<GmpBigInteger> m_Validator;
     850    public PrimesBigInteger ValidateInput(TextBox tbSource)
     851    {
     852      PrimesBigInteger result = PrimesBigInteger.Zero;
     853      InputValidator<PrimesBigInteger> m_Validator;
    854854      if (m_Validators.ContainsKey(tbSource.Tag.ToString()))
    855855      {
     
    858858      else
    859859      {
    860         m_Validator = new InputValidator<GmpBigInteger>();
     860        m_Validator = new InputValidator<PrimesBigInteger>();
    861861        m_Validator.Validator = new BigIntegerValidator(tbSource.Text);
    862862      }
    863863      try
    864864      {
    865         TextBoxValidator<GmpBigInteger> tbvalidator = new TextBoxValidator<GmpBigInteger>(m_Validator.Validator, tbSource,m_Validator.DefaultValue);
     865        TextBoxValidator<PrimesBigInteger> tbvalidator = new TextBoxValidator<PrimesBigInteger>(m_Validator.Validator, tbSource,m_Validator.DefaultValue);
    866866        tbvalidator.Validate(ref result);
    867867      }
     
    877877
    878878    #region Validation of Calculate Input
    879     public void ValidateCalcInput(ref GmpBigInteger value)
     879    public void ValidateCalcInput(ref PrimesBigInteger value)
    880880    {
    881881      try
    882882      {
    883         GmpBigInteger factor = ValidateInput(m_tbCalcFactor);
    884         GmpBigInteger base_ = ValidateInput(m_tbCalcBase);
    885         GmpBigInteger exp = ValidateInput(m_tbCalcExp);
    886         GmpBigInteger sum = ValidateInput(m_tbCalcSum);
     883        PrimesBigInteger factor = ValidateInput(m_tbCalcFactor);
     884        PrimesBigInteger base_ = ValidateInput(m_tbCalcBase);
     885        PrimesBigInteger exp = ValidateInput(m_tbCalcExp);
     886        PrimesBigInteger sum = ValidateInput(m_tbCalcSum);
    887887        value = base_.Pow(exp.IntValue).Multiply(factor).Add(sum);
    888888      }
     
    10411041    {
    10421042      if (KeyDownNoValidation != null) KeyDownNoValidation((sender as TextBox).Text);
    1043       GmpBigInteger value = GetValue();
     1043      PrimesBigInteger value = GetValue();
    10441044      if (value != null && KeyDown!=null)
    10451045      {
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Components/LogControl.xaml.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    217217using System.Diagnostics;
    218218using System.Collections;
    219 using LibGmpWrapper;
     219using Primes.Bignum;
    220220
    221221namespace Primes.WpfControls.Components
     
    365365    private void FireRowMouseOverEvent(int value)
    366366    {
    367       if (RowMouseOver != null) RowMouseOver(GmpBigInteger.ValueOf(value).Divide(GmpBigInteger.Two));
     367      if (RowMouseOver != null) RowMouseOver(PrimesBigInteger.ValueOf(value).Divide(PrimesBigInteger.Two));
    368368    }
    369369    #endregion
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Components/NumberButton.cs

    r4 r808  
    215215using System.Windows.Shapes;
    216216
    217 using LibGmpWrapper;
     217using Primes.Bignum;
    218218using Primes.Library;
    219219
     
    253253  public class NumberButton : Button
    254254  {
    255     private static readonly GmpBigInteger MAX = GmpBigInteger.ValueOf(999);
    256     private GmpBigInteger m_Number;
     255    private static readonly PrimesBigInteger MAX = PrimesBigInteger.ValueOf(999);
     256    private PrimesBigInteger m_Number;
    257257    private string m_StrNumber;
    258258    private bool m_ShowContent;
     
    290290    }
    291291
    292     public GmpBigInteger BINumber
    293     {
    294       get { return new GmpBigInteger(m_StrNumber); }
     292    public PrimesBigInteger BINumber
     293    {
     294      get { return new PrimesBigInteger(m_StrNumber); }
    295295      set {
    296296        m_Number = value;
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Factorization/FactorizationControl.xaml.cs

    r4 r808  
    218218using Primes.Library.FactorTree;
    219219using Primes.WpfControls.Validation.Validator;
    220 using LibGmpWrapper;
     220using Primes.Bignum;
    221221using Primes.WpfControls.Components;
    222222using Primes.Library;
     
    230230  public partial class FactorizationControl : UserControl, IPrimeMethodDivision
    231231  {
    232     private GmpBigInteger m_Integer;
     232    private PrimesBigInteger m_Integer;
    233233
    234234    private IFactorizer _rho;
     
    281281    private void SetInputValidators()
    282282    {
    283       InputValidator<GmpBigInteger> ivExp = new InputValidator<GmpBigInteger>();
    284       ivExp.Validator = new BigIntegerMinValueMaxValueValidator(null, GmpBigInteger.One, GmpBigInteger.OneHundret);
     283      InputValidator<PrimesBigInteger> ivExp = new InputValidator<PrimesBigInteger>();
     284      ivExp.Validator = new BigIntegerMinValueMaxValueValidator(null, PrimesBigInteger.One, PrimesBigInteger.OneHundret);
    285285      inputnumbermanager.AddInputValidator(InputSingleControl.CalcExp, ivExp);
    286286
    287       //inputnumbermanager.SetValueValidator(InputSingleControl.Value, new BigIntegerMinValueValidator(null, GmpBigInteger.Two));
     287      //inputnumbermanager.SetValueValidator(InputSingleControl.Value, new BigIntegerMinValueValidator(null, PrimesBigInteger.Two));
    288288    }
    289289
     
    291291    void _rho_ForceGetValue(ExecuteIntegerDelegate del)
    292292    {
    293       GmpBigInteger value = inputnumbermanager.GetValue();
     293      PrimesBigInteger value = inputnumbermanager.GetValue();
    294294      if (value != null && del != null) del(value);
    295295    }
    296296
    297297   
    298     private void Factorize(GmpBigInteger value)
     298    private void Factorize(PrimesBigInteger value)
    299299    {
    300300      ClearInfoPanel();
     
    361361        case KOF.Rho:
    362362        case KOF.QS:
    363           OnFoundFactor_Enumerator(o as IEnumerator<KeyValuePair<GmpBigInteger, GmpBigInteger>>);
     363          OnFoundFactor_Enumerator(o as IEnumerator<KeyValuePair<PrimesBigInteger, PrimesBigInteger>>);
    364364          break;
    365365      }
     
    376376        {
    377377          sbFactors.Append(factor.ToString());
    378           GmpBigInteger factorcount = ft.GetFactorCount(factor);
    379           if (factorcount.CompareTo(GmpBigInteger.One) > 0)
     378          PrimesBigInteger factorcount = ft.GetFactorCount(factor);
     379          if (factorcount.CompareTo(PrimesBigInteger.One) > 0)
    380380          {
    381381            sbFactors.Append("^");
     
    394394
    395395
    396     public void OnFoundFactor_Enumerator(IEnumerator<KeyValuePair<GmpBigInteger,GmpBigInteger>> _enum)
     396    public void OnFoundFactor_Enumerator(IEnumerator<KeyValuePair<PrimesBigInteger,PrimesBigInteger>> _enum)
    397397    {
    398398      StringBuilder sbFactors = new StringBuilder();
     
    400400      while (_enum.MoveNext())
    401401      {
    402         KeyValuePair<GmpBigInteger, GmpBigInteger> current = _enum.Current;
     402        KeyValuePair<PrimesBigInteger, PrimesBigInteger> current = _enum.Current;
    403403        sbFactors.Append(current.Key.ToString());
    404         GmpBigInteger factorcount = current.Value;
    405         if (factorcount.CompareTo(GmpBigInteger.One) > 0)
     404        PrimesBigInteger factorcount = current.Value;
     405        if (factorcount.CompareTo(PrimesBigInteger.One) > 0)
    406406        {
    407407          sbFactors.Append("^");
     
    415415    }
    416416
    417     private void InputSingleNumberControl_Execute(GmpBigInteger integer)
     417    private void InputSingleNumberControl_Execute(PrimesBigInteger integer)
    418418    {
    419419      m_Integer = integer;
     
    532532    private void UserControl_Loaded(object sender, RoutedEventArgs e)
    533533    {
    534       inputnumbermanager.FreeText = GmpBigInteger.Random(5).ToString();
     534      inputnumbermanager.FreeText = PrimesBigInteger.Random(5).ToString();
    535535      inputnumbermanager.CalcFactorText = "1";
    536       inputnumbermanager.CalcBaseText = GmpBigInteger.RandomM(GmpBigInteger.ValueOf(3)).Add(GmpBigInteger.Two).ToString();
    537       inputnumbermanager.CalcExpText = GmpBigInteger.RandomM(GmpBigInteger.ValueOf(7)).Add(GmpBigInteger.Two).ToString();
    538       inputnumbermanager.CalcSumText = GmpBigInteger.RandomM(GmpBigInteger.ValueOf(7)).Add(GmpBigInteger.Two).ToString();
     536      inputnumbermanager.CalcBaseText = PrimesBigInteger.RandomM(PrimesBigInteger.ValueOf(3)).Add(PrimesBigInteger.Two).ToString();
     537      inputnumbermanager.CalcExpText = PrimesBigInteger.RandomM(PrimesBigInteger.ValueOf(7)).Add(PrimesBigInteger.Two).ToString();
     538      inputnumbermanager.CalcSumText = PrimesBigInteger.RandomM(PrimesBigInteger.ValueOf(7)).Add(PrimesBigInteger.Two).ToString();
    539539    }
    540540
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Factorization/FactorizationGraph.xaml.cs

    r4 r808  
    217217using Primes.Library.FactorTree;
    218218using Primes.WpfControls.ShapeManagement.Ellipse;
    219 using LibGmpWrapper;
     219using Primes.Bignum;
    220220using Primes.Library;
    221221using Primes.WpfControls.Validation.Validator;
     
    261261    }
    262262
    263     void m_FactorTree_OnActualDivisorChanged(GmpBigInteger value)
     263    void m_FactorTree_OnActualDivisorChanged(PrimesBigInteger value)
    264264    {
    265265      ControlHandler.SetPropertyValue(lblActualDivisor, "Text", Primes.Resources.lang.WpfControls.Factorization.Factorization.bf_actualdiv+ value.ToString("D"));
     
    269269    object test = new object();
    270270
    271     public void Execute(GmpBigInteger from, GmpBigInteger to) { }
    272     public void Execute(GmpBigInteger value)
     271    public void Execute(PrimesBigInteger from, PrimesBigInteger to) { }
     272    public void Execute(PrimesBigInteger value)
    273273    {
    274274      m_Start = DateTime.Now;
     
    515515
    516516
    517     public Primes.WpfControls.Validation.IValidator<GmpBigInteger> Validator
    518     {
    519       get { return new BigIntegerMinValueValidator(null, GmpBigInteger.Three); }
     517    public Primes.WpfControls.Validation.IValidator<PrimesBigInteger> Validator
     518    {
     519      get { return new BigIntegerMinValueValidator(null, PrimesBigInteger.Three); }
    520520    }
    521521
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Factorization/IFactorizer.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    205205using System.Collections.Generic;
    206206using System.Text;
    207 using LibGmpWrapper;
     207using Primes.Bignum;
    208208using Primes.WpfControls.Components;
    209209using Primes.Library;
     
    215215  public interface IFactorizer:IPrimeVisualization
    216216  {
    217     //void Factorize(GmpBigInteger value);
     217    //void Factorize(PrimesBigInteger value);
    218218    //void CancelFactorization();
    219219    //event FoundFactor FoundFactor;
     
    226226    event FoundFactor FoundFactor;
    227227    TimeSpan Needs { get; }
    228     IValidator<GmpBigInteger> Validator { get; }
     228    IValidator<PrimesBigInteger> Validator { get; }
    229229
    230230  }
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Factorization/QS/BaseStep.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    210210using Primes.Library;
    211211using System.Windows.Media;
    212 using LibGmpWrapper;
     212using Primes.Bignum;
    213213
    214214namespace Primes.WpfControls.Factorization.QS
     
    287287    }
    288288
    289     protected bool ModuloTest(GmpBigInteger a, GmpBigInteger b, GmpBigInteger mod)
     289    protected bool ModuloTest(PrimesBigInteger a, PrimesBigInteger b, PrimesBigInteger mod)
    290290    {
    291291      bool result = true;
    292       GmpBigInteger _a = a.Abs();
    293       GmpBigInteger _b = b.Abs();
    294       result = !a.Subtract(b).Mod(mod).Equals(GmpBigInteger.Zero);
     292      PrimesBigInteger _a = a.Abs();
     293      PrimesBigInteger _b = b.Abs();
     294      result = !a.Subtract(b).Mod(mod).Equals(PrimesBigInteger.Zero);
    295295      if (result)
    296296      {
    297         _a = _a.Multiply(GmpBigInteger.NegativeOne);
    298         _b = _b.Multiply(GmpBigInteger.NegativeOne);
    299         GmpBigInteger res = _a.Add(_b);
    300         result = !res.Abs().Mod(mod).Equals(GmpBigInteger.Zero);
     297        _a = _a.Multiply(PrimesBigInteger.NegativeOne);
     298        _b = _b.Multiply(PrimesBigInteger.NegativeOne);
     299        PrimesBigInteger res = _a.Add(_b);
     300        result = !res.Abs().Mod(mod).Equals(PrimesBigInteger.Zero);
    301301      }
    302302      return result;
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Factorization/QS/QSData.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    207207using System.Text;
    208208using System.Windows;
    209 using LibGmpWrapper;
     209using Primes.Bignum;
    210210
    211211namespace Primes.WpfControls.Factorization.QS
     
    216216    public QSData()
    217217    {
    218       m_IgnoreQuadrats = new List<GmpBigInteger>();
     218      m_IgnoreQuadrats = new List<PrimesBigInteger>();
    219219    }
    220220    #region Properties
     
    223223    {
    224224      List<int> result = new List<int>();
    225       GmpBigInteger b = GmpBigInteger.ValueOf(m_B);
    226       GmpBigInteger c = GmpBigInteger.One;
     225      PrimesBigInteger b = PrimesBigInteger.ValueOf(m_B);
     226      PrimesBigInteger c = PrimesBigInteger.One;
    227227      while (c.CompareTo(b) <= 0)
    228228      {
     
    284284
    285285    #endregion
    286     private IList<GmpBigInteger> m_IgnoreQuadrats;
    287 
    288     public void AddIgnoreQuadrat(GmpBigInteger value)
     286    private IList<PrimesBigInteger> m_IgnoreQuadrats;
     287
     288    public void AddIgnoreQuadrat(PrimesBigInteger value)
    289289    {
    290290      m_IgnoreQuadrats.Add(value);
    291291    }
    292292
    293     public bool IsIgnored(GmpBigInteger value)
     293    public bool IsIgnored(PrimesBigInteger value)
    294294    {
    295295      return m_IgnoreQuadrats.Contains(value);
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Factorization/QS/QuadraticSieveControl.xaml.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    215215using System.Windows.Shapes;
    216216using System.Threading;
    217 using LibGmpWrapper;
     217using Primes.Bignum;
    218218using Primes.Library;
    219219using Primes.WpfControls.Components;
     
    240240
    241241    private ManualResetEvent resetEvent;
    242     private IDictionary<GmpBigInteger, GmpBigInteger> m_Factors;
     242    private IDictionary<PrimesBigInteger, PrimesBigInteger> m_Factors;
    243243
    244244    private bool stepwise;
     
    262262
    263263      m_Data = new QSData();
    264       m_Factors = new Dictionary<GmpBigInteger, GmpBigInteger>();
     264      m_Factors = new Dictionary<PrimesBigInteger, PrimesBigInteger>();
    265265      //m_Data.From = -41;
    266266      //m_Data.To = 41;
     
    270270    #region IFactorizer Members
    271271
    272     public void Execute(GmpBigInteger from, GmpBigInteger to) { }
    273 
    274     public void Execute(LibGmpWrapper.GmpBigInteger value)
     272    public void Execute(PrimesBigInteger from, PrimesBigInteger to) { }
     273
     274    public void Execute(PrimesBigInteger value)
    275275    {
    276276      m_Value = value.LongValue;
     
    382382        lblInfoStep1,
    383383        "Text",
    384         "Die Quadratwurzel aus " + m_Value.ToString("D") + " ist " + Math.Sqrt(m_Value).ToString("N")+" "+sqrt);
     384        "Die Quadratwurzel aus " + m_Value.ToString("D") + " ist " + Math.Sqrt(m_Value).ToString("N")+" ≈ "+sqrt);
    385385      int counter = 0;
    386386
     
    390390      {
    391391        ControlHandler.AddRowDefintion(gridFirstStep, 1, GridUnitType.Auto);
    392         string a = (sqrt + counter).ToString("N") + "²";
     392        string a = (sqrt + counter).ToString("N") + "²";
    393393        string aminus1 = (Math.Pow((sqrt + counter), 2) - m_Value).ToString("N");
    394394
     
    416416
    417417      TextBlock tbA = new TextBlock();
    418       tbA.Text = "a²";
     418      tbA.Text = "a²";
    419419      tbA.Margin = new Thickness(5);
    420420
    421421      TextBlock tbAMinusN = new TextBlock();
    422       tbAMinusN.Text = "a²-n";
     422      tbAMinusN.Text = "a²-n";
    423423      tbAMinusN.Margin = new Thickness(5);
    424424
     
    482482    void m_Step4_FoundFactor(object o)
    483483    {
    484       if (o != null && o.GetType() == typeof(GmpBigInteger))
    485       {
    486         GmpBigInteger value = o as GmpBigInteger;
     484      if (o != null && o.GetType() == typeof(PrimesBigInteger))
     485      {
     486        PrimesBigInteger value = o as PrimesBigInteger;
    487487        if (!m_Factors.ContainsKey(value))
    488           m_Factors.Add(value, GmpBigInteger.Zero);
    489         GmpBigInteger tmp = m_Factors[value];
    490         m_Factors[value] = tmp.Add(GmpBigInteger.One);
     488          m_Factors.Add(value, PrimesBigInteger.Zero);
     489        PrimesBigInteger tmp = m_Factors[value];
     490        m_Factors[value] = tmp.Add(PrimesBigInteger.One);
    491491      }
    492492      FireFoundFactorEvent(m_Factors.GetEnumerator());
     
    558558
    559559
    560     public Primes.WpfControls.Validation.IValidator<GmpBigInteger> Validator
    561     {
    562       get { return new BigIntegerMinValueMaxValueValidator(null, GmpBigInteger.Two, GmpBigInteger.ValueOf(10000)); }
     560    public Primes.WpfControls.Validation.IValidator<PrimesBigInteger> Validator
     561    {
     562      get { return new BigIntegerMinValueMaxValueValidator(null, PrimesBigInteger.Two, PrimesBigInteger.ValueOf(10000)); }
    563563    }
    564564
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Factorization/QS/Step3.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    210210using System.Windows;
    211211using System.Threading;
    212 using LibGmpWrapper;
     212using Primes.Bignum;
    213213
    214214namespace Primes.WpfControls.Factorization.QS
     
    238238        StringBuilder msg = new StringBuilder();
    239239        msg.Append(pair.B);
    240         if (data.IsIgnored(GmpBigInteger.ValueOf(pair.B)))
     240        if (data.IsIgnored(PrimesBigInteger.ValueOf(pair.B)))
    241241          pair.QuadraticStatus = QuadraticStatus.Ignore;
    242242        if (pair.QuadraticStatus == QuadraticStatus.Ignore)
     
    298298            if (erg != 0)
    299299            {
    300               if (data.IsIgnored(GmpBigInteger.ValueOf((long)erg)))
     300              if (data.IsIgnored(PrimesBigInteger.ValueOf((long)erg)))
    301301              {
    302302                ControlHandler.SetPropertyValue(tb, "Text", string.Format(Primes.Resources.lang.WpfControls.Factorization.Factorization.qs_step3_testcombiignore, new object[] { msg.ToString(), erg.ToString("N") }));
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Factorization/QS/Step4.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    209209using System.Windows.Controls;
    210210using System.Windows;
    211 using LibGmpWrapper;
     211using Primes.Bignum;
    212212using System.Threading;
    213213
     
    229229    {
    230230      QSResult result = QSResult.Ok;
    231       GmpBigInteger _n = GmpBigInteger.ValueOf(data.N);
     231      PrimesBigInteger _n = PrimesBigInteger.ValueOf(data.N);
    232232      int counter = 0;
    233233      IList<QuadraticPair> pairs = data.BSmooth;
    234       GmpBigInteger productAQuad = null;
    235       GmpBigInteger productA = null;
    236       GmpBigInteger productB = null;
     234      PrimesBigInteger productAQuad = null;
     235      PrimesBigInteger productA = null;
     236      PrimesBigInteger productB = null;
    237237
    238238      foreach (QuadraticPair pair in pairs)
     
    240240        if (pair.QuadraticStatus == QuadraticStatus.Quadratic)
    241241        {
    242           productAQuad = GmpBigInteger.ValueOf(pair.A).Pow(2);
    243           productA = GmpBigInteger.ValueOf(pair.A);
    244           productB = GmpBigInteger.ValueOf(pair.B);
     242          productAQuad = PrimesBigInteger.ValueOf(pair.A).Pow(2);
     243          productA = PrimesBigInteger.ValueOf(pair.A);
     244          productB = PrimesBigInteger.ValueOf(pair.B);
    245245          break;
    246246        }
     
    252252          if (pair.QuadraticStatus == QuadraticStatus.Part)
    253253          {
    254             if (productAQuad == null) productAQuad = GmpBigInteger.ValueOf(pair.A).Pow(2).Mod(_n);
    255             else productAQuad = productAQuad.Multiply(GmpBigInteger.ValueOf(pair.A).Pow(2)).Mod(_n);
    256 
    257             if (productA == null) productA = GmpBigInteger.ValueOf(pair.A).Mod(_n);
    258             else productA = productA.Multiply(GmpBigInteger.ValueOf(pair.A)).Mod(_n);
    259 
    260             if (productB == null) productB = GmpBigInteger.ValueOf(pair.B).Mod(_n);
    261             else productB = productB.Multiply(GmpBigInteger.ValueOf(pair.B)).Mod(_n);
     254            if (productAQuad == null) productAQuad = PrimesBigInteger.ValueOf(pair.A).Pow(2).Mod(_n);
     255            else productAQuad = productAQuad.Multiply(PrimesBigInteger.ValueOf(pair.A).Pow(2)).Mod(_n);
     256
     257            if (productA == null) productA = PrimesBigInteger.ValueOf(pair.A).Mod(_n);
     258            else productA = productA.Multiply(PrimesBigInteger.ValueOf(pair.A)).Mod(_n);
     259
     260            if (productB == null) productB = PrimesBigInteger.ValueOf(pair.B).Mod(_n);
     261            else productB = productB.Multiply(PrimesBigInteger.ValueOf(pair.B)).Mod(_n);
    262262          }
    263263        }
     
    270270      sbInfo.Append(productB.SquareRoot().ToString("D"));
    271271      sbInfo.Append(Primes.Resources.lang.WpfControls.Factorization.Factorization.qs_step4_checkcong);
    272       sbInfo.Append("a² ≡ b² (mod n), a !≡ b (mod n)");
     272      sbInfo.Append("a² ≡ b² (mod n), a !≡ b (mod n)");
    273273      ControlHandler.SetPropertyValue(m_lblInfo, "Text", sbInfo.ToString());
    274274      if (result == QSResult.Ok)
    275275      {
    276         result = (ModuloTest(productA.Mod(_n), productB.SquareRoot().Mod(_n), GmpBigInteger.ValueOf(data.N)))?QSResult.Ok:QSResult.Failed;
     276        result = (ModuloTest(productA.Mod(_n), productB.SquareRoot().Mod(_n), PrimesBigInteger.ValueOf(data.N)))?QSResult.Ok:QSResult.Failed;
    277277        if (result == QSResult.Ok)
    278278        {
     
    290290              "AddToGrid",
    291291              new object[] { Grid, BuildMod(productA,productB.SquareRoot(),_n), counter, 0, 0, 0 });
    292             GmpBigInteger factor1 = GmpBigInteger.GCD(productA.Add(productB.SquareRoot().Mod(_n)).Abs().Mod(_n), _n);
    293             GmpBigInteger factor2 = GmpBigInteger.GCD(productA.Subtract(productB.SquareRoot().Mod(_n)).Abs().Mod(_n), _n);
    294 
    295             if (factor1.Equals(GmpBigInteger.One) || factor2.Equals(GmpBigInteger.One))
     292            PrimesBigInteger factor1 = PrimesBigInteger.GCD(productA.Add(productB.SquareRoot().Mod(_n)).Abs().Mod(_n), _n);
     293            PrimesBigInteger factor2 = PrimesBigInteger.GCD(productA.Subtract(productB.SquareRoot().Mod(_n)).Abs().Mod(_n), _n);
     294
     295            if (factor1.Equals(PrimesBigInteger.One) || factor2.Equals(PrimesBigInteger.One))
    296296            {
    297297              data.AddIgnoreQuadrat(productB);
     
    304304                new object[] {
    305305                  Grid,
    306                   string.Format("Die Faktorisierung mit den Werten a = {0} und b = {1} war nicht erfolgreich. Mit Klick auf Neustart starten Sie Faktorisierung neu. Die ungültigen Werte werden ab sofort ignoriert.",new object[]{ productA.ToString("D"), productB.SquareRoot().ToString("D")}), counter, 0, 0, 0 });
     306                  string.Format("Die Faktorisierung mit den Werten a = {0} und b = {1} war nicht erfolgreich. Mit Klick auf Neustart starten Sie Faktorisierung neu. Die ungÃŒltigen Werte werden ab sofort ignoriert.",new object[]{ productA.ToString("D"), productB.SquareRoot().ToString("D")}), counter, 0, 0, 0 });
    307307
    308308            }
     
    345345                "AddToGrid",
    346346                new object[] { Grid, sbfactor2.ToString(), counter, 0, 0, 0 });
    347               GmpBigInteger notPrime = null;
     347              PrimesBigInteger notPrime = null;
    348348              if (!factor1.IsPrime(10)) notPrime = factor1;
    349349              else if (!factor2.IsPrime(10)) notPrime = factor2;
     
    383383      return result;
    384384    }
    385     private string BuildQuadMod(GmpBigInteger producta, GmpBigInteger productb, GmpBigInteger mod)
     385    private string BuildQuadMod(PrimesBigInteger producta, PrimesBigInteger productb, PrimesBigInteger mod)
    386386    {
    387387      StringBuilder sbQuadMod = new StringBuilder();
    388388      sbQuadMod.Append(producta.ToString("D"));
    389       sbQuadMod.Append("² ≡ ");
     389      sbQuadMod.Append("² ≡ ");
    390390      sbQuadMod.Append(productb.ToString("D"));
    391       sbQuadMod.Append("² (mod ");
     391      sbQuadMod.Append("² (mod ");
    392392      sbQuadMod.Append(mod.ToString("D"));
    393393      sbQuadMod.Append(")");
     
    395395    }
    396396
    397     private string BuildMod(GmpBigInteger producta, GmpBigInteger productb, GmpBigInteger mod)
     397    private string BuildMod(PrimesBigInteger producta, PrimesBigInteger productb, PrimesBigInteger mod)
    398398    {
    399399      StringBuilder sbQuadMod = new StringBuilder();
    400400      sbQuadMod.Append(producta.ToString("D"));
    401       sbQuadMod.Append("   ");
     401      sbQuadMod.Append(" ≢  ");
    402402      sbQuadMod.Append(productb.ToString("D"));
    403403      sbQuadMod.Append(" (mod ");
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Factorization/Rho/RhoControl.xaml.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    216216using Primes.WpfControls.Components;
    217217using Primes.WpfControls.Validation;
    218 using LibGmpWrapper;
     218using Primes.Bignum;
    219219using Primes.WpfControls.Validation.Validator;
    220220using System.Threading;
     
    228228  public partial class RhoControl : UserControl, IFactorizer
    229229  {
    230     private GmpBigInteger m_A;
    231     private GmpBigInteger m_StartFX;
    232     private GmpBigInteger m_Value;
     230    private PrimesBigInteger m_A;
     231    private PrimesBigInteger m_StartFX;
     232    private PrimesBigInteger m_Value;
    233233    private Thread m_Thread;
    234     private IDictionary<GmpBigInteger, GmpBigInteger> m_Factors;
    235     private IDictionary<GmpBigInteger, int> m_FactorsTmp;
     234    private IDictionary<PrimesBigInteger, PrimesBigInteger> m_Factors;
     235    private IDictionary<PrimesBigInteger, int> m_FactorsTmp;
    236236   
    237237
     
    239239    {
    240240      InitializeComponent();
    241       InputValidator<GmpBigInteger> validatorStartX = new InputValidator<LibGmpWrapper.GmpBigInteger>();
    242       validatorStartX.Validator = new BigIntegerMinValueMaxValueValidator(null, GmpBigInteger.ValueOf(1), GmpBigInteger.ValueOf(1000));
     241      InputValidator<PrimesBigInteger> validatorStartX = new InputValidator<PrimesBigInteger>();
     242      validatorStartX.Validator = new BigIntegerMinValueMaxValueValidator(null, PrimesBigInteger.ValueOf(1), PrimesBigInteger.ValueOf(1000));
    243243      validatorStartX.LinkOnlinehelp = Primes.OnlineHelp.OnlineHelpActions.Factorization_BruteForce;
    244244
     
    246246
    247247
    248       InputValidator<GmpBigInteger> validatorA = new InputValidator<LibGmpWrapper.GmpBigInteger>();
    249       validatorA.Validator = new BigIntegerMinValueMaxValueValidator(null, GmpBigInteger.ValueOf(1), GmpBigInteger.ValueOf(1000));
     248      InputValidator<PrimesBigInteger> validatorA = new InputValidator<PrimesBigInteger>();
     249      validatorA.Validator = new BigIntegerMinValueMaxValueValidator(null, PrimesBigInteger.ValueOf(1), PrimesBigInteger.ValueOf(1000));
    250250      validatorA.LinkOnlinehelp = Primes.OnlineHelp.OnlineHelpActions.Factorization_Rho;
    251251      a.AddInputValidator(InputSingleControl.Free, validatorA);
     
    256256      a.Execute += new ExecuteSingleDelegate(ForceGetValue_Execute);
    257257      startfx.Execute += new ExecuteSingleDelegate(ForceGetValue_Execute);
    258       m_Factors = new Dictionary<GmpBigInteger, GmpBigInteger>();
    259       m_FactorsTmp = new Dictionary<GmpBigInteger, int>();
    260     }
    261 
    262     void ForceGetValue_Execute(GmpBigInteger value)
     258      m_Factors = new Dictionary<PrimesBigInteger, PrimesBigInteger>();
     259      m_FactorsTmp = new Dictionary<PrimesBigInteger, int>();
     260    }
     261
     262    void ForceGetValue_Execute(PrimesBigInteger value)
    263263    {
    264264      FireEventForceGetValue();
     
    273273    #region IFactorizer Members
    274274
    275     public void Execute(GmpBigInteger from, GmpBigInteger to) { }
    276 
    277     public void Execute(LibGmpWrapper.GmpBigInteger value)
     275    public void Execute(PrimesBigInteger from, PrimesBigInteger to) { }
     276
     277    public void Execute(PrimesBigInteger value)
    278278    {
    279279      m_Value = value;
     
    298298      FireStopEvent();
    299299    }
    300     private void DoFactorize(GmpBigInteger value)
     300    private void DoFactorize(PrimesBigInteger value)
    301301    {
    302302      /*
     
    307307        factor(N.divide(divisor));
    308308       */
    309       if (value.Equals(GmpBigInteger.One))
     309      if (value.Equals(PrimesBigInteger.One))
    310310      {
    311311        return;
     
    314314      {
    315315        if (!m_Factors.ContainsKey(value))
    316           m_Factors.Add(value, GmpBigInteger.Zero);
    317         GmpBigInteger tmp = m_Factors[value];
    318         m_Factors[value] = tmp.Add(GmpBigInteger.One);
     316          m_Factors.Add(value, PrimesBigInteger.Zero);
     317        PrimesBigInteger tmp = m_Factors[value];
     318        m_Factors[value] = tmp.Add(PrimesBigInteger.One);
    319319       
    320320        if (FoundFactor != null) FoundFactor(m_Factors.GetEnumerator());
     
    330330        {
    331331          log.Info(value.ToString()+" Zu oft");
    332           m_A = GmpBigInteger.RandomM(value).Add(GmpBigInteger.Two);
     332          m_A = PrimesBigInteger.RandomM(value).Add(PrimesBigInteger.Two);
    333333          m_FactorsTmp.Remove(value);
    334334        }
    335335      }
    336       GmpBigInteger  div = CalculateFactor(value);
     336      PrimesBigInteger  div = CalculateFactor(value);
    337337      DoFactorize(div);
    338338      DoFactorize(value.Divide(div));
    339339    }
    340340
    341     private GmpBigInteger CalculateFactor(GmpBigInteger value)
    342     {
    343       GmpBigInteger x = m_StartFX;
    344       GmpBigInteger y = m_StartFX;
    345       GmpBigInteger d = GmpBigInteger.One;
    346       GmpBigInteger a = m_A;
     341    private PrimesBigInteger CalculateFactor(PrimesBigInteger value)
     342    {
     343      PrimesBigInteger x = m_StartFX;
     344      PrimesBigInteger y = m_StartFX;
     345      PrimesBigInteger d = PrimesBigInteger.One;
     346      PrimesBigInteger a = m_A;
    347347      int i=0;
    348       if (value.Mod(GmpBigInteger.Two).Equals(GmpBigInteger.Zero)) return GmpBigInteger.Two;
     348      if (value.Mod(PrimesBigInteger.Two).Equals(PrimesBigInteger.Zero)) return PrimesBigInteger.Two;
    349349      do
    350350      {
    351         x = x.ModPow(GmpBigInteger.Two, value).Add(a).Mod(value);
    352         y = y.ModPow(GmpBigInteger.Two, value).Add(a).Mod(value);
    353         y = y.ModPow(GmpBigInteger.Two, value).Add(a).Mod(value);
    354         d = GmpBigInteger.GCD(x.Subtract(y), value);
     351        x = x.ModPow(PrimesBigInteger.Two, value).Add(a).Mod(value);
     352        y = y.ModPow(PrimesBigInteger.Two, value).Add(a).Mod(value);
     353        y = y.ModPow(PrimesBigInteger.Two, value).Add(a).Mod(value);
     354        d = PrimesBigInteger.GCD(x.Subtract(y), value);
    355355        i++;
    356356        if (y.Equals(x))
    357357        {
    358358          log.Info("Change Values");
    359           a = GmpBigInteger.ValueOf(new Random().Next());
    360           x = y = GmpBigInteger.ValueOf(new Random().Next());
     359          a = PrimesBigInteger.ValueOf(new Random().Next());
     360          x = y = PrimesBigInteger.ValueOf(new Random().Next());
    361361          i = 0;
    362362        }
    363363      }
    364       while (d.Equals(GmpBigInteger.One));
     364      while (d.Equals(PrimesBigInteger.One));
    365365      return d;
    366366
     
    439439
    440440
    441     public IValidator<GmpBigInteger> Validator
     441    public IValidator<PrimesBigInteger> Validator
    442442    {
    443443      get { throw new NotImplementedException(); }
  • trunk/CrypPlugins/Primes/Primes/WpfControls/IPrimeVisualization.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    207207using System.Text;
    208208using Primes.WpfControls.Components;
    209 using LibGmpWrapper;
     209using Primes.Bignum;
    210210using Primes.Library;
    211211
     
    224224    event CallbackDelegateGetInteger ForceGetIntegerInterval;
    225225
    226     void Execute(GmpBigInteger value);
     226    void Execute(PrimesBigInteger value);
    227227
    228228    void CancelExecute();
    229229
    230     void Execute(GmpBigInteger from, GmpBigInteger to);
     230    void Execute(PrimesBigInteger from, PrimesBigInteger to);
    231231  }
    232232}
  • trunk/CrypPlugins/Primes/Primes/WpfControls/NumberTheory/NumberTheoryFunctions/BaseNTFunction.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    206206using System.Text;
    207207using System.Threading;
    208 using LibGmpWrapper;
     208using Primes.Bignum;
    209209using System.Windows.Controls;
    210210using Primes.WpfControls.Components;
     
    242242    #region Properties
    243243    protected Thread m_Thread;
    244     protected GmpBigInteger m_From;
    245     protected GmpBigInteger m_To;
     244    protected PrimesBigInteger m_From;
     245    protected PrimesBigInteger m_To;
    246246    #endregion
    247247    #region INTFunction Members
    248248
    249249
    250     public virtual void Start(LibGmpWrapper.GmpBigInteger from, LibGmpWrapper.GmpBigInteger to)
     250    public virtual void Start(PrimesBigInteger from, PrimesBigInteger to)
    251251    {
    252252      Stop();
     
    290290    }
    291291    public event NumberTheoryMessageDelegate Message;
    292     protected void FireOnMessage(INTFunction function, GmpBigInteger value, string message)
     292    protected void FireOnMessage(INTFunction function, PrimesBigInteger value, string message)
    293293    {
    294294      if (Message != null) Message(function, value, message);
  • trunk/CrypPlugins/Primes/Primes/WpfControls/NumberTheory/NumberTheoryFunctions/EulerPhi.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    208208using System.Windows.Controls;
    209209using System.Threading;
    210 using LibGmpWrapper;
     210using Primes.Bignum;
    211211using Primes.Library;
    212212using System.Windows;
     
    223223    {
    224224      FireOnStart();
    225       GmpBigInteger from = m_From;
     225      PrimesBigInteger from = m_From;
    226226      while (from.CompareTo(m_To) <= 0)
    227227      {
    228228        if (from.IsPrime(20))
    229229        {
    230            FireOnMessage(this, from, from.Subtract(GmpBigInteger.One).ToString("D"));
     230           FireOnMessage(this, from, from.Subtract(PrimesBigInteger.One).ToString("D"));
    231231        }
    232232        else
    233233        {
    234           GmpBigInteger d = GmpBigInteger.One;
    235           GmpBigInteger counter = GmpBigInteger.Zero;
     234          PrimesBigInteger d = PrimesBigInteger.One;
     235          PrimesBigInteger counter = PrimesBigInteger.Zero;
    236236           
    237237          while (d.CompareTo(from) < 0)
    238238          {
    239             if (GmpBigInteger.GCD(d, from).Equals(GmpBigInteger.One))
     239            if (PrimesBigInteger.GCD(d, from).Equals(PrimesBigInteger.One))
    240240            {
    241               counter = counter.Add(GmpBigInteger.One);
     241              counter = counter.Add(PrimesBigInteger.One);
    242242              FireOnMessage(this, from, counter.ToString("D"));
    243243
    244244            }
    245             d = d.Add(GmpBigInteger.One);
     245            d = d.Add(PrimesBigInteger.One);
    246246
    247247          }
     
    249249
    250250        }
    251         from = from.Add(GmpBigInteger.One);
     251        from = from.Add(PrimesBigInteger.One);
    252252      }
    253253
  • trunk/CrypPlugins/Primes/Primes/WpfControls/NumberTheory/NumberTheoryFunctions/EulerPhiSum.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    205205using System.Collections.Generic;
    206206using System.Text;
    207 using LibGmpWrapper;
     207using Primes.Bignum;
    208208using Primes.WpfControls.Components;
    209209using System.Windows.Controls;
     
    223223    {
    224224      FireOnStart();
    225       GmpBigInteger from = m_From;
     225      PrimesBigInteger from = m_From;
    226226      while (from.CompareTo(m_To) <= 0)
    227227      {
    228         GmpBigInteger result = GmpBigInteger.Zero;
    229         GmpBigInteger k = GmpBigInteger.One;
     228        PrimesBigInteger result = PrimesBigInteger.Zero;
     229        PrimesBigInteger k = PrimesBigInteger.One;
    230230        while (k.CompareTo(from) <= 0)
    231231        {
    232           if (from.Mod(k).Equals(GmpBigInteger.Zero))
     232          if (from.Mod(k).Equals(PrimesBigInteger.Zero))
    233233          {
    234             GmpBigInteger phik = EulerPhi(k);
     234            PrimesBigInteger phik = EulerPhi(k);
    235235            result = result.Add(phik);
    236236            FireOnMessage(this, from, result.ToString());
    237237          }
    238           k = k.Add(GmpBigInteger.One);
     238          k = k.Add(PrimesBigInteger.One);
    239239        }
    240         from = from.Add(GmpBigInteger.One);
     240        from = from.Add(PrimesBigInteger.One);
    241241      }
    242242      FireOnStop();
     
    244244    }
    245245
    246     private GmpBigInteger EulerPhi(GmpBigInteger n)
    247     {
    248       if (n.Equals(GmpBigInteger.One)) return GmpBigInteger.One;
    249       GmpBigInteger result = GmpBigInteger.Zero;
    250       GmpBigInteger k = GmpBigInteger.One;
     246    private PrimesBigInteger EulerPhi(PrimesBigInteger n)
     247    {
     248      if (n.Equals(PrimesBigInteger.One)) return PrimesBigInteger.One;
     249      PrimesBigInteger result = PrimesBigInteger.Zero;
     250      PrimesBigInteger k = PrimesBigInteger.One;
    251251      while (k.CompareTo(n) <= 0)
    252252      {
    253         if (GmpBigInteger.GCD(k, n).Equals(GmpBigInteger.One))
     253        if (PrimesBigInteger.GCD(k, n).Equals(PrimesBigInteger.One))
    254254        {
    255           result = result.Add(GmpBigInteger.One);
     255          result = result.Add(PrimesBigInteger.One);
    256256        }
    257         k = k.Add(GmpBigInteger.One);
     257        k = k.Add(PrimesBigInteger.One);
    258258      }
    259259      return result;
  • trunk/CrypPlugins/Primes/Primes/WpfControls/NumberTheory/NumberTheoryFunctions/EulerPhiValues.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    208208using System.Windows.Controls;
    209209using System.Threading;
    210 using LibGmpWrapper;
     210using Primes.Bignum;
    211211using Primes.Library;
    212212using System.Windows;
     
    223223    {
    224224      FireOnStart();
    225       GmpBigInteger from = m_From;
     225      PrimesBigInteger from = m_From;
    226226      while (from.CompareTo(m_To) <= 0)
    227227      {
    228228        StringBuilder sbMessage = new StringBuilder("[");
    229         GmpBigInteger d = GmpBigInteger.One;
     229        PrimesBigInteger d = PrimesBigInteger.One;
    230230        while (d.CompareTo(from) < 0)
    231231        {
    232           if (GmpBigInteger.GCD(d, from).Equals(GmpBigInteger.One))
     232          if (PrimesBigInteger.GCD(d, from).Equals(PrimesBigInteger.One))
    233233          {
    234234            if(sbMessage.Length>1) 
     
    237237            FireOnMessage(this, from, sbMessage.ToString());
    238238          }
    239           d = d.Add(GmpBigInteger.One);
     239          d = d.Add(PrimesBigInteger.One);
    240240
    241241        }
     
    243243        FireOnMessage(this, from, sbMessage.ToString());
    244244
    245         from = from.Add(GmpBigInteger.One);
     245        from = from.Add(PrimesBigInteger.One);
    246246      }
    247247
  • trunk/CrypPlugins/Primes/Primes/WpfControls/NumberTheory/NumberTheoryFunctions/INTFunction.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    207207using Primes.WpfControls.Components;
    208208using System.Windows.Controls;
    209 using LibGmpWrapper;
     209using Primes.Bignum;
    210210using System.Collections.ObjectModel;
    211211using Primes.Library;
     
    213213namespace Primes.WpfControls.NumberTheory.NumberTheoryFunctions
    214214{
    215   public delegate void NumberTheoryMessageDelegate(INTFunction function, GmpBigInteger value, string message);
     215  public delegate void NumberTheoryMessageDelegate(INTFunction function, PrimesBigInteger value, string message);
    216216  public interface INTFunction
    217217  {
    218     void Start(GmpBigInteger from, GmpBigInteger to);
     218    void Start(PrimesBigInteger from, PrimesBigInteger to);
    219219    void Stop();
    220220    event VoidDelegate OnStart;
  • trunk/CrypPlugins/Primes/Primes/WpfControls/NumberTheory/NumberTheoryFunctions/NumberTheoryFunctionsControl.xaml.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    223223using Primes.WpfControls.Components;
    224224using System.IO;
     225using Primes.Bignum;
    225226
    226227namespace Primes.WpfControls.NumberTheory.NumberTheoryFunctions
     
    446447    private object locksetdata = new object();
    447448
    448     void f1_Message(INTFunction function, LibGmpWrapper.GmpBigInteger value, string message)
     449    void f1_Message(INTFunction function, PrimesBigInteger value, string message)
    449450    {
    450451      lock (locksetdata)
     
    500501    }
    501502
    502     void irc_Execute(LibGmpWrapper.GmpBigInteger from, LibGmpWrapper.GmpBigInteger to)
     503    void irc_Execute(PrimesBigInteger from, PrimesBigInteger to)
    503504    {
    504505      m_DataTable.Clear();
    505506
    506       LibGmpWrapper.GmpBigInteger _from = from;
     507      PrimesBigInteger _from = from;
    507508      int c = 0;
    508509      int column = m_DataTable.Columns.IndexOf(m_DcN);
     
    511512        int i = _from.IntValue;
    512513        SetData(column, c, i.ToString());
    513         _from = _from.Add(LibGmpWrapper.GmpBigInteger.One);
     514        _from = _from.Add(PrimesBigInteger.One);
    514515        c++;
    515516      }
  • trunk/CrypPlugins/Primes/Primes/WpfControls/NumberTheory/NumberTheoryFunctions/PiX.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    208208using System.Windows.Controls;
    209209using System.Threading;
    210 using LibGmpWrapper;
     210using Primes.Bignum;
    211211using Primes.Library;
    212212using System.Windows;
     
    225225      FireOnStart();
    226226      FunctionPiX pix = new FunctionPiX();
    227       GmpBigInteger from = m_From;
    228       GmpBigInteger _counterTmp = GmpBigInteger.Two;
     227      PrimesBigInteger from = m_From;
     228      PrimesBigInteger _counterTmp = PrimesBigInteger.Two;
    229229      while (_counterTmp.CompareTo(from) <= 0)
    230230      {
    231231        double result = pix.Execute(_counterTmp.DoubleValue);
    232232        FireOnMessage(this, from, StringFormat.FormatDoubleToIntString(result));
    233         _counterTmp = _counterTmp.Add(GmpBigInteger.One);
     233        _counterTmp = _counterTmp.Add(PrimesBigInteger.One);
    234234      }
    235235      while (from.CompareTo(m_To) <= 0)
     
    237237        double result = pix.Execute(from.DoubleValue);
    238238        FireOnMessage(this, from, StringFormat.FormatDoubleToIntString(result));
    239         from = from.Add(GmpBigInteger.One);
     239        from = from.Add(PrimesBigInteger.One);
    240240
    241241      }
  • trunk/CrypPlugins/Primes/Primes/WpfControls/NumberTheory/NumberTheoryFunctions/Rho.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    205205using System.Collections.Generic;
    206206using System.Text;
    207 using LibGmpWrapper;
     207using Primes.Bignum;
    208208using Primes.WpfControls.Components;
    209209using System.Windows.Controls;
     
    225225    {
    226226      FireOnStart();
    227       GmpBigInteger from = m_From;
     227      PrimesBigInteger from = m_From;
    228228      while (from.CompareTo(m_To) <= 0)
    229229      {
    230         GmpBigInteger sum = GmpBigInteger.Zero;
    231         GmpBigInteger d = GmpBigInteger.One;
    232         while (d.Multiply(GmpBigInteger.Two).CompareTo(from) <= 0)
     230        PrimesBigInteger sum = PrimesBigInteger.Zero;
     231        PrimesBigInteger d = PrimesBigInteger.One;
     232        while (d.Multiply(PrimesBigInteger.Two).CompareTo(from) <= 0)
    233233        {
    234           if (from.Mod(d).Equals(GmpBigInteger.Zero))
     234          if (from.Mod(d).Equals(PrimesBigInteger.Zero))
    235235          {
    236236            sum = sum.Add(d);
    237237            FireOnMessage(this, from, sum.ToString());
    238238          }
    239           d = d.Add(GmpBigInteger.One);
     239          d = d.Add(PrimesBigInteger.One);
    240240        }
    241241
    242242        sum = sum.Add(from);
    243243        FireOnMessage(this, from, sum.ToString());
    244         from = from.Add(GmpBigInteger.One);
     244        from = from.Add(PrimesBigInteger.One);
    245245      }
    246246      FireOnStop();
  • trunk/CrypPlugins/Primes/Primes/WpfControls/NumberTheory/NumberTheoryFunctions/Tau.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    207207using Primes.WpfControls.Components;
    208208using System.Windows.Controls;
    209 using LibGmpWrapper;
     209using Primes.Bignum;
    210210using Primes.Library;
    211211using System.Windows;
     
    222222    {
    223223      FireOnStart();
    224       GmpBigInteger from = m_From;
     224      PrimesBigInteger from = m_From;
    225225      while (from.CompareTo(m_To) <= 0)
    226226      {
    227         GmpBigInteger d = GmpBigInteger.One;
    228         GmpBigInteger counter = GmpBigInteger.Zero;
    229 
    230         while (d.Multiply(GmpBigInteger.Two).CompareTo(from) <= 0)
     227        PrimesBigInteger d = PrimesBigInteger.One;
     228        PrimesBigInteger counter = PrimesBigInteger.Zero;
     229
     230        while (d.Multiply(PrimesBigInteger.Two).CompareTo(from) <= 0)
    231231        {
    232           if (from.Mod(d).Equals(GmpBigInteger.Zero))
     232          if (from.Mod(d).Equals(PrimesBigInteger.Zero))
    233233          {
    234             counter = counter.Add(GmpBigInteger.One);
     234            counter = counter.Add(PrimesBigInteger.One);
    235235            FireOnMessage(this, from, counter.ToString());
    236236          }
    237           d = d.Add(GmpBigInteger.One);
     237          d = d.Add(PrimesBigInteger.One);
    238238        }
    239         counter = counter.Add(GmpBigInteger.One);
     239        counter = counter.Add(PrimesBigInteger.One);
    240240        FireOnMessage(this, from, counter.ToString());
    241         from = from.Add(GmpBigInteger.One);
     241        from = from.Add(PrimesBigInteger.One);
    242242      }
    243243      FireOnStop();
  • trunk/CrypPlugins/Primes/Primes/WpfControls/NumberTheory/NumberTheoryFunctions/TauValues.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    207207using Primes.WpfControls.Components;
    208208using System.Windows.Controls;
    209 using LibGmpWrapper;
     209using Primes.Bignum;
    210210using Primes.Library;
    211211using System.Windows;
     
    222222    {
    223223      FireOnStart();
    224       GmpBigInteger from = m_From;
     224      PrimesBigInteger from = m_From;
    225225      while (from.CompareTo(m_To) <= 0)
    226226      {
    227227        StringBuilder sbMessage = new StringBuilder("[");
    228228
    229         GmpBigInteger d = GmpBigInteger.One;
    230 
    231         while (d.Multiply(GmpBigInteger.Two).CompareTo(from) <= 0)
     229        PrimesBigInteger d = PrimesBigInteger.One;
     230
     231        while (d.Multiply(PrimesBigInteger.Two).CompareTo(from) <= 0)
    232232        {
    233           if (from.Mod(d).Equals(GmpBigInteger.Zero))
     233          if (from.Mod(d).Equals(PrimesBigInteger.Zero))
    234234          {
    235235            if (sbMessage.Length > 1)
     
    239239            FireOnMessage(this, from, sbMessage.ToString());
    240240          }
    241           d = d.Add(GmpBigInteger.One);
     241          d = d.Add(PrimesBigInteger.One);
    242242        }
    243243        sbMessage.Append(", "+from.ToString()+"]");
    244244        FireOnMessage(this, from, sbMessage.ToString());
    245         from = from.Add(GmpBigInteger.One);
     245        from = from.Add(PrimesBigInteger.One);
    246246      }
    247247      FireOnStop();
  • trunk/CrypPlugins/Primes/Primes/WpfControls/NumberTheory/PowerMod/PowerModControl.xaml.cs

    r234 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    217217using Primes.WpfControls.Validation.Validator;
    218218using Primes.WpfControls.Validation;
    219 using LibGmpWrapper;
     219using Primes.Bignum;
    220220using System.Threading;
    221221using Primes.WpfControls.Components;
     
    248248            m_ArrowsWithSourceAndDestination = new Dictionary<Pair<Ellipse, Ellipse>, ArrowLine>();
    249249            //m_Arrows = new List<ArrowLine>();
    250             m_ArrowsMark = new Dictionary<GmpBigInteger, ArrowLine>();
     250            m_ArrowsMark = new Dictionary<PrimesBigInteger, ArrowLine>();
    251251            //m_Circles = new List<Polyline>();
    252             m_CirclesMark = new Dictionary<GmpBigInteger, Polyline>();
     252            m_CirclesMark = new Dictionary<PrimesBigInteger, Polyline>();
    253253            m_RunningLockObject = new object();
    254254            m_Initialized = true;
     
    258258        }
    259259
    260         void log_RowMouseOver(GmpBigInteger value)
     260        void log_RowMouseOver(PrimesBigInteger value)
    261261        {
    262262            ArrowLine al = null;
     
    285285            iscBase.Execute += new ExecuteSingleDelegate(iscBase_Execute);
    286286            iscBase.SetText(InputSingleControl.Free, "2");
    287             InputValidator<LibGmpWrapper.GmpBigInteger> ivBase = new InputValidator<LibGmpWrapper.GmpBigInteger>();
    288             ivBase.Validator = new BigIntegerMinValueValidator(null, LibGmpWrapper.GmpBigInteger.Two);
     287            InputValidator<PrimesBigInteger> ivBase = new InputValidator<PrimesBigInteger>();
     288            ivBase.Validator = new BigIntegerMinValueValidator(null, PrimesBigInteger.Two);
    289289            iscBase.AddInputValidator(
    290290              Primes.WpfControls.Components.InputSingleControl.Free,
     
    294294            iscExp.Execute += new ExecuteSingleDelegate(iscExp_Execute);
    295295            iscExp.SetText(InputSingleControl.Free, "28");
    296             InputValidator<LibGmpWrapper.GmpBigInteger> ivExp = new InputValidator<LibGmpWrapper.GmpBigInteger>();
    297             ivExp.Validator = new BigIntegerMinValueValidator(null, LibGmpWrapper.GmpBigInteger.One);
     296            InputValidator<PrimesBigInteger> ivExp = new InputValidator<PrimesBigInteger>();
     297            ivExp.Validator = new BigIntegerMinValueValidator(null, PrimesBigInteger.One);
    298298            iscExp.AddInputValidator(
    299299              Primes.WpfControls.Components.InputSingleControl.Free,
     
    303303            iscMod.KeyDown += new ExecuteSingleDelegate(iscMod_KeyDown);
    304304            iscMod.SetText(InputSingleControl.Free, "13");
    305             InputValidator<LibGmpWrapper.GmpBigInteger> ivMod = new InputValidator<LibGmpWrapper.GmpBigInteger>();
    306             ivMod.Validator = new BigIntegerMinValueMaxValueValidator(null, LibGmpWrapper.GmpBigInteger.Two, LibGmpWrapper.GmpBigInteger.ValueOf(150));
     305            InputValidator<PrimesBigInteger> ivMod = new InputValidator<PrimesBigInteger>();
     306            ivMod.Validator = new BigIntegerMinValueMaxValueValidator(null, PrimesBigInteger.Two, PrimesBigInteger.ValueOf(150));
    307307            iscMod.AddInputValidator(
    308308              Primes.WpfControls.Components.InputSingleControl.Free,
     
    312312            this.Stop += new VoidDelegate(PowerModControl_Stop);
    313313            this.Cancel += new VoidDelegate(PowerModControl_Cancel);
    314             this.Exp = GmpBigInteger.ValueOf(28);
    315             this.Base = GmpBigInteger.ValueOf(2);
    316             this.Mod = GmpBigInteger.ValueOf(13);
    317 
    318         }
    319 
    320         void iscMod_KeyDown(GmpBigInteger value)
     314            this.Exp = PrimesBigInteger.ValueOf(28);
     315            this.Base = PrimesBigInteger.ValueOf(2);
     316            this.Mod = PrimesBigInteger.ValueOf(13);
     317
     318        }
     319
     320        void iscMod_KeyDown(PrimesBigInteger value)
    321321        {
    322322            if (value != null)
     
    326326
    327327
    328         void iscMod_Execute(GmpBigInteger value)
     328        void iscMod_Execute(PrimesBigInteger value)
    329329        {
    330330            this.Mod = value;
     
    334334        private void slidermodulus_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
    335335        {
    336             this.Mod = GmpBigInteger.ValueOf((long)e.NewValue);
    337         }
    338 
    339         void iscExp_Execute(GmpBigInteger value)
     336            this.Mod = PrimesBigInteger.ValueOf((long)e.NewValue);
     337        }
     338
     339        void iscExp_Execute(PrimesBigInteger value)
    340340        {
    341341            this.Exp = value;
     
    343343        }
    344344
    345         void iscBase_Execute(GmpBigInteger value)
     345        void iscBase_Execute(PrimesBigInteger value)
    346346        {
    347347            this.Base = value;
     
    358358        //private IList<Polyline> m_Circles;
    359359        private IDictionary<Ellipse, Polyline> m_CirclesSource;
    360         private IDictionary<GmpBigInteger, Polyline> m_CirclesMark;
     360        private IDictionary<PrimesBigInteger, Polyline> m_CirclesMark;
    361361        //private IList<ArrowLine> m_Arrows;
    362362        private IDictionary<Pair<Ellipse, Ellipse>, ArrowLine> m_ArrowsWithSourceAndDestination;
    363         private IDictionary<GmpBigInteger, ArrowLine> m_ArrowsMark;
     363        private IDictionary<PrimesBigInteger, ArrowLine> m_ArrowsMark;
    364364
    365365        double offset = 0;
    366366
    367         private GmpBigInteger m_Base;
    368 
    369         public GmpBigInteger Base
     367        private PrimesBigInteger m_Base;
     368
     369        public PrimesBigInteger Base
    370370        {
    371371            get { return m_Base; }
    372372            set { m_Base = value; }
    373373        }
    374         private GmpBigInteger m_Exp;
    375 
    376         public GmpBigInteger Exp
     374        private PrimesBigInteger m_Exp;
     375
     376        public PrimesBigInteger Exp
    377377        {
    378378            get { return m_Exp; }
    379379            set { m_Exp = value; }
    380380        }
    381         private GmpBigInteger m_Mod;
    382 
    383         public GmpBigInteger Mod
     381        private PrimesBigInteger m_Mod;
     382
     383        public PrimesBigInteger Mod
    384384        {
    385385            get { return m_Mod; }
     
    729729            }
    730730        }
    731         //public void Execute(GmpBigInteger value)
     731        //public void Execute(PrimesBigInteger value)
    732732        //{
    733733        //  tabItemGraphic.IsEnabled = true;
     
    739739        //  log.Columns = 1;
    740740        //  log.Clear();
    741         //  if (value.CompareTo(GmpBigInteger.ValueOf(150))>0)
     741        //  if (value.CompareTo(PrimesBigInteger.ValueOf(150))>0)
    742742        //  {
    743743        //    tcStats.SelectedIndex = 1;
     
    792792            Point lastPoint = new Point(-1, -1);
    793793            Ellipse lastEllipse = null;
    794             GmpBigInteger i = GmpBigInteger.One;
    795             GmpBigInteger result = null;
    796             GmpBigInteger tmp = m_Base.Mod(m_Mod);
     794            PrimesBigInteger i = PrimesBigInteger.One;
     795            PrimesBigInteger result = null;
     796            PrimesBigInteger tmp = m_Base.Mod(m_Mod);
    797797            Ellipse e = this.GetEllipseAt(m_Points[tmp.IntValue]);
    798798            if (e != null)
     
    808808                {
    809809                    result = m_Base.Mod(m_Mod);
    810                     log.Info(string.Format(Primes.Resources.lang.Numbertheory.Numbertheory.powermod_executionfirst, new object[] { GmpBigInteger.One.ToString(), m_Base.ToString("D"), m_Mod.ToString("D"), result.ToString("D") }));
     810                    log.Info(string.Format(Primes.Resources.lang.Numbertheory.Numbertheory.powermod_executionfirst, new object[] { PrimesBigInteger.One.ToString(), m_Base.ToString("D"), m_Mod.ToString("D"), result.ToString("D") }));
    811811                }
    812812                else
    813813                {
    814                     GmpBigInteger tmpResult = result;
     814                    PrimesBigInteger tmpResult = result;
    815815                    result = result.Multiply(m_Base).Mod(m_Mod);
    816816                    log.Info(string.Format(Primes.Resources.lang.Numbertheory.Numbertheory.powermod_execution, new object[] { i.ToString("D"), tmpResult.ToString("D"), m_Base.ToString("D"), m_Mod.ToString("D"), result.ToString("D") }));
     
    825825                    Ellipse _e = this.GetEllipseAt(m_Points[result.IntValue]);
    826826                    Point newPoint = m_Points[result.IntValue];
    827                     //CreateArrow(i.Subtract(GmpBigInteger.One), lastPoint, newPoint);
    828                     CreateArrow(i.Subtract(GmpBigInteger.One), lastEllipse, _e);
     827                    //CreateArrow(i.Subtract(PrimesBigInteger.One), lastPoint, newPoint);
     828                    CreateArrow(i.Subtract(PrimesBigInteger.One), lastEllipse, _e);
    829829                    lastPoint = newPoint;
    830830                    lastEllipse = _e;
    831831                }
    832                 i = i.Add(GmpBigInteger.One);
    833                 if (i.CompareTo(GmpBigInteger.Three) >= 0)
     832                i = i.Add(PrimesBigInteger.One);
     833                if (i.CompareTo(PrimesBigInteger.Three) >= 0)
    834834                    WaitStepWise();
    835835            }
     
    861861
    862862
    863         //private void CreateArrow(GmpBigInteger counter, Point from, Point to)
     863        //private void CreateArrow(PrimesBigInteger counter, Point from, Point to)
    864864        //{
    865865        //    ArrowLine l = null;
     
    901901        //}
    902902
    903         private void CreateArrow(GmpBigInteger counter, Ellipse from, Ellipse to)
     903        private void CreateArrow(PrimesBigInteger counter, Ellipse from, Ellipse to)
    904904        {
    905905           
     
    954954        //}
    955955
    956         private void ResetLine(GmpBigInteger counter, ArrowLine l)
     956        private void ResetLine(PrimesBigInteger counter, ArrowLine l)
    957957        {
    958958            if (l != null)
     
    989989        //}
    990990
    991         //public void AddCircle(GmpBigInteger counter, double x, double y)
     991        //public void AddCircle(PrimesBigInteger counter, double x, double y)
    992992        //{
    993993        //    Polyline p = ControlHandler.CreateObject(typeof(Polyline)) as Polyline;
     
    10181018        //}
    10191019
    1020         public void AddCircle(GmpBigInteger counter, Ellipse source)
     1020        public void AddCircle(PrimesBigInteger counter, Ellipse source)
    10211021        {
    10221022            Polyline p = ControlHandler.CreateObject(typeof(Polyline)) as Polyline;
     
    10611061        }
    10621062
    1063         private void ResetCircle(GmpBigInteger counter, Polyline p)
     1063        private void ResetCircle(PrimesBigInteger counter, Polyline p)
    10641064        {
    10651065
     
    10751075        }
    10761076
    1077         //private void ResetCircle(GmpBigInteger counter, double x, double y)
     1077        //private void ResetCircle(PrimesBigInteger counter, double x, double y)
    10781078        //{
    10791079
  • trunk/CrypPlugins/Primes/Primes/WpfControls/NumberTheory/PrimitivRoots/PrimitivRootControl.xaml.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    217217using Primes.WpfControls.Components;
    218218using Primes.Library;
    219 using LibGmpWrapper;
     219using Primes.Bignum;
    220220using Primes.WpfControls.Validation;
    221221using Primes.WpfControls.Validation.Validator;
     
    236236      this.OnStart += new VoidDelegate(PrimitivRootControl_OnStart);
    237237      this.OnStop += new VoidDelegate(PrimitivRootControl_OnStop);
    238       validator = new BigIntegerMinValueMaxValueValidator(null, GmpBigInteger.Five,MAX);
    239       primes = new List<GmpBigInteger>();
     238      validator = new BigIntegerMinValueMaxValueValidator(null, PrimesBigInteger.Five,MAX);
     239      primes = new List<PrimesBigInteger>();
    240240      log.OverrideText = true;
    241241      int mersenneexp = mersenneseed[new Random().Next(mersenneseed.Length - 1)];
    242       tbInput.Text = GmpBigInteger.Random(2).Add(GmpBigInteger.Three).NextProbablePrime().ToString();
     242      tbInput.Text = PrimesBigInteger.Random(2).Add(PrimesBigInteger.Three).NextProbablePrime().ToString();
    243243      tbInput.Text += ", 2^" + mersenneexp + "-1";
    244       GmpBigInteger rangeval =GmpBigInteger.Random(2).Add(GmpBigInteger.Three);
    245 
    246       tbInput.Text += ", " + rangeval.ToString() + ";" + rangeval.Add(GmpBigInteger.Ten).ToString();
     244      PrimesBigInteger rangeval =PrimesBigInteger.Random(2).Add(PrimesBigInteger.Three);
     245
     246      tbInput.Text += ", " + rangeval.ToString() + ";" + rangeval.Add(PrimesBigInteger.Ten).ToString();
    247247
    248248      rndGenerate = new Random((int)(DateTime.Now.Ticks% int.MaxValue));
     
    289289              if (_inputrange.Length == 1)
    290290              {
    291                 GmpBigInteger ipt = null;
     291                PrimesBigInteger ipt = null;
    292292                validator.Value = s;
    293293                Primes.WpfControls.Validation.ValidationResult res = validator.Validate(ref ipt);
     
    324324                else
    325325                {
    326                   GmpBigInteger i1 = IsGmpBigInteger(_inputrange[0]);
    327                   GmpBigInteger i2 = IsGmpBigInteger(_inputrange[1]);
     326                  PrimesBigInteger i1 = IsGmpBigInteger(_inputrange[0]);
     327                  PrimesBigInteger i2 = IsGmpBigInteger(_inputrange[1]);
    328328                  if (i1 != null && i2 != null)
    329329                  {
     
    362362    }
    363363
    364     private GmpBigInteger IsGmpBigInteger(string s)
    365     {
    366       GmpBigInteger ipt = null;
     364    private PrimesBigInteger IsGmpBigInteger(string s)
     365    {
     366      PrimesBigInteger ipt = null;
    367367      validator.Value = s;
    368368      Primes.WpfControls.Validation.ValidationResult res = validator.Validate(ref ipt);
     
    384384    }
    385385    #region Constants
    386     private static readonly GmpBigInteger MAX = GmpBigInteger.ValueOf(1000000);
     386    private static readonly PrimesBigInteger MAX = PrimesBigInteger.ValueOf(1000000);
    387387    #endregion
    388388    #region Properites
    389     private IList<GmpBigInteger> primes;
    390     private IValidator<GmpBigInteger> validator;
     389    private IList<PrimesBigInteger> primes;
     390    private IValidator<PrimesBigInteger> validator;
    391391    private Random rndGenerate;
    392392
     
    449449      DateTime start = DateTime.Now;
    450450      FireOnStart();
    451       foreach (GmpBigInteger prime in primes)
     451      foreach (PrimesBigInteger prime in primes)
    452452      {
    453453        int row1 = log.NewLine();
     
    455455
    456456        StringBuilder sbResult = new StringBuilder();
    457         GmpBigInteger primeroot = GmpBigInteger.One;
     457        PrimesBigInteger primeroot = PrimesBigInteger.One;
    458458        while(primeroot.CompareTo(prime)<0)
    459459        {
     
    463463             
    464464            }
    465           primeroot = primeroot.Add(GmpBigInteger.One);
     465          primeroot = primeroot.Add(PrimesBigInteger.One);
    466466        }
    467         GmpBigInteger i = GmpBigInteger.One;
    468         GmpBigInteger primeMinus1 = prime.Subtract(GmpBigInteger.One);
    469         GmpBigInteger counter = GmpBigInteger.Zero;
     467        PrimesBigInteger i = PrimesBigInteger.One;
     468        PrimesBigInteger primeMinus1 = prime.Subtract(PrimesBigInteger.One);
     469        PrimesBigInteger counter = PrimesBigInteger.Zero;
    470470        while (i.CompareTo(primeMinus1) <= 0)
    471471        {
     
    478478          //  }
    479479          //}
    480           if (GmpBigInteger.GCD(i, primeMinus1).Equals(GmpBigInteger.One))
     480          if (PrimesBigInteger.GCD(i, primeMinus1).Equals(PrimesBigInteger.One))
    481481          {
    482482            lock (m_JumpLockObject)
     
    489489              }
    490490            }
    491             GmpBigInteger proot = primeroot.ModPow(i, prime);
    492             counter = counter.Add(GmpBigInteger.One);
     491            PrimesBigInteger proot = primeroot.ModPow(i, prime);
     492            counter = counter.Add(PrimesBigInteger.One);
    493493            log.Info(string.Format(Primes.Resources.lang.Numbertheory.Numbertheory.proot_skipcalc,new object[]{counter.ToString(), prime.ToString()}), 0, row1);
    494494            sbResult.Append(proot.ToString());
     
    496496            log.Info(sbResult.ToString(), 0, row2);
    497497          }
    498           i = i.Add(GmpBigInteger.One);
     498          i = i.Add(PrimesBigInteger.One);
    499499        }
    500500        int r3 = log.NewLine();
     
    506506    }
    507507
    508     private bool IsPrimitiveRoot(GmpBigInteger root, GmpBigInteger prime)
     508    private bool IsPrimitiveRoot(PrimesBigInteger root, PrimesBigInteger prime)
    509509    {
    510510      bool result = true;     
    511       if(GmpBigInteger.GCD(root,prime).Equals(GmpBigInteger.One)){
    512           GmpBigInteger k = GmpBigInteger.One;
    513           while (k.CompareTo(prime.Subtract(GmpBigInteger.One)) < 0)
     511      if(PrimesBigInteger.GCD(root,prime).Equals(PrimesBigInteger.One)){
     512          PrimesBigInteger k = PrimesBigInteger.One;
     513          while (k.CompareTo(prime.Subtract(PrimesBigInteger.One)) < 0)
    514514          {           
    515             if(root.ModPow(k,prime).Subtract(GmpBigInteger.One).Equals(GmpBigInteger.Zero)){
     515            if(root.ModPow(k,prime).Subtract(PrimesBigInteger.One).Equals(PrimesBigInteger.Zero)){
    516516              result = false;
    517517              break;
    518518            }
    519             k = k.Add(GmpBigInteger.One);
     519            k = k.Add(PrimesBigInteger.One);
    520520          }
    521521      }
     
    579579    {
    580580      int rndNumber = rndGenerate.Next(950);
    581       GmpBigInteger prime = GmpBigInteger.ValueOf(rndNumber).NextProbablePrime();
     581      PrimesBigInteger prime = PrimesBigInteger.ValueOf(rndNumber).NextProbablePrime();
    582582      if (!string.IsNullOrEmpty(tbInput.Text))
    583583        tbInput.Text += ", ";
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Primegeneration/Function/EulerPolynom.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    206206using System.Text;
    207207using Primes.WpfControls.Components;
    208 using LibGmpWrapper;
     208using Primes.Bignum;
    209209
    210210namespace Primes.WpfControls.Primegeneration.Function
     
    216216    {
    217217      m_StrImageUri = "pack://application:,,,/Primes;Component/Resources/icons/eulerpolynom.jpg";
    218       base.SetParameter(A, new PolynomFactor(A, GmpBigInteger.One, true));
    219       base.SetParameter(B, new PolynomFactor(B, GmpBigInteger.NegativeOne, true));
    220       base.SetParameter(C, new PolynomFactor(C, GmpBigInteger.ValueOf(41), true));
    221     }
    222 
    223     public override GmpBigInteger Execute(GmpBigInteger input)
    224     {
    225       return (input.Pow(2).Subtract(input)).Add(GmpBigInteger.ValueOf(41));
     218      base.SetParameter(A, new PolynomFactor(A, PrimesBigInteger.One, true));
     219      base.SetParameter(B, new PolynomFactor(B, PrimesBigInteger.NegativeOne, true));
     220      base.SetParameter(C, new PolynomFactor(C, PrimesBigInteger.ValueOf(41), true));
     221    }
     222
     223    public override PrimesBigInteger Execute(PrimesBigInteger input)
     224    {
     225      return (input.Pow(2).Subtract(input)).Add(PrimesBigInteger.ValueOf(41));
    226226    }
    227227    public override ICollection<PolynomFactor> Factors
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Primegeneration/Function/FunctionExecuter.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    205205using System.Collections.Generic;
    206206using System.Text;
    207 using LibGmpWrapper;
     207using Primes.Bignum;
    208208using System.Threading;
    209209using Primes.WpfControls.Components;
     
    212212namespace Primes.WpfControls.Primegeneration.Function
    213213{
    214   public delegate void ExpressionResultDelegate(GmpBigInteger result, GmpBigInteger input);
    215   public delegate void PolynomeRangeResultDelegate(IPolynom p, GmpBigInteger primesCount, GmpBigInteger primesCountReal, GmpBigInteger count);
     214  public delegate void ExpressionResultDelegate(PrimesBigInteger result, PrimesBigInteger input);
     215  public delegate void PolynomeRangeResultDelegate(IPolynom p, PrimesBigInteger primesCount, PrimesBigInteger primesCountReal, PrimesBigInteger count);
    216216  public class ExpressionExecuter
    217217  {
     
    221221    public event VoidDelegate Stop;
    222222
    223     private GmpBigInteger m_From;
    224 
    225     public GmpBigInteger From
     223    private PrimesBigInteger m_From;
     224
     225    public PrimesBigInteger From
    226226    {
    227227      get { return m_From; }
    228228      set { m_From = value; }
    229229    }
    230     private GmpBigInteger m_To;
    231 
    232     public GmpBigInteger To
     230    private PrimesBigInteger m_To;
     231
     232    public PrimesBigInteger To
    233233    {
    234234      get { return m_To; }
     
    244244    }
    245245
    246     public virtual void Execute(GmpBigInteger from, GmpBigInteger to)
     246    public virtual void Execute(PrimesBigInteger from, PrimesBigInteger to)
    247247    {
    248248      m_To = to;
     
    280280      while (m_From.CompareTo(m_To) <= 0)
    281281      {
    282         GmpBigInteger result = m_Function.Execute(m_From);
     282        PrimesBigInteger result = m_Function.Execute(m_From);
    283283        if (FunctionResult != null) FunctionResult(result, m_From);
    284         m_From = m_From.Add(GmpBigInteger.One);
     284        m_From = m_From.Add(PrimesBigInteger.One);
    285285      }
    286286      if (Stop != null) Stop();
     
    308308    }
    309309
    310     private GmpBigInteger m_NumberOfCalculations;
    311 
    312     public GmpBigInteger NumberOfCalculations
     310    private PrimesBigInteger m_NumberOfCalculations;
     311
     312    public PrimesBigInteger NumberOfCalculations
    313313    {
    314314      get { return m_NumberOfCalculations; }
    315315      set { m_NumberOfCalculations = value; }
    316316    }
    317     private GmpBigInteger m_NumberOfFormulars;
    318 
    319     public GmpBigInteger NumberOfFormulars
     317    private PrimesBigInteger m_NumberOfFormulars;
     318
     319    public PrimesBigInteger NumberOfFormulars
    320320    {
    321321      get { return m_NumberOfFormulars; }
     
    333333
    334334    #region override ExpressionExecuter
    335     public override void Execute(GmpBigInteger from, GmpBigInteger to)
     335    public override void Execute(PrimesBigInteger from, PrimesBigInteger to)
    336336    {
    337337      Execute();
     
    370370    //private void ComputeRandom()
    371371    //{
    372     //  GmpBigInteger i = GmpBigInteger.One;
     372    //  PrimesBigInteger i = PrimesBigInteger.One;
    373373    //  while (i.CompareTo(this.NumberOfFormulars) < 0)
    374374    //  {
    375     //    GmpBigInteger j = GmpBigInteger.One;
    376     //    GmpBigInteger to = this.NumberOfCalculations;
    377     //    if (NumberOfCalculations.Equals(GmpBigInteger.NaN))
     375    //    PrimesBigInteger j = PrimesBigInteger.One;
     376    //    PrimesBigInteger to = this.NumberOfCalculations;
     377    //    if (NumberOfCalculations.Equals(PrimesBigInteger.NaN))
    378378    //    {
    379379    //      j = From;
     
    381381
    382382    //    }
    383     //    GmpBigInteger counter = GmpBigInteger.Zero;
    384     //    GmpBigInteger primesCounter = GmpBigInteger.Zero;
     383    //    PrimesBigInteger counter = PrimesBigInteger.Zero;
     384    //    PrimesBigInteger primesCounter = PrimesBigInteger.Zero;
    385385    //    while(j.CompareTo(to)<=0){
    386386    //      foreach (KeyValuePair<string, Range> kvp in this.Parameters)
    387387    //      {
    388     //        GmpBigInteger value = GmpBigInteger.RandomM(kvp.Value.From.Add(kvp.Value.RangeAmount)).Add(GmpBigInteger.One);
     388    //        PrimesBigInteger value = PrimesBigInteger.RandomM(kvp.Value.From.Add(kvp.Value.RangeAmount)).Add(PrimesBigInteger.One);
    389389    //        Function.SetParameter(kvp.Key, value);
    390390    //      }
    391     //      GmpBigInteger input = j;
    392     //      if (!NumberOfCalculations.Equals(GmpBigInteger.NaN))
     391    //      PrimesBigInteger input = j;
     392    //      if (!NumberOfCalculations.Equals(PrimesBigInteger.NaN))
    393393    //      {
    394     //        input = GmpBigInteger.RandomM(NumberOfCalculations);
     394    //        input = PrimesBigInteger.RandomM(NumberOfCalculations);
    395395    //      }
    396     //      GmpBigInteger res = Function.Execute(input);
     396    //      PrimesBigInteger res = Function.Execute(input);
    397397    //      if(res.IsPrime(10)){
    398     //        primesCounter = primesCounter.Add(GmpBigInteger.One);
     398    //        primesCounter = primesCounter.Add(PrimesBigInteger.One);
    399399    //      }
    400     //      j = j.Add(GmpBigInteger.One);
    401     //      counter = counter.Add(GmpBigInteger.One);
     400    //      j = j.Add(PrimesBigInteger.One);
     401    //      counter = counter.Add(PrimesBigInteger.One);
    402402    //    }
    403403    //    if (this.FunctionResult != null) this.FunctionResult(this.Function as IPolynom, primesCounter, counter);
    404     //    i = i.Add(GmpBigInteger.One);
     404    //    i = i.Add(PrimesBigInteger.One);
    405405
    406406    //  }
     
    411411      Random r = new Random();
    412412
    413       GmpBigInteger i = GmpBigInteger.One;
    414       GmpBigInteger j = null;
    415       GmpBigInteger to = null;
    416       GmpBigInteger counter = null;
    417       GmpBigInteger primesCounter = null;
    418       IList<GmpBigInteger> m_PrimeList = new List<GmpBigInteger>();
     413      PrimesBigInteger i = PrimesBigInteger.One;
     414      PrimesBigInteger j = null;
     415      PrimesBigInteger to = null;
     416      PrimesBigInteger counter = null;
     417      PrimesBigInteger primesCounter = null;
     418      IList<PrimesBigInteger> m_PrimeList = new List<PrimesBigInteger>();
    419419      while (i.CompareTo(this.NumberOfFormulars) <= 0)
    420420      {
    421         j = GmpBigInteger.One;
     421        j = PrimesBigInteger.One;
    422422        to = this.NumberOfCalculations;
    423         if (NumberOfCalculations.Equals(GmpBigInteger.NaN))
     423        if (NumberOfCalculations.Equals(PrimesBigInteger.NaN))
    424424        {
    425425          j = From;
     
    427427
    428428        }
    429         counter = GmpBigInteger.Zero;
    430         primesCounter = GmpBigInteger.Zero;
     429        counter = PrimesBigInteger.Zero;
     430        primesCounter = PrimesBigInteger.Zero;
    431431        foreach (KeyValuePair<string, Range> kvp in this.Parameters)
    432432        {
    433           GmpBigInteger mod = kvp.Value.To.Subtract(kvp.Value.From).Add(GmpBigInteger.One);
    434           GmpBigInteger value = GmpBigInteger.ValueOf(r.Next(int.MaxValue)).Mod(mod).Add(kvp.Value.From);//GmpBigInteger.RandomM(kvp.Value.From.Add(kvp.Value.RangeAmount)).Add(GmpBigInteger.One);
     433          PrimesBigInteger mod = kvp.Value.To.Subtract(kvp.Value.From).Add(PrimesBigInteger.One);
     434          PrimesBigInteger value = PrimesBigInteger.ValueOf(r.Next(int.MaxValue)).Mod(mod).Add(kvp.Value.From);//PrimesBigInteger.RandomM(kvp.Value.From.Add(kvp.Value.RangeAmount)).Add(PrimesBigInteger.One);
    435435          Function.SetParameter(kvp.Key, value);
    436436        }
    437437        while (j.CompareTo(to) <= 0)
    438438        {
    439           GmpBigInteger input = j;
    440           if (!NumberOfCalculations.Equals(GmpBigInteger.NaN))
     439          PrimesBigInteger input = j;
     440          if (!NumberOfCalculations.Equals(PrimesBigInteger.NaN))
    441441          {
    442             input = GmpBigInteger.ValueOf(r.Next(int.MaxValue)).Mod(NumberOfCalculations);//GmpBigInteger.RandomM(NumberOfCalculations);
     442            input = PrimesBigInteger.ValueOf(r.Next(int.MaxValue)).Mod(NumberOfCalculations);//PrimesBigInteger.RandomM(NumberOfCalculations);
    443443          }
    444           GmpBigInteger res = Function.Execute(input);
    445           if (res.CompareTo(GmpBigInteger.Zero)>=0 && res.IsPrime(10))
     444          PrimesBigInteger res = Function.Execute(input);
     445          if (res.CompareTo(PrimesBigInteger.Zero)>=0 && res.IsPrime(10))
    446446          {
    447447            if (!m_PrimeList.Contains(res))
     
    449449              m_PrimeList.Add(res);
    450450            }
    451             primesCounter = primesCounter.Add(GmpBigInteger.One);
     451            primesCounter = primesCounter.Add(PrimesBigInteger.One);
    452452          }
    453           j = j.Add(GmpBigInteger.One);
    454           counter = counter.Add(GmpBigInteger.One);
     453          j = j.Add(PrimesBigInteger.One);
     454          counter = counter.Add(PrimesBigInteger.One);
    455455        }
    456         if (this.FunctionResult != null) this.FunctionResult(this.Function as IPolynom, primesCounter, GmpBigInteger.ValueOf(m_PrimeList.Count), counter);
    457         i = i.Add(GmpBigInteger.One);
     456        if (this.FunctionResult != null) this.FunctionResult(this.Function as IPolynom, primesCounter, PrimesBigInteger.ValueOf(m_PrimeList.Count), counter);
     457        i = i.Add(PrimesBigInteger.One);
    458458
    459459      }
     
    464464      Range rangeb = this.Parameters[1].Value;
    465465      Range rangec = this.Parameters[2].Value;
    466       GmpBigInteger ca = rangea.From;
    467       GmpBigInteger counter = GmpBigInteger.Zero;
     466      PrimesBigInteger ca = rangea.From;
     467      PrimesBigInteger counter = PrimesBigInteger.Zero;
    468468      while (ca.CompareTo(rangea.To) <= 0)
    469469      {
    470470        m_Function.SetParameter("a", ca);
    471         GmpBigInteger cb = rangeb.From;
     471        PrimesBigInteger cb = rangeb.From;
    472472        while (cb.CompareTo(rangeb.To) <= 0)
    473473        {
    474474          m_Function.SetParameter("b", cb);
    475           GmpBigInteger cc = rangec.From;
     475          PrimesBigInteger cc = rangec.From;
    476476          while (cc.CompareTo(rangec.To) <= 0)
    477477          {
    478478            m_Function.SetParameter("c", cc);
    479479
    480             GmpBigInteger from = From;
    481             GmpBigInteger primesCounter = GmpBigInteger.Zero;
    482             IList<GmpBigInteger> m_PrimeList = new List<GmpBigInteger>();
     480            PrimesBigInteger from = From;
     481            PrimesBigInteger primesCounter = PrimesBigInteger.Zero;
     482            IList<PrimesBigInteger> m_PrimeList = new List<PrimesBigInteger>();
    483483            while (from.CompareTo(To) <= 0)
    484484            {
    485               GmpBigInteger res = Function.Execute(from);
     485              PrimesBigInteger res = Function.Execute(from);
    486486              if (res.IsPrime(10))
    487487              {
     
    490490                  m_PrimeList.Add(res);
    491491                }
    492                 primesCounter = primesCounter.Add(GmpBigInteger.One);
     492                primesCounter = primesCounter.Add(PrimesBigInteger.One);
    493493              }
    494               counter = counter.Add(GmpBigInteger.One);
    495               from = from.Add(GmpBigInteger.One);
     494              counter = counter.Add(PrimesBigInteger.One);
     495              from = from.Add(PrimesBigInteger.One);
    496496            }
    497             if (this.FunctionResult != null) this.FunctionResult(this.Function as IPolynom, primesCounter,GmpBigInteger.ValueOf(m_PrimeList.Count), counter);
    498 
    499             cc = cc.Add(GmpBigInteger.One);
     497            if (this.FunctionResult != null) this.FunctionResult(this.Function as IPolynom, primesCounter,PrimesBigInteger.ValueOf(m_PrimeList.Count), counter);
     498
     499            cc = cc.Add(PrimesBigInteger.One);
    500500          }
    501           cb = cb.Add(GmpBigInteger.One);
     501          cb = cb.Add(PrimesBigInteger.One);
    502502        }
    503         ca = ca.Add(GmpBigInteger.One);
     503        ca = ca.Add(PrimesBigInteger.One);
    504504      }
    505505
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Primegeneration/Function/GenerateMDigitPrimes.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    205205using System.Collections.Generic;
    206206using System.Text;
    207 using LibGmpWrapper;
     207using Primes.Bignum;
    208208using Primes.WpfControls.Components;
    209209using Primes.Library;
     
    214214  {
    215215    public static readonly string LEN = "Lenght";
    216     private IList<GmpBigInteger> m_GeneratedPrimes;
    217     private GmpBigInteger m_LastPrime;
    218     private GmpBigInteger m_Length;
     216    private IList<PrimesBigInteger> m_GeneratedPrimes;
     217    private PrimesBigInteger m_LastPrime;
     218    private PrimesBigInteger m_Length;
    219219    public event VoidDelegate NonFurtherPrimeFound;
    220220    public GenerateMDigitPrimes()
    221221    {
    222       m_GeneratedPrimes = new List<GmpBigInteger>();
     222      m_GeneratedPrimes = new List<PrimesBigInteger>();
    223223    }
    224224    #region IFunction Members
    225225
    226     public LibGmpWrapper.GmpBigInteger Execute(GmpBigInteger input)
     226    public PrimesBigInteger Execute(PrimesBigInteger input)
    227227    {
    228228      m_LastPrime = GetStartBigInteger();
     
    244244              sn[i] = '0';
    245245            }
    246             GmpBigInteger x = new GmpBigInteger(new string(sn)).NextProbablePrime();
     246            PrimesBigInteger x = new PrimesBigInteger(new string(sn)).NextProbablePrime();
    247247            for (int i = 0; i < 100000; i++)
    248248            {
     
    265265      return m_LastPrime;
    266266    }
    267     private GmpBigInteger GetStartBigInteger()
    268     {
    269       GmpBigInteger _len = m_Length.Add(GmpBigInteger.One);
    270       GmpBigInteger result = GmpBigInteger.Random(_len).NextProbablePrime();
     267    private PrimesBigInteger GetStartBigInteger()
     268    {
     269      PrimesBigInteger _len = m_Length.Add(PrimesBigInteger.One);
     270      PrimesBigInteger result = PrimesBigInteger.Random(_len).NextProbablePrime();
    271271      while (result.ToString().Length != this.m_Length.IntValue+1)
    272         result = GmpBigInteger.Random(_len).NextProbablePrime();
     272        result = PrimesBigInteger.Random(_len).NextProbablePrime();
    273273      return result;
    274274    }
    275     public void SetParameter(string name, GmpBigInteger value)
     275    public void SetParameter(string name, PrimesBigInteger value)
    276276    {
    277277      if (name.Equals(LEN))
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Primegeneration/Function/IExpression.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    205205using System.Collections.Generic;
    206206using System.Text;
    207 using LibGmpWrapper;
     207using Primes.Bignum;
    208208
    209209namespace Primes.WpfControls.Primegeneration.Function
     
    211211  public interface IExpression
    212212  {
    213     GmpBigInteger Execute(GmpBigInteger input);
    214     void SetParameter(string name, GmpBigInteger value);
     213    PrimesBigInteger Execute(PrimesBigInteger input);
     214    void SetParameter(string name, PrimesBigInteger value);
    215215    void Reset();
    216216  }
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Primegeneration/Function/SecondDegreePolynom.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    210210using System.Resources;
    211211using Primes.WpfControls.Components;
    212 using LibGmpWrapper;
     212using Primes.Bignum;
    213213
    214214namespace Primes.WpfControls.Primegeneration.Function
     
    225225    #region Properties
    226226    private System.Windows.Controls.Image m_Image;
    227     protected GmpBigInteger a;
    228     protected GmpBigInteger b;
    229     protected GmpBigInteger c;
     227    protected PrimesBigInteger a;
     228    protected PrimesBigInteger b;
     229    protected PrimesBigInteger c;
    230230    protected IDictionary<string, PolynomFactor> m_list;
    231231    protected string m_StrImageUri;
     
    234234    public SecondDegreePolynom()
    235235    {
    236       a = GmpBigInteger.One;
    237       b = GmpBigInteger.One;
    238       c = GmpBigInteger.Zero;
     236      a = PrimesBigInteger.One;
     237      b = PrimesBigInteger.One;
     238      c = PrimesBigInteger.Zero;
    239239      m_list = new Dictionary<string, PolynomFactor>();
    240240      m_list.Add(A,new PolynomFactor(A, a));
     
    271271    public virtual string Name
    272272    {
    273       get { return "Eingabe der Koeffizienten für eine Formel"; }
     273      get { return "Eingabe der Koeffizienten fÃŒr eine Formel"; }
    274274    }
    275275
     
    278278    #region IExpression Members
    279279
    280     public virtual LibGmpWrapper.GmpBigInteger Execute(LibGmpWrapper.GmpBigInteger input)
    281     {
    282       GmpBigInteger a = (m_list[A] as PolynomFactor). Value;
    283       GmpBigInteger b = (m_list[B] as PolynomFactor).Value;
    284       GmpBigInteger c = (m_list[C] as PolynomFactor).Value;
     280    public virtual PrimesBigInteger Execute(PrimesBigInteger input)
     281    {
     282      PrimesBigInteger a = (m_list[A] as PolynomFactor). Value;
     283      PrimesBigInteger b = (m_list[B] as PolynomFactor).Value;
     284      PrimesBigInteger c = (m_list[C] as PolynomFactor).Value;
    285285      return (input.Pow(2).Multiply(a).Add(b.Multiply(input))).Add(c);
    286286    }
    287287
    288     public void SetParameter(string name, GmpBigInteger value)
     288    public void SetParameter(string name, PrimesBigInteger value)
    289289    {
    290290      if (A.Equals(name)) (m_list[A] as PolynomFactor).Value = value;
     
    309309    public void Reset()
    310310    {
    311       a = GmpBigInteger.One;
    312       b = GmpBigInteger.One;
    313       c = GmpBigInteger.Zero;
     311      a = PrimesBigInteger.One;
     312      b = PrimesBigInteger.One;
     313      c = PrimesBigInteger.Zero;
    314314    }
    315315
     
    320320      StringBuilder result = new StringBuilder();
    321321      result.Append((m_list[A].Value));
    322       result.Append("*x² + ");
     322      result.Append("*x² + ");
    323323      result.Append((m_list[B].Value));
    324324      result.Append("*x + ");
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Primegeneration/Function/SecondDegreePolynomRange.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    206206using System.Text;
    207207using Primes.WpfControls.Components;
    208 using LibGmpWrapper;
     208using Primes.Bignum;
    209209using Primes.Library;
    210210using System.Windows.Media.Imaging;
     
    272272    }
    273273
    274     public GmpBigInteger Execute(GmpBigInteger input)
     274    public PrimesBigInteger Execute(PrimesBigInteger input)
    275275    {
    276276      throw new NotImplementedException();
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Primegeneration/InputControlNTimesM.xaml.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    215215using System.Windows.Shapes;
    216216using Primes.WpfControls.Primegeneration.Function;
    217 using LibGmpWrapper;
     217using Primes.Bignum;
    218218using Primes.WpfControls.Validation.Validator;
    219219using Primes.WpfControls.Validation;
     
    229229  /// Interaction logic for InputControlNTimesM.xaml
    230230  /// </summary>
    231   internal delegate void Execute_N_Digits_Delegate(GmpBigInteger n, GmpBigInteger digits);
     231  internal delegate void Execute_N_Digits_Delegate(PrimesBigInteger n, PrimesBigInteger digits);
    232232
    233233  public partial class InputControlNTimesM : UserControl
     
    239239
    240240    #region Properties
    241     private GmpBigInteger m_MaxDigits;
    242     public GmpBigInteger MaxDigits
     241    private PrimesBigInteger m_MaxDigits;
     242    public PrimesBigInteger MaxDigits
    243243    {
    244244      get { return m_MaxDigits; }
     
    250250    {
    251251      InitializeComponent();
    252       m_MaxDigits = GmpBigInteger.ValueOf(500);
     252      m_MaxDigits = PrimesBigInteger.ValueOf(500);
    253253    }
    254254
     
    256256    private void btnExec_Click(object sender, RoutedEventArgs e)
    257257    {
    258       GmpBigInteger n = GetPrimesCount();
    259       GmpBigInteger digits = GetDigits();
     258      PrimesBigInteger n = GetPrimesCount();
     259      PrimesBigInteger digits = GetDigits();
    260260      if (digits != null && n != null)
    261261      {
     
    266266        else
    267267        {
    268           if (Execute != null) Execute(n, digits.Subtract(GmpBigInteger.One));
     268          if (Execute != null) Execute(n, digits.Subtract(PrimesBigInteger.One));
    269269        }
    270270      }
    271271    }
    272272
    273     private GmpBigInteger GetPrimesCount()
    274     {
    275       GmpBigInteger result = GmpBigInteger.One;
     273    private PrimesBigInteger GetPrimesCount()
     274    {
     275      PrimesBigInteger result = PrimesBigInteger.One;
    276276      try
    277277      {
    278         IValidator<GmpBigInteger> validator = new BigIntegerMinValueValidator(tbN.Text, GmpBigInteger.ValueOf(2));
    279         TextBoxValidator<GmpBigInteger> tbValidator = new TextBoxValidator<GmpBigInteger>(validator, tbN, "2");
     278        IValidator<PrimesBigInteger> validator = new BigIntegerMinValueValidator(tbN.Text, PrimesBigInteger.ValueOf(2));
     279        TextBoxValidator<PrimesBigInteger> tbValidator = new TextBoxValidator<PrimesBigInteger>(validator, tbN, "2");
    280280        tbValidator.Validate(ref result);
    281281      }
     
    295295    }
    296296
    297     private GmpBigInteger GetDigits()
    298     {
    299       GmpBigInteger result = GmpBigInteger.One;
     297    private PrimesBigInteger GetDigits()
     298    {
     299      PrimesBigInteger result = PrimesBigInteger.One;
    300300      try
    301301      {
    302         IValidator<GmpBigInteger> validator = new BigIntegerMinValueValidator(tbM.Text,GmpBigInteger.Two);
    303         TextBoxValidator<GmpBigInteger> tbValidator = new TextBoxValidator<GmpBigInteger>(validator, tbM, "2");
     302        IValidator<PrimesBigInteger> validator = new BigIntegerMinValueValidator(tbM.Text,PrimesBigInteger.Two);
     303        TextBoxValidator<PrimesBigInteger> tbValidator = new TextBoxValidator<PrimesBigInteger>(validator, tbM, "2");
    304304        tbValidator.Validate(ref result);
    305305      }
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Primegeneration/InputControlPolynom.xaml.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    215215using System.Windows.Shapes;
    216216using Primes.WpfControls.Components;
    217 using LibGmpWrapper;
     217using Primes.Bignum;
    218218using Primes.WpfControls.Validation;
    219219using Primes.WpfControls.Validation.Validator;
     
    226226  /// Interaction logic for InputControlExpression.xaml
    227227  /// </summary>
    228   internal delegate void ExecutePolynomDelegate(GmpBigInteger from, GmpBigInteger to, IPolynom p);
     228  internal delegate void ExecutePolynomDelegate(PrimesBigInteger from, PrimesBigInteger to, IPolynom p);
    229229  public partial class InputControlPolynom : UserControl
    230230  {
     
    280280      result.IsEnabled = !factor.Readonly;
    281281
    282       InputValidator<GmpBigInteger> validatorFree = new InputValidator<GmpBigInteger>();
     282      InputValidator<PrimesBigInteger> validatorFree = new InputValidator<PrimesBigInteger>();
    283283      validatorFree.DefaultValue = "0";
    284284      validatorFree.Validator = new BigIntegerValidator();
    285285      result.AddInputValidator(InputSingleControl.Free, validatorFree);
    286286
    287       InputValidator<GmpBigInteger> validatorFactor = new InputValidator<GmpBigInteger>();
     287      InputValidator<PrimesBigInteger> validatorFactor = new InputValidator<PrimesBigInteger>();
    288288      validatorFactor.DefaultValue = "0";
    289       validatorFactor.Validator = new BigIntegerMinValueValidator(null, GmpBigInteger.Zero);
    290 
    291       InputValidator<GmpBigInteger> validatorBase = new InputValidator<GmpBigInteger>();
     289      validatorFactor.Validator = new BigIntegerMinValueValidator(null, PrimesBigInteger.Zero);
     290
     291      InputValidator<PrimesBigInteger> validatorBase = new InputValidator<PrimesBigInteger>();
    292292      validatorBase.DefaultValue = "1";
    293293      validatorBase.Validator = new BigIntegerValidator();
    294294
    295       InputValidator<GmpBigInteger> validatorExp = new InputValidator<GmpBigInteger>();
     295      InputValidator<PrimesBigInteger> validatorExp = new InputValidator<PrimesBigInteger>();
    296296      validatorExp.DefaultValue = "0";
    297297      validatorExp.Validator = new BigIntegerValidator();
    298298
    299       InputValidator<GmpBigInteger> validatorSum = new InputValidator<GmpBigInteger>();
     299      InputValidator<PrimesBigInteger> validatorSum = new InputValidator<PrimesBigInteger>();
    300300      validatorSum.DefaultValue = "0";
    301       validatorSum.Validator = new BigIntegerMinValueMaxValueValidator(null, GmpBigInteger.ValueOf(-100), GmpBigInteger.ValueOf(100));
     301      validatorSum.Validator = new BigIntegerMinValueMaxValueValidator(null, PrimesBigInteger.ValueOf(-100), PrimesBigInteger.ValueOf(100));
    302302      result.AddInputValidator(InputSingleControl.CalcFactor, validatorFactor);
    303303      result.AddInputValidator(InputSingleControl.CalcBase, validatorBase);
     
    319319      result.Tag = factor.Name;
    320320
    321       InputValidator<GmpBigInteger> validatorFreeFrom = new InputValidator<GmpBigInteger>();
     321      InputValidator<PrimesBigInteger> validatorFreeFrom = new InputValidator<PrimesBigInteger>();
    322322      validatorFreeFrom.DefaultValue = "0";
    323       validatorFreeFrom.Validator = new BigIntegerMinValueMaxValueValidator(null,GmpBigInteger.ValueOf(-1000),GmpBigInteger.ValueOf(1000));
     323      validatorFreeFrom.Validator = new BigIntegerMinValueMaxValueValidator(null,PrimesBigInteger.ValueOf(-1000),PrimesBigInteger.ValueOf(1000));
    324324      result.AddInputValidator(InputRangeControl.FreeFrom, validatorFreeFrom);
    325325
    326       InputValidator<GmpBigInteger> validatorFreeTo = new InputValidator<GmpBigInteger>();
     326      InputValidator<PrimesBigInteger> validatorFreeTo = new InputValidator<PrimesBigInteger>();
    327327      validatorFreeTo.DefaultValue = "0";
    328       validatorFreeTo.Validator = new BigIntegerMinValueMaxValueValidator(null, GmpBigInteger.ValueOf(-1000), GmpBigInteger.ValueOf(1000));
     328      validatorFreeTo.Validator = new BigIntegerMinValueMaxValueValidator(null, PrimesBigInteger.ValueOf(-1000), PrimesBigInteger.ValueOf(1000));
    329329      result.AddInputValidator(InputRangeControl.FreeTo, validatorFreeTo);
    330330
     
    355355      rangeinputcontrol.Cancel += new VoidDelegate(rangeinputcontrol_Cancel);
    356356
    357       //rangeinputcontrol.AddSingleAdisors(InputRangeControl.From, new LargeNumberAdvisor(GmpBigInteger.ValueOf(200), OnlineHelpActions.Graph_LargeNumbers));
    358       //rangeinputcontrol.AddSingleAdisors(InputRangeControl.To, new LargeNumberAdvisor(GmpBigInteger.ValueOf(200), OnlineHelpActions.Graph_LargeNumbers));
     357      //rangeinputcontrol.AddSingleAdisors(InputRangeControl.From, new LargeNumberAdvisor(PrimesBigInteger.ValueOf(200), OnlineHelpActions.Graph_LargeNumbers));
     358      //rangeinputcontrol.AddSingleAdisors(InputRangeControl.To, new LargeNumberAdvisor(PrimesBigInteger.ValueOf(200), OnlineHelpActions.Graph_LargeNumbers));
    359359
    360360    }
     
    373373    private void SetFreeInputValidators()
    374374    {
    375       InputValidator<GmpBigInteger> validatorFrom = new InputValidator<GmpBigInteger>();
     375      InputValidator<PrimesBigInteger> validatorFrom = new InputValidator<PrimesBigInteger>();
    376376      validatorFrom.DefaultValue = "0";
    377       validatorFrom.Validator = new BigIntegerMinValueValidator(null, GmpBigInteger.Zero);
    378 
    379       InputValidator<GmpBigInteger> validatorTo = new InputValidator<GmpBigInteger>();
     377      validatorFrom.Validator = new BigIntegerMinValueValidator(null, PrimesBigInteger.Zero);
     378
     379      InputValidator<PrimesBigInteger> validatorTo = new InputValidator<PrimesBigInteger>();
    380380      validatorTo.DefaultValue = "1";
    381       validatorTo.Validator = new BigIntegerMinValueValidator(null, GmpBigInteger.One);
     381      validatorTo.Validator = new BigIntegerMinValueValidator(null, PrimesBigInteger.One);
    382382
    383383      rangeinputcontrol.AddInputValidator(InputRangeControl.FreeFrom, validatorFrom);
     
    387387    private void SetCalcInputValidators()
    388388    {
    389       InputValidator<GmpBigInteger> validatorFromFactor = new InputValidator<GmpBigInteger>();
     389      InputValidator<PrimesBigInteger> validatorFromFactor = new InputValidator<PrimesBigInteger>();
    390390      validatorFromFactor.DefaultValue = "1";
    391       validatorFromFactor.Validator = new BigIntegerMinValueValidator(null, GmpBigInteger.Zero);
    392 
    393       InputValidator<GmpBigInteger> validatorFromBase = new InputValidator<GmpBigInteger>();
     391      validatorFromFactor.Validator = new BigIntegerMinValueValidator(null, PrimesBigInteger.Zero);
     392
     393      InputValidator<PrimesBigInteger> validatorFromBase = new InputValidator<PrimesBigInteger>();
    394394      validatorFromBase.DefaultValue = "1";
    395       validatorFromBase.Validator = new BigIntegerMinValueValidator(null, GmpBigInteger.One);
    396 
    397       InputValidator<GmpBigInteger> validatorFromExp = new InputValidator<GmpBigInteger>();
     395      validatorFromBase.Validator = new BigIntegerMinValueValidator(null, PrimesBigInteger.One);
     396
     397      InputValidator<PrimesBigInteger> validatorFromExp = new InputValidator<PrimesBigInteger>();
    398398      validatorFromExp.DefaultValue = "0";
    399       validatorFromExp.Validator = new BigIntegerMinValueValidator(null, GmpBigInteger.Zero);
    400 
    401       InputValidator<GmpBigInteger> validatorFromSum = new InputValidator<GmpBigInteger>();
     399      validatorFromExp.Validator = new BigIntegerMinValueValidator(null, PrimesBigInteger.Zero);
     400
     401      InputValidator<PrimesBigInteger> validatorFromSum = new InputValidator<PrimesBigInteger>();
    402402      validatorFromSum.DefaultValue = "0";
    403       validatorFromSum.Validator = new BigIntegerMinValueMaxValueValidator(null, GmpBigInteger.ValueOf(-100), GmpBigInteger.ValueOf(100));
    404 
    405       InputValidator<GmpBigInteger> validatorToFactor = new InputValidator<GmpBigInteger>();
     403      validatorFromSum.Validator = new BigIntegerMinValueMaxValueValidator(null, PrimesBigInteger.ValueOf(-100), PrimesBigInteger.ValueOf(100));
     404
     405      InputValidator<PrimesBigInteger> validatorToFactor = new InputValidator<PrimesBigInteger>();
    406406      validatorToFactor.DefaultValue = "1";
    407       validatorToFactor.Validator = new BigIntegerMinValueValidator(null, GmpBigInteger.Zero);
    408 
    409       InputValidator<GmpBigInteger> validatorToBase = new InputValidator<GmpBigInteger>();
     407      validatorToFactor.Validator = new BigIntegerMinValueValidator(null, PrimesBigInteger.Zero);
     408
     409      InputValidator<PrimesBigInteger> validatorToBase = new InputValidator<PrimesBigInteger>();
    410410      validatorToBase.DefaultValue = "1";
    411       validatorToBase.Validator = new BigIntegerMinValueValidator(null, GmpBigInteger.One);
    412 
    413       InputValidator<GmpBigInteger> validatorToExp = new InputValidator<GmpBigInteger>();
     411      validatorToBase.Validator = new BigIntegerMinValueValidator(null, PrimesBigInteger.One);
     412
     413      InputValidator<PrimesBigInteger> validatorToExp = new InputValidator<PrimesBigInteger>();
    414414      validatorToExp.DefaultValue = "0";
    415       validatorToExp.Validator = new BigIntegerMinValueValidator(null, GmpBigInteger.Zero);
    416 
    417       InputValidator<GmpBigInteger> validatorToSum = new InputValidator<GmpBigInteger>();
     415      validatorToExp.Validator = new BigIntegerMinValueValidator(null, PrimesBigInteger.Zero);
     416
     417      InputValidator<PrimesBigInteger> validatorToSum = new InputValidator<PrimesBigInteger>();
    418418      validatorToSum.DefaultValue = "0";
    419       validatorToSum.Validator = new BigIntegerMinValueMaxValueValidator(null, GmpBigInteger.ValueOf(-100), GmpBigInteger.ValueOf(100));
     419      validatorToSum.Validator = new BigIntegerMinValueMaxValueValidator(null, PrimesBigInteger.ValueOf(-100), PrimesBigInteger.ValueOf(100));
    420420
    421421      rangeinputcontrol.AddInputValidator(InputRangeControl.CalcFromFactor, validatorFromFactor);
     
    454454
    455455    #endregion
    456     void rangeinputcontrol_Execute(GmpBigInteger from, GmpBigInteger to)
     456    void rangeinputcontrol_Execute(PrimesBigInteger from, PrimesBigInteger to)
    457457    {
    458458      bool doExecute = true;
     
    462462        {
    463463          InputSingleControl isc = element as InputSingleControl;
    464           GmpBigInteger i = isc.GetValue();
     464          PrimesBigInteger i = isc.GetValue();
    465465          doExecute &= i != null;
    466466          if (doExecute)
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Primegeneration/InputControlPolynomRange.xaml.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    215215using System.Windows.Shapes;
    216216using Primes.WpfControls.Components;
    217 using LibGmpWrapper;
     217using Primes.Bignum;
    218218using Primes.WpfControls.Validation;
    219219using Primes.WpfControls.Validation.Validator;
     
    229229  public delegate void ExecutePolynomRangeDelegate(
    230230    IPolynom p,
    231     GmpBigInteger from,
    232     GmpBigInteger to,
    233     GmpBigInteger numberOfCalculations,
    234     GmpBigInteger numberOfFormulars,
     231    PrimesBigInteger from,
     232    PrimesBigInteger to,
     233    PrimesBigInteger numberOfCalculations,
     234    PrimesBigInteger numberOfFormulars,
    235235    IList<KeyValuePair<string, Range>> parameters);
    236236 
     
    293293      result.Execute += new ExecuteDelegate(InputRangeControl_Execute);
    294294
    295       InputValidator<GmpBigInteger> validatorFreeFrom = new InputValidator<GmpBigInteger>();
     295      InputValidator<PrimesBigInteger> validatorFreeFrom = new InputValidator<PrimesBigInteger>();
    296296      validatorFreeFrom.DefaultValue = "0";
    297297      validatorFreeFrom.Validator = new BigIntegerValidator();
    298298      result.AddInputValidator(InputRangeControl.FreeFrom, validatorFreeFrom);
    299299
    300       InputValidator<GmpBigInteger> validatorFreeTo = new InputValidator<GmpBigInteger>();
     300      InputValidator<PrimesBigInteger> validatorFreeTo = new InputValidator<PrimesBigInteger>();
    301301      validatorFreeTo.DefaultValue = "1";
    302302      validatorFreeTo.Validator = new BigIntegerValidator();
     
    379379    private void SetNumberOfCalculationsValidators()
    380380    {
    381       InputValidator<GmpBigInteger> validatorNumberOfCalculations = new InputValidator<GmpBigInteger>();
     381      InputValidator<PrimesBigInteger> validatorNumberOfCalculations = new InputValidator<PrimesBigInteger>();
    382382      validatorNumberOfCalculations.DefaultValue = "1";
    383       validatorNumberOfCalculations.Validator = new BigIntegerMinValueValidator(null, GmpBigInteger.One);
     383      validatorNumberOfCalculations.Validator = new BigIntegerMinValueValidator(null, PrimesBigInteger.One);
    384384      icNumberOfCalculations.AddInputValidator(InputSingleControl.Free, validatorNumberOfCalculations);
    385385    }
     
    408408        {
    409409          InputRangeControl isc = element as InputRangeControl;
    410           GmpBigInteger _from = null;
    411           GmpBigInteger _to = null;
     410          PrimesBigInteger _from = null;
     411          PrimesBigInteger _to = null;
    412412
    413413          isc.GetValue(ref _from, ref _to);
     
    444444    private void ExecuteRandom(IList<KeyValuePair<string, Range>> parameters)
    445445    {
    446       GmpBigInteger numberOfCalculations = icNumberOfCalculations.GetValue();
    447       GmpBigInteger numberOfFormulars = icNumberOfFormulars.GetValue();
    448       GmpBigInteger xfrom = null;
    449       GmpBigInteger xto = null;
     446      PrimesBigInteger numberOfCalculations = icNumberOfCalculations.GetValue();
     447      PrimesBigInteger numberOfFormulars = icNumberOfFormulars.GetValue();
     448      PrimesBigInteger xfrom = null;
     449      PrimesBigInteger xto = null;
    450450      ircRandomChooseXRange.GetValue(ref xfrom, ref xto);
    451451      if (numberOfFormulars != null)
     
    455455          if (xfrom != null && xto != null)
    456456          {
    457             numberOfCalculations = GmpBigInteger.NaN;
     457            numberOfCalculations = PrimesBigInteger.NaN;
    458458            Execute(m_Polynom, xfrom, xto, numberOfCalculations, numberOfFormulars, parameters);
    459459          }
     
    464464          if (numberOfCalculations != null)
    465465          {
    466             xfrom = GmpBigInteger.NaN;
    467             xto = GmpBigInteger.NaN;
     466            xfrom = PrimesBigInteger.NaN;
     467            xto = PrimesBigInteger.NaN;
    468468
    469469            Execute(m_Polynom, xfrom, xto, numberOfCalculations, numberOfFormulars, parameters);
     
    476476    private void ExecuteSystematic(IList<KeyValuePair<string, Range>> parameters)
    477477    {
    478       GmpBigInteger xfrom = null;
    479       GmpBigInteger xto = null;
     478      PrimesBigInteger xfrom = null;
     479      PrimesBigInteger xto = null;
    480480      ircSystematicChooseXRange.GetValue(ref xfrom, ref xto);
    481481      if (xfrom != null && xto != null)
    482482      {
    483         Execute(m_Polynom, xfrom, xto, GmpBigInteger.NaN, GmpBigInteger.NaN, parameters);
     483        Execute(m_Polynom, xfrom, xto, PrimesBigInteger.NaN, PrimesBigInteger.NaN, parameters);
    484484      }
    485485    }
     
    507507    }
    508508
    509     private void InputSingleControl_Execute(GmpBigInteger value)
     509    private void InputSingleControl_Execute(PrimesBigInteger value)
    510510    {
    511511      DoExecute();
     
    513513    }
    514514
    515     private void InputRangeControl_Execute(GmpBigInteger from, GmpBigInteger to)
     515    private void InputRangeControl_Execute(PrimesBigInteger from, PrimesBigInteger to)
    516516    {
    517517      DoExecute();
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Primegeneration/PrimesgenerationControl.xaml.cs

    r4 r808  
    1 /*                              Apache License
     1/*                              Apache License
    22                           Version 2.0, January 2004
    33                        http://www.apache.org/licenses/
     
    217217using Primes.WpfControls.Components;
    218218using Primes.WpfControls.Primegeneration.Function;
    219 using LibGmpWrapper;
     219using Primes.Bignum;
    220220using Primes.WpfControls.Validation;
    221221using Primes.WpfControls.Validation.Validator;
     
    280280      int row = log.NewLine();
    281281
    282       bool rndExecution = m_PolynomRangeExecuter.From.Equals(GmpBigInteger.NaN) && m_PolynomRangeExecuter.To.Equals(GmpBigInteger.NaN);
     282      bool rndExecution = m_PolynomRangeExecuter.From.Equals(PrimesBigInteger.NaN) && m_PolynomRangeExecuter.To.Equals(PrimesBigInteger.NaN);
    283283      if (!rndExecution)
    284284      {
     
    315315          string.Format(
    316316            Primes.Resources.lang.WpfControls.Generation.PrimesGeneration.statAvgCountPrimes,
    317             new object[] { m_PrimesCounter.Divide(m_ResultCounter).ToString(), m_PrimesCounter.Multiply(GmpBigInteger.ValueOf(100)).Divide(m_ResultCounter).ToString() }), 0, row);
     317            new object[] { m_PrimesCounter.Divide(m_ResultCounter).ToString(), m_PrimesCounter.Multiply(PrimesBigInteger.ValueOf(100)).Divide(m_ResultCounter).ToString() }), 0, row);
    318318      }
    319319      row = log.NewLine();
     
    378378      m_ListMostPrimes.Clear();
    379379      m_ListLeastPrimes.Clear();
    380       m_ResultCounter = GmpBigInteger.Zero;
    381       m_PrimesCounter = GmpBigInteger.Zero;
    382       m_PolynomCounter = GmpBigInteger.Zero;
     380      m_ResultCounter = PrimesBigInteger.Zero;
     381      m_PrimesCounter = PrimesBigInteger.Zero;
     382      m_PolynomCounter = PrimesBigInteger.Zero;
    383383
    384384      m_MostPrimes = null;
     
    395395    void m_InputControlPolynomRange_Execute(
    396396      IPolynom p,
    397       GmpBigInteger from,
    398       GmpBigInteger to,
    399       GmpBigInteger numberOfCalculations,
    400       GmpBigInteger numberOfFormulars,
     397      PrimesBigInteger from,
     398      PrimesBigInteger to,
     399      PrimesBigInteger numberOfCalculations,
     400      PrimesBigInteger numberOfFormulars,
    401401      IList<KeyValuePair<string, Primes.Library.Range>> parameters)
    402402    {
     
    422422    private IList<IPolynom> m_ListMostPrimesAbsolut = new List<IPolynom>();
    423423    private IList<IPolynom> m_ListLeastPrimes = new List<IPolynom>();
    424     private GmpBigInteger m_ResultCounter = GmpBigInteger.Zero;
    425     private GmpBigInteger m_PrimesCounter = GmpBigInteger.Zero;
    426     private GmpBigInteger m_PolynomCounter = GmpBigInteger.Zero;
    427 
    428     private GmpBigInteger m_MostPrimes = null;
    429     private GmpBigInteger m_MostPrimesAbsolut = null;
    430 
    431     private GmpBigInteger m_LeastPrimes = null;
    432 
    433     void m_PolynomRangeExecuter_FunctionResult(IPolynom p, GmpBigInteger primesCount, GmpBigInteger primesCountReal, GmpBigInteger counter)
     424    private PrimesBigInteger m_ResultCounter = PrimesBigInteger.Zero;
     425    private PrimesBigInteger m_PrimesCounter = PrimesBigInteger.Zero;
     426    private PrimesBigInteger m_PolynomCounter = PrimesBigInteger.Zero;
     427
     428    private PrimesBigInteger m_MostPrimes = null;
     429    private PrimesBigInteger m_MostPrimesAbsolut = null;
     430
     431    private PrimesBigInteger m_LeastPrimes = null;
     432
     433    void m_PolynomRangeExecuter_FunctionResult(IPolynom p, PrimesBigInteger primesCount, PrimesBigInteger primesCountReal, PrimesBigInteger counter)
    434434    {
    435435      int row = log.NewLine();
    436436      log.Info(p.ToString(), 0, row);
    437       GmpBigInteger percent = primesCount.Multiply(GmpBigInteger.ValueOf(100)).Divide(counter);
    438       GmpBigInteger percentAbsolut = primesCountReal.Multiply(GmpBigInteger.ValueOf(100)).Divide(counter);
     437      PrimesBigInteger percent = primesCount.Multiply(PrimesBigInteger.ValueOf(100)).Divide(counter);
     438      PrimesBigInteger percentAbsolut = primesCountReal.Multiply(PrimesBigInteger.ValueOf(100)).Divide(counter);
    439439
    440440      /*Most Primes*/
     
    508508      m_ResultCounter = m_ResultCounter.Add(counter);
    509509      m_PrimesCounter = m_PrimesCounter.Add(primesCount);
    510       m_PolynomCounter = m_PolynomCounter.Add(GmpBigInteger.One);
     510      m_PolynomCounter = m_PolynomCounter.Add(PrimesBigInteger.One);
    511511      log.Info(string.Format(Primes.Resources.lang.WpfControls.Generation.PrimesGeneration.statGenerated, new object[] { primesCount, percent, primesCountReal }), 1, row);
    512512     
     
    540540    }
    541541
    542     void m_InputControlPolynom_Execute(GmpBigInteger from, GmpBigInteger to, IPolynom p)
     542    void m_InputControlPolynom_Execute(PrimesBigInteger from, PrimesBigInteger to, IPolynom p)
    543543    {
    544544      log.Clear();
     
    596596      if (sender != null && sender.GetType() == typeof(Button))
    597597      {
    598         GmpBigInteger digits = null;
    599         if (sender == btnGeneratePrimes10Times20) digits = GmpBigInteger.ValueOf(20);
    600         else if (sender == btnGeneratePrimes10Times50) digits = GmpBigInteger.ValueOf(50);
    601         else if (sender == btnGeneratePrimes10Times100) digits = GmpBigInteger.ValueOf(100);
     598        PrimesBigInteger digits = null;
     599        if (sender == btnGeneratePrimes10Times20) digits = PrimesBigInteger.ValueOf(20);
     600        else if (sender == btnGeneratePrimes10Times50) digits = PrimesBigInteger.ValueOf(50);
     601        else if (sender == btnGeneratePrimes10Times100) digits = PrimesBigInteger.ValueOf(100);
    602602        else if (sender == btnGeneratePrimesNTimesM)
    603603        {
     
    609609    }
    610610
    611     private void ExecuteGenerate10Primes(LibGmpWrapper.GmpBigInteger digits)
    612     {
    613       ExecuteGenerateNPrimes(GmpBigInteger.ValueOf(10), digits);
    614     }
    615 
    616     private void ExecuteGenerateNPrimes(LibGmpWrapper.GmpBigInteger count, LibGmpWrapper.GmpBigInteger digits)
     611    private void ExecuteGenerate10Primes(PrimesBigInteger digits)
     612    {
     613      ExecuteGenerateNPrimes(PrimesBigInteger.ValueOf(10), digits);
     614    }
     615
     616    private void ExecuteGenerateNPrimes(PrimesBigInteger count, PrimesBigInteger digits)
    617617    {
    618618
     
    624624
    625625      m_ExpressionExecuter.Function = exp;
    626       m_ExpressionExecuter.Execute(LibGmpWrapper.GmpBigInteger.ValueOf(1), count);
     626      m_ExpressionExecuter.Execute(PrimesBigInteger.ValueOf(1), count);
    627627    }
    628628
     
    639639
    640640    object counterlockobject = new object();
    641     void exec_FunctionResult(LibGmpWrapper.GmpBigInteger result, LibGmpWrapper.GmpBigInteger input)
     641    void exec_FunctionResult(PrimesBigInteger result, PrimesBigInteger input)
    642642    {
    643643      int row = log.NewLine();
     
    665665      {
    666666        p = new SecondDegreePolynom();
    667         p.SetParameter("a", GmpBigInteger.ValueOf(3));
    668         p.SetParameter("b", GmpBigInteger.ValueOf(7));
    669         p.SetParameter("c", GmpBigInteger.ValueOf(13));
     667        p.SetParameter("a", PrimesBigInteger.ValueOf(3));
     668        p.SetParameter("b", PrimesBigInteger.ValueOf(7));
     669        p.SetParameter("c", PrimesBigInteger.ValueOf(13));
    670670        m_InputControlPolynom.SetText(InputRangeControl.FreeFrom, "0");
    671671        m_InputControlPolynom.SetText(InputRangeControl.FreeTo, "49");
  • trunk/CrypPlugins/Primes/Primes/WpfControls/Primegeneration/SieveOfAtkin/Numbergrid.xaml.cs

    r4 r808  
    216216using Primes.WpfControls.Components;
    217217
    218 using LibGmpWrapper;
     218using Primes.Bignum;
    219