1.0000000.9782470.9271480.8471880.7318440.5724400.3689310.1433720.000000

struct BetaSchedule : SigmaSchedule {    static constexpr double alpha = 0.6;    static constexpr double beta  = 0.6;    // Log Beta function    static double log_beta(double a, double b) {        return std::lgamma(a) + std::lgamma(b) - std::lgamma(a + b);    }    // Regularized incomplete beta function using continued fraction    static double incbeta(double x, double a, double b) {        if (x <= 0.0) return 0.0;        if (x >= 1.0) return 1.0;        // Use the continued fraction approximation (Lentz’s method)        const int MAX_ITER = 200;        const double EPSILON = 3.0e-7;        double aa, c, d, del, h;        double qab = a + b;        double qap = a + 1.0;        double qam = a - 1.0;        c = 1.0;        d = 1.0 - qab * x / qap;        if (std::fabs(d) < 1e-30) d = 1e-30;        d = 1.0 / d;        h = d;        for (int m = 1; m <= MAX_ITER; m++) {            int m2 = 2 * m;            // Even term            aa = m * (b - m) * x / ((qam + m2) * (a + m2));            d = 1.0 + aa * d;            if (std::fabs(d) < 1e-30) d = 1e-30;            c = 1.0 + aa / c;            if (std::fabs(c) < 1e-30) c = 1e-30;            d = 1.0 / d;            h *= d * c;            // Odd term            aa = -(a + m) * (qab + m) * x / ((a + m2) * (qap + m2));            d = 1.0 + aa * d;            if (std::fabs(d) < 1e-30) d = 1e-30;            c = 1.0 + aa / c;            if (std::fabs(c) < 1e-30) c = 1e-30;            d = 1.0 / d;            del = d * c;            h *= del;            if (std::fabs(del - 1.0) < EPSILON) break;        }        return std::exp(a * std::log(x) + b * std::log(1.0 - x) - log_beta(a, b)) / a * h;    }    // Beta CDF using symmetry for better convergence    static double beta_cdf(double x, double a, double b) {        if (x == 0.0) return 0.0;        if (x == 1.0) return 1.0;        if (x < (a + 1.0) / (a + b + 2.0)) {            return incbeta(x, a, b);        } else {            return 1.0 - incbeta(1.0 - x, b, a);        }    }    // Inverse Beta CDF (PPF) using Newton-Raphson    static double beta_ppf(double u, double a, double b, int max_iter = 30) {        double x = 0.5; // initial guess        for (int i = 0; i < max_iter; i++) {            double f = beta_cdf(x, a, b) - u;            if (std::fabs(f) < 1e-10) break;            // derivative = x^(a-1) * (1-x)^(b-1) / B(a,b)            double df = std::exp((a-1.0)*std::log(x) + (b-1.0)*std::log(1.0-x) - log_beta(a,b));            x -= f / df;            if (x <= 0.0) x = 1e-10;            if (x >= 1.0) x = 1.0 - 1e-10;        }        return x;    }    std::vector<float> get_sigmas(uint32_t n, float /*sigma_min*/, float /*sigma_max*/, t_to_sigma_t t_to_sigma) override {        std::vector<float> result;        result.reserve(n + 1);        int t_max = TIMESTEPS - 1;        if (n == 0) return result;        if (n == 1) {            result.push_back(t_to_sigma((float)t_max));            result.push_back(0.f);            return result;        }        int last_t = -1;        for (uint32_t i = 0; i < n; i++) {            double u = 1.0 - double(i)/double(n);  // reversed linspace            double t_cont = beta_ppf(u, alpha, beta) * t_max;            int t = (int)std::lround(t_cont);            if (t != last_t) {                result.push_back(t_to_sigma((float)t));                last_t = t;            }        }        result.push_back(0.f);        return result;    }};

diff --git a/denoiser.hpp b/denoiser.hppindex d841f03..541bb99 100644--- a/denoiser.hpp+++ b/denoiser.hpp@@ -280,8 +280,8 @@ struct BetaDist {          double x = u < 0.5 ? u * u : 1.0 - (1.0 - u) * (1.0 - u);-        const int max_iterations = 50;-        const double tolerance = 1e-12;+        const int max_iterations = 1000;+        const double tolerance = 1e-20;          for (int i = 0; i < max_iterations; ++i) {             double err = beta_cdf(x) - u;@@ -333,8 +333,8 @@ private:     double incomplete_beta(double a, double b, double x) {          double f = 1.0, c = 1.0, d = 0.0;-        const int max_iterations = 200;-        const double tolerance = 1e-15;+        const int max_iterations = 1000;+        const double tolerance = 1e-20;          for (int i = 0; i <= max_iterations; ++i) {             int m = i / 2;

sd -M img_gen -p "Character: one 18-year-old elven woman, long delicate pastel pink hair in intricate braids, short pointed ears, realistic skin, natural hair, realistic proportions, hyper-realistic, life-like, photorealistic. Pose: Standing gracefully in a mystical forest clearing beneath the sacred elven life tree, shy yet seductive expression, averted gaze, slight smile, biting lower lip, subtle arch in back, one hand on collarbone, leaning forward slightly.Clothing: Flowing, light, ethereal elven garments with intricate details on fabric and hair.Atmosphere: Inviting, cozy, magical, warm dimmed lighting filtering through trees, cinematic lighting, enchanting and immersive, hyper-realistic textures, subtle motion blur for natural realism.Technical: Medium-wide shot, professional color photography, high-resolution, perfect composition, captured with Bolex H16." -n "illustration, anime, drawing, artwork, bad hands. artwork" --sampling-method heun --steps 8 --scheduler simple -W 512 -H 512 -b 1 --cfg-scale 1 -s 512944566 --clip-skip -1 --embd-dir /home/phil2sat/sd.cpp-webui/models/embeddings/ --lora-model-dir /home/phil2sat/sd.cpp-webui/models/loras/ -t 0 --rng cuda -o /home/phil2sat/sd.cpp-webui/outputs/txt2img/4.png --diffusion-model /home/phil2sat/sd.cpp-webui/models/unet/chroma-unlocked-v47-flash-heun-8-steps-cfg-1-Q8_0.gguf --vae /home/phil2sat/sd.cpp-webui/models/vae/flux-vae-Q8_0.gguf --t5xxl /home/phil2sat/sd.cpp-webui/models/clip/t5xxl-unchained-Q8_0.gguf --guidance 7 --color

struct BezierSchedule : SigmaSchedule {    // Inverse Quadratic Bézier from Don Lancaster    static float quadraticBezier(float x, float a, float b) {        const float epsilon = 0.00001f;        a = std::clamp(a, 0.0f, 1.0f);        b = std::clamp(b, 0.0f, 1.0f);        if (a == 0.5f) a += epsilon;        // Solve t from x (inverse quadratic Bézier)        float om2a = 1.0f - 2.0f * a;        float t = (std::sqrt(a*a + om2a*x) - a) / om2a;        float y = (1.0f - 2.0f * b) * (t*t) + 2.0f * b * t;        return y;    }    std::vector<float> get_sigmas(uint32_t n, float /*sigma_min*/, float /*sigma_max*/, t_to_sigma_t t_to_sigma) override {        std::vector<float> result;        result.reserve(n + 1);        const int t_max = TIMESTEPS - 1;        if (n == 0) {            // Handle zero-step case: push max sigma and 0            result.push_back(t_to_sigma(static_cast<float>(t_max)));            result.push_back(0.f);            return result;        }        // Parameters for a Flux-Chroma-like distribution.        // These values were tuned experimentally to match the desired 8-step curve        const float a = 0.38f; // Quadratic Bézier X control point        const float b = 0.96f; // Quadratic Bézier Y control point        for (uint32_t i = 0; i < n; i++) {            // Uniform parameter in [0,1] for all steps            float u = static_cast<float>(i) / static_cast<float>(n - 1);                        // Compute the inverted quadratic Bézier value and scale to timestep            float t_cont = (1.0f - quadraticBezier(u, a, b)) * t_max;                        int t = static_cast<int>(std::lround(t_cont));            result.push_back(t_to_sigma(static_cast<float>(t)));        }        // Ensure the last sigma value is zero (final step)        result.push_back(0.f);        return result;    }};