Fix a second round of unreachable methods (#696)

A JET pass over the merged master turned up more methods that could
not run: a garbled expression in the product of two LowRankOperators,
a field access on the wrong object in BandedMatrix(::SubOperator),
and an exception type that was moved out of Base. The LowRankFun
constructors now report unsupported arguments instead of failing with
an UndefVarError.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: jishnub

src/Multivariate/LowRankFun.jl

@@ -104,6 +104,8 @@ function LowRankFun(f::Function, dx::Space, dy::Space;
         else
             F = LowRankFun(copy(G.A), map(b->Fun(b,dy),G.B))
         end
+    else
+        throw(ArgumentError("unsupported method \$method, expected :standard or :Cholesky"))
     end
     retmax ? (F,maxabsf) : F
 end
@@ -145,10 +147,12 @@ function standardLowRankFun(f::Function, dx::Space, dy::Space;
     end
 
     A,B=typeof(a)[],typeof(b)[]
-    if tolerance == :relative
-        tol = 100maxabsf*eps(T)
-    elseif tolerance[1] == :absolute
-        tol = 100*tolerance[2]*eps(T)
+    tol = if tolerance == :relative
+        100maxabsf*eps(T)
+    elseif tolerance isa Tuple && tolerance[1] == :absolute
+        100*tolerance[2]*eps(T)
+    else
+        throw(ArgumentError("unsupported tolerance \$tolerance, expected :relative or (:absolute, tol)"))
     end
     tol10 = tol/10
     Avals,Bvals = zeros(T,gridx),zeros(T,gridy)
@@ -209,10 +213,12 @@ function CholeskyLowRankFun(f::Function,dx::Space;
     end
 
     A,B=typeof(a)[],typeof(a)[]
-    if tolerance == :relative
-        tol = 100maxabsf*eps(T)
-    elseif tolerance[1] == :absolute
-        tol = 100*tolerance[2]*eps(T)
+    tol = if tolerance == :relative
+        100maxabsf*eps(T)
+    elseif tolerance isa Tuple && tolerance[1] == :absolute
+        100*tolerance[2]*eps(T)
+    else
+        throw(ArgumentError("unsupported tolerance \$tolerance, expected :relative or (:absolute, tol)"))
     end
     tol10 = tol/10
     Avals = zeros(T,grid)

src/Operators/almostbanded/LowRankOperator.jl

@@ -71,7 +71,9 @@ rank(L::LowRankOperator) = length(L.U)
 *(L::LowRankOperator,f::Fun) = sum(map((u,v)->u*(v*f),L.U,L.V))
 
 
-*(A::LowRankOperator,B::LowRankOperator) = LowRankOperator(transpose(A.V*B.transpose(U))*A.U,B.V)
+# (A*B)*f == A*(B*f) == sum(A*B.U[k] * (B.V[k]*f) for k in eachindex(B.U)),
+# as B.V[k]*f is a constant
+*(A::LowRankOperator,B::LowRankOperator) = LowRankOperator(map(u->A*u, B.U), B.V)
 # avoid ambiguity
 for TYP in (:TimesOperator,:PlusOperator,:Conversion,:Operator)
     @eval *(L::LowRankOperator,B::$TYP) = LowRankOperator(L.U,map(v->v*B,L.V))

src/Operators/general/FiniteOperator.jl

@@ -50,10 +50,10 @@ function getindex(F::FiniteOperator,k::Integer)
 end
 
 function BandedMatrix(S::SubOperator{T,FiniteOperator{AT,T}}) where {AT<:BandedMatrix,T}
-    kr,jr=parentindices(S)
-    if last(kr[1]) ≤ size(S.matrix,1) &&
-        last(jr[2]) ≤ size(S.matrix,2)
-        matrix[kr,jr]
+    kr,jr = parentindices(S)
+    M = parent(S).matrix
+    if last(kr) ≤ size(M,1) && last(jr) ≤ size(M,2)
+        M[kr,jr]
     else
         default_copy(S)
     end

src/specialfunctions.jl

@@ -291,7 +291,8 @@ function airy(k::Number,f::Fun)
     end
 end
 
-besselh(ν,k::Integer,f::Fun) = k == 1 ? hankelh1(ν,f) : k == 2 ? hankelh2(ν,f) : throw(Base.Math.AmosException(1))
+besselh(ν,k::Integer,f::Fun) = k == 1 ? hankelh1(ν,f) : k == 2 ? hankelh2(ν,f) :
+    throw(ArgumentError("k must be 1 or 2, received \$k"))
 
 for jy in (:j, :y)
     bjy = Symbol(:bessel, jy)

test/runtests.jl

@@ -867,4 +867,28 @@ end
         f = Fun(ApproxFunBase.SequenceSpace(), [3.0, 4.0])
         @test f[CartesianIndex()] == f[1] == 3.0
     end
+
+    @testset "product of LowRankOperators" begin
+        H = ApproxFunBase.HeavisideSpace([-1.0, 0.0, 1.0])
+        A = ApproxFunBase.LowRankOperator(Fun(H, [1.0, 2.0]), Evaluation(H, -0.5))
+        B = ApproxFunBase.LowRankOperator(Fun(H, [3.0, -1.0]), Evaluation(H, 0.5))
+        AB = A*B
+        @test AB isa ApproxFunBase.LowRankOperator
+        @test rank(AB) == rank(B)
+        f = Fun(H, [2.0, 5.0])
+        @test coefficients(AB*f) ≈ coefficients(A*(B*f))
+    end
+
+    @testset "BandedMatrix of a FiniteOperator view" begin
+        M = BandedMatrix(0 => Float64[1, 2, 3], 1 => Float64[4, 5])
+        F = ApproxFunBase.FiniteOperator(M)
+        @test BandedMatrix(view(F, 1:2, 1:2)) == M[1:2, 1:2]
+        @test BandedMatrix(view(F, 2:3, 2:3)) == M[2:3, 2:3]
+    end
+
+    @testset "argument errors" begin
+        @test_throws ArgumentError besselh(0, 3, Fun(1.0))
+        @test_throws ArgumentError LowRankFun((x,y) -> x*y, PointSpace(1:3), PointSpace(1:3),
+                                                method = :neither)
+    end
 end