better AbstractArray interface support

Author: Krastanov

CHANGELOG.md

@@ -1,5 +1,9 @@
 # News
 
+## v0.10.16 - 2025-04-21
+
+- `IGVector*` and `IGMatrix*` support the corresponding julia `AbstractArray` interfaces now.
+
 ## v0.10.15 - 2025-04-17
 
 - First release of IGraphs.jl closely wrapping the C library igraph v0.10.15

Project.toml

@@ -1,7 +1,7 @@
 name = "IGraphs"
 uuid = "647e90d3-2106-487c-adb4-c91fc07b96ea"
 authors = ["Stefan Krastanov <stefan@krastanov.org>"]
-version = "0.10.15"
+version = "0.10.16"
 
 [deps]
 CEnum = "fa961155-64e5-5f13-b03f-caf6b980ea82"

README.md

@@ -6,7 +6,7 @@ Most C types (like `igraph_vector_int_t`) are directly available in `IGraphs.Lib
 
 ### High-level Julian interfaces
 
-The Julian `IGraph` wrapper of the C `igraph_t` follows the `Graphs.jl` interface. Similarly the `IGVector*` which wrap `igraph_vector_*_t` follow the Julia array interface. Other Julian interfaces are not implemented yet.
+The Julian `IGraph` wrapper of the C `igraph_t` follows the `Graphs.jl` interface. Similarly the (`IGVector*` which wrap `igraph_vector_*_t`) and `IGMatrix*` (which wrap `igraph_matrix_*_t`) follow the Julia array interface. Other Julian interfaces are not implemented yet.
 
 By default, all of these types are initialized, but empty. If you want to create unsafe uninitialized types (i.e. wrappers around uninitialized C structs) use `T(;_uninitialized=Var(true))` -- but be careful, uninitialized structs can cause segfaults on garbage collection.
 
@@ -65,11 +65,11 @@ julia> IGraphs.allbindings |> length
 
 # how many functions are wrapped in a more Julian call interface and accessible through `LibIGraph.functionname`
 julia> IGraphs.translatedbindings |> length
-1181
+1243
 
 # the difference between those two numbers
 julia> IGraphs.untranslatedbindings |> length
-876
+814
 
 # the number of C types with Julian wrappers
 julia> IGraphs.wrappedtypes |> length

src/array_api.jl

@@ -1,44 +1,23 @@
-const vtypes = [
-    (:IGVectorInt, LibIGraph.igraph_integer_t, "_int"),
-    (:IGVectorFloat, LibIGraph.igraph_real_t, ""),
-    (:IGVectorComplex, Complex{LibIGraph.igraph_real_t}, "_complex"),
-    (:IGVectorBool, LibIGraph.igraph_bool_t, "_bool"),
-    (:IGVectorChar, Cchar, "_char")
-]
-
 for (VT, ET, suffix) in vtypes
     api = quote
         # iteration
-        Base.iterate(v::$VT) = length(v)==0 ? nothing : (v[1], 1)
-        Base.iterate(v::$VT, state) = length(v)==state ? nothing : (v[state+1], state+1)
-        # iteration (optional)
-        Base.eltype(v::$VT) = $ET
+        #Base.iterate(v::$VT) # default
+        #Base.iterate(v::$VT, state) # default
+        #Base.eltype(v::$VT) # default
         # indexing
-        Base.getindex(v::$VT, i::Number) = LibIGraph.$(Symbol(:vector,suffix,:_get))(v,i-1)::$ET
-        Base.getindex(v::$VT, I) = [S[i] for i in I]
+        Base.getindex(v::$VT, i::Number) = LibIGraph.$(Symbol(:vector,suffix,:_get))(v,i[1]-1)::$ET
         function Base.setindex!(v::$VT, x, i::Number)
             LibIGraph.$(Symbol(:vector,suffix,:_set))(v,i-1,x)
             x
         end
-        function Base.setindex!(v::$VT, X, I)
-            for (x,i) in zip(X,I)
-                v[i] = x
-            end
-            X
-        end
-        Base.firstindex(v::$VT) = 1
-        Base.lastindex(v::$VT) = length(v)
+        #Base.firstindex(v::$VT) # default
+        #Base.lastindex(v::$VT) # default
         # abstract arrays
-        Base.size(v::$VT) = (length(v), )
-        #Base.getindex(v::$VT, I::Vararg{Int, 1})
-        # abstract arrays (optional)
-        Base.length(v::$VT) = LibIGraph.$(Symbol(:vector,suffix,:_size))(v)
-
+        Base.size(v::$VT) = (LibIGraph.$(Symbol(:vector,suffix,:_size))(v), )
+        Base.IndexStyle(::Type{$VT}) = Base.IndexLinear()
         # other
         Base.push!(v::$VT, x) = LibIGraph.$(Symbol(:vector,suffix,:_push_back))(v, x)
-
         # constructor conversion
-        Vector(v::$VT) = v[begin:end]
         function $VT(v::Vector)
             vout = $VT(_uninitialized=Val(false))
             LibIGraph.$(Symbol(:vector,suffix,:_init))(vout, length(v))
@@ -47,6 +26,41 @@ for (VT, ET, suffix) in vtypes
             end
             return vout
         end
+        Vector(v::$VT) = v[begin:end]::Vector{$ET}
+    end
+    eval(api)
+end
+
+
+for (MT, ET, suffix) in mtypes
+    api = quote
+        # iteration
+        #Base.iterate(m::$MT) # default
+        #Base.iterate(m::$MT, state) # default
+        #Base.eltype(m::$MT) # default
+        # indexing
+        function Base.getindex(m::$MT, i::Number, j::Number)
+            LibIGraph.$(Symbol(:matrix,suffix,:_get))(m,(i-1),(j-1))::$ET
+        end
+        function Base.setindex!(m::$MT, x, i::Number, j::Number)
+            LibIGraph.$(Symbol(:matrix,suffix,:_set))(m,i-1,j-1,x)
+            x
+        end
+        #Base.firstindex(m::$MT) # default
+        #Base.lastindex(m::$MT) # default
+        # abstract arrays
+        Base.size(m::$MT) = (LibIGraph.$(Symbol(:matrix,suffix,:_nrow))(m), LibIGraph.$(Symbol(:matrix,suffix,:_ncol))(m))
+        Base.IndexStyle(::Type{$MT}) = Base.IndexCartesian()
+        # constructor conversion
+        function $MT(m::Matrix)
+            mout = $MT(_uninitialized=Val(false))
+            LibIGraph.$(Symbol(:matrix,suffix,:_init))(mout, size(m,1), size(m,2))
+            for (i,x) in enumerate(m)
+                mout[i]=x
+            end
+            return mout
+        end
+        Matrix(m::$MT) = m[begin:end, begin:end]::Matrix{$ET}
     end
     eval(api)
 end

src/types.jl

@@ -20,10 +20,31 @@ function initializer(ctype)
     end
 end
 
+const vtypes = [
+    (:IGVectorInt, LibIGraph.igraph_integer_t, "_int"),
+    (:IGVectorFloat, LibIGraph.igraph_real_t, ""),
+    (:IGVectorComplex, Complex{LibIGraph.igraph_real_t}, "_complex"),
+    (:IGVectorBool, LibIGraph.igraph_bool_t, "_bool"),
+    (:IGVectorChar, Cchar, "_char")
+]
+const mtypes = [
+    (:IGMatrixInt, LibIGraph.igraph_integer_t, "_int"),
+    (:IGMatrixFloat, LibIGraph.igraph_real_t, ""),
+    (:IGMatrixComplex, Complex{LibIGraph.igraph_real_t}, "_complex"),
+    (:IGMatrixBool, LibIGraph.igraph_bool_t, "_bool"),
+    (:IGMatrixChar, Cchar, "_char")
+]
+
+const parent_types = Dict(
+    [jtype=>:(AbstractVector{$eltype}) for (jtype, eltype, _) in vtypes]...,
+    [jtype=>:(AbstractMatrix{$eltype}) for (jtype, eltype, _) in mtypes]...
+)
+
 for (ptr_ctype, jtype) in pairs(wrappedtypes)
     ctype = ptr_ctype.args[2]
+    ptype = get(parent_types, jtype, Any)
     expr = quote
-        struct $jtype
+        struct $jtype <: $ptype
             objref::Ref{LibIGraph.$ctype}
         end
         function $jtype(;_uninitialized::Val{B}=Val(false)) where {B}
@@ -38,6 +59,5 @@ for (ptr_ctype, jtype) in pairs(wrappedtypes)
             return $jtype(cinstance)
         end
     end
-    #println(expr)
     eval(expr)
 end

src/wrapccall.jl

@@ -92,7 +92,7 @@ function modifymodule(mod)
 end
 
 const nativetypes = Set([ # cenums are elsewhere, because we are dynamically gathering them (and because we want to exclude them from nativepointertypes)
-    :igraph_integer_t, :igraph_bool_t, :igraph_real_t, :igraph_complex_t
+    :igraph_integer_t, :igraph_bool_t, :igraph_real_t, :igraph_complex_t, :Cchar
 ])
 const nativepointertypes = Set([:(Ptr{$t}) for t in nativetypes])
 const wrappedtypes = Dict(
@@ -152,7 +152,7 @@ const returntypes = Dict(
     :igraph_real_t => :Float64,
     :igraph_complex_t => :ComplexF64,
     :Cint => :Int,
-    :Cchar => :Char,
+    :Cchar => :Cchar,
 )
 allreturntypes = union(Set([:igraph_error_t,:Cvoid]), keys(returntypes))
 

test/Project.toml

@@ -1,9 +1,11 @@
 [deps]
 Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
+BaseInterfaces = "0b829d9d-522b-4e79-acc1-14feb8e2795d"
 DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
 IGraphs = "647e90d3-2106-487c-adb4-c91fc07b96ea"
+Interfaces = "85a1e053-f937-4924-92a5-1367d23b7b87"
 JET = "c3a54625-cd67-489e-a8e7-0a5a0ff4e31b"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"

test/test_interfaces.jl

@@ -0,0 +1,34 @@
+@testitem "Interface tests" begin
+
+import Interfaces, BaseInterfaces
+using IGraphs
+using Test
+
+for (VTs, ET, _) in IGraphs.vtypes
+    VT = eval(VTs)
+    Interfaces.test(BaseInterfaces.IterationInterface, VT, [VT(rand(ET,10))])
+    Interfaces.test(BaseInterfaces.IterationInterface{(:indexing)}, VT, [VT(rand(ET,10))])
+
+    Interfaces.test(BaseInterfaces.ArrayInterface, VT, [VT(rand(ET,10))])
+    Interfaces.test(BaseInterfaces.ArrayInterface{(:logical,:setindex!)}, VT, [VT(rand(ET,10))])
+
+    v = VT(rand(ET,10))
+    @test Vector(VT(Vector(v))) == Vector(v)
+    @test VT(Vector(v)) == v
+end
+
+for (MTs, ET, _) in IGraphs.mtypes
+    MT = eval(MTs)
+    Interfaces.test(BaseInterfaces.IterationInterface, MT, [MT(rand(ET,10,5))])
+    Interfaces.test(BaseInterfaces.IterationInterface{(:indexing)}, MT, [MT(rand(ET,10,5))])
+
+
+    Interfaces.test(BaseInterfaces.ArrayInterface, MT, [MT(rand(ET,10,5))])
+    Interfaces.test(BaseInterfaces.ArrayInterface{(:logical,:setindex!)}, MT, [MT(rand(ET,10,5))])
+
+    m = MT(rand(ET,10,5))
+    @test Matrix(MT(Matrix(m))) == Matrix(m)
+    @test MT(Matrix(m)) == m
+end
+
+end