Exemple #1
0
        /// <summary>
        /// Теорема Ферма утверждает, что если число простое, то любое число a удовлетворяет равенству:
        /// a^(n-1)=1(mod n). Если а = 2, то это дает неплохие результаты. Данная функция является
        /// улучшеним проверки 2^(n-1)=1(mod n)
        /// </summary>
        /// <param name="a">Любое а</param>
        /// <param name="n">Проверяемое на простоту число</param>
        /// <returns>возвращает true в случае, если число составное</returns>
        private static bool Witness(BigInteger a, BigInteger n)
        {
            /*мы раскладываем число n-1=2^t*u, где u — нечетное. После этого мы проверяем корни на нетривиальность.
             * В результате после t итераций мы либо вычисляем a^(n-1), либо находим нетривиальные корни*/
            BigInteger u = n.Substract(new BigInteger("1"));
            int        t = 0;

            while (u.Mod(new BigInteger("2")).Equals(new BigInteger("0")))
            {
                t++;
                u = u.Div(new BigInteger("2"));
            }
            BigInteger[] x = new BigInteger[t + 1];
            x[0] = a.Pow(u, n);
            for (int i = 1; i <= t; i++)
            {
                x[i] = x[i - 1].Pow(new BigInteger("2"), n);
                if (x[i].Equals(new BigInteger("1")) && !x[i - 1].Equals(new BigInteger("1")) &&
                    !x[i - 1].Equals(n.Substract(new BigInteger("1"))))
                {
                    return(true);
                }
            }
            if (!x[t].Equals(new BigInteger("1")))
            {
                return(true);
            }
            return(false);
        }
Exemple #2
0
        private void button3_Click(object sender, EventArgs e)
        {
            BigInteger inst = new BigInteger();

            res.Text = inst.Div(first.Text, second.Text);
            if (res.Text == "")
            {
                MessageBox.Show("Result = Error You Cant Divide By Zero \nReminder =  :) ", "Math Error", MessageBoxButtons.OK, MessageBoxIcon.Stop);
            }
        }
Exemple #3
0
        /// <summary>
        /// Возведение в квадрат по формуле Герона
        /// </summary>
        /// <param name="a">Число, из которого извлекаем корень</param>
        /// <param name="b">Будущий ответ</param>
        /// <param name="step">На какой итерации мы сейчас</param>
        /// <param name="n">Число вычислений (итераций)</param>
        /// <returns>Квадратный корень</returns>
        private static BigInteger GeronFunction(BigInteger a, BigInteger b, int step, int n)
        {
            int        r   = 0;
            BigInteger ans = (b.Add(a.Div(b))).Divide(2, out r);

            if (step >= n || ans.Substract(b).CompareTo(new BigInteger("1")) == 0)
            {
                return(ans);
            }
            return(GeronFunction(a, ans, step + 1, n));
        }
Exemple #4
0
        public static string GetAsciiString(string msg)
        {
            List <char> ans           = new List <char>();
            var         msgBigInteger = new BigInteger(msg);

            while (msgBigInteger.value.Count > 1 || msgBigInteger.ToString() != "0")
            {
                var mod = msgBigInteger.Mod(_base);
                ans.Add((char)int.Parse(mod.ToString()));
                msgBigInteger = msgBigInteger.Div(_base);
            }
            ans.Reverse();
            return(new string (ans.ToArray()));
        }
Exemple #5
0
        /// <summary>
        /// Поиск  обратного элемента в кольце по модулю N
        /// Расширенный алгоритм Евклида
        /// </summary>
        /// <param name="n">По модулю какого числа</param>
        /// <returns>Обратный элемент</returns>
        public BigInteger Inverse(BigInteger n)
        {
            /*Для того, чтобы найти обратный элемент в кольце по модулю n достаточно решить уравнение ax+ny = d,
             * при этом НОД(a, n) = 1, иначе решения не существует. Искомый x и будет обратным элементом.
             * Основная идея рекурсивного алгоритма Евклида в том, что НОД(a,b) = НОД(b % a, a), очевидно,
             * что данный переход должен происходить на каждом шаге нашего цикла. Кроме того нам нужно как — то
             * подсчитываться НОД и x. Очевидно, что d на следующем шаге равняется x на предыдущем шаге минус q
             * умножить на d на этом шаге, где. Тогда x это d на предыдущем шаге.
             * 1. Использовать расширенный алгоритм Евклида для нахождения x и y, таких что ax + ny = d, где d=НОД(a,n).
             * 2. Если d > 1, то обратного элемента не существует. Иначе возвращаем x.*/
            BigInteger a = new BigInteger(this.ToString()); //Копия числа, к которому ищем обратное
            BigInteger b = n,                               //Временно храним модуль
                       x = new BigInteger("0"),             //Обратный элемент
                       d = new BigInteger("1");             //Искомый НОД

            while (a.CompareTo(new BigInteger("0")) == 1)   //a>0
            {
                BigInteger q = b.Div(a);                    // q это b / a
                BigInteger y = a;

                a = b.Mod(a); //НОД(a,b) = НОД(b % a, a)
                b = y;        //Присваиваем b = a

                y = d;

                //d на следующем шаге равняется x на предыдущем шаге минус q(b.Div(a)) * d(на этом шаге)
                d = x.Substract(q.Multiply(d));
                x = y;
            }

            x = x.Mod(n);

            //Eсли обратный получился меньше нуля, то давайте сделаем его положительным.
            if (x.CompareTo(new BigInteger("0")) == -1)//x<0
            {
                x = (x.Add(n)).Mod(n);
            }
            return(x);
        }
        private void button3_Click(object sender, EventArgs e)
        {
            BigInteger inst = new BigInteger();

            res.Text = inst.Div(first.Text, second.Text);
        }