Aritmetik modular dan pengoptimuman NTT (medan terhingga DFT)

Pernyataan Masalah

Saya mahu menggunakan NTT dengan pantas kuasa dua (lihat pengiraan kuasa dua besar bignum cepat), tetapi hasilnya adalah perlahan walaupun untuk nombor yang sangat besar .. lebih daripada 12000 bit.

Jadi soalan saya ialah:

1. Adakah terdapat 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 adalah kod sumber saya (sudah dioptimumkan) dalam C untuk NTT (ia lengkap dan 100% berfungsi dalam C tanpa memerlukan sebarang lib pihak ketiga dan juga harus selamat untuk benang. Berhati-hati susunan sumber digunakan sebagai sementara!!!, Juga ia tidak boleh mengubah tatasusunan kepada dirinya sendiri).

Penyelesaian Dioptimumkan

1. Menggunakan Prakiraan Kuasa: Prakira dan simpan kuasa W dan iW (akar primitif perpaduan dan songsangnya) untuk mengelakkan pengiraan semula semasa proses NTT. Ini boleh mengurangkan bilangan pendaraban dan pembahagian dengan ketara, yang membawa kepada pengiraan yang lebih pantas.
2. Membuka Gelung: Buka gulungan dalam algoritma NTT untuk mengurangkan overhed yang dikaitkan dengan lelaran gelung. Ini boleh meningkatkan prestasi dengan mengurangkan bilangan arahan cawangan.
3. Mengoptimumkan Aritmetik Modular: Gunakan operasi bitwise dan bahasa himpunan untuk melaksanakan operasi aritmetik modular (tambah, tolak, darab dan eksponen) dengan cekap . Ini boleh menghapuskan pernyataan bercabang dan bersyarat yang tidak diperlukan, menghasilkan pelaksanaan yang lebih pantas.

Contoh Pelaksanaan

Berikut ialah contoh pelaksanaan NTT yang dioptimumkan dalam C menggunakan kuasa prapengiraan dan operasi bitwise:

class NTT {
public:
    NTT() {
        // Initialize constants
        p = 0xc0000001;
        W = modpow(2, 0x30000000 / n);
        iW = modpow(2, p - 1 - 0x30000000 / n);
        rN = modpow(n, p - 2);
        NN = n >> 1;

        // Precompute W and iW powers
        WW = new uint32_t[n];
        iWW = new uint32_t[n];
        WW[0] = 1;
        iWW[0] = 1;
        for (uint32_t i = 1; i < n; i++) {
            WW[i] = modmul(WW[i - 1], W);
            iWW[i] = modmul(iWW[i - 1], iW);
        }
    }

    void NTT(uint32_t *dst, uint32_t *src, uint32_t n) {
        if (n > 0) {
            // Reorder even, odd elements
            for (uint32_t i = 0, j = 0; i < NN; i++, j += 2) {
                dst[i] = src[j];
            }
            for (j = 1; i < n; i++, j += 2) {
                dst[i] = src[j];
            }

            // Recursive NTT
            NTT(src, dst, NN);  // Even
            NTT(src + NN, dst + NN, NN);  // Odd

            // Restore results
            for (uint32_t i = 0, j = NN; i < NN; i++, j++) {
                uint32_t a0 = src[i];
                uint32_t a1 = modmul(src[j], WW[i]);
                dst[i] = modadd(a0, a1);
                dst[j] = modsub(a0, a1);
            }
        }
    }

private:
    uint32_t p, n, NN, W, iW, rN;
    uint32_t *WW, *iWW;

    // Modular arithmetic operations
    inline uint32_t modadd(uint32_t a, uint32_t b) {
        uint32_t d = a + b;
        if (d >= p) d -= p;
        return d;
    }

    inline uint32_t modsub(uint32_t a, uint32_t b) {
        uint32_t d = a - b;
        if (d > a) d += p;
        return d;
    }

    inline uint32_t modmul(uint32_t a, uint32_t b) {
        uint32_t m = (uint64_t)a * b;
        return m - (p * (m / p));
    }

    inline uint32_t modpow(uint32_t a, uint32_t b) {
        if (b == 0) return 1;
        uint32_t t = modpow(a, b / 2);
        t = modmul(t, t);
        if (b &amp; 1) t = modmul(t, a);
        return t;
    }
};

Tambahan Petua

• Gunakan bahasa peringkat lebih tinggi yang menyokong operasi bitwise dan pemasangan sebaris, seperti C .
• Gunakan profiler untuk mengenal pasti kesesakan dalam kod anda dan menyasarkannya untuk pengoptimuman.
• Pertimbangkan untuk menyelaraskan algoritma NTT menggunakan berbilang urutan atau arahan SIMD.

Atas ialah kandungan terperinci Bagaimanakah saya boleh mengoptimumkan Transformasi Teori Nombor (NTT) dan aritmetik modular saya untuk pengiraan yang lebih pantas, terutamanya dengan nombor yang sangat besar (cth., melebihi 12000 bit)?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!