Update app.cpp

app.cpp

@@ -1,4 +1,4 @@
-// app.cpp - Modified version for Hugging Face Spaces
+// app.cpp - Modified version for Hugging Face Spaces (calculation only)
 #include <opencv2/opencv.hpp>
 #include <algorithm>
 #include <cmath>
@@ -10,6 +10,7 @@
 #include <limits>
 #include <sstream>
 #include <string>
+#include <fstream>
 
 // Function to compute the theoretical max value
 double compute_theoretical_max(double a, double y, double beta) {
@@ -56,7 +57,7 @@ double compute_theoretical_max(double a, double y, double beta) {
     }
     
     // Multiply the result by y before returning
-    return f((a_gs + b_gs) / 2.0) *y ;
+    return f((a_gs + b_gs) / 2.0) * y;
 }
 
 // Function to compute the theoretical min value
@@ -107,13 +108,77 @@ double compute_theoretical_min(double a, double y, double beta) {
     }
     
     // Multiply the result by y before returning
-    return f((a_gs + b_gs) / 2.0) *y ;
+    return f((a_gs + b_gs) / 2.0) * y;
+}
+
+// Function to save data as JSON
+void save_as_json(const std::string& filename, 
+                 const std::vector<double>& beta_values,
+                 const std::vector<double>& max_eigenvalues,
+                 const std::vector<double>& min_eigenvalues,
+                 const std::vector<double>& theoretical_max_values,
+                 const std::vector<double>& theoretical_min_values) {
+    
+    std::ofstream outfile(filename);
+    
+    if (!outfile.is_open()) {
+        std::cerr << "Error: Could not open file " << filename << " for writing." << std::endl;
+        return;
+    }
+    
+    // Start JSON object
+    outfile << "{\n";
+    
+    // Write beta values
+    outfile << "  \"beta_values\": [";
+    for (size_t i = 0; i < beta_values.size(); ++i) {
+        outfile << beta_values[i];
+        if (i < beta_values.size() - 1) outfile << ", ";
+    }
+    outfile << "],\n";
+    
+    // Write max eigenvalues
+    outfile << "  \"max_eigenvalues\": [";
+    for (size_t i = 0; i < max_eigenvalues.size(); ++i) {
+        outfile << max_eigenvalues[i];
+        if (i < max_eigenvalues.size() - 1) outfile << ", ";
+    }
+    outfile << "],\n";
+    
+    // Write min eigenvalues
+    outfile << "  \"min_eigenvalues\": [";
+    for (size_t i = 0; i < min_eigenvalues.size(); ++i) {
+        outfile << min_eigenvalues[i];
+        if (i < min_eigenvalues.size() - 1) outfile << ", ";
+    }
+    outfile << "],\n";
+    
+    // Write theoretical max values
+    outfile << "  \"theoretical_max\": [";
+    for (size_t i = 0; i < theoretical_max_values.size(); ++i) {
+        outfile << theoretical_max_values[i];
+        if (i < theoretical_max_values.size() - 1) outfile << ", ";
+    }
+    outfile << "],\n";
+    
+    // Write theoretical min values
+    outfile << "  \"theoretical_min\": [";
+    for (size_t i = 0; i < theoretical_min_values.size(); ++i) {
+        outfile << theoretical_min_values[i];
+        if (i < theoretical_min_values.size() - 1) outfile << ", ";
+    }
+    outfile << "]\n";
+    
+    // Close JSON object
+    outfile << "}\n";
+    
+    outfile.close();
 }
 
 int main(int argc, char* argv[]) {
     // ─── Inputs from command line ───────────────────────────────────────────
-    if (argc != 6) {
-        std::cerr << "Usage: " << argv[0] << " <n> <p> <a> <y> <output_file>" << std::endl;
+    if (argc != 7) {
+        std::cerr << "Usage: " << argv[0] << " <n> <p> <a> <y> <fineness> <output_file>" << std::endl;
         return 1;
     }
     
@@ -121,15 +186,16 @@ int main(int argc, char* argv[]) {
     int p = std::stoi(argv[2]);
     double a = std::stod(argv[3]);
     double y = std::stod(argv[4]);
-    std::string output_file = argv[5];
+    int fineness = std::stoi(argv[5]);
+    std::string output_file = argv[6];
     const double b = 1.0;
     
     std::cout << "Running with parameters: n = " << n << ", p = " << p 
-              << ", a = " << a << ", y = " << y << std::endl;
+              << ", a = " << a << ", y = " << y << ", fineness = " << fineness << std::endl;
     std::cout << "Output will be saved to: " << output_file << std::endl;
     
     // ─── Beta range parameters ────────────────────────────────────────
-    const int num_beta_points = 100; // More points for smoother curves
+    const int num_beta_points = fineness; // Controlled by fineness parameter
     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);
@@ -183,281 +249,22 @@ int main(int argc, char* argv[]) {
         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) {
+        // Progress indicator for Streamlit
+        double progress = static_cast<double>(beta_idx + 1) / num_beta_points;
+        std::cout << "PROGRESS:" << progress << std::endl;
+        
+        // Less verbose output for Streamlit
+        if (beta_idx % 20 == 0 || beta_idx == num_beta_points - 1) {
             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);
-    }
+    // Save data as JSON for Python to read
+    save_as_json(output_file, beta_values, max_eigenvalues, min_eigenvalues, 
+                theoretical_max_values, theoretical_min_values);
     
-    // ─── 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 ───────────────────────────
-    cv::imwrite(output_file, canvas);
-    std::cout << "Plot saved as " << output_file << std::endl;
+    std::cout << "Data saved to " << output_file << std::endl;
     
     return 0;
 }