Локализация комментариев и документации на русский язык

Выполнен перевод всех комментариев, документации и описаний алгоритмов с английского на русский язык во всех файлах библиотеки BigInt. Удалены директивы ReSharper из заголовков файлов, добавлена BOM-метка для поддержки UTF-8. Переведены ссылки на литературу и описание алгоритмов в BigInt.Core.cs. Комментарии и вывод тестов теперь на русском языке. В методах проверки простоты и алгоритмах Лукаса все пояснения и XML-документация приведены к русскоязычным формулировкам, добавлены подробные описания параметров и возвращаемых значений. Исправлены отдельные формулировки для соответствия математической терминологии. Изменения направлены на улучшение читаемости, унификацию стиля и адаптацию библиотеки для русскоязычных пользователей.

Author: Infarh

MathCore/BigInt.Arithmetic.cs

@@ -1,8 +1,4 @@
-// ReSharper disable MemberCanBePrivate.Global
-// ReSharper disable ConvertToAutoPropertyWithPrivateSetter
-// ReSharper disable UnusedMember.Global
-
-namespace MathCore;
+namespace MathCore;
 
 public partial class BigInt
 {

MathCore/BigInt.Bits.cs

@@ -1,8 +1,4 @@
-// ReSharper disable MemberCanBePrivate.Global
-// ReSharper disable ConvertToAutoPropertyWithPrivateSetter
-// ReSharper disable UnusedMember.Global
-
-namespace MathCore;
+namespace MathCore;
 
 public partial class BigInt
 {

MathCore/BigInt.Constructors.cs

@@ -1,8 +1,4 @@
-// ReSharper disable MemberCanBePrivate.Global
-// ReSharper disable ConvertToAutoPropertyWithPrivateSetter
-// ReSharper disable UnusedMember.Global
-
-namespace MathCore;
+namespace MathCore;
 
 public partial class BigInt
 {
@@ -246,7 +242,7 @@ public BigInt(uint[] UintWords)
         while (_DataLength > 1 && _Data[_DataLength - 1] == 0)
             _DataLength--;
 
-        //Console.WriteLine("Len = " + _DataLength);
+        //Console.WriteLine("Длина = " + _DataLength);
     }
 
 

MathCore/BigInt.Core.cs

@@ -1,5 +1,4 @@
-// ReSharper disable CommentTypo
-//************************************************************************************
+//************************************************************************************
 // Класс BigInteger версии 1.03
 //
 // Авторские права (c) 2002 Chew Keong TAN
@@ -54,7 +53,7 @@
 // Известная проблема
 // ------------------
 // Это псевдопростое число проходит мою реализацию проверки простоты,
-// но не проходит тест SDK IsProbablePrime
+// но не проходит тест SDK функции `IsProbablePrime`
 //
 //       byte[] pseudoPrime1 = { (byte)0x00,
 //             (byte)0x85, (byte)0x84, (byte)0x64, (byte)0xFD, (byte)0x70, (byte)0x6A,
@@ -78,13 +77,13 @@
 //    - Добавлена генерация последовательности Лукаса
 //    - Добавлен сильный тест простоты Лукаса
 //    - Добавлен метод целочисленного квадратного корня
-//    - Добавлены методы setBit/unsetBit
+//    - Добавлены методы установки и сброса бита
 //    - Новый метод IsProbablePrime() без параметра confident
 //
 // 2) 29 августа 2002 (версия 1.02)
 //    - Исправлена ошибка в возведении в степень для отрицательных чисел
 //    - Ускорено модульное возведение в степень с редукцией Барретта
-//    - Добавлен метод getBytes()
+//    - Добавлен метод GetBytes()
 //    - Исправлена ошибка в методе ToHexString
 //    - Добавлена перегрузка оператора ^
 //    - Ускорено вычисление символа Якоби
@@ -101,30 +100,25 @@
 //
 //
 // Ссылки
-// [1] D. E. Knuth, "Seminumerical Algorithms", The Art of Computer Programming Vol. 2,
-//     3rd Edition, Addison-Wesley, 1998
-// [2] K. H. Rosen, "Elementary Number Theory and Its Applications", 3rd Ed,
-//     Addison-Wesley, 1993
-// [3] B. Schneier, "Applied Cryptography", 2nd Ed, John Wiley & Sons, 1996
-// [4] A. Menezes, P. van Oorschot, and S. Vanstone, "Handbook of Applied Cryptography",
-//     CRC Press, 1996, www.cacr.math.uwaterloo.ca/hac
-// [5] A. Bosselaers, R. Govaerts, and J. Vandewalle, "Comparison of Three Modular
-//     Reduction Functions," Proc. CRYPTO'93, pp.175-186
-// [6] R. Baillie and S. S. Wagstaff Jr, "Lucas Pseudoprimes", Mathematics of Computation,
-//     Vol. 35, No. 152, Oct 1980, pp. 1391-1417
-// [7] H. C. Williams, "Édouard Lucas and Primality Testing", Canadian Mathematical
-//     Society Series of Monographs and Advance Texts, vol. 22, John Wiley & Sons, New York,
-//     NY, 1998
-// [8] P. Ribenboim, "The new book of prime number records", 3rd edition, Springer-Verlag,
-//     New York, NY, 1995
-// [9] M. Joye and J.-J. Quisquater, "Efficient computation of full Lucas sequences",
-//     Electronics Letters, 32(6), 1996, pp 537-538
+// [1] Д. Е. Кнут, «Полу численные алгоритмы», Искусство программирования, т. 2,
+//     3-е издание, Эддисон-Уэсли, 1998
+// [2] К. Х. Розен, «Элементарная теория чисел и её приложения», 3-е изд.,
+//     Эддисон-Уэсли, 1993
+// [3] Б. Шнайер, «Прикладная криптография», 2-е изд., Джон Уайли энд Санз, 1996
+// [4] А. Менезес, П. ван Ооршот и С. Ванстоун, «Справочник по прикладной криптографии»,
+//     СиАрСи Пресс, 1996, www.cacr.math.uwaterloo.ca/hac
+// [5] А. Босселаэрс, Р. Говаэртс и Дж. Вандевалле, «Сравнение трёх функций редукции»,
+//     труды Крипто'93, стр. 175-186
+// [6] Р. Бейли и С. С. Вагстафф мл., «Псевдопростые Лукаса», Математика вычислений,
+//     том 35, № 152, октябрь 1980, стр. 1391-1417
+// [7] Х. К. Уильямс, «Эдуар Лукас и тестирование простоты», Серия монографий
+//     Канадского математического общества и продвинутые тексты, т. 22,
+//     Джон Уайли энд Санз, Нью-Йорк, 1998
+// [8] П. Рибенбойм, «Новая книга рекордов простых чисел», 3-е изд., Шпрингер-Ферлаг,
+//     Нью-Йорк, 1995
+// [9] М. Жуа и Ж.-Ж. Кискатер, «Эффективное вычисление полных последовательностей Лукаса»,
+//     Электроникс Леттерс, 32(6), 1996, стр. 537-538
 //************************************************************************************
-// ReSharper restore CommentTypo
-
-// ReSharper disable MemberCanBePrivate.Global
-// ReSharper disable ConvertToAutoPropertyWithPrivateSetter
-// ReSharper disable UnusedMember.Global
 
 namespace MathCore;
 
@@ -145,7 +139,7 @@ public partial class BigInt
     /// <summary>Байты числа</summary>
     private readonly uint[] _Data;
 
-    /// <summary>Число символов числа</summary>
+    /// <summary>Число символов номера</summary>
     private int _DataLength;
 
     /// <summary>Число символов числа</summary>

MathCore/BigInt.Formatting.cs

@@ -1,8 +1,4 @@
-// ReSharper disable MemberCanBePrivate.Global
-// ReSharper disable ConvertToAutoPropertyWithPrivateSetter
-// ReSharper disable UnusedMember.Global
-
-namespace MathCore;
+namespace MathCore;
 
 public partial class BigInt
 {

MathCore/BigInt.Lucas.cs

@@ -1,43 +1,44 @@
-// ReSharper disable MemberCanBePrivate.Global
-// ReSharper disable ConvertToAutoPropertyWithPrivateSetter
-// ReSharper disable UnusedMember.Global
-
-namespace MathCore;
+namespace MathCore;
 
 public partial class BigInt
 {
     //***********************************************************************
-    // Returns the k_th number in the Lucas Sequence reduced modulo n.
+    // Возвращает k-й элемент последовательности Лукаса по модулю n
     //
-    // Uses index doubling to speed up the process.  For example, to calculate V(k),
-    // we maintain two numbers in the sequence V(n) and V(n+1).
+    // Использует удвоение индекса для ускорения. Например, для вычисления V(k)
+    // поддерживаются два числа последовательности V(n) и V(n+1)
     //
-    // To obtain V(2n), we use the identity
+    // Для получения V(2n) используется тождество
     //      V(2n) = (V(n) * V(n)) - (2 * Q^n)
-    // To obtain V(2n+1), we first write it as
+    // Для получения V(2n+1) сначала записываем
     //      V(2n+1) = V((n+1) + n)
-    // and use the identity
+    // и используем тождество
     //      V(m+n) = V(m) * V(n) - Q * V(m-n)
-    // Hence,
+    // Следовательно,
     //      V((n+1) + n) = V(n+1) * V(n) - Q^n * V((n+1) - n)
     //                   = V(n+1) * V(n) - Q^n * V(1)
     //                   = V(n+1) * V(n) - Q^n * P
     //
-    // We use k in its binary expansion and perform index doubling for each
-    // bit position.  For each bit position that is set, we perform an
-    // index doubling followed by an index addition.  This means that for V(n),
-    // we need to update it to V(2n+1).  For V(n+1), we need to update it to
-    // V((2n+1)+1) = V(2*(n+1))
+    // Используется двоичное представление k и удвоение индекса для каждого бита
+    // Для каждого установленного бита выполняется удвоение индекса и добавление
+    // Это означает, что для V(n) нужно обновить значение до V(2n+1)
+    // Для V(n+1) нужно обновить значение до V((2n+1)+1) = V(2*(n+1))
     //
-    // This function returns
+    // Функция возвращает
     // [0] = U(k)
     // [1] = V(k)
     // [2] = Q^n
     //
-    // Where U(0) = 0 % n, U(1) = 1 % n
+    // Где U(0) = 0 % n, U(1) = 1 % n
     //       V(0) = 2 % n, V(1) = P % n
     //***********************************************************************
 
+    /// <summary>Вычисление элементов последовательности Лукаса по модулю</summary>
+    /// <param name="P">Параметр P</param>
+    /// <param name="Q">Параметр Q</param>
+    /// <param name="k">Номер элемента</param>
+    /// <param name="n">Модуль</param>
+    /// <returns>Массив значений U(k), V(k) и Q^n</returns>
     public static BigInt[] LucasSequence(
         BigInt P,
         BigInt Q,
@@ -52,8 +53,8 @@ public static BigInt[] LucasSequence(
             return result;
         }
 
-        // calculate constant = b^(2k) / m
-        // for Barrett Reduction
+        // Вычисление constant = b^(2k) / m
+        // для редукции Барретта
         var constant = new BigInt();
 
         var n_len = n._DataLength << 1;
@@ -62,7 +63,7 @@ public static BigInt[] LucasSequence(
 
         constant /= n;
 
-        // calculate values of s and t
+        // Вычисление значений s и t
         var s = 0;
 
         for (var index = 0; index < k._DataLength; index++)
@@ -72,7 +73,7 @@ public static BigInt[] LucasSequence(
             for (var i = 0; i < 32; i++, mask <<= 1, s++)
                 if ((k._Data[index] & mask) != 0)
                 {
-                    index = k._DataLength; // to break the outer loop
+                    index = k._DataLength; // выход из внешнего цикла
                     break;
                 }
         }
@@ -82,10 +83,10 @@ public static BigInt[] LucasSequence(
 
 
     //***********************************************************************
-    // Performs the calculation of the kth term in the Lucas Sequence.
-    // For details of the algorithm, see reference [9].
+    // Выполняет вычисление k-го элемента последовательности Лукаса
+    // Подробнее об алгоритме см. ссылку [9]
     //
-    // k must be odd.  i.e LSB == 1
+    // k должно быть нечётным, т.е. младший бит равен 1
     //***********************************************************************
 
     private static BigInt[] LucasSequenceHelper(
@@ -110,16 +111,16 @@ private static BigInt[] LucasSequenceHelper(
         var u1 = q_k;
         var flag = true;
 
-        for (var i = k._DataLength - 1; i >= 0; i--) // iterate on the binary expansion of k
+        for (var i = k._DataLength - 1; i >= 0; i--) // итерация по двоичному представлению k
         {
             while (mask != 0)
             {
-                if (i == 0 && mask == 0x00000001) // last bit
+                if (i == 0 && mask == 0x00000001) // последний бит
                     break;
 
-                if ((k._Data[i] & mask) != 0) // bit is set
+                if ((k._Data[i] & mask) != 0) // бит установлен
                 {
-                    // index doubling with addition
+                    // удвоение индекса с добавлением
 
                     u1 = u1 * v1 % n;
 
@@ -136,7 +137,7 @@ private static BigInt[] LucasSequenceHelper(
                 }
                 else
                 {
-                    // index doubling
+                    // удвоение индекса
                     u1 = (u1 * v - q_k) % n;
 
                     v1 = (v * v1 - P * q_k) % n;
@@ -157,8 +158,8 @@ private static BigInt[] LucasSequenceHelper(
             mask = 0x80000000;
         }
 
-        // at this point u1 = u(n+1) and v = v(n)
-        // since the last bit always 1, we need to transform u1 to u(2n+1) and v to v(2n+1)
+        // на этом этапе u1 = u(n+1) и v = v(n)
+        // так как последний бит всегда равен 1, нужно преобразовать u1 в u(2n+1), а v в v(2n+1)
 
         u1 = (u1 * v - q_k) % n;
         v = (v * v1 - P * q_k) % n;
@@ -172,7 +173,7 @@ private static BigInt[] LucasSequenceHelper(
 
         for (var i = 0; i < s; i++)
         {
-            // index doubling
+            // удвоение индекса
             u1 = u1 * v % n;
             v = (v * v - (q_k << 1)) % n;
 

MathCore/BigInt.NumberTheory.cs

@@ -1,8 +1,4 @@
-// ReSharper disable MemberCanBePrivate.Global
-// ReSharper disable ConvertToAutoPropertyWithPrivateSetter
-// ReSharper disable UnusedMember.Global
-
-namespace MathCore;
+namespace MathCore;
 
 public partial class BigInt
 {
@@ -116,3 +112,5 @@ public static BigInt GetPseudoPrime(int bits, int confidence, Random rand)
     // Генерирует случайное число заданной длины бит так,
     // что gcd(number, this) = 1
     //***********************************************************************
+
+}

MathCore/BigInt.Operators.cs

@@ -1,8 +1,4 @@
-// ReSharper disable MemberCanBePrivate.Global
-// ReSharper disable ConvertToAutoPropertyWithPrivateSetter
-// ReSharper disable UnusedMember.Global
-
-namespace MathCore;
+namespace MathCore;
 
 public partial class BigInt
 {