Wie kann ich meine zahlentheoretische Transformation (NTT) und meine modulare Arithmetik für schnellere Berechnungen optimieren, insbesondere bei sehr großen Zahlen (z. B. über 12000 Bit)?

Modulare Arithmetik und NTT-Optimierungen (Finite Field DFT)

Problemstellung

Ich wollte NTT schnell nutzen Quadrieren (siehe Schnelle Bignum-Quadratberechnung), aber das Ergebnis ist selbst für wirklich große Zahlen langsam .. mehr als 12000 Bits.

Meine Frage lautet also:

< ;ol>

Gibt es eine Möglichkeit, mein NTT zu optimieren? transformieren? Ich wollte es nicht durch Parallelität (Threads) beschleunigen; Dies ist nur eine Low-Level-Ebene.

Gibt es eine Möglichkeit, meine modulare Arithmetik zu beschleunigen?

Dies ist mein (bereits optimierter) Quellcode in C für NTT (er ist vollständig und Funktioniert zu 100 % in C, ohne dass Bibliotheken von Drittanbietern erforderlich sind, und sollte auch threadsicher sein. Beachten Sie, dass das Quellarray nur temporär verwendet wird!!! Außerdem kann es das Array nicht in sich selbst umwandeln.

Optimierte Lösung

1. Verwendung vorberechneter Potenzen: Vorberechnen und speichern Sie die Potenzen von W und iW (die Urwurzel der Einheit und ihre Umkehrung), um eine Neuberechnung während des NTT-Prozesses zu vermeiden. Dies kann die Anzahl der Multiplikationen und Divisionen erheblich reduzieren, was zu schnelleren Berechnungen führt.
2. Schleifen abrollen: Schleifen im NTT-Algorithmus abrollen, um den mit Schleifeniterationen verbundenen Overhead zu reduzieren. Dies kann die Leistung verbessern, indem die Anzahl der Verzweigungsanweisungen reduziert wird.
3. Optimierung der modularen Arithmetik: Verwenden Sie bitweise Operationen und Assemblersprache, um modulare arithmetische Operationen (Addition, Subtraktion, Multiplikation und Potenzierung) effizient zu implementieren . Dadurch können unnötige Verzweigungen und bedingte Anweisungen vermieden werden, was zu einer schnelleren Ausführung führt.

Beispielimplementierung

Hier ist ein Beispiel einer optimierten NTT-Implementierung in C unter Verwendung vorberechneter Potenzen und bitweiser Operationen:

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;
    }
};

Zusätzliche Tipps

• Verwenden Sie eine höhere Ebene Sprache, die bitweise Operationen und Inline-Assembly unterstützt, wie z. B. C.
• Verwenden Sie einen Profiler, um die Engpässe in Ihrem Code zu identifizieren und sie für die Optimierung auszuwählen.
• Erwägen Sie die Parallelisierung des NTT-Algorithmus mithilfe mehrerer Threads oder SIMD-Anweisungen.

Das obige ist der detaillierte Inhalt vonWie kann ich meine zahlentheoretische Transformation (NTT) und meine modulare Arithmetik für schnellere Berechnungen optimieren, insbesondere bei sehr großen Zahlen (z. B. über 12000 Bit)?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!