Refactor

Author: kojix2

spec/reference_spec.cr

@@ -860,6 +860,18 @@ describe "Julia reference output compatibility" do
   end
 
   describe "heatmap" do
+    it "matches heatmap/default_0x0" do
+      z = Array(Array(Float64)).new(0) { Array(Float64).new(0, 0.0) }
+      p = UnicodePlot.heatmap(z, labels: false)
+      test_ref("heatmap/default_0x0.txt", p)
+    end
+
+    it "matches heatmap/default_5x0" do
+      z = Array.new(5) { [] of Float64 }
+      p = UnicodePlot.heatmap(z, labels: false)
+      test_ref("heatmap/default_5x0.txt", p)
+    end
+
     # integers_20x20: repeat(collect(1:20), outer=(1,20)) → A[i,j] = i
     it "matches heatmap/integers_20x20" do
       z = Array.new(20) { |i| Array.new(20) { |_j| (i + 1).to_f } }
@@ -1140,6 +1152,12 @@ describe "Julia reference output compatibility" do
     end
 
     describe "sizing" do
+      it "matches spy/default_0x0" do
+        a = Array(Array(Float64)).new(0) { Array(Float64).new(0, 0.0) }
+        p = UnicodePlot.spy(a)
+        test_ref("spy/default_0x0.txt", p)
+      end
+
       it "matches spy/default_10x10" do
         p = UnicodePlot.spy(spy_fixture_matrix("10x10"))
         test_ref("spy/default_10x10.txt", p)

spec/unicode_plot_spec.cr

@@ -470,10 +470,9 @@ describe UnicodePlot do
       p.xlabel.should contain("⩵ 0")
     end
 
-    it "rejects empty matrices" do
-      expect_raises(ArgumentError, /must not be empty/) do
-        UnicodePlot.spy([] of Array(Float64))
-      end
+    it "accepts empty matrices" do
+      p = UnicodePlot.spy([] of Array(Float64))
+      p.should be_a(UnicodePlot::Plot)
     end
   end
 

src/unicode_plot/interface/heatmap.cr

@@ -134,7 +134,6 @@ z : Array(Array(Float64)),
               fix_ar : Bool = false,
               out_stream : IO? = nil,) : Plot
     matrix = MatrixView.new(z)
-    raise ArgumentError.new("z must not be empty") if matrix.empty?
 
     data_nrows = matrix.nrows
     data_ncols = matrix.ncols
@@ -145,12 +144,12 @@ z : Array(Array(Float64)),
 
     # autolims: {0,0} means auto → use full data range.
     eff_ylim = if ylim == {0.0, 0.0}
-                 y_arr.empty? ? {0.0, 1.0} : {y_arr.min, y_arr.max}
+                 y_arr.empty? ? {0.0, 0.0} : {y_arr.min, y_arr.max}
                else
                  {ylim[0].to_f, ylim[1].to_f}
                end
     eff_xlim = if xlim == {0.0, 0.0}
-                 x_arr.empty? ? {0.0, 1.0} : {x_arr.min, x_arr.max}
+                 x_arr.empty? ? {0.0, 0.0} : {x_arr.min, x_arr.max}
                else
                  {xlim[0].to_f, xlim[1].to_f}
                end

src/unicode_plot/interface/spy.cr

@@ -31,6 +31,8 @@ module UnicodePlot
     fix_ar : Bool,
     out_stream : IO? = nil,
   ) : {Int32, Int32}
+    return {0, 0} if nrows == 0 && ncols == 0
+
     yppc, xppc = spy_canvas_pixel_per_char(canvas)
     canv_height = nrows.to_f64 / yppc
     canv_width = ncols.to_f64 / xppc
@@ -82,6 +84,7 @@ module UnicodePlot
 
     {final_h.clamp(1, Int32::MAX), final_w.clamp(1, Int32::MAX)}
   end
+
   # ameba:enable Metrics/CyclomaticComplexity
 
   def spy(
@@ -111,7 +114,6 @@ module UnicodePlot
     thousands_separator : Char = ' ',
   ) : Plot
     matrix = MatrixView.new(a)
-    raise ArgumentError.new("a must not be empty") if matrix.empty?
 
     nrows = matrix.nrows
     ncols = matrix.ncols
@@ -162,8 +164,9 @@ module UnicodePlot
       grid: false,
       # Julia's spy passes canvas_kw: (height: 1 + nrow, width: 1 + ncol).
       # build_plot has no canvas_kw, so use widened limits to match the same mapping scale.
-      xlim: {1.0, ncols.to_f64 + 2.0},
-      ylim: {1.0, nrows.to_f64 + 2.0},
+      # For 0x0 matrices, Julia uses xlim=[1,0]/ylim=[1,0] (inverted); Crystal maps this to {0.0,1.0}.
+      xlim: ncols == 0 ? {0.0, 1.0} : {1.0, ncols.to_f64 + 2.0},
+      ylim: nrows == 0 ? {0.0, 1.0} : {1.0, nrows.to_f64 + 2.0},
       xflip: xflip,
       yflip: yflip,
       unicode_exponent: unicode_exponent,
@@ -191,12 +194,26 @@ module UnicodePlot
       plot.xlabel = "#{plot.nice_repr(vals.size)} #{show_zeros ? "⩵ 0" : "≠ 0"}"
     end
 
-    # Keep displayed axis endpoints identical to Julia's spy (1..ncol, 1..nrow).
+    # Keep displayed axis endpoints identical to Julia's spy.
     bc = ansi_color(border_color)
-    plot.label!(:bl, xflip ? nice_repr(ncols, unicode_exponent, thousands_separator) : "1", bc)
-    plot.label!(:br, xflip ? "1" : nice_repr(ncols, unicode_exponent, thousands_separator), bc)
-    plot.label!(:l, plot.canvas.nrows, yflip ? nice_repr(nrows, unicode_exponent, thousands_separator) : "1", bc)
-    plot.label!(:l, 1, yflip ? "1" : nice_repr(nrows, unicode_exponent, thousands_separator), bc)
+    x_left, x_right = matrix_horizontal_axis_labels(
+      ncols,
+      flip: xflip,
+      unicode_exponent: unicode_exponent,
+      thousands_separator: thousands_separator,
+      zero_fallback_range: true,
+    )
+    y_top, y_bottom = matrix_vertical_axis_labels(
+      nrows,
+      flip: yflip,
+      unicode_exponent: unicode_exponent,
+      thousands_separator: thousands_separator,
+      zero_fallback_range: true,
+    )
+    plot.label!(:bl, x_left, bc)
+    plot.label!(:br, x_right, bc)
+    plot.label!(:l, plot.canvas.nrows, y_top, bc)
+    plot.label!(:l, 1, y_bottom, bc)
 
     plot
   end

src/unicode_plot/matrix.cr

@@ -47,6 +47,48 @@ module UnicodePlot
     end
   end
 
+  # Returns {low_label, high_label} for matrix index coordinates.
+  # Standard matrix indexing is 1..n; for 0-sized axes in Julia compatibility mode
+  # we use 0..1 to reflect the plotted fallback range.
+  def matrix_index_range_labels(
+    size : Int32,
+    unicode_exponent : Bool = true,
+    thousands_separator : Char = ' ',
+    zero_fallback_range : Bool = true,
+  ) : {String, String}
+    if size == 0
+      zero_fallback_range ? {"0", "1"} : {"1", "0"}
+    else
+      {"1", nice_repr(size, unicode_exponent, thousands_separator)}
+    end
+  end
+
+  # Returns {left_label, right_label} for horizontal axis labels.
+  def matrix_horizontal_axis_labels(
+    size : Int32,
+    *,
+    flip : Bool,
+    unicode_exponent : Bool = true,
+    thousands_separator : Char = ' ',
+    zero_fallback_range : Bool = true,
+  ) : {String, String}
+    lo, hi = matrix_index_range_labels(size, unicode_exponent, thousands_separator, zero_fallback_range)
+    flip ? {hi, lo} : {lo, hi}
+  end
+
+  # Returns {top_label, bottom_label} for vertical axis labels.
+  def matrix_vertical_axis_labels(
+    size : Int32,
+    *,
+    flip : Bool,
+    unicode_exponent : Bool = true,
+    thousands_separator : Char = ' ',
+    zero_fallback_range : Bool = true,
+  ) : {String, String}
+    lo, hi = matrix_index_range_labels(size, unicode_exponent, thousands_separator, zero_fallback_range)
+    flip ? {hi, lo} : {lo, hi}
+  end
+
   def matrix_extrema_finite(matrix : MatrixView(T)) : {Float64, Float64}? forall T
     {% unless T <= Number %}
       {% raise "matrix_extrema_finite requires numeric matrix elements" %}