매우 큰 수의 빠른 제곱을 위해 NTT(수 이론 변환) 및 모듈식 산술을 어떻게 최적화할 수 있습니까?

모듈식 연산 및 NTT(유한장 DFT) 최적화

문제: 사용하고 싶었습니다. 빠른 제곱을 위한 NTT(빠른 빅넘 제곱 계산 참조), 결과는 느리지만 정말 큰 숫자의 경우 .. 12000비트가 넘습니다.

제 질문은 다음과 같습니다.

1. Is NTT 변환을 최적화할 수 있는 방법이 있나요?
   
   속도를 높이려는 의도는 아니었습니다. 병렬성(스레드); 이것은 낮은 수준의 레이어에만 적용됩니다.


2. 모듈 연산 속도를 높일 수 있는 방법이 있나요?

이것은 NTT용 C 소스 코드입니다(완전하고 C에서 100% 작동합니다). 타사 라이브러리가 필요 없으며 스레드로부터 안전해야 합니다. 소스 배열이 임시로 사용된다는 점에 유의하세요!!! 또한 배열을 자체적으로 변환할 수도 없습니다.

//---------------------------------------------------------------------------
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>

위 내용은 매우 큰 수의 빠른 제곱을 위해 NTT(수 이론 변환) 및 모듈식 산술을 어떻게 최적화할 수 있습니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!