Bagaimanakah Saya Boleh Mengoptimumkan Transformasi Teoritik Nombor (NTT) dan Aritmetik Modular Saya untuk Kuadrat Pantas Nombor Sangat Besar?

Aritmetik modular dan pengoptimuman NTT (medan terhingga DFT)

Masalah: Saya ingin menggunakan NTT untuk kuasa dua pantas (lihat pengiraan kuasa dua besar Bignum Cepat), tetapi hasilnya adalah perlahan walaupun untuk benar-benar nombor besar .. lebih daripada 12000 bit.

Jadi soalan saya ialah:

1. Adakah cara untuk mengoptimumkan transformasi NTT saya?
   
   Saya tidak bermaksud untuk mempercepatkannya dengan selari (benang); ini adalah lapisan aras rendah sahaja.


2. Adakah terdapat cara untuk mempercepatkan aritmetik modular saya?

Ini ialah kod sumber saya (sudah dioptimumkan) dalam C untuk NTT (ia lengkap dan 100% bekerja dalam C tanpa sebarang keperluan untuk lib pihak ketiga dan juga harus selamat untuk thread. Awas tatasusunan sumber digunakan sebagai sementara!!!, Ia juga tidak boleh mengubah tatasusunan kepada dirinya sendiri).

//---------------------------------------------------------------------------
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>>1;
    for (wj=1,j=0;j<n a="0;" for wi="modmul(wi,wj);" dst wj="modmul(wj,w);" void fourier_ntt::intt_slow n w dword i>>1;
    for (wj=1,j=0;j<n a="0;" for wi="modmul(wi,wj);" dst wj="modmul(wj,iW);"></n></n></n2></n>

Atas ialah kandungan terperinci Bagaimanakah Saya Boleh Mengoptimumkan Transformasi Teoritik Nombor (NTT) dan Aritmetik Modular Saya untuk Kuadrat Pantas Nombor Sangat Besar?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!