Implement reverse for more Matrix variants

stdlib/LinearAlgebra/src/bidiag.jl

@@ -184,6 +184,10 @@ end
     return x
 end
 
+Base._reverse(A::Bidiagonal, dims) = reverse!(Matrix(A); dims)
+Base._reverse(A::Bidiagonal, dims::Colon) = Bidiagonal(reverse(A.dv), reverse(A.ev), A.uplo)
+Base._reverse!(A::Bidiagonal, dims::Colon) = (reverse!(A.dv); reverse!(A.ev); A)
+
 ## structured matrix methods ##
 function Base.replace_in_print_matrix(A::Bidiagonal,i::Integer,j::Integer,s::AbstractString)
     if A.uplo == 'U'

stdlib/LinearAlgebra/src/diagonal.jl

@@ -187,6 +187,10 @@ end
 diagzero(::Diagonal{T}, i, j) where {T} = zero(T)
 diagzero(D::Diagonal{<:AbstractMatrix{T}}, i, j) where {T} = zeros(T, size(D.diag[i], 1), size(D.diag[j], 2))
 
+Base._reverse(A::Diagonal, dims) = reverse!(Matrix(A); dims)
+Base._reverse(A::Diagonal, dims::Colon) = Diagonal(reverse(A.diag))
+Base._reverse!(A::Diagonal, dims::Colon) = (reverse!(A.diag); A)
+
 function setindex!(D::Diagonal, v, i::Int, j::Int)
     @boundscheck checkbounds(D, i, j)
     if i == j
@@ -946,4 +950,4 @@ end
 
 function Base.muladd(A::Diagonal, B::Diagonal, z::Diagonal)
     Diagonal(A.diag .* B.diag .+ z.diag)
-end
+end

stdlib/LinearAlgebra/src/hessenberg.jl

@@ -90,6 +90,10 @@ Base.isassigned(H::UpperHessenberg, i::Int, j::Int) =
 Base.@propagate_inbounds getindex(H::UpperHessenberg{T}, i::Integer, j::Integer) where {T} =
     i <= j+1 ? convert(T, H.data[i,j]) : zero(T)
 
+Base._reverse(A::UpperHessenberg, dims) = reverse(Matrix(A); dims)
+Base._reverse(A::UpperHessenberg, dims::Colon) = (reverse(Matrix(A)), A.data)
+Base._reverse!(A::UpperHessenberg, dims::Colon) = (reverse!(A.data); A)
+
 Base.@propagate_inbounds function setindex!(A::UpperHessenberg, x, i::Integer, j::Integer)
     if i > j+1
         x == 0 || throw(ArgumentError("cannot set index in the lower triangular part " *

stdlib/LinearAlgebra/src/symmetric.jl

@@ -254,11 +254,19 @@ end
     end
 end
 
+Base._reverse(A::Symmetric, dims::Integer) = (reverse((Matrix(A)); dims))
+Base._reverse(A::Symmetric, dims::Colon) = Symmetric(reverse(Matrix(A)))
+Base._reverse!(A::Symmetric, dims::Colon) = (reverse!(A.data); A)
+
 @propagate_inbounds function setindex!(A::Symmetric, v, i::Integer, j::Integer)
     i == j || throw(ArgumentError("Cannot set a non-diagonal index in a symmetric matrix"))
     setindex!(A.data, v, i, j)
 end
 
+Base._reverse(A::Hermitian, dims) = Hermitian(reverse(Matrix(A)); dims)
+Base._reverse(A::Hermitian, dims::Colon) = Hermitian(reverse(Matrix(A)))
+Base._reverse!(A::Hermitian, dims::Colon) = (reverse!(A.data); A)
+
 @propagate_inbounds function setindex!(A::Hermitian, v, i::Integer, j::Integer)
     if i != j
         throw(ArgumentError("Cannot set a non-diagonal index in a Hermitian matrix"))

stdlib/LinearAlgebra/src/triangular.jl

@@ -272,6 +272,11 @@ Base.isstored(A::UpperTriangular, i::Int, j::Int) =
 @propagate_inbounds getindex(A::UpperTriangular, i::Integer, j::Integer) =
     i <= j ? A.data[i,j] : _zero(A.data,j,i)
 
+Base._reverse(A::UpperTriangular, dims::Integer) = (reverse((Matrix(A)); dims))
+Base._reverse(A::UpperTriangular, dims::Colon) = (reverse(Matrix(A)))
+Base._reverse!(A::UpperTriangular, dims::Colon) = UpperTriangular(reverse!(A.data); A)
+
+
 @propagate_inbounds function setindex!(A::UpperTriangular, x, i::Integer, j::Integer)
     if i > j
         iszero(x) || throw(ArgumentError("cannot set index in the lower triangular part " *
@@ -295,6 +300,10 @@ end
     return A
 end
 
+Base._reverse(A::LowerTriangular, dims) = LowerTriangular(reverse((Matrix(A)); dims))
+Base._reverse(A::LowerTriangular, dims::Colon) = LowerTriangular(reverse(Matrix(A)))
+Base._reverse!(A::LowerTriangular, dims::Colon) = (reverse!(A.data); A)
+
 @propagate_inbounds function setindex!(A::LowerTriangular, x, i::Integer, j::Integer)
     if i < j
         iszero(x) || throw(ArgumentError("cannot set index in the upper triangular part " *

stdlib/LinearAlgebra/src/tridiag.jl

@@ -458,6 +458,10 @@ end
     end
 end
 
+Base._reverse(A::SymTridiagonal, dims) = reverse!(Matrix(A); dims)
+Base._reverse(A::SymTridiagonal, dims::Colon) = SymTridiagonal(reverse(A.dv), reverse(A.ev))
+Base._reverse!(A::SymTridiagonal, dims::Colon) = (reverse!(A.dv); reverse!(A.ev); A)
+
 @inline function setindex!(A::SymTridiagonal, x, i::Integer, j::Integer)
     @boundscheck checkbounds(A, i, j)
     if i == j
@@ -693,6 +697,10 @@ end
     end
 end
 
+Base._reverse(A::Tridiagonal, dims) = reverse!(Matrix(A); dims)
+Base._reverse(A::Tridiagonal, dims::Colon) = Tridiagonal(reverse(A.dl), reverse(A.d), reverse(A.du))
+Base._reverse!(A::Tridiagonal, dims::Colon) = (reverse!(A.dl); reverse!(A.d); reverse!(A.du); A)
+
 @inline function setindex!(A::Tridiagonal, x, i::Integer, j::Integer)
     @boundscheck checkbounds(A, i, j)
     if i == j

stdlib/LinearAlgebra/test/bidiag.jl

@@ -904,6 +904,17 @@ end
     @test mul!(C1, B, sv, 1, 2) == mul!(C2, B, v, 1 ,2)
 end
 
+@testset "Reverse operation on Bidiagonal" begin
+    n = 5
+    d = randn(n)
+    e = randn(n - 1)
+    B = Bidiagonal(d, e)
+    @test reverse(B, dims=1) == reverse(Matrix(B), dims=1)
+    @test reverse(B, dims=2) == reverse(Matrix(B), dims=2)
+    @test reverse(B) == reverse(Matrix(B))
+end
+
+
 @testset "Matrix conversion for non-numeric and undef" begin
     B = Bidiagonal(Vector{BigInt}(undef, 4), fill(big(3), 3), :U)
     M = Matrix(B)

stdlib/LinearAlgebra/test/diagonal.jl

@@ -61,6 +61,16 @@ Random.seed!(1)
         @test_throws MethodError convert(Diagonal, [1,2,3,4])
         @test_throws DimensionMismatch convert(Diagonal, [1 2 3 4])
         @test_throws InexactError convert(Diagonal, ones(2,2))
+
+        # Test reversing
+        # Test reversing along rows
+        @test reverse(D, dims=1) == reverse(Matrix(D), dims=1)
+
+        # Test reversing along columns
+        @test reverse(D, dims=2) == reverse(Matrix(D), dims=2)
+
+        # Test reversing the entire matrix
+        @test reverse(D) == reverse(Matrix(D))
     end
 
     @testset "Basic properties" begin
@@ -609,6 +619,15 @@ end
     end
 end
 
+@testset "Test reverse" begin
+    d = randn(n)
+    D = Diagonal(d)
+    @test reverse(D, dims=1) == reverse(Matrix(D), dims=1)
+    @test reverse(D, dims=2) == reverse(Matrix(D), dims=2)
+    @test reverse(D) == reverse(Matrix(D))
+end
+
+
 @testset "inverse" begin
     for d in Any[randn(n), Int[], [1, 2, 3], [1im, 2im, 3im], [1//1, 2//1, 3//1], [1+1im//1, 2//1, 3im//1]]
         D = Diagonal(d)

stdlib/LinearAlgebra/test/hessenberg.jl

@@ -202,6 +202,13 @@ let n = 10
     end
 end
 
+@testset "Reverse operation on UpperHessenberg" begin
+    A = UpperHessenberg(randn(n, n))
+    @test reverse(A, dims=1) == reverse(Matrix(A), dims=1)
+    @test reverse(A, dims=2) == reverse(Matrix(A), dims=2)
+    @test reverse(A) == reverse(Matrix(A))
+end
+
 @testset "hessenberg(::AbstractMatrix)" begin
     n = 10
     A = Tridiagonal(rand(n-1), rand(n), rand(n-1))

stdlib/LinearAlgebra/test/symmetric.jl

@@ -531,6 +531,21 @@ end
     end
 end
 
+@testset "Reverse operation on Symmetric" begin
+    A = Symmetric(randn(n, n))
+    @test reverse(A, dims=1) == reverse(Matrix(A), dims=1)
+    @test reverse(A, dims=2) == reverse(Matrix(A), dims=2)
+    @test reverse(A) == reverse(Matrix(A))
+end
+
+@testset "Reverse operation on Hermitian" begin
+    A = Hermitian(randn(ComplexF64, n, n))
+    @test reverse(A, dims=1) == reverse(Matrix(A), dims=1)
+    @test reverse(A, dims=2) == reverse(Matrix(A), dims=2)
+    @test reverse(A) == reverse(Matrix(A))
+end
+
+
 # bug identified in PR #52318: dot products of quaternionic Hermitian matrices,
 # or any number type where conj(a)*conj(b) ≠ conj(a*b):
 @testset "dot Hermitian quaternion #52318" begin

stdlib/LinearAlgebra/test/triangular.jl

@@ -728,6 +728,22 @@ end
 # Issue 16196
 @test UpperTriangular(Matrix(1.0I, 3, 3)) \ view(fill(1., 3), [1,2,3]) == fill(1., 3)
 
+
+@testset "Reverse operation on UpperTriangular" begin
+    A = UpperTriangular(randn(n, n))
+    @test reverse(A, dims=1) == reverse(Matrix(A), dims=1)
+    @test reverse(A, dims=2) == reverse(Matrix(A), dims=2)
+    @test reverse(A) == reverse(Matrix(A))
+end
+
+@testset "Reverse operation on LowerTriangular" begin
+    A = LowerTriangular(randn(n, n))
+    @test reverse(A, dims=1) == reverse(Matrix(A), dims=1)
+    @test reverse(A, dims=2) == reverse(Matrix(A), dims=2)
+    @test reverse(A) == reverse(Matrix(A))
+end
+
+
 # dimensional correctness:
 const BASE_TEST_PATH = joinpath(Sys.BINDIR, "..", "share", "julia", "test")
 isdefined(Main, :Furlongs) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "Furlongs.jl"))

stdlib/LinearAlgebra/test/tridiag.jl

@@ -859,6 +859,28 @@ end
     @test axes(B) === (ax, ax)
 end
 
+@testset "Reverse operation on Tridiagonal" begin
+    n = 5
+    d = randn(n)
+    dl = randn(n - 1)
+    du = randn(n - 1)
+    T = Tridiagonal(dl, d, du)
+    @test reverse(T, dims=1) == reverse(Matrix(T), dims=1)
+    @test reverse(T, dims=2) == reverse(Matrix(T), dims=2)
+    @test reverse(T) == reverse(Matrix(T))
+end
+
+@testset "Reverse operation on SymTridiagonal" begin
+    n = 5
+    d = randn(n)
+    dl = randn(n - 1)
+    ST = SymTridiagonal(d, dl)
+    @test reverse(ST, dims=1) == reverse(Matrix(ST), dims=1)
+    @test reverse(ST, dims=2) == reverse(Matrix(ST), dims=2)
+    @test reverse(ST) == reverse(Matrix(ST))
+end
+
+
 @testset "Matrix conversion for non-numeric and undef" begin
     T = Tridiagonal(fill(big(3), 3), Vector{BigInt}(undef, 4), fill(big(3), 3))
     M = Matrix(T)