Improved grapher

Author: raharrison

src/main/java/uk/co/ryanharrison/mathengine/gui/MainFrame.java

@@ -136,7 +136,7 @@ public void keyTyped(KeyEvent e) {
         setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
         setMinimumSize(new Dimension(MIN_WIDTH, MIN_HEIGHT));
 
-        input.requestFocus();
+        SwingUtilities.invokeLater(input::grabFocus);
     }
 
     private void evaluateAndDisplay(String expression) {
@@ -159,8 +159,7 @@ private void evaluateAndDisplay(String expression) {
     private void appendToOutput(String text, SimpleAttributeSet style) {
         try {
             output.getDocument().insertString(output.getDocument().getLength(), text, style);
-        } catch (BadLocationException e) {
-            e.printStackTrace();
+        } catch (BadLocationException ignore) {
         }
     }
 }

src/main/java/uk/co/ryanharrison/mathengine/plotting/FunctionListPanel.java

@@ -244,10 +244,10 @@ private void editSelectedFunction() {
         gbc.insets = new Insets(5, 5, 5, 5);
         gbc.fill = GridBagConstraints.HORIZONTAL;
 
-        JTextField nameField = new JTextField(currentFunc.getName(), 15);
+        JTextField nameField = new JTextField(currentFunc.name(), 15);
         JTextField equationField = new JTextField(currentFunc.getEquation(), 15);
         JButton colorButton = new JButton("Change Color");
-        final Color[] selectedColor = {currentFunc.getColor()};
+        final Color[] selectedColor = {currentFunc.color()};
 
         colorButton.setBackground(selectedColor[0]);
         colorButton.setOpaque(true);
@@ -294,10 +294,10 @@ private void editSelectedFunction() {
                     Function func = new Function(equation);
                     PlottedFunction newFunc = PlottedFunction.builder()
                             .function(func)
-                            .name(name.isEmpty() ? currentFunc.getName() : name)
+                            .name(name.isEmpty() ? currentFunc.name() : name)
                             .color(selectedColor[0])
-                            .strokeWidth(currentFunc.getStrokeWidth())
-                            .visible(currentFunc.isVisible())
+                            .strokeWidth(currentFunc.strokeWidth())
+                            .visible(currentFunc.visible())
                             .build();
 
                     updateFunction(index, newFunc);
@@ -322,7 +322,7 @@ private void removeSelectedFunction() {
 
         int confirm = JOptionPane.showConfirmDialog(
                 this,
-                "Remove function: " + listModel.get(index).function.getName() + "?",
+                "Remove function: " + listModel.get(index).function.name() + "?",
                 "Confirm Remove",
                 JOptionPane.YES_NO_OPTION
         );
@@ -336,7 +336,7 @@ private void removeSelectedFunction() {
     private void toggleFunctionVisibility(int index) {
         if (index >= 0 && index < listModel.size()) {
             FunctionListItem item = listModel.get(index);
-            PlottedFunction newFunc = item.function.withVisible(!item.function.isVisible());
+            PlottedFunction newFunc = item.function.withVisible(!item.function.visible());
             listModel.set(index, new FunctionListItem(newFunc, item.index));
             functionList.repaint();
             fireFunctionUpdated(index, newFunc);
@@ -384,14 +384,7 @@ default void onFunctionRemoved(int index) {
     /**
      * Internal wrapper for list items.
      */
-    private static class FunctionListItem {
-        final PlottedFunction function;
-        final int index;
-
-        FunctionListItem(PlottedFunction function, int index) {
-            this.function = function;
-            this.index = index;
-        }
+    private record FunctionListItem(PlottedFunction function, int index) {
     }
 
     /**
@@ -438,9 +431,9 @@ public Component getListCellRendererComponent(
 
             PlottedFunction func = item.function;
 
-            visibilityCheckbox.setSelected(func.isVisible());
-            colorLabel.setBackground(func.getColor());
-            nameLabel.setText(func.getName());
+            visibilityCheckbox.setSelected(func.visible());
+            colorLabel.setBackground(func.color());
+            nameLabel.setText(func.name());
             equationLabel.setText(func.getEquation());
 
             if (isSelected) {

src/main/java/uk/co/ryanharrison/mathengine/plotting/FunctionRenderer.java

@@ -1,7 +1,6 @@
 package uk.co.ryanharrison.mathengine.plotting;
 
 import java.awt.*;
-import java.awt.geom.Line2D;
 import java.awt.geom.Path2D;
 import java.awt.geom.Point2D;
 import java.util.ArrayList;
@@ -42,9 +41,6 @@ public final class FunctionRenderer {
     // Minimum horizontal distance between sample points (in pixels)
     private static final double MIN_SAMPLE_DISTANCE = 0.5;
 
-    // Maximum horizontal distance between sample points (in pixels)
-    private static final double MAX_SAMPLE_DISTANCE = 2.0;
-
     /**
      * Renders a function onto the given graphics context.
      *
@@ -53,14 +49,14 @@ public final class FunctionRenderer {
      * @param coords   the coordinate system for transformations
      */
     public void render(Graphics2D g, PlottedFunction function, GraphCoordinateSystem coords) {
-        if (!function.isVisible()) {
+        if (!function.visible()) {
             return;
         }
 
-        g.setColor(function.getColor());
+        g.setColor(function.color());
         // Use high-quality stroke with round caps and joins for smooth curves
         g.setStroke(new BasicStroke(
-                function.getStrokeWidth(),
+                function.strokeWidth(),
                 BasicStroke.CAP_ROUND,
                 BasicStroke.JOIN_ROUND,
                 10.0f,  // Miter limit
@@ -95,7 +91,6 @@ private List<Point2D.Double> sampleFunction(PlottedFunction function, GraphCoord
         // Determine sampling density based on zoom level
         // More samples per pixel at higher zoom for smooth curves
         int baseSamples = (int) (screenWidth / MIN_SAMPLE_DISTANCE);
-        int maxSamples = Math.min(baseSamples * 2, 4000); // Cap for performance
 
         // Initial uniform sampling
         double dx = (maxX - minX) / baseSamples;
@@ -201,7 +196,7 @@ private void renderSegment(Graphics2D g, List<Point2D.Double> segment) {
         }
 
         Path2D.Double path = new Path2D.Double();
-        Point2D.Double first = segment.get(0);
+        Point2D.Double first = segment.getFirst();
         path.moveTo(first.x, first.y);
 
         for (int i = 1; i < segment.size(); i++) {
@@ -211,65 +206,4 @@ private void renderSegment(Graphics2D g, List<Point2D.Double> segment) {
 
         g.draw(path);
     }
-
-    /**
-     * Renders a simple point-to-point version of the function (legacy mode).
-     * <p>
-     * This is a faster but lower-quality rendering method that doesn't
-     * handle discontinuities as well. Useful for real-time preview during
-     * dragging operations.
-     * </p>
-     *
-     * @param g        the graphics context
-     * @param function the function to render
-     * @param coords   the coordinate system
-     */
-    public void renderSimple(Graphics2D g, PlottedFunction function, GraphCoordinateSystem coords) {
-        if (!function.isVisible()) {
-            return;
-        }
-
-        g.setColor(function.getColor());
-        g.setStroke(new BasicStroke(function.getStrokeWidth()));
-
-        double minX = coords.getMinVisibleX();
-        double width = coords.getWidth();
-        double dx = (coords.getMaxVisibleX() - minX) / width;
-
-        double clippingThreshold = calculateClippingThreshold(coords);
-
-        double prevX = minX;
-        double prevY = function.evaluateAt(prevX);
-        if (Math.abs(prevY) > clippingThreshold) {
-            prevY = Math.signum(prevY) * clippingThreshold;
-        }
-
-        for (int i = 1; i <= width; i++) {
-            double x = minX + i * dx;
-            double y = function.evaluateAt(x);
-
-            if (Double.isNaN(y)) {
-                prevX = x;
-                prevY = y;
-                continue;
-            }
-
-            if (Math.abs(y) > clippingThreshold) {
-                y = Math.signum(y) * clippingThreshold;
-            }
-
-            if (!Double.isNaN(prevY)) {
-                Point2D.Double p1 = coords.toScreen(prevX, prevY);
-                Point2D.Double p2 = coords.toScreen(x, y);
-
-                // Simple discontinuity check
-                if (Math.abs(p2.y - p1.y) < coords.getHeight() * DISCONTINUITY_THRESHOLD) {
-                    g.draw(new Line2D.Double(p1.x, p1.y, p2.x, p2.y));
-                }
-            }
-
-            prevX = x;
-            prevY = y;
-        }
-    }
 }

src/main/java/uk/co/ryanharrison/mathengine/plotting/GraphCoordinateSystem.java

@@ -1,6 +1,8 @@
 package uk.co.ryanharrison.mathengine.plotting;
 
 import java.awt.geom.Point2D;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * Manages coordinate transformations between screen space and Cartesian graph space.
@@ -35,15 +37,43 @@
  */
 public final class GraphCoordinateSystem {
     // Predefined zoom levels - graph units per 80 pixels
-    private static final double[] UNITS = {
-            0.00005, 0.0001, 0.0002, 0.0005, 0.001, 0.002, 0.005,
-            0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0,
-            20.0, 50.0, 100.0, 200.0, 500.0, 1000.0
-    };
+    // Much finer increments for smooth, Google Maps-like zooming
+    private static final double[] UNITS = generateZoomLevels();
 
     // Fixed pixel distance for unit scaling
     private static final double PIXELS_PER_UNIT_STEP = 80.0;
 
+    /**
+     * Generates fine-grained zoom levels using 1.15x increments.
+     * This creates smooth zoom transitions like Google Maps.
+     * Includes exact "nice" values like 0.1, 1, 10, 100 for clean defaults.
+     */
+    private static double[] generateZoomLevels() {
+        List<Double> levels = new ArrayList<>();
+
+        // Generate smooth levels from 0.00001 to 10000
+        double current = 0.00001;
+        while (current <= 10000.0) {
+            levels.add(current);
+            current *= 1.15; // ~15% increase per level for smooth transitions
+        }
+
+        // Add exact "nice" values if not already present
+        double[] niceValues = {0.00001, 0.0001, 0.001, 0.01, 0.1, 1.0, 10.0, 100.0, 1000.0, 10000.0};
+        for (double nice : niceValues) {
+            if (!levels.contains(nice)) {
+                levels.add(nice);
+            }
+        }
+
+        // Sort and remove duplicates
+        return levels.stream()
+                .distinct()
+                .sorted()
+                .mapToDouble(Double::doubleValue)
+                .toArray();
+    }
+
     private final double width;
     private final double height;
 
@@ -57,6 +87,7 @@ public final class GraphCoordinateSystem {
     // Derived value: pixels per graph unit at current zoom
     private double scale;
 
+
     /**
      * Creates a coordinate system for a viewport of the given dimensions.
      *
@@ -76,10 +107,33 @@ public GraphCoordinateSystem(double width, double height) {
         this.height = height;
         this.originX = 0.0;
         this.originY = 0.0;
-        this.zoomLevel = 13; // Default zoom showing ~1 unit per 80 pixels
+        this.zoomLevel = findDefaultZoomLevel(); // Default zoom showing ~1 unit per 80 pixels
         updateScale();
     }
 
+    /**
+     * Finds the zoom level for exactly 1.0 units per 80 pixels.
+     */
+    private static int findDefaultZoomLevel() {
+        // Find exact match for 1.0 first
+        for (int i = 0; i < UNITS.length; i++) {
+            if (Math.abs(UNITS[i] - 1.0) < 0.001) {
+                return i;
+            }
+        }
+        // If not found, find closest to 1.0
+        int bestIndex = 0;
+        double bestDiff = Double.MAX_VALUE;
+        for (int i = 0; i < UNITS.length; i++) {
+            double diff = Math.abs(UNITS[i] - 1.0);
+            if (diff < bestDiff) {
+                bestDiff = diff;
+                bestIndex = i;
+            }
+        }
+        return bestIndex;
+    }
+
     /**
      * Updates the viewport dimensions.
      * <p>
@@ -233,7 +287,7 @@ public boolean zoomToward(double screenX, double screenY, boolean zoomIn) {
     public void resetView() {
         originX = 0.0;
         originY = 0.0;
-        zoomLevel = 13;
+        zoomLevel = findDefaultZoomLevel();
         updateScale();
     }
 
@@ -256,10 +310,11 @@ public void setOrigin(double x, double y) {
      */
     public void setZoom(int zoomLevel) {
         if (zoomLevel < 0 || zoomLevel >= UNITS.length) {
-            throw new IllegalArgumentException(
-                    "Zoom level must be between 0 and " + (UNITS.length - 1) + ", got: " + zoomLevel);
+            // Clamp instead of throwing to handle edge cases gracefully
+            this.zoomLevel = Math.max(0, Math.min(UNITS.length - 1, zoomLevel));
+        } else {
+            this.zoomLevel = zoomLevel;
         }
-        this.zoomLevel = zoomLevel;
         updateScale();
     }