Jak mogę zrobić mod bez operatora mod?

Question

Ten głupi język skryptowy nie ma wartości% ani Mod(). Mam Fix(), który odciąga część dziesiętną liczby. Potrzebuję tylko pozytywnych wyników, więc nie bądź zbyt solidny.

Answer 1

Will

// mod = a % b 

c = Fix(a/b) 
mod = a - b * c 

zrobić? Zakładam, że możesz tu przynajmniej podzielić. Wszystkie zakłady są wyłączone na liczbach ujemnych.

Answer 2

ta może nie działać dla ciebie wydajności mądry, ale:

while (num >= mod_limit) 
    num = num - mod_limit 

Answer 3

a mod n = a - (n * Fix(a/n))

Answer 4

Co to jest język?

Podstawowy algorytm może być:

hold the modulo in a variable (modulo); 
hold the target number in a variable (target); 
initialize modulus variable; 

while (target > 0) { 
    if (target > modulo) { 
    target -= modulo; 
    } 
    else if(target < modulo) { 
    modulus = target; 
    break; 
    } 
} 

Answer 5

dla potomności, BrightScript ma teraz operator modulo, wygląda to tak:

c = a mod b 

Answer 6

w JavaScript:

function modulo(num1, num2) {  
    if (num2 === 0 || isNaN(num1) || isNaN(num2)) { 
    return NaN; 
    } 

    if (num1 === 0) { 
    return 0; 
    } 

    var remainderIsPositive = num1 >= 0; 

    num1 = Math.abs(num1); 
    num2 = Math.abs(num2); 

    while (num1 >= num2) { 
    num1 -= num2 
    } 

    return remainderIsPositive ? num1 : 0 - num1; 
} 

Answer 7

Jeśli Ktoś przyjedzie później, oto kilka bardziej aktualnych algorytmów (z błędami ... przeczytaj uważnie)

https://eprint.iacr.org/2014/755.pdf

Są faktycznie dwa główne rodzaj wzorów redukcyjnych: Barett i Montgomery. W pracy z ePrint powtarzać zarówno w różnych wersjach (algorytmy 1-3) i dać „ulepszoną” wersję algorytmu 4.

Przegląd

daję teraz przegląd Algorytm 4.:

1.) Oblicz "A * B" i zapisz cały produkt w "C", w którym C i moduł $ p $ jest wejściem dla tego algorytmu.

2.) Oblicz bitową długość $ p $, na przykład: funkcja "Szerokość (p)" zwraca dokładnie tę wartość.

3.) Podziel dane wejściowe $ C $ na N "bloków" o wielkości "Szerokość (p)" i zapisz każdą z nich w G. Rozpocznij w G [0] = lsb (p) i zakończ w G [N- 1] = msb (p). (Opis jest rzeczywiście wadliwy papieru)

4.) Start pętli, przy czym: ustawia się N = N-1 (osiągnąć ostatni element) wstępnego wyliczenia $ B: = 2^{szerokość (t)} \ bmod p $

while N>0 do: 
    T = G[N] 
    for(i=0; i<Width(p); i++) do: //Note: that counter doesn't matter, it limits the loop) 
     T = T << 1 //leftshift by 1 bit 
     while is_set(bit(T, Width(p))) do // (N+1)-th bit of T is 1 
      unset(bit(T, Width(p))) // unset the (N+1)-th bit of T (==0) 
      T += b 
     endwhile 
    endfor 
    G[N-1] += T 
    while is_set(bit(G[N-1], Width(p))) do 
     unset(bit(G[N-1], Width(p))) 
     G[N-1] += b 
    endwhile 
    N -= 1 
endwhile 

To dużo. Nie musimy tylko recursivly zmniejszyć G [0]:

while G[0] > p do 
    G[0] -= p 
endwhile 
return G[0]// = C mod p 

Pozostałe trzy algorytmy są dobrze zdefiniowane, ale brakuje pewnych informacji lub przedstawienia to naprawdę źle. Ale działa na dowolny rozmiar;)