Оператор за модулем (%) дає різні результати для різних версій .NET у C #

Я шифрую введення користувача для створення рядка для пароля. Але рядок коду дає різні результати в різних версіях фреймворку. Частковий код зі значенням натиснутої користувачем клавіші:

Натиснута клавіша: 1. Змінна ascii49. Значення 'e' та 'n' після деякого обчислення:

e = 103, 
n = 143,

Math.Pow(ascii, e) % n

Результат вищевказаного коду:

• У .NET 3.5 (C #)

  Math.Pow(ascii, e) % n

  дає 9.0.

• У .NET 4 (C #)

  Math.Pow(ascii, e) % n

  дає 77.0.

Math.Pow() дає правильний (однаковий) результат в обох версіях.

Що є причиною та чи є рішення?

Math.Powпрацює над числами з плаваючою комою з подвійною точністю; таким чином, не слід сподіватися, що більше перших 15–17 цифр результату будуть точними:

Усі числа з плаваючою комою також мають обмежену кількість значущих цифр, що також визначає, наскільки точно значення з плаваючою точкою наближає дійсне число. DoubleЗначення має до 15 десяткових цифр точності, але не більше 17 цифр підтримуються всередині.

Однак арифметика за модулем вимагає, щоб усі цифри були точними. У вашому випадку ви обчислюєте 49 ¹⁰³ , результат якого складається з 175 цифр, роблячи модульну операцію безглуздою в обох ваших відповідях.

Щоб визначити правильне значення, слід використовувати арифметику довільної точності, як передбачено BigIntegerкласом (введено в .NET 4.0).

int val = (int)(BigInteger.Pow(49, 103) % 143);   // gives 114

Змінити : Як зазначив Марк Пітерс у коментарях нижче, слід використовувати BigInteger.ModPowметод, призначений спеціально для такого роду операцій:

int val = (int)BigInteger.ModPow(49, 103, 143);   // gives 114

Окрім того, що ваша хеш-функція не дуже хороша ^* , найбільшою проблемою вашого коду є не те, що він повертає інше число залежно від версії .NET, а те, що в обох випадках він повертає абсолютно безглузде число: правильна відповідь на задачу

49 ¹⁰³ мод 143 = - це 114. ( посилання на Wolfram Alpha )

Ви можете використовувати цей код для обчислення такої відповіді:

private static int PowMod(int a, int b, int mod) {
    if (b == 0) {
        return 1;
    }
    var tmp = PowMod(a, b/2, mod);
    tmp *= tmp;
    if (b%2 != 0) {
        tmp *= a;
    }
    return tmp%mod;
}

Причиною того, чому ваше обчислення дає інший результат, є те, що для отримання відповіді ви використовуєте проміжне значення, яке скидає більшість значущих цифр числа 49 ¹⁰³ : правильні лише перші 16 із 175 цифр!

1230824813134842807283798520430636310264067713738977819859474030746648511411697029659004340261471771152928833391663821316264359104254030819694748088798262075483562075061997649

Решта 159 цифр помилкові. Операція мода, однак, шукає результат, який вимагає, щоб кожна окрема цифра була правильною, включаючи останню. Тому навіть найменше поліпшення точностіMath.Pow яке, можливо, було впроваджено в .NET 4, призведе до різкої різниці у вашому обчисленні, що, по суті, дає довільний результат.

^* Оскільки в цьому питанні йдеться про підвищення цілих чисел до великих рівнів у контексті хешування паролів, може бути дуже гарною ідеєю прочитати це _{посилання на} відповідь, перш ніж вирішити, чи слід змінити ваш поточний підхід на потенційно кращий.

Те, що ви бачите, - це помилка округлення вдвічі. Math.Powпрацює з подвійним, і різниця така:

.NET 2.0 та 3.5 => var powerResult = Math.Pow(ascii, e);повертає:

1.2308248131348429E+174

.NET 4.0 та 4.5 => var powerResult = Math.Pow(ascii, e);повертає:

1.2308248131348427E+174

Зверніть увагу на останню цифру перед тим, Eщо спричиняє різницю в результаті. Це не оператор модуля (%) .

Точність з плаваючою точкою може варіюватися в залежності від машини і навіть на одній машині .

Однак .NET робить віртуальну машину для ваших додатків ... але різні версії змінюються.

Тому не слід покладатися на це, щоб отримати стабільні результати. Для шифрування використовуйте класи, які надає Framework, а не прокручуйте власні.

Є багато відповідей про те, як код поганий. Однак, чому результат інший ...

FPU Intel використовують внутрішньо 80-бітний формат, щоб отримати більшу точність для проміжних результатів. Отже, якщо значення знаходиться в регістрі процесора, воно отримує 80 біт, але коли воно записується в стек, воно зберігається в 64 бітах .

Я сподіваюся, що нова версія .NET має кращий оптимізатор у своїй компіляції Just in Time (JIT), тому вона зберігає значення в реєстрі, а не записує його в стек, а потім зчитує назад із стеку.

Можливо, JIT тепер може повертати значення в регістрі, а не в стеці. Або передайте значення функції MOD в реєстрі.

Див. Також запитання щодо переповнення стека. Які програми / переваги 80-бітового типу розширеної точності даних?

Інші процесори, наприклад ARM, дадуть різні результати для цього коду.

Можливо, найкраще обчислити це самостійно, використовуючи лише цілу арифметику. Щось на зразок:

int n = 143;
int e = 103;
int result = 1;
int ascii = (int) 'a';

for (i = 0; i < e; ++i) 
    result = result * ascii % n;

Ви можете порівняти ефективність із ефективністю рішення BigInteger, розміщеного в інших відповідях.