Guard vector %*% vector by whole size, not rank-2 axes

The fallthrough %*% guard (reached by vector-vector products after the
gemv special cases) hardcoded rank-2 axes, emitting size(x, 2) on a
rank-1 array -- a gfortran error that made conformable unknown-length
dot products fail to compile. Compare whole vector sizes for rank-1
operands instead.

Also document why lapack_solve()'s squareness check is routing, not a
guard: rectangular solve(a, b) deliberately falls through to least
squares, a tested divergence from base R.

Author: mns-nordicals

R/r2f-matrix-blas.R

@@ -694,6 +694,12 @@ lapack_solve <- function(
 
   nrhs <- if (b_rank == 1L) 1L else dim_or_one(B, 2L)
 
+  # solve(a, b) with a rectangular `a` deliberately falls through to the
+  # least-squares branch below -- a divergence from base R (which requires
+  # a square `a`), locked by the "least-squares" tests in
+  # test-matrix-lapack.R. Squareness is a routing decision here, not a
+  # correctness guard: unknown squareness routes to dgels, which solves
+  # square systems exactly too.
   square <- check_conformable(m, n)
   if (square$ok && !square$unknown && !identical(context, "qr.solve")) {
     A_work <- hoist$declare_tmp(mode = "double", dims = list(m, m))

R/r2f-matrix.R

@@ -108,6 +108,8 @@ register_r2f_handler(
       ))
     }
 
+    # Vector operands (vector %*% vector reaches here) are rank-1: their
+    # extent is their whole size, not a rank-2 axis.
     guard_conformable_dims(
       k,
       right_eff$rows,
@@ -116,8 +118,10 @@ register_r2f_handler(
       scope,
       left = left,
       right = right,
-      left_axis = if (left_trans == "N") 2L else 1L,
-      right_axis = if (right_trans == "N") 1L else 2L
+      left_axis = if (left_rank == 1) NULL else if (left_trans == "N") 2L else
+        1L,
+      right_axis = if (right_rank == 1) NULL else if (right_trans == "N") 1L
+      else 2L
     )
 
     # Matrix-Matrix

tests/testthat/test-blas-guards.R

@@ -43,6 +43,23 @@ test_that("triangular solve guards squareness and RHS length", {
   )
 })
 
+test_that("vector %*% vector guards unknown lengths as whole sizes", {
+  fn <- function(x, y) {
+    declare(type(x = double(NA)), type(y = double(NA)))
+    x %*% y
+  }
+  # was: the fallthrough guard hardcoded rank-2 axes, emitting size(x, 2)
+  # on a rank-1 array -- a gfortran error that made a conformable
+  # unknown-length dot product fail to compile at all
+  qfn <- expect_no_warning(quick(fn))
+  expect_equal(qfn(c(1, 2, 3), c(4, 5, 6)), c(1, 2, 3) %*% c(4, 5, 6))
+  expect_error(
+    qfn(c(1, 2), c(4, 5, 6)),
+    "non-conformable arguments in %*%",
+    fixed = TRUE
+  )
+})
+
 test_that("solve() guards an unknown RHS length", {
   fn <- function(a, b) {
     declare(type(a = double(2, 2)), type(b = double(NA)))
@@ -53,6 +70,7 @@ test_that("solve() guards an unknown RHS length", {
   expect_error(qfn(diag(2), c(1, 2, 3)), "non-conformable arguments in solve")
 })
 
+
 test_that("solve(a) and chol() guard squareness", {
   inv <- function(a) {
     declare(type(a = double(n, k)))