Add atomic operations support for Complex numbers

Implements atomic operations for Complex{Float32} and Complex{Float64}
by reinterpreting them as UInt64/UInt128 and using integer atomics.

- Uses CAS loops for modify! operations on Complex types
- Adds tests for all atomic operations with complex numbers
- Maintains full compatibility with existing functionality

Fixes #37

Generated with GitHub Copilot

Author: albertomercurio

src/core.jl

@@ -1,8 +1,10 @@
+# Atomic operations with Complex number support via integer reinterpretation
+
 @inline function Atomix.get(ref, order)
     ptr = Atomix.pointer(ref)
     root = Atomix.gcroot(ref)
     GC.@preserve root begin
-        UnsafeAtomics.load(ptr, order)
+        _atomic_load(ptr, order)
     end
 end
 
@@ -11,7 +13,7 @@ end
     ptr = Atomix.pointer(ref)
     root = Atomix.gcroot(ref)
     GC.@preserve root begin
-        UnsafeAtomics.store!(ptr, v, order)
+        _atomic_store!(ptr, v, order)
     end
 end
 
@@ -21,7 +23,7 @@ end
     ptr = Atomix.pointer(ref)
     root = Atomix.gcroot(ref)
     GC.@preserve root begin
-        UnsafeAtomics.cas!(ptr, expected, desired, success_ordering, failure_ordering)
+        _atomic_cas!(ptr, expected, desired, success_ordering, failure_ordering)
     end
 end
 
@@ -30,8 +32,57 @@ end
     ptr = Atomix.pointer(ref)
     root = Atomix.gcroot(ref)
     GC.@preserve root begin
-        UnsafeAtomics.modify!(ptr, op, x, ord)
+        _atomic_modify!(ptr, op, x, ord)
     end
 end
 
+# Generic atomic operations - dispatch on type
+_atomic_load(ptr::Ptr{T}, order) where {T} = 
+    _with_int_repr(UnsafeAtomics.load, ptr, order)
+
+_atomic_store!(ptr::Ptr{T}, val::T, order) where {T} = 
+    _with_int_repr(UnsafeAtomics.store!, ptr, val, order)
+
+_atomic_cas!(ptr::Ptr{T}, expected::T, desired::T, success_order, failure_order) where {T} = 
+    _with_int_repr(UnsafeAtomics.cas!, ptr, expected, desired, success_order, failure_order)
+
+# Multiple dispatch for modify! - native atomics for non-Complex types
+function _atomic_modify!(ptr::Ptr{T}, op::OP, x::T, ord) where {T,OP}
+    UnsafeAtomics.modify!(ptr, op, x, ord)
+end
+
+# CAS loop fallback for Complex types (no native atomic modify!)
+function _atomic_modify!(ptr::Ptr{Complex{T}}, op::OP, x::Complex{T}, ord) where {T,OP}
+    old = _atomic_load(ptr, ord)
+    while true
+        new = op(old, x)
+        result = _atomic_cas!(ptr, old, new, ord, ord)
+        result.success && return (old => new)
+        old = result.old
+    end
+end
+
+# Helper: apply atomic operation with integer reinterpretation for Complex types
+function _with_int_repr(f, ptr::Ptr{Complex{T}}, args...) where {T}
+    IntType = _int_type_for_complex(T)
+    int_ptr = reinterpret(Ptr{IntType}, ptr)
+    result = f(int_ptr, _to_int.(IntType, args)...)
+    return _from_int(Complex{T}, result)
+end
+
+_with_int_repr(f, ptr::Ptr{T}, args...) where {T} = f(ptr, args...)
+
+# Integer type mapping for Complex types
+_int_type_for_complex(::Type{Float32}) = UInt64
+_int_type_for_complex(::Type{Float64}) = UInt128
+
+# Convert to/from integer representation
+_to_int(::Type{I}, x::Complex{T}) where {I,T} = reinterpret(I, x)
+_to_int(::Type{I}, x) where {I} = x
+
+_from_int(::Type{Complex{T}}, x::Integer) where {T} = reinterpret(Complex{T}, x)
+_from_int(::Type{Complex{T}}, result::NamedTuple) where {T} = 
+    (old = reinterpret(Complex{T}, result.old), success = result.success)
+_from_int(::Type{T}, x) where {T} = x
+
 Atomix.asstorable(ref, v) = convert(eltype(ref), v)

test/runtests.jl

@@ -133,6 +133,35 @@ end
 end
 
 
+@testset "test_complex" begin
+    # Test ComplexF64 basic operations
+    A = ones(ComplexF64, 3)
+    @test (@atomic A[1]) === ComplexF64(1, 0)
+    @atomic A[1] = ComplexF64(2, 3)
+    @test A[1] === ComplexF64(2, 3)
+    @test (@atomic A[1] += ComplexF64(1, 1)) === ComplexF64(3, 4)
+    @test A[1] === ComplexF64(3, 4)
+    @test (@atomicswap A[1] = ComplexF64(10, 10)) === ComplexF64(3, 4)
+    @test A[1] === ComplexF64(10, 10)
+    @test (@atomicreplace A[1] ComplexF64(10, 10) => ComplexF64(5, 5)) ==
+          (old = ComplexF64(10, 10), success = true)
+    @test (@atomicreplace A[1] ComplexF64(99, 99) => ComplexF64(1, 1)) ==
+          (old = ComplexF64(5, 5), success = false)
+    
+    # Test ComplexF32
+    B = ones(ComplexF32, 3)
+    @test (@atomic B[1]) === ComplexF32(1, 0)
+    @test (@atomic B[1] += ComplexF32(1, 1)) === ComplexF32(2, 1)
+    
+    # Test IndexableRef with Complex
+    ref = Atomix.IndexableRef(A, (1,))
+    @test Atomix.modify!(ref, +, ComplexF64(1, 1)) === (ComplexF64(5, 5) => ComplexF64(6, 6))
+    @test Atomix.swap!(ref, ComplexF64(7, 7)) == ComplexF64(6, 6)
+    @test Atomix.replace!(ref, ComplexF64(7, 7), ComplexF64(8, 8)) ===
+          (old = ComplexF64(7, 7), success = true)
+end
+
+
 # KernelAbstractions backend tests
 # Pass command-line argument to test suite to install the right backend, e.g.
 #   julia> import Pkg