Optimize parser func_name allocation; add comments to parser, viewport, graph cache, evaluator, graph widget

Made-with: Cursor

Author: tegaidogun

src/core/evaluator.cpp

@@ -25,6 +25,8 @@ double Evaluator::evaluate(const ASTNode* node, double x) {
     }
 }
 
+// Sample the function at num_points over [x_min, x_max]. Pre-sized vector and index assignment
+// avoid repeated growth and can be friendlier to the cache in tight loops.
 std::vector<Point> Evaluator::generate_points(const ASTNode* node,
                                                double x_min,
                                                double x_max,
@@ -35,15 +37,13 @@ std::vector<Point> Evaluator::generate_points(const ASTNode* node,
 
     std::vector<Point> points;
     points.resize(static_cast<std::size_t>(num_points));
-    
     double step = (x_max - x_min) / (num_points - 1);
 
     for (int i = 0; i < num_points; ++i) {
         double x = x_min + i * step;
         double y = evaluate(node, x);
         points[static_cast<std::size_t>(i)] = Point{x, y};
     }
-    
     return points;
 }
 

src/core/parser.cpp

@@ -10,6 +10,9 @@
 namespace plot_genius {
 namespace core {
 
+// Recursive-descent parser: expression (lowest precedence) -> term -> factor (highest).
+// Precedence: + - (expression) < * / (term) < unary, number, func, x, (), ^ (factor).
+
 std::unique_ptr<ASTNode> Parser::parse(const std::string& equation) {
     m_input = equation;
     m_position = 0;
@@ -26,6 +29,7 @@ std::unique_ptr<ASTNode> Parser::parse(const std::string& equation) {
     return node;
 }
 
+// Expression = term (('+' | '-') term)*  -- additive precedence level.
 std::unique_ptr<ASTNode> Parser::parse_expression() {
     auto left = parse_term();
     if (!left) return nullptr;
@@ -60,6 +64,7 @@ std::unique_ptr<ASTNode> Parser::parse_expression() {
     return left;
 }
 
+// Term = factor (('*' | '/') factor)*  -- multiplicative precedence level.
 std::unique_ptr<ASTNode> Parser::parse_term() {
     auto left = parse_factor();
     if (!left) return nullptr;
@@ -94,6 +99,7 @@ std::unique_ptr<ASTNode> Parser::parse_term() {
     return left;
 }
 
+// Factor: optional unary minus, then base (number | function | constant | 'x' | '(' expr ')'), then optional '^' factor.
 std::unique_ptr<ASTNode> Parser::parse_factor() {
     skip_whitespace();
 
@@ -191,6 +197,7 @@ std::unique_ptr<ASTNode> Parser::parse_function() {
     skip_whitespace();
 
     std::string func_name;
+    func_name.reserve(8);  // Avoid realloc for common names: sin, cos, sqrt, etc.
     size_t start = m_position;
 
     while (m_position < m_input.length() && std::isalpha(m_input[m_position])) {

src/graph/graph.cpp

@@ -46,19 +46,19 @@ void Graph::set_equation_enabled(size_t index, bool enabled) {
     }
 }
 
+// Generate sampled points for all enabled equations. Uses a cache keyed by viewport range,
+// sample count, and equation identity (AST pointer + enabled flag) to skip recomputation on repaint.
 std::vector<std::vector<core::Point>> Graph::generate_all_points(int num_points) const {
     double x_min, x_max, y_min, y_max;
     m_viewport.get_range(x_min, x_max, y_min, y_max);
 
-    // Reuse cached series when viewport and equation set have not changed.
     if (m_points_cache) {
         const auto& cache = *m_points_cache;
         if (cache.num_points == num_points &&
             cache.x_min == x_min &&
             cache.x_max == x_max &&
             cache.ast_snapshot.size() == m_equations.size() &&
             cache.enabled_snapshot.size() == m_equations.size()) {
-            
             bool matches = true;
             for (std::size_t i = 0; i < m_equations.size(); ++i) {
                 const auto& eq = m_equations[i];
@@ -68,10 +68,8 @@ std::vector<std::vector<core::Point>> Graph::generate_all_points(int num_points)
                     break;
                 }
             }
-            
-            if (matches) {
+            if (matches)
                 return cache.series;
-            }
         }
     }
 
@@ -87,6 +85,7 @@ std::vector<std::vector<core::Point>> Graph::generate_all_points(int num_points)
         }
     }
 
+    // Store snapshot of AST pointers (identity) and enabled flags so we can detect changes.
     PointsCache cache;
     cache.x_min = x_min;
     cache.x_max = x_max;

src/graph/viewport.cpp

@@ -29,6 +29,7 @@ void Viewport::set_range(double x_min, double x_max, double y_min, double y_max)
     }
 }
 
+// Pan: shift visible range by a fraction of the current range (dx, dy in [-1,1]).
 void Viewport::pan(double dx, double dy) {
     double x_range = m_x_max - m_x_min;
     double y_range = m_y_max - m_y_min;
@@ -39,6 +40,7 @@ void Viewport::pan(double dx, double dy) {
     m_y_max += dy * y_range;
 }
 
+// Zoom: scale distance from (center_x, center_y). factor > 1 zooms in, < 1 zooms out.
 void Viewport::zoom(double factor, double center_x, double center_y) {
     if (factor <= 0.0) return;
 
@@ -61,6 +63,7 @@ void Viewport::reset() {
     m_y_max = DEFAULT_Y_MAX;
 }
 
+// Map world (math) coords to pixel coords. Y is flipped so +y is up in world, down on screen.
 void Viewport::world_to_screen(double world_x, double world_y,
                               int screen_width, int screen_height,
                               int& screen_x, int& screen_y) const {
@@ -74,12 +77,12 @@ void Viewport::world_to_screen(double world_x, double world_y,
     }
 
     double normalized_x = (world_x - m_x_min) / x_range;
-    double normalized_y = 1.0 - (world_y - m_y_min) / y_range; // Flip Y axis
-    
+    double normalized_y = 1.0 - (world_y - m_y_min) / y_range;  // Flip Y: world +y = screen top
     screen_x = static_cast<int>(normalized_x * screen_width);
     screen_y = static_cast<int>(normalized_y * screen_height);
 }
 
+// Map pixel coords back to world coords (inverse of world_to_screen, same Y flip).
 void Viewport::screen_to_world(int screen_x, int screen_y,
                                int screen_width, int screen_height,
                                double& world_x, double& world_y) const {
@@ -93,8 +96,7 @@ void Viewport::screen_to_world(int screen_x, int screen_y,
     }
 
     double normalized_x = static_cast<double>(screen_x) / screen_width;
-    double normalized_y = 1.0 - static_cast<double>(screen_y) / screen_height; // Flip Y axis
-    
+    double normalized_y = 1.0 - static_cast<double>(screen_y) / screen_height;
     world_x = m_x_min + normalized_x * x_range;
     world_y = m_y_min + normalized_y * y_range;
 }

src/ui/graph_widget.cpp

@@ -317,14 +317,15 @@ void GraphWidget::draw_grid(QPainter& painter) {
     }
 }
 
+// Pick a grid step that gives ~target_lines and rounds to "nice" values (1, 2, 5, 10 * 10^n).
+// Uses magnitude = 10^floor(log10(ideal)) and normalizes to choose 1, 2, 5, or 10.
 double GraphWidget::calculate_grid_step(double range, int target_lines) const {
     if (range <= 0 || target_lines <= 0) return 1.0;
 
     double ideal_step = range / target_lines;
     double magnitude = std::pow(10.0, std::floor(std::log10(ideal_step)));
     double normalized = ideal_step / magnitude;
 
-    // Round to nice numbers: 1, 2, 5, 10
     if (normalized <= 1.5) {
         return magnitude;
     } else if (normalized <= 3.0) {
@@ -414,12 +415,13 @@ void GraphWidget::draw_axis_labels(QPainter& painter) {
     }
 }
 
+// Draw each equation as a polyline. Points are in world coords; we transform to screen,
+// skip segments far off-widget to avoid huge paths, and use moveTo/lineTo for disconnected segments.
 void GraphWidget::draw_graphs(QPainter& painter) {
     if (!m_graph) return;
 
     auto all_points = m_graph->generate_all_points(m_config.points_per_graph);
 
-    // Track basic performance metrics: total points rendered
     int total_points = 0;
     for (const auto& series : all_points) {
         total_points += static_cast<int>(series.size());
@@ -430,27 +432,23 @@ void GraphWidget::draw_graphs(QPainter& painter) {
     for (const auto& points : all_points) {
         if (points.empty()) continue;
 
-        // Use smooth, high-quality line rendering
         QPen pen(m_config.equation_colors[color_index % 5], m_config.line_width);
         pen.setCapStyle(Qt::RoundCap);
         pen.setJoinStyle(Qt::RoundJoin);
         painter.setPen(pen);
 
-        // Build path for smooth curves
         QPainterPath path;
         bool first_point = true;
 
         for (const auto& point : points) {
             int screen_x, screen_y;
             viewport.world_to_screen(point.x, point.y, width(), height(), screen_x, screen_y);
-            
-            // Skip points outside visible area for performance
+            // Clip to widget + margin so we start a new segment when re-entering view instead of one long line.
             if (screen_x < -100 || screen_x > width() + 100 ||
                 screen_y < -100 || screen_y > height() + 100) {
                 first_point = true;
                 continue;
             }
-            
             QPointF screen_point(screen_x, screen_y);
             if (first_point) {
                 path.moveTo(screen_point);