Improve README and add cached points structure

Made-with: Cursor

Author: tegaidogun

README.md

@@ -1,30 +1,39 @@
 Plot Genius
+==========
 
-A cross-platform mathematical function plotting application.
+Plot Genius is a fast, cross‑platform function plotter built with modern C++ and Qt 6.
 
-Features
+It is designed as a small, focused desktop tool that feels native on each platform while still showing solid engineering practices under the hood.
 
-- Parse and evaluate mathematical expressions
-- Interactive graph with pan and zoom
-- Multiple equation management
-- Graph export (PNG/JPEG)
-- Customizable appearance
-- Automatic theme detection
+Features
+--------
+- **Math expressions**: Parse and evaluate real‑valued functions of \(x\) (for example `x^2 + 2*x + 1`).
+- **Multiple equations**: Add, remove, enable, or disable several curves at once.
+- **Interactive graph**: Pan, zoom, and auto‑fit the viewport to all visible equations.
+- **Graph export**: Save the current graph as PNG or JPEG.
+- **Adaptive theming**: Follows the system theme (with native macOS styling where available).
+- **Performance aware**: Caches sampled points and surfaces basic render metrics for repeatable, smooth updates.
 
-Building
+Build
+-----
 
 Requirements:
 - C++17 compiler
 - CMake 3.16+
-- Qt6 (Core, Widgets, Gui)
+- Qt 6 (Core, Widgets, Gui)
+
+Steps:
 
-Build:
 ```bash
-mkdir build && cd build
-cmake ..
+mkdir build
+cd build
+cmake .. -DCMAKE_BUILD_TYPE=Release
 cmake --build . -j4
 ```
 
+On success, the executable will be built as `Plot Genius` inside the `build` directory.
+
 License
+-------
 
 MIT License

include/graph/graph.hpp

@@ -12,6 +12,7 @@
 #include <memory>
 #include <vector>
 #include <string>
+#include <optional>
 
 namespace plot_genius {
 namespace graph {
@@ -76,9 +77,19 @@ class Graph {
     std::string get_last_error() const { return m_parser.get_last_error(); }
 
 private:
+    struct PointsCache {
+        double x_min{};
+        double x_max{};
+        int num_points{};
+        std::vector<std::vector<core::Point>> series;
+        std::vector<const core::ASTNode*> ast_snapshot;
+        std::vector<bool> enabled_snapshot;
+    };
+
     std::vector<Equation> m_equations;
     core::Parser m_parser;
     Viewport m_viewport;
+    mutable std::optional<PointsCache> m_points_cache;
 };
 
 } // namespace graph

src/graph/graph.cpp

@@ -23,31 +23,61 @@ bool Graph::add_equation(const std::string& expression) {
     eq.enabled = true;
 
     m_equations.push_back(std::move(eq));
+    m_points_cache.reset();
     return true;
 }
 
 void Graph::remove_equation(size_t index) {
     if (index < m_equations.size()) {
         m_equations.erase(m_equations.begin() + index);
+        m_points_cache.reset();
     }
 }
 
 void Graph::clear_all_equations() {
     m_equations.clear();
+    m_points_cache.reset();
 }
 
 void Graph::set_equation_enabled(size_t index, bool enabled) {
     if (index < m_equations.size()) {
         m_equations[index].enabled = enabled;
+        m_points_cache.reset();
     }
 }
 
 std::vector<std::vector<core::Point>> Graph::generate_all_points(int num_points) const {
-    std::vector<std::vector<core::Point>> all_points;
-    
     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];
+                if (cache.ast_snapshot[i] != eq.ast.get() ||
+                    cache.enabled_snapshot[i] != eq.enabled) {
+                    matches = false;
+                    break;
+                }
+            }
+            
+            if (matches) {
+                return cache.series;
+            }
+        }
+    }
+
+    std::vector<std::vector<core::Point>> all_points;
+    all_points.reserve(m_equations.size());
+    
     for (const auto& eq : m_equations) {
         if (eq.enabled && eq.ast) {
             auto points = core::Evaluator::generate_points(
@@ -57,6 +87,19 @@ std::vector<std::vector<core::Point>> Graph::generate_all_points(int num_points)
         }
     }
 
+    PointsCache cache;
+    cache.x_min = x_min;
+    cache.x_max = x_max;
+    cache.num_points = num_points;
+    cache.series = all_points;
+    cache.ast_snapshot.reserve(m_equations.size());
+    cache.enabled_snapshot.reserve(m_equations.size());
+    for (const auto& eq : m_equations) {
+        cache.ast_snapshot.push_back(eq.ast.get());
+        cache.enabled_snapshot.push_back(eq.enabled);
+    }
+    m_points_cache = std::move(cache);
+    
     return all_points;
 }