Initial commit

Author: raphasampaio

src/ndsparsearray.jl

@@ -514,15 +514,21 @@ function add!(A::NDSparseArray{T, N}, B::NDSparseArray{S, N}) where {T, S, N}
 end
 
 """
-    add!(A::NDSparseArray, scalar::Number)
+    add!(A::NDSparseArray, scalar)
 
 In-place addition of scalar to all stored elements in sparse array `A`.
 More efficient than `A = A + scalar`.
-"""
-function add!(A::NDSparseArray{T}, scalar::Number) where {T}
-    # If scalar is zero, no operation needed
-    if scalar == zero(typeof(scalar))
-        return A
+Works with any type that supports addition with the array's element type.
+"""
+function add!(A::NDSparseArray{T}, scalar) where {T}
+    # For generic types, we can't assume zero() exists, so we try to check if it's zero
+    # For most numeric types this will work, for others we'll skip the check
+    try
+        if scalar == zero(typeof(scalar))
+            return A
+        end
+    catch MethodError
+        # zero() not defined for this type, continue with the operation
     end
 
     # Add scalar to all stored values, converting to A's type
@@ -568,15 +574,21 @@ function sub!(A::NDSparseArray{T, N}, B::NDSparseArray{S, N}) where {T, S, N}
 end
 
 """
-    sub!(A::NDSparseArray, scalar::Number)
+    sub!(A::NDSparseArray, scalar)
 
 In-place subtraction of scalar from all stored elements in sparse array `A`.
 More efficient than `A = A - scalar`.
-"""
-function sub!(A::NDSparseArray{T}, scalar::Number) where {T}
-    # If scalar is zero, no operation needed
-    if scalar == zero(typeof(scalar))
-        return A
+Works with any type that supports subtraction with the array's element type.
+"""
+function sub!(A::NDSparseArray{T}, scalar) where {T}
+    # For generic types, we can't assume zero() exists, so we try to check if it's zero
+    # For most numeric types this will work, for others we'll skip the check
+    try
+        if scalar == zero(typeof(scalar))
+            return A
+        end
+    catch MethodError
+        # zero() not defined for this type, continue with the operation
     end
 
     # Subtract scalar from all stored values, converting to A's type
@@ -589,21 +601,30 @@ function sub!(A::NDSparseArray{T}, scalar::Number) where {T}
 end
 
 """
-    mul!(A::NDSparseArray, scalar::Number)
+    mul!(A::NDSparseArray, scalar)
 
 In-place scalar multiplication of sparse array `A`.
 More efficient than `A = A * scalar`.
-"""
-function mul!(A::NDSparseArray{T}, scalar::Number) where {T}
-    # If scalar is zero, clear all elements
-    if scalar == zero(typeof(scalar))
-        empty!(A.data)
-        return A
+Works with any type that supports multiplication with the array's element type.
+"""
+function mul!(A::NDSparseArray{T}, scalar) where {T}
+    # For generic types, we can't assume zero() or one() exist, so we try to check
+    # For most numeric types this will work, for others we'll skip the check
+    try
+        if scalar == zero(typeof(scalar))
+            empty!(A.data)
+            return A
+        end
+    catch MethodError
+        # zero() not defined for this type, continue
     end
 
-    # If scalar is one, no operation needed
-    if scalar == one(typeof(scalar))
-        return A
+    try
+        if scalar == one(typeof(scalar))
+            return A
+        end
+    catch MethodError
+        # one() not defined for this type, continue
     end
 
     # Multiply all stored values, converting scalar to A's type

test/test_inplace_operations.jl

@@ -342,6 +342,70 @@ using Test
         @test A[2, 2, 2] == 20
         @test A[1, 2, 1] == 14
     end
+    
+    @testset "Generic scalar types" begin
+        # Test with custom numeric type that supports +, -, *
+        struct CustomNumber
+            value::Float64
+        end
+        Base.:+(a::CustomNumber, b::CustomNumber) = CustomNumber(a.value + b.value)
+        Base.:-(a::CustomNumber, b::CustomNumber) = CustomNumber(a.value - b.value)
+        Base.:*(a::CustomNumber, b::CustomNumber) = CustomNumber(a.value * b.value)
+        Base.convert(::Type{CustomNumber}, x::CustomNumber) = x
+        
+        A = NDSparseArray{CustomNumber, 2}((2, 2))
+        A[1, 1] = CustomNumber(5.0)
+        A[2, 2] = CustomNumber(10.0)
+        
+        add!(A, CustomNumber(3.0))
+        
+        @test A[1, 1].value == 8.0
+        @test A[2, 2].value == 13.0
+        @test nnz(A) == 2
+        
+        # Test with rational numbers
+        B = NDSparseArray{Rational{Int}, 2}((2, 2))
+        B[1, 1] = 1//2
+        B[2, 2] = 3//4
+        
+        add!(B, 1//4)
+        
+        @test B[1, 1] == 3//4
+        @test B[2, 2] == 1//1
+        @test nnz(B) == 2
+        
+        # Test with complex numbers and complex scalar
+        C = NDSparseArray{Complex{Int}, 2}((2, 2))
+        C[1, 1] = 2 + 3im
+        C[2, 2] = 1 + 1im
+        
+        add!(C, 1 + 2im)
+        
+        @test C[1, 1] == 3 + 5im
+        @test C[2, 2] == 2 + 3im
+        @test nnz(C) == 2
+        
+        # Test multiplication with rational
+        mul!(B, 2//3)
+        
+        @test B[1, 1] == 1//2  # (3//4) * (2//3) = 1//2
+        @test B[2, 2] == 2//3  # (1//1) * (2//3) = 2//3
+        @test nnz(B) == 2
+    end
+    
+    @testset "Generic type error handling" begin
+        # Test that incompatible types still give sensible errors
+        A = NDSparseArray{Int, 2}((2, 2))
+        A[1, 1] = 5
+        
+        # Test with incompatible scalar type that can't convert
+        struct IncompatibleType
+            value::String
+        end
+        
+        incompatible = IncompatibleType("test")
+        @test_throws MethodError add!(A, incompatible)
+    end
 end
 
 end