source: trunk/PKCS1/Library/MathFunctions.cs @ 1650

Last change on this file since 1650 was 1650, checked in by schomburg, 11 years ago

initial commit of PKCS1 Plugin

File size: 4.7 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using Org.BouncyCastle.Math;
6using Emil.GMP;
7
8namespace PKCS1.Library
9{
10    class MathFunctions
11    {
12        // nur zum Test; nutzt Emil.GMP lib
13        static public BigInteger cuberoot2(BigInteger radicant)
14        {
15            BigInt test = new BigInt(radicant.ToString());
16            BigInt returnBigInt = test.Root(3);
17            return new BigInteger(returnBigInt.ToString());
18        }
19
20        // Heron Algorithmus
21        static public BigInteger cuberoot(BigInteger radicant)
22        {
23            int i = 0;
24            BigInteger biStart = BigInteger.ValueOf(1000);
25            BigInteger biFix2 = BigInteger.Two;
26            BigInteger biFix3 = BigInteger.Three;
27            BigInteger biFromBevor = BigInteger.Zero;
28
29            while (!biStart.Equals(biFromBevor))
30            {
31                biFromBevor = biStart;
32                // (2 * biStart + (x/ biStart^2)) / 3
33                biStart = biFix2.Multiply(biStart).Add(radicant.Divide(biStart.Pow(2))).Divide(biFix3);               
34                i++;
35            }
36            return biStart; 
37        }
38
39        static public bool compareBigInt(BigInteger value1, BigInteger value2, int length)
40        {
41            byte[] array1 = value1.ToByteArray();
42            byte[] array2 = value2.ToByteArray();
43
44            return compareByteArray(array1, array2, length);
45        }
46
47        static public bool compareByteArray(byte[] array1, byte[] array2, int length)
48        {
49            for(int i = length-1; i>0; i--)
50            {
51                if (array1[i] != array2[i])
52                {
53                    return false;
54                }
55            }
56            return true;
57       
58            /*
59            for (int i = 0; i < length; i++)
60            {
61                if (array1[i] != array2[i])
62                {
63                    return false;
64                }
65            }
66            return true;
67             */
68        }
69    }
70
71    /*
72     /// <summary>
73     /// Computes an approximate cube root of a number,
74     /// by using the Newton approximation for next guess.
75     /// </summary>
76     /// <param name="x">The number to compute the cube root from.</param>
77     /// <returns></returns>
78     public static BigInteger Cbrt(BigInteger x)
79     {
80         BigInteger y;               // Guess
81         BigInteger d;               // Last difference of y3 and x
82         BigInteger l;               // The limit for optimal guess
83
84         // Check for simple cases:
85         #region
86         if (x.Equals( BigInteger.Zero))
87             return BigInteger.Zero;
88         else if (x.Equals(BigInteger.One))
89             return BigInteger.One;
90         else if (x.Equals(BigInteger.ValueOf(-1)))
91             return BigInteger.ValueOf(-1);
92         else
93         #endregion
94         {
95
96             //l = Math.Abs(x * 1E-14);                // Set the limit appropriately
97             BigInteger E = new BigInteger("0,00000000001");
98             l = x.Multiply(E).Abs();
99             // the multiplication with x (its magnitude) should
100             // ensure no infinite loops, at the cost
101             // of some precision on high numbers.
102
103             // Make initial guess:
104             #region
105             //double g = Math.Abs(x);     // Do this guess on a positive number
106             BigInteger g = x.Abs();
107             if (g < BigInteger.One)
108                 y = x;
109             else if (g < 10)
110                 y = x / 3;
111             else if (g < 20)
112                 y = x / 6;
113             else if (g < 50)
114                 y = x / 10;
115             else if (g < 100)
116                 y = x / 20;
117             else if (g < 1000)
118                 y = x / 50;
119             else if (g < 5000)
120                 y = x / 100;
121             else if (g < 10000)
122                 y = x / 500;
123             else if (g < 50000)
124                 y = x / 1000;
125             else if (g < 100000)
126                 y = x / 50000;
127             else
128                 y = x / 100000;
129             #endregion
130
131             // Improve guess immediately:
132             y = ((x / (y * y)) + 2 * y) / 3;            // Newton's approx. for new guess
133             d = Math.Abs(y * y * y - x);                // Calculate difference
134             #region
135             while (l < d)
136             {
137                 y = ((x / (y * y)) + 2 * y) / 3;        // Newton's approx. for new guess
138                 d = Math.Abs(y * y * y - x);            // Calculate difference
139             }
140             #endregion
141             return y;
142         }
143     }*/
144}
Note: See TracBrowser for help on using the repository browser.