// Freivalds a mano: una matriz C que difiere de A·B, y lo que ve cada uno de los 2^n vectores
// de ceros y unos. Los números son pequeños para poder seguirlos; se calcula módulo 10^9 + 7,
// que aquí no cambia nada porque ningún resultado llega a ese tamaño.
//
//   build/freivalds_demo
#include <cstdio>
#include <string>

#include "freivalds.h"

std::string show(const Vector& v) {
    std::string s = "(";
    for (std::size_t i = 0; i < v.size(); i++) {
        s += (i > 0 ? ", " : "") + std::to_string(v[i]);
    }
    return s + ")";
}

void print_matrix(const char* name, const Matrix& m) {
    for (std::size_t i = 0; i < m.size(); i++) {
        std::printf("%s", i == 0 ? name : "     ");
        for (std::uint64_t x : m[i]) {
            std::printf(" %3llu", static_cast<unsigned long long>(x));
        }
        std::printf("\n");
    }
}

// Prueba los 2^n vectores y devuelve cuántos detectan que A·B ≠ C.
int try_all_vectors(const Matrix& a, const Matrix& b, const Matrix& c) {
    const std::size_t n = a.size();
    int detected = 0;
    std::printf("  r           B·r            A·(B·r)         C·r             ¿detecta?\n");
    for (unsigned mask = 0; mask < (1u << n); mask++) {
        Vector r(n);
        for (std::size_t j = 0; j < n; j++) {
            r[j] = (mask >> (n - 1 - j)) & 1u;
        }
        const Vector br = times(b, r, kPrime);
        const Vector abr = times(a, br, kPrime);
        const Vector cr = times(c, r, kPrime);
        const bool differs = abr != cr;
        detected += differs ? 1 : 0;
        std::printf("  %-11s %-14s %-15s %-15s %s\n", show(r).c_str(), show(br).c_str(), show(abr).c_str(),
                    show(cr).c_str(), differs ? "sí" : "no");
    }
    return detected;
}

int main() {
    const Matrix a = {{1, 2, 0}, {0, 1, 3}, {2, 0, 1}};
    const Matrix b = {{2, 1, 0}, {1, 0, 2}, {0, 3, 1}};
    const Matrix product = multiply(a, b, kPrime);
    print_matrix("A   =", a);
    print_matrix("B   =", b);
    print_matrix("A·B =", product);

    // C1: una sola entrada cambiada, la de la fila 2 y la columna 3.
    Matrix c1 = product;
    c1[1][2] += 1;
    std::printf("\nC1: igual a A·B salvo la entrada (2, 3), que vale %llu en vez de %llu.\n",
                static_cast<unsigned long long>(c1[1][2]), static_cast<unsigned long long>(product[1][2]));
    const int d1 = try_all_vectors(a, b, c1);
    std::printf("  Detectan la diferencia %d de 8 vectores.\n", d1);

    // C2: dos entradas cambiadas en la misma fila, una en +1 y otra en -1.
    Matrix c2 = product;
    c2[0][0] += 1;
    c2[0][1] -= 1;
    std::printf("\nC2: en la fila 1, la entrada (1, 1) vale uno más y la (1, 2) uno menos.\n");
    const int d2 = try_all_vectors(a, b, c2);
    std::printf("  Detectan la diferencia %d de 8 vectores.\n", d2);

    // C3: una entrada cambiada en cada fila, en columnas distintas.
    Matrix c3 = product;
    c3[0][0] += 1;
    c3[1][1] += 1;
    c3[2][2] += 1;
    std::printf("\nC3: las tres entradas de la diagonal valen uno más.\n");
    const int d3 = try_all_vectors(a, b, c3);
    std::printf("  Detectan la diferencia %d de 8 vectores.\n", d3);
}
