Wie kann ich meine zahlentheoretische Transformation (NTT) und meine modulare Arithmetik für eine schnellere Quadrierung großer Zahlen optimieren?

Modulare Arithmetik und NTT-Optimierungen (Finite Field DFT)

Ursprüngliche Frage:

I wollte NTT für eine schnelle Quadrierung verwenden (siehe Schnelle Bignum-Quadratberechnung), aber das Ergebnis ist selbst bei wirklich großen Zahlen langsam .. mehr als 12000 Bits.

Meine Frage ist:

1. Gibt es eine Möglichkeit, meine NTT-Transformation zu optimieren?
   Das hatte ich nicht vor beschleunigen Sie es durch Parallelität (Threads); Dies ist nur eine Low-Level-Ebene.
2. Gibt es eine Möglichkeit, meine modulare Arithmetik zu beschleunigen?

Code:

//---------------------------------------------------------------------------
class fourier_NTT                                    // Number theoretic transform
    {

public:
    DWORD r,L,p,N;
    DWORD W,iW,rN;
    fourier_NTT(){ r=0; L=0; p=0; W=0; iW=0; rN=0; }

    // main interface
    void  NTT(DWORD *dst,DWORD *src,DWORD n=0);               // DWORD dst[n] = fast  NTT(DWORD src[n])
    void iNTT(DWORD *dst,DWORD *src,DWORD n=0);               // DWORD dst[n] = fast INTT(DWORD src[n])

    // Helper functions
    bool init(DWORD n);                                       // init r,L,p,W,iW,rN
    void  NTT_fast(DWORD *dst,DWORD *src,DWORD n,DWORD w);    // DWORD dst[n] = fast  NTT(DWORD src[n])

    // Only for testing
    void  NTT_slow(DWORD *dst,DWORD *src,DWORD n,DWORD w);    // DWORD dst[n] = slow  NTT(DWORD src[n])
    void iNTT_slow(DWORD *dst,DWORD *src,DWORD n,DWORD w);    // DWORD dst[n] = slow INTT(DWORD src[n])

    // DWORD arithmetics
    DWORD shl(DWORD a);
    DWORD shr(DWORD a);

    // Modular arithmetics
    DWORD mod(DWORD a);
    DWORD modadd(DWORD a,DWORD b);
    DWORD modsub(DWORD a,DWORD b);
    DWORD modmul(DWORD a,DWORD b);
    DWORD modpow(DWORD a,DWORD b);
    };

//---------------------------------------------------------------------------
void fourier_NTT:: NTT(DWORD *dst,DWORD *src,DWORD n)
    {
    if (n>0) init(n);
    NTT_fast(dst,src,N,W);
//    NTT_slow(dst,src,N,W);
    }

//---------------------------------------------------------------------------
void fourier_NTT::INTT(DWORD *dst,DWORD *src,DWORD n)
    {
    if (n>0) init(n);
    NTT_fast(dst,src,N,iW);
    for (DWORD i=0;i<n dst intt_slow bool fourier_ntt::init n p else ntt overflow can ocur r="2;" if>0x10000000)) { r=0; L=0; p=0; W=0; iW=0; rN=0; N=0; return false; } L=0x30000000/n; // 32:30 bit best for unsigned 32 bit
//    r=2; p=0x78000001; if ((n0x04000000)) { r=0; L=0; p=0; W=0; iW=0; rN=0; N=0; return false; } L=0x3c000000/n; // 31:27 bit best for signed 32 bit
//    r=2; p=0x00010001; if ((n0x00000020)) { r=0; L=0; p=0; W=0; iW=0; rN=0; N=0; return false; } L=0x00000020/n; // 17:16 bit best for 16 bit
//    r=2; p=0x0a000001; if ((n0x01000000)) { r=0; L=0; p=0; W=0; iW=0; rN=0; N=0; return false; } L=0x01000000/n; // 28:25 bit
     N=n;                // size of vectors [DWORDs]
     W=modpow(r,    L);    // Wn for NTT
    iW=modpow(r,p-1-L);    // Wn for INTT
    rN=modpow(n,p-2  );    // scale for INTT
    return true;
    }

//---------------------------------------------------------------------------
void fourier_NTT:: NTT_fast(DWORD *dst,DWORD *src,DWORD n,DWORD w)
    {
    if (n>1,w2=modmul(w,w);
    // reorder even,odd
    for (i=0,j=0;i<n2 dst for j="1;i<n" recursion ntt_fast even odd restore results a0="src[i];" a1="modmul(src[j],w2);" void fourier_ntt:: ntt_slow n w dword i a="0;" wi="modmul(wi,wj);" wj="modmul(wj,w);" fourier_ntt::intt_slow fourier_ntt::shl return fourier_ntt::shr>>1)&0x7FFFFFFF; }

//---------------------------------------------------------------------------
DWORD fourier_NTT::mod(DWORD a)
    {
    DWORD bb;</n2></n>

Das obige ist der detaillierte Inhalt vonWie kann ich meine zahlentheoretische Transformation (NTT) und meine modulare Arithmetik für eine schnellere Quadrierung großer Zahlen optimieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!