app.cpp

// app.cpp - Modified version of eigen_analysis_corrected.cpp for Streamlit integration
#include <opencv2/opencv.hpp>
#include <algorithm>
#include <cmath>
#include <iostream>
#include <iomanip>
#include <numeric>
#include <random>
#include <vector>
#include <limits>
#include <sstream>

// Function to compute the theoretical max value
double compute_theoretical_max(double a, double y, double beta) {
    auto f = [a, y, beta](double k) -> double {
        return (y * beta * (a - 1) * k + (a * k + 1) * ((y - 1) * k - 1)) / 
               ((a * k + 1) * (k * k + k));  // Divide by y here
    };
    
    // Use numerical optimization to find the maximum
    // Grid search followed by golden section search
    double best_k = 1.0;
    double best_val = f(best_k);
    
    // Initial grid search over a wide range
    const int num_grid_points = 200;
    for (int i = 0; i < num_grid_points; ++i) {
        double k = 0.01 + 100.0 * i / (num_grid_points - 1); // From 0.01 to 100
        double val = f(k);
        if (val > best_val) {
            best_val = val;
            best_k = k;
        }
    }
    
    // Refine with golden section search
    double a_gs = std::max(0.01, best_k / 10.0);
    double b_gs = best_k * 10.0;
    const double golden_ratio = (1.0 + std::sqrt(5.0)) / 2.0;
    const double tolerance = 1e-10;
    
    double c_gs = b_gs - (b_gs - a_gs) / golden_ratio;
    double d_gs = a_gs + (b_gs - a_gs) / golden_ratio;
    
    while (std::abs(b_gs - a_gs) > tolerance) {
        if (f(c_gs) > f(d_gs)) {
            b_gs = d_gs;
            d_gs = c_gs;
            c_gs = b_gs - (b_gs - a_gs) / golden_ratio;
        } else {
            a_gs = c_gs;
            c_gs = d_gs;
            d_gs = a_gs + (b_gs - a_gs) / golden_ratio;
        }
    }
    
    // Multiply the result by y before returning
    return f((a_gs + b_gs) / 2.0) *y ;
}

// Function to compute the theoretical min value
double compute_theoretical_min(double a, double y, double beta) {
    auto f = [a, y, beta](double t) -> double {
        return (y * beta * (a - 1) * t + (a * t + 1) * ((y - 1) * t - 1)) / 
               ((a * t + 1) * (t * t + t) * y);  // Divide by y here
    };
    
    // Use numerical optimization to find the minimum
    // Grid search followed by golden section search
    double best_t = -0.5 / a; // Midpoint of (-1/a, 0)
    double best_val = f(best_t);
    
    // Initial grid search over the range (-1/a, 0)
    const int num_grid_points = 200;
    for (int i = 1; i < num_grid_points; ++i) {
        // From slightly above -1/a to slightly below 0
        double t = -0.999/a + 0.998/a * i / (num_grid_points - 1);
        if (t >= 0 || t <= -1.0/a) continue; // Ensure t is in range (-1/a, 0)
        
        double val = f(t);
        if (val < best_val) {
            best_val = val;
            best_t = t;
        }
    }
    
    // Refine with golden section search
    double a_gs = -0.999/a; // Slightly above -1/a
    double b_gs = -0.001/a; // Slightly below 0
    const double golden_ratio = (1.0 + std::sqrt(5.0)) / 2.0;
    const double tolerance = 1e-10;
    
    double c_gs = b_gs - (b_gs - a_gs) / golden_ratio;
    double d_gs = a_gs + (b_gs - a_gs) / golden_ratio;
    
    while (std::abs(b_gs - a_gs) > tolerance) {
        if (f(c_gs) < f(d_gs)) {
            b_gs = d_gs;
            d_gs = c_gs;
            c_gs = b_gs - (b_gs - a_gs) / golden_ratio;
        } else {
            a_gs = c_gs;
            c_gs = d_gs;
            d_gs = a_gs + (b_gs - a_gs) / golden_ratio;
        }
    }
    
    // Multiply the result by y before returning
    return f((a_gs + b_gs) / 2.0) *y ;
}

int main(int argc, char* argv[]) {
    // ─── Inputs from command line ───────────────────────────────────────────
    if (argc != 5) {
        std::cerr << "Usage: " << argv[0] << " <n> <p> <a> <y>" << std::endl;
        return 1;
    }
    
    int n = std::stoi(argv[1]);
    int p = std::stoi(argv[2]);
    double a = std::stod(argv[3]);
    double y = std::stod(argv[4]);
    const double b = 1.0;
    
    std::cout << "Running with parameters: n = " << n << ", p = " << p 
              << ", a = " << a << ", y = " << y << std::endl;
    
    // ─── Beta range parameters ────────────────────────────────────────
    const int num_beta_points = 100; // More points for smoother curves
    std::vector<double> beta_values(num_beta_points);
    for (int i = 0; i < num_beta_points; ++i) {
        beta_values[i] = static_cast<double>(i) / (num_beta_points - 1);
    }
    
    // ─── Storage for results ────────────────────────────────────────
    std::vector<double> max_eigenvalues(num_beta_points);
    std::vector<double> min_eigenvalues(num_beta_points);
    std::vector<double> theoretical_max_values(num_beta_points);
    std::vector<double> theoretical_min_values(num_beta_points);
    
    // ─── Random‐Gaussian X and S_n ────────────────────────────────
    std::mt19937_64 rng{std::random_device{}()};
    std::normal_distribution<double> norm(0.0, 1.0);
    
    cv::Mat X(p, n, CV_64F);
    for(int i = 0; i < p; ++i)
        for(int j = 0; j < n; ++j)
            X.at<double>(i,j) = norm(rng);
    
    // ─── Process each beta value ─────────────────────────────────
    for (int beta_idx = 0; beta_idx < num_beta_points; ++beta_idx) {
        double beta = beta_values[beta_idx];
        
        // Compute theoretical values
        theoretical_max_values[beta_idx] = compute_theoretical_max(a, y, beta);
        theoretical_min_values[beta_idx] = compute_theoretical_min(a, y, beta);
        
        // ─── Build T_n matrix ──────────────────────────────────
        int k = static_cast<int>(std::floor(beta * p));
        std::vector<double> diags(p);
        std::fill_n(diags.begin(), k, a);
        std::fill_n(diags.begin()+k, p-k, b);
        std::shuffle(diags.begin(), diags.end(), rng);
        
        cv::Mat T_n = cv::Mat::zeros(p, p, CV_64F);
        for(int i = 0; i < p; ++i){
            T_n.at<double>(i,i) = diags[i];
        }
        
        // ─── Form B_n = (1/n) * X * T_n * X^T ────────────
        cv::Mat B = (X.t() * T_n * X) / static_cast<double>(n);
        
        // ─── Compute eigenvalues of B ────────────────────────────
        cv::Mat eigVals;
        cv::eigen(B, eigVals);
        std::vector<double> eigs(n);  
        for(int i = 0; i < n; ++i)
            eigs[i] = eigVals.at<double>(i, 0);
        
        max_eigenvalues[beta_idx] = *std::max_element(eigs.begin(), eigs.end());
        min_eigenvalues[beta_idx] = *std::min_element(eigs.begin(), eigs.end());
        
        // Progress indicator - modified to be less verbose for Streamlit
        if (beta_idx % 20 == 0) {
            std::cout << "Processing beta = " << beta 
                      << " (" << beta_idx+1 << "/" << num_beta_points << ")" << std::endl;
        }
    }
    
    // ─── Prepare canvas for plotting ────────────────────────────────
    const int H = 950, W = 1200; // Taller canvas to accommodate legend below
    cv::Mat canvas(H, W, CV_8UC3, cv::Scalar(250, 250, 250)); // Slightly off-white background
    
    // ─── Find min/max for scaling ───────────────────────────────────
    double min_y = std::numeric_limits<double>::max();
    double max_y = std::numeric_limits<double>::lowest();
    
    for (double v : max_eigenvalues) max_y = std::max(max_y, v);
    for (double v : min_eigenvalues) min_y = std::min(min_y, v);
    for (double v : theoretical_max_values) max_y = std::max(max_y, v);
    for (double v : theoretical_min_values) min_y = std::min(min_y, v);
    
    // Add some padding
    double y_padding = (max_y - min_y) * 0.15; // More padding for better spacing
    min_y -= y_padding;
    max_y += y_padding;
    
    // ─── Draw coordinate axes ───────────────────────────────────────
    const int margin = 100; // Larger margin for better spacing
    const int plot_width = W - 2 * margin;
    const int plot_height = H - 2 * margin - 150; // Reduced height to make room for legend below
    
    // Plot area background (light gray)
    cv::rectangle(canvas, 
                 cv::Point(margin, margin),
                 cv::Point(W - margin, margin + plot_height),
                 cv::Scalar(245, 245, 245), cv::FILLED);
    
    // X-axis (beta)
    cv::line(canvas, 
             cv::Point(margin, margin + plot_height),
             cv::Point(W - margin, margin + plot_height),
             cv::Scalar(40, 40, 40), 2);
    
    // Y-axis (eigenvalues)
    cv::line(canvas,
             cv::Point(margin, margin + plot_height),
             cv::Point(margin, margin),
             cv::Scalar(40, 40, 40), 2);
    
    // ─── Draw axes labels ────────────────────────────────────────────
    cv::putText(canvas, "β", 
                cv::Point(W - margin/2, margin + plot_height + 30),
                cv::FONT_HERSHEY_COMPLEX, 1.0, cv::Scalar(0, 0, 0), 2);
                
    // Y-axis label (fixed - no rotation)
    cv::putText(canvas, "Eigenvalues", 
                cv::Point(margin/4, margin/2 - 10),
                cv::FONT_HERSHEY_COMPLEX, 1.0, cv::Scalar(0, 0, 0), 2);
                
    // ─── Draw title ───────────────────────────────────────────────────
    std::stringstream title_ss;
    title_ss << std::fixed << std::setprecision(2);
    title_ss << "Eigenvalue Analysis: a = " << a << ", y = " << y;
    cv::putText(canvas, title_ss.str(),
                cv::Point(W/2 - 200, 45),
                cv::FONT_HERSHEY_COMPLEX, 1.2, cv::Scalar(0, 0, 0), 2);
    
    // ─── Draw grid lines ────────────────────────────────────────────────
    const int num_grid_lines = 11; // 0.0, 0.1, 0.2, ..., 1.0 for beta
    for (int i = 0; i < num_grid_lines; ++i) {
        // Horizontal grid lines
        int y_pos = margin + i * (plot_height / (num_grid_lines - 1));
        cv::line(canvas,
                 cv::Point(margin, y_pos),
                 cv::Point(W - margin, y_pos),
                 cv::Scalar(220, 220, 220), 1);
                 
        // Vertical grid lines
        int x_pos = margin + i * (plot_width / (num_grid_lines - 1));
        cv::line(canvas,
                 cv::Point(x_pos, margin),
                 cv::Point(x_pos, margin + plot_height),
                 cv::Scalar(220, 220, 220), 1);
                 
        // X-axis labels (beta values)
        double beta_val = static_cast<double>(i) / (num_grid_lines - 1);
        std::stringstream ss;
        ss << std::fixed << std::setprecision(1) << beta_val;
        cv::putText(canvas, ss.str(),
                    cv::Point(x_pos - 10, margin + plot_height + 30),
                    cv::FONT_HERSHEY_SIMPLEX, 0.7, cv::Scalar(0, 0, 0), 1);
                    
        // Y-axis labels (eigenvalue values)
        double eig_val = min_y + (max_y - min_y) * i / (num_grid_lines - 1);
        std::stringstream ss2;
        ss2 << std::fixed << std::setprecision(2) << eig_val;
        cv::putText(canvas, ss2.str(),
                    cv::Point(margin/2 - 40, margin + plot_height - i * (plot_height / (num_grid_lines - 1)) + 5),
                    cv::FONT_HERSHEY_SIMPLEX, 0.7, cv::Scalar(0, 0, 0), 1);
    }
    
    // ─── Draw the four curves ───────────────────────────────────────────
    // Convert data points to pixel coordinates
    auto to_point = [&](double beta, double val) -> cv::Point {
        int x = margin + static_cast<int>(beta * plot_width);
        int y = margin + plot_height - static_cast<int>((val - min_y) / (max_y - min_y) * plot_height);
        return cv::Point(x, y);
    };
    
    // Better colors for visibility
    cv::Scalar emp_max_color(60, 60, 220);    // Dark red
    cv::Scalar emp_min_color(220, 60, 60);    // Dark blue
    cv::Scalar theo_max_color(30, 180, 30);   // Dark green
    cv::Scalar theo_min_color(180, 30, 180);  // Dark purple
    
    // Empirical max eigenvalues (red)
    std::vector<cv::Point> max_eig_points;
    for (int i = 0; i < num_beta_points; ++i) {
        max_eig_points.push_back(to_point(beta_values[i], max_eigenvalues[i]));
    }
    cv::polylines(canvas, max_eig_points, false, emp_max_color, 3);
    
    // Empirical min eigenvalues (blue)
    std::vector<cv::Point> min_eig_points;
    for (int i = 0; i < num_beta_points; ++i) {
        min_eig_points.push_back(to_point(beta_values[i], min_eigenvalues[i]));
    }
    cv::polylines(canvas, min_eig_points, false, emp_min_color, 3);
    
    // Theoretical max values (green)
    std::vector<cv::Point> theo_max_points;
    for (int i = 0; i < num_beta_points; ++i) {
        theo_max_points.push_back(to_point(beta_values[i], theoretical_max_values[i]));
    }
    cv::polylines(canvas, theo_max_points, false, theo_max_color, 3);
    
    // Theoretical min values (purple)
    std::vector<cv::Point> theo_min_points;
    for (int i = 0; i < num_beta_points; ++i) {
        theo_min_points.push_back(to_point(beta_values[i], theoretical_min_values[i]));
    }
    cv::polylines(canvas, theo_min_points, false, theo_min_color, 3);
    
    // ─── Draw markers on the curves for better visibility ──────────────
    const int marker_interval = 10; // Show markers every 10 points
    for (int i = 0; i < num_beta_points; i += marker_interval) {
        // Max empirical eigenvalue markers
        cv::circle(canvas, max_eig_points[i], 5, emp_max_color, cv::FILLED);
        cv::circle(canvas, max_eig_points[i], 5, cv::Scalar(255, 255, 255), 1);
        
        // Min empirical eigenvalue markers
        cv::circle(canvas, min_eig_points[i], 5, emp_min_color, cv::FILLED);
        cv::circle(canvas, min_eig_points[i], 5, cv::Scalar(255, 255, 255), 1);
        
        // Theoretical max markers
        cv::drawMarker(canvas, theo_max_points[i], theo_max_color, cv::MARKER_DIAMOND, 10, 2);
        
        // Theoretical min markers
        cv::drawMarker(canvas, theo_min_points[i], theo_min_color, cv::MARKER_DIAMOND, 10, 2);
    }
    
    // ─── Draw legend BELOW the graph ────────────────────────────────────
    // Set up dimensions for the legend
    const int legend_width = 600;
    const int legend_height = 100;
    // Center the legend horizontally
    const int legend_x = W/2 - legend_width/2;
    // Position legend below the graph
    const int legend_y = margin + plot_height + 70;
    const int line_length = 40;
    const int line_spacing = 35;
    
    // Box around legend with shadow effect
    cv::rectangle(canvas,
                 cv::Point(legend_x + 3, legend_y + 3),
                 cv::Point(legend_x + legend_width + 3, legend_y + legend_height + 3),
                 cv::Scalar(180, 180, 180), cv::FILLED); // Shadow
    cv::rectangle(canvas,
                 cv::Point(legend_x, legend_y),
                 cv::Point(legend_x + legend_width, legend_y + legend_height),
                 cv::Scalar(240, 240, 240), cv::FILLED); // Main box
    cv::rectangle(canvas,
                 cv::Point(legend_x, legend_y),
                 cv::Point(legend_x + legend_width, legend_y + legend_height),
                 cv::Scalar(0, 0, 0), 1); // Border
    
    // Legend title
    cv::putText(canvas, "Legend",
                cv::Point(legend_x + legend_width/2 - 30, legend_y + 20),
                cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 0), 1);
    cv::line(canvas,
             cv::Point(legend_x + 5, legend_y + 30),
             cv::Point(legend_x + legend_width - 5, legend_y + 30),
             cv::Scalar(150, 150, 150), 1);
    
    // Two legend entries per row, in two columns
    // First row
    // Empirical max (red)
    cv::line(canvas, 
             cv::Point(legend_x + 20, legend_y + 50),
             cv::Point(legend_x + 20 + line_length, legend_y + 50),
             emp_max_color, 3);
    cv::circle(canvas, cv::Point(legend_x + 20 + line_length/2, legend_y + 50), 5, emp_max_color, cv::FILLED);
    cv::putText(canvas, "Empirical Max Eigenvalue",
                cv::Point(legend_x + 20 + line_length + 10, legend_y + 50 + 5),
                cv::FONT_HERSHEY_SIMPLEX, 0.7, cv::Scalar(0, 0, 0), 1);
                
    // Empirical min (blue)
    cv::line(canvas, 
             cv::Point(legend_x + 20 + legend_width/2, legend_y + 50),
             cv::Point(legend_x + 20 + line_length + legend_width/2, legend_y + 50),
             emp_min_color, 3);
    cv::circle(canvas, cv::Point(legend_x + 20 + line_length/2 + legend_width/2, legend_y + 50), 5, emp_min_color, cv::FILLED);
    cv::putText(canvas, "Empirical Min Eigenvalue",
                cv::Point(legend_x + 20 + line_length + 10 + legend_width/2, legend_y + 50 + 5),
                cv::FONT_HERSHEY_SIMPLEX, 0.7, cv::Scalar(0, 0, 0), 1);
    
    // Second row
    // Theoretical max (green)
    cv::line(canvas, 
             cv::Point(legend_x + 20, legend_y + 80),
             cv::Point(legend_x + 20 + line_length, legend_y + 80),
             theo_max_color, 3);
    cv::drawMarker(canvas, cv::Point(legend_x + 20 + line_length/2, legend_y + 80), 
                  theo_max_color, cv::MARKER_DIAMOND, 10, 2);
    cv::putText(canvas, "Theoretical Max Function",
                cv::Point(legend_x + 20 + line_length + 10, legend_y + 80 + 5),
                cv::FONT_HERSHEY_SIMPLEX, 0.7, cv::Scalar(0, 0, 0), 1);
                
    // Theoretical min (purple)
    cv::line(canvas, 
             cv::Point(legend_x + 20 + legend_width/2, legend_y + 80),
             cv::Point(legend_x + 20 + line_length + legend_width/2, legend_y + 80),
             theo_min_color, 3);
    cv::drawMarker(canvas, cv::Point(legend_x + 20 + line_length/2 + legend_width/2, legend_y + 80), 
                  theo_min_color, cv::MARKER_DIAMOND, 10, 2);
    cv::putText(canvas, "Theoretical Min Function",
                cv::Point(legend_x + 20 + line_length + 10 + legend_width/2, legend_y + 80 + 5),
                cv::FONT_HERSHEY_SIMPLEX, 0.7, cv::Scalar(0, 0, 0), 1);
    
    // ─── Draw mathematical formulas in a box ──────────────────────────────
    cv::rectangle(canvas,
                 cv::Point(margin + 3, H - 80 + 3),
                 cv::Point(W - margin + 3, H - 20 + 3),
                 cv::Scalar(180, 180, 180), cv::FILLED); // Shadow
    cv::rectangle(canvas,
                 cv::Point(margin, H - 80),
                 cv::Point(W - margin, H - 20),
                 cv::Scalar(240, 240, 240), cv::FILLED); // Main box
    cv::rectangle(canvas,
                 cv::Point(margin, H - 80),
                 cv::Point(W - margin, H - 20),
                 cv::Scalar(0, 0, 0), 1); // Border
    
    std::string formula_text1 = "Max Function: max{k ∈ (0,∞)} [yβ(a-1)k + (ak+1)((y-1)k-1)]/[(ak+1)(k²+k)y]";
    std::string formula_text2 = "Min Function: min{t ∈ (-1/a,0)} [yβ(a-1)t + (at+1)((y-1)t-1)]/[(at+1)(t²+t)y]";
    
    cv::putText(canvas, formula_text1,
                cv::Point(margin + 20, H - 55),
                cv::FONT_HERSHEY_SIMPLEX, 0.6, theo_max_color, 2);
                
    cv::putText(canvas, formula_text2,
                cv::Point(W/2 + 20, H - 55),
                cv::FONT_HERSHEY_SIMPLEX, 0.6, theo_min_color, 2);
    
    // ─── Draw parameter info ────────────────────────────────────────────
    std::stringstream params_ss;
    params_ss << std::fixed << std::setprecision(2);
    params_ss << "Parameters: n = " << n << ", p = " << p << ", a = " << a << ", y = " << y;
    cv::putText(canvas, params_ss.str(),
                cv::Point(margin, 80),
                cv::FONT_HERSHEY_COMPLEX, 0.8, cv::Scalar(0, 0, 0), 1);
    
    // ─── Save the image to the output directory ───────────────────────────
    std::string output_path = "/app/output/eigenvalue_analysis.png";
    cv::imwrite(output_path, canvas);
    std::cout << "Plot saved as " << output_path << std::endl;
    
    return 0;
}