allow identity matrices of types with alternative unity (#732)

Closes #731

Author: araujoms

src/sparsematrix.jl

@@ -2205,7 +2205,7 @@ end
 import Base._one
 function Base._one(unit::T, S::AbstractSparseMatrixCSC) where T
     size(S, 1) == size(S, 2) || throw(DimensionMismatch("multiplicative identity only defined for square matrices"))
-    return SparseMatrixCSC{T}(I, size(S, 1), size(S, 2))
+    return _spscaling(T, Int, unit, size(S, 1), size(S, 2))
 end
 
 ## SparseMatrixCSC construction from UniformScaling
@@ -2217,13 +2217,19 @@ SparseMatrixCSC(s::UniformScaling, dims::Dims{2}) = SparseMatrixCSC{eltype(s)}(s
 function SparseMatrixCSC{Tv,Ti}(s::UniformScaling, dims::Dims{2}) where {Tv,Ti}
     @boundscheck first(dims) < 0 && throw(ArgumentError("first dimension invalid ($(first(dims)) < 0)"))
     @boundscheck last(dims) < 0 && throw(ArgumentError("second dimension invalid ($(last(dims)) < 0)"))
-    iszero(s.λ) && return spzeros(Tv, Ti, dims...)
-    m, n, k = dims..., min(dims...)
-    nzval = fill!(Vector{Tv}(undef, k), Tv(s.λ))
+    return _spscaling(Tv, Ti, s.λ, dims...)
+end
+
+function _spscaling(::Type{Tv}, ::Type{Ti}, λ, m, n) where {Tv,Ti<:Integer}
+    iszero(λ) && return spzeros(Tv, Ti, m, n)
+    k = min(m, n)
+    nzval = fill!(Vector{Tv}(undef, k), Tv(λ))
     rowval = copyto!(Vector{Ti}(undef, k), 1:k)
     colptr = copyto!(Vector{Ti}(undef, n + 1), 1:(k + 1))
-    for i in (k + 2):(n + 1) colptr[i] = (k + 1) end
-    SparseMatrixCSC{Tv,Ti}(dims..., colptr, rowval, nzval)
+    for i in (k + 2):(n + 1)
+        colptr[i] = (k + 1)
+    end
+    return SparseMatrixCSC{Tv,Ti}(m, n, colptr, rowval, nzval)
 end
 
 Base.iszero(A::AbstractSparseMatrixCSC) = iszero(nzvalview(A))

test/sparsematrix_constructors_indexing.jl

@@ -976,6 +976,26 @@ end
     @test one(sparse([1 1; 1 1]))::SparseMatrixCSC == [1 0; 0 1]
 end
 
+struct MockTropical{T} <: Number begin
+    n::T
+    end
+end
+MockTropical{T}(x::MockTropical{T}) where {T} = x
+Base.zero(::Type{MockTropical{T}}) where {T} = MockTropical{T}(typemin(T))
+Base.zero(x::MockTropical{T}) where {T} = zero(MockTropical{T})
+Base.one(::Type{MockTropical{T}}) where {T} = MockTropical{T}(zero(T))
+Base.one(x::MockTropical{T}) where {T} = one(MockTropical{T})
+Base.:*(a::MockTropical{T}, b::MockTropical{T}) where {T} = MockTropical{T}(a.n + b.n)
+Base.:+(a::MockTropical{T}, b::MockTropical{T}) where {T} = MockTropical{T}(max(a.n, b.n))
+
+@testset "issue #731" begin
+    x = MockTropical{Float64}(1.0)
+    B = sparse([1, 2], [1,2], [x, x])
+    C = [one(x) zero(x); zero(x) one(x)]
+    @test one(B) == C
+    @test B^0 == C
+end
+
 @testset "sparsevec" begin
     local A = sparse(fill(1, 5, 5))
     @test sparsevec(A) == fill(1, 25)