// Seed-compatible CPU Gaussian source for Kokoro's strided PyTorch 2.8 path. // Uses the standard MT19937 engine and FP64 Box-Muller; no approximate math. #include #include #include #include #include namespace { double uniform(std::mt19937& engine) { const auto high = static_cast(engine()); const auto low = static_cast(engine()); return static_cast(((high << 32) | low) & ((UINT64_C(1) << 53) - 1)) * 0x1p-53; } } extern "C" int kokoro_normal(std::uint64_t seed, std::int64_t samples, int harmonics, float* output, int threads) noexcept { if (!output || samples < 1 || samples > 288000 || harmonics != 9 || (samples * harmonics) % 2 != 0 || threads < 1 || threads > 16) return -1; try { const auto pairs = samples * harmonics / 2; std::mt19937 engine(static_cast(seed)); // The original source consumes one FP32 uniform per initial phase. engine.discard(static_cast(harmonics)); std::vector draws(static_cast(pairs) * 2); for (std::int64_t i = 0; i < pairs; ++i) { draws[2 * i] = uniform(engine); draws[2 * i + 1] = uniform(engine); } #pragma omp parallel for num_threads(threads) schedule(static) for (std::int64_t i = 0; i < pairs; ++i) { const double radius = std::sqrt(-2.0 * std::log1p(-draws[2 * i + 1])); const double theta = (2.0 * std::numbers::pi) * draws[2 * i]; output[2 * i] = static_cast(radius * std::cos(theta)); output[2 * i + 1] = static_cast(radius * std::sin(theta)); } return 0; } catch (...) { return -2; } }