From be27d08d155540b339f07a64f80fecab75c2f715 Mon Sep 17 00:00:00 2001 From: Benjamin Lorenz Date: Thu, 7 Mar 2024 16:16:35 +0100 Subject: [PATCH 1/9] add decoration and various helpers regarding pairs, bigobjecttype,... --- src/arrays.jl | 8 +++++++- src/convert.jl | 11 ++++++++++- src/perlobj.jl | 5 +++++ src/polymake/julia.rules | 25 +++++++++++++++++++++++++ src/setup_types.jl | 1 + src/std/pairs.jl | 3 +++ 6 files changed, 51 insertions(+), 2 deletions(-) diff --git a/src/arrays.jl b/src/arrays.jl index a4b2a554..c1fbc75c 100644 --- a/src/arrays.jl +++ b/src/arrays.jl @@ -3,10 +3,13 @@ const Array_suppT = Union{Int64, CxxWrap.CxxLong, OscarNumber, String, CxxWrap.StdString, StdPair{CxxWrap.CxxLong,CxxWrap.CxxLong}, + StdPair{Set{CxxWrap.CxxLong},CxxWrap.CxxLong}, + StdPair{Set{Int64},Int64}, StdList{StdPair{CxxWrap.CxxLong,CxxWrap.CxxLong}}, Set{Int64}, Set{CxxWrap.CxxLong}, Array{Int64}, Array{CxxWrap.CxxLong}, - Array{Integer}, Array{Rational}, Matrix{Integer}} + Array{Integer}, Array{Rational}, Matrix{Integer}, + BasicDecoration} function Array{T}(::UndefInitializer, n::Base.Integer) where T <: Array_suppT @@ -53,3 +56,6 @@ function Base.append!(A::Array{T}, itr) where T end return A end + +Array(nm::NodeMap{Dir,T}) where {Dir, T} = + Polymake.call_function(:common, :nodemap_as_array, nm)::Array{T} diff --git a/src/convert.jl b/src/convert.jl index eb13b1e8..700bc427 100644 --- a/src/convert.jl +++ b/src/convert.jl @@ -22,6 +22,8 @@ convert(::Type{Set{T}}, itr::AbstractArray) where T = Set{T}(itr) convert(::Type{<:Polynomial{C,E}}, itr::Polynomial{C,E}) where {C,E} = itr convert(::Type{<:Polynomial{C1,E1}}, itr::Polynomial{C2,E2}) where {C1,C2,E1,E2} = Polynomial{C1,E1}(itr) +convert(::Type{BasicDecoration}, p::StdPair) = BasicDecoration(first(p),last(p)) + ########### Converting to objects polymake understands ############### struct PolymakeType end @@ -31,6 +33,9 @@ convert(::Type{PolymakeType}, v::Visual) = v.obj convert(::Type{PolymakeType}, ::Nothing) = call_function(PropertyValue, :common, :get_undef) convert(::Type{OptionSet}, dict) = OptionSet(dict) +as_perl_array(t::SmallObject) = Polymake.call_function(PropertyValue, :common, :as_perl_array, t) +as_perl_array_of_array(t::SmallObject) = Polymake.call_function(PropertyValue, :common, :as_perl_array_of_array, t) + ############### Adjusting type parameter to CxxWrap ################## to_cxx_type(::Type{T}) where T = T @@ -68,7 +73,8 @@ Int64(r::Rational) = Int64(new_int_from_rational(r)) convert_to_pm_type(T::Type) = throw(ArgumentError("Unrecognized argument type: $T.\nYou need to convert to polymake compatible type first.")) convert_to_pm_type(::Type{T}) where T <: Union{Int64, Float64} = T -convert_to_pm_type(::Type{T}) where T <: Union{BigObject, PropertyValue, OptionSet, TropicalNumber} = T +convert_to_pm_type(::Type{T}) where T <: Union{BigObject, BigObjectType, PropertyValue, OptionSet} = T +convert_to_pm_type(::Type{T}) where T <: TropicalNumber = T convert_to_pm_type(::Nothing) = Nothing convert_to_pm_type(::Type{Int32}) = Int64 @@ -77,6 +83,7 @@ convert_to_pm_type(::Type{<:AbstractString}) = String convert_to_pm_type(::Type{<:Union{Base.Integer, Integer}}) = Integer convert_to_pm_type(::Type{<:Union{Base.Rational, Rational}}) = Rational convert_to_pm_type(::Type{<:OscarNumber}) = OscarNumber +convert_to_pm_type(::Type{<:NodeMap}) = NodeMap convert_to_pm_type(::Type{<:Union{AbstractVector, Vector}}) = Vector convert_to_pm_type(::Type{<:Union{AbstractMatrix, Matrix}}) = Matrix convert_to_pm_type(::Type{<:Union{AbstractSparseMatrix, SparseMatrix}}) = SparseMatrix @@ -84,7 +91,9 @@ convert_to_pm_type(::Type{<:AbstractSparseMatrix{<:Union{Bool, CxxWrap.CxxBool}} convert_to_pm_type(::Type{<:Union{AbstractSparseVector, SparseVector}}) = SparseVector convert_to_pm_type(::Type{<:Array}) = Array convert_to_pm_type(::Type{<:Union{Pair, <:StdPair}}) = StdPair +convert_to_pm_type(::Type{<:Tuple{A,B}}) where {A,B} = StdPair{convert_to_pm_type(A),convert_to_pm_type(B)} convert_to_pm_type(::Type{<:Polynomial{<:Rational, <:Union{Int64, CxxWrap.CxxLong}}}) = Polynomial{Rational, CxxWrap.CxxLong} +convert_to_pm_type(::Type{<:AbstractVector{T}}) where T<:Tuple = Polymake.Array{convert_to_pm_type(T)} # Graph, EdgeMap, NodeMap const DirType = Union{Directed, Undirected} diff --git a/src/perlobj.jl b/src/perlobj.jl index e4d58cae..6204bc56 100644 --- a/src/perlobj.jl +++ b/src/perlobj.jl @@ -31,6 +31,11 @@ function bigobject_qualifiedname(obj::BigObject) return String(res) end +function bigobject_prop_type(obj::BigObjectType, path::String) + res = call_function(:common, :bigobject_prop_type, obj, path) + return String(res) +end + # polymake can either just give a reference or do a full copy. # but even that full copy will contain references to the same data # objects in memory, but this is fine since most of them are immutable anyway. diff --git a/src/polymake/julia.rules b/src/polymake/julia.rules index dc34b380..f2e6af29 100644 --- a/src/polymake/julia.rules +++ b/src/polymake/julia.rules @@ -103,6 +103,31 @@ function get_bigobject_qualified_name($) { return $_[0]->type->qualified_name; } +function nodemap_as_array(NodeMap) { + my ($nm) = @_; + return new Array($nm); +} + +function as_perl_array($) { + return [@{$_[0]}]; +} + +function as_perl_array_of_array($) { + return [map {[@$_]} @{$_[0]}]; +} + +function bigobject_prop_type($$) { + my ($bot, $path) = @_; + while (my ($parent, $elem) = $path =~ /^([^\.]*)\.(.*)$/) { + my $prop = $bot->lookup_property($parent); + $bot = $prop->subobject_type(); + return "" unless defined($bot); + $path = $elem; + } + my $t = $bot->lookup_property($path)->type; + return instanceof Core::BigObjectType($t) ? $t->pure_type->name : $t->name; +} + package Polymake::User; function get_shell_scalar($) { diff --git a/src/setup_types.jl b/src/setup_types.jl index 9bdc9522..d8f8738c 100644 --- a/src/setup_types.jl +++ b/src/setup_types.jl @@ -19,6 +19,7 @@ const SmallObject = Union{ OscarNumber, EdgeMap, NodeMap, + BasicDecoration, } const VecOrMat_eltypes = Union{Int64, Integer, Rational, Float64, QuadraticExtension{Rational}, OscarNumber, CxxWrap.CxxLong, Polynomial{Rational, CxxWrap.CxxLong}, TropicalNumber{Polymake.Max, Polymake.Rational}, TropicalNumber{Polymake.Min, Polymake.Rational}} diff --git a/src/std/pairs.jl b/src/std/pairs.jl index 30af3d6d..848812ad 100644 --- a/src/std/pairs.jl +++ b/src/std/pairs.jl @@ -1,5 +1,8 @@ StdPair(a::T,b::T) where T = StdPair{T,T}(a,b) StdPair(p::Pair) = StdPair(first(p), last(p)) +StdPair(t::Tuple{A,B}) where {A,B} = StdPair{A,B}(first(t),last(t)) + +Base.convert(::Type{<:StdPair{A,B}}, t::Tuple{C,D}) where {A,B,C,D} = StdPair{A,B}(A(first(t)), B(last(t))) Base.Pair(p::StdPair) = Pair(first(p), last(p)) Base.Pair{S, T}(p::StdPair) where {S, T} = Pair{S, T}(first(p), last(p)) From af9a035d8e5cc09d294bb4354fb54738487347dc Mon Sep 17 00:00:00 2001 From: Benjamin Lorenz Date: Thu, 28 Mar 2024 14:27:11 +0100 Subject: [PATCH 2/9] version bump --- Project.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Project.toml b/Project.toml index fdfaa8e4..2c4af578 100644 --- a/Project.toml +++ b/Project.toml @@ -1,7 +1,7 @@ name = "Polymake" uuid = "d720cf60-89b5-51f5-aff5-213f193123e7" repo = "https://github.com/oscar-system/Polymake.jl.git" -version = "0.11.17" +version = "0.11.18" [deps] AbstractAlgebra = "c3fe647b-3220-5bb0-a1ea-a7954cac585d" From 8261ae69a12f1d65ce00dd48d26dd80abc2d94cd Mon Sep 17 00:00:00 2001 From: Benjamin Lorenz Date: Fri, 24 May 2024 16:48:54 +0200 Subject: [PATCH 3/9] deref array access elements --- src/arrays.jl | 2 +- src/map.jl | 2 +- src/matrices.jl | 2 +- src/sparsematrix.jl | 2 +- src/sparsevector.jl | 2 +- src/vectors.jl | 2 +- test/vectors.jl | 4 ++-- 7 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/arrays.jl b/src/arrays.jl index c1fbc75c..49eb9695 100644 --- a/src/arrays.jl +++ b/src/arrays.jl @@ -38,7 +38,7 @@ Base.eltype(v::Array{T}) where T = to_jl_type(T) Base.@propagate_inbounds function getindex(A::Array{T}, n::Base.Integer) where T @boundscheck checkbounds(A, n) - return convert(to_jl_type(T), _getindex(A, convert(Int64, n))) + return convert(to_jl_type(T), _getindex(A, convert(Int64, n))[]) end Base.@propagate_inbounds function Base.setindex!(A::Array{T}, val, n::Base.Integer) where T diff --git a/src/map.jl b/src/map.jl index ee3389cb..9e2807a8 100644 --- a/src/map.jl +++ b/src/map.jl @@ -3,7 +3,7 @@ function Map{String,String}() end function Base.getindex(M::Map{TK, TV}, key) where {TK, TV} - return convert(to_jl_type(TV), _getindex(M, convert(to_cxx_type(TK), key))) + return convert(to_jl_type(TV), _getindex(M, convert(to_cxx_type(TK), key))[]) end function Base.setindex!(M::Map{TK, TV}, val, key) where {TK, TV} diff --git a/src/matrices.jl b/src/matrices.jl index ce7fa873..a85b0a1e 100644 --- a/src/matrices.jl +++ b/src/matrices.jl @@ -33,7 +33,7 @@ end Base.@propagate_inbounds function Base.getindex(M::Matrix , i::Base.Integer, j::Base.Integer) @boundscheck checkbounds(M, i, j) - return _getindex(M, convert(Int64, i), convert(Int64, j)) + return _getindex(M, convert(Int64, i), convert(Int64, j))[] end Base.@propagate_inbounds function Base.setindex!(M::Matrix{T}, val, i::Base.Integer, j::Base.Integer) where T diff --git a/src/sparsematrix.jl b/src/sparsematrix.jl index 75e37aea..c1872a41 100644 --- a/src/sparsematrix.jl +++ b/src/sparsematrix.jl @@ -53,7 +53,7 @@ end Base.@propagate_inbounds function Base.getindex(M::SparseMatrix , i::Base.Integer, j::Base.Integer) @boundscheck checkbounds(M, i, j) - return _getindex(M, convert(Int64, i), convert(Int64, j)) + return _getindex(M, convert(Int64, i), convert(Int64, j))[] end Base.@propagate_inbounds function Base.setindex!(M::SparseMatrix{T}, val, i::Base.Integer, j::Base.Integer) where T diff --git a/src/sparsevector.jl b/src/sparsevector.jl index 88db5448..bd0d61ee 100644 --- a/src/sparsevector.jl +++ b/src/sparsevector.jl @@ -33,7 +33,7 @@ Base.eltype(m::SparseVector{T}) where T = to_jl_type(T) Base.@propagate_inbounds function Base.getindex(V::SparseVector, n::Base.Integer) @boundscheck checkbounds(V, n) - return _getindex(V, convert(Int64, n)) + return _getindex(V, convert(Int64, n))[] end Base.@propagate_inbounds function Base.setindex!(V::SparseVector{T}, val, n::Base.Integer) where T diff --git a/src/vectors.jl b/src/vectors.jl index cf6fa27e..148f5f3e 100644 --- a/src/vectors.jl +++ b/src/vectors.jl @@ -21,7 +21,7 @@ Base.eltype(v::Vector{T}) where T = to_jl_type(T) Base.@propagate_inbounds function Base.getindex(V::Vector, n::Base.Integer) @boundscheck checkbounds(V, n) - return _getindex(V, convert(Int64, n)) + return _getindex(V, convert(Int64, n))[] end Base.@propagate_inbounds function Base.setindex!(V::Vector{T}, val, n::Base.Integer) where T diff --git a/test/vectors.jl b/test/vectors.jl index 04cad51e..a1f7a30d 100644 --- a/test/vectors.jl +++ b/test/vectors.jl @@ -131,7 +131,7 @@ using Polymake.CxxWrap for T in [IntTypes; Polymake.Integer] V = Polymake.Vector{Polymake.Integer}(jl_v) # local copy @test setindex!(V, T(5), 1) isa Polymake.Vector{Polymake.Integer} - @test V[T(1)] isa Polymake.Polymake.IntegerAllocated + @test V[T(1)] isa Polymake.Polymake.Integer @test V[T(1)] == 5 # testing the return value of brackets operator @test V[2] = T(10) isa T @@ -154,7 +154,7 @@ using Polymake.CxxWrap for T in [IntTypes; Polymake.Integer] @test setindex!(V, T(5)//T(3), 1) isa Polymake.Vector{Polymake.Rational} - @test V[T(1)] isa Polymake.Polymake.RationalAllocated + @test V[T(1)] isa Polymake.Polymake.Rational @test V[T(1)] == 5//3 # testing the return value of brackets operator if T != Polymake.Integer From 7cdab121e9a636033c749ab73525e1de7422fae2 Mon Sep 17 00:00:00 2001 From: Benjamin Lorenz Date: Tue, 28 May 2024 12:40:24 +0200 Subject: [PATCH 4/9] Revert "deref array access elements" revert returning refs in libpolymake_julia due to comparison issues This reverts commit 8261ae69a12f1d65ce00dd48d26dd80abc2d94cd. --- src/arrays.jl | 2 +- src/map.jl | 2 +- src/matrices.jl | 2 +- src/sparsematrix.jl | 2 +- src/sparsevector.jl | 2 +- src/vectors.jl | 2 +- test/vectors.jl | 4 ++-- 7 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/arrays.jl b/src/arrays.jl index 49eb9695..c1fbc75c 100644 --- a/src/arrays.jl +++ b/src/arrays.jl @@ -38,7 +38,7 @@ Base.eltype(v::Array{T}) where T = to_jl_type(T) Base.@propagate_inbounds function getindex(A::Array{T}, n::Base.Integer) where T @boundscheck checkbounds(A, n) - return convert(to_jl_type(T), _getindex(A, convert(Int64, n))[]) + return convert(to_jl_type(T), _getindex(A, convert(Int64, n))) end Base.@propagate_inbounds function Base.setindex!(A::Array{T}, val, n::Base.Integer) where T diff --git a/src/map.jl b/src/map.jl index 9e2807a8..ee3389cb 100644 --- a/src/map.jl +++ b/src/map.jl @@ -3,7 +3,7 @@ function Map{String,String}() end function Base.getindex(M::Map{TK, TV}, key) where {TK, TV} - return convert(to_jl_type(TV), _getindex(M, convert(to_cxx_type(TK), key))[]) + return convert(to_jl_type(TV), _getindex(M, convert(to_cxx_type(TK), key))) end function Base.setindex!(M::Map{TK, TV}, val, key) where {TK, TV} diff --git a/src/matrices.jl b/src/matrices.jl index a85b0a1e..ce7fa873 100644 --- a/src/matrices.jl +++ b/src/matrices.jl @@ -33,7 +33,7 @@ end Base.@propagate_inbounds function Base.getindex(M::Matrix , i::Base.Integer, j::Base.Integer) @boundscheck checkbounds(M, i, j) - return _getindex(M, convert(Int64, i), convert(Int64, j))[] + return _getindex(M, convert(Int64, i), convert(Int64, j)) end Base.@propagate_inbounds function Base.setindex!(M::Matrix{T}, val, i::Base.Integer, j::Base.Integer) where T diff --git a/src/sparsematrix.jl b/src/sparsematrix.jl index c1872a41..75e37aea 100644 --- a/src/sparsematrix.jl +++ b/src/sparsematrix.jl @@ -53,7 +53,7 @@ end Base.@propagate_inbounds function Base.getindex(M::SparseMatrix , i::Base.Integer, j::Base.Integer) @boundscheck checkbounds(M, i, j) - return _getindex(M, convert(Int64, i), convert(Int64, j))[] + return _getindex(M, convert(Int64, i), convert(Int64, j)) end Base.@propagate_inbounds function Base.setindex!(M::SparseMatrix{T}, val, i::Base.Integer, j::Base.Integer) where T diff --git a/src/sparsevector.jl b/src/sparsevector.jl index bd0d61ee..88db5448 100644 --- a/src/sparsevector.jl +++ b/src/sparsevector.jl @@ -33,7 +33,7 @@ Base.eltype(m::SparseVector{T}) where T = to_jl_type(T) Base.@propagate_inbounds function Base.getindex(V::SparseVector, n::Base.Integer) @boundscheck checkbounds(V, n) - return _getindex(V, convert(Int64, n))[] + return _getindex(V, convert(Int64, n)) end Base.@propagate_inbounds function Base.setindex!(V::SparseVector{T}, val, n::Base.Integer) where T diff --git a/src/vectors.jl b/src/vectors.jl index 148f5f3e..cf6fa27e 100644 --- a/src/vectors.jl +++ b/src/vectors.jl @@ -21,7 +21,7 @@ Base.eltype(v::Vector{T}) where T = to_jl_type(T) Base.@propagate_inbounds function Base.getindex(V::Vector, n::Base.Integer) @boundscheck checkbounds(V, n) - return _getindex(V, convert(Int64, n))[] + return _getindex(V, convert(Int64, n)) end Base.@propagate_inbounds function Base.setindex!(V::Vector{T}, val, n::Base.Integer) where T diff --git a/test/vectors.jl b/test/vectors.jl index a1f7a30d..04cad51e 100644 --- a/test/vectors.jl +++ b/test/vectors.jl @@ -131,7 +131,7 @@ using Polymake.CxxWrap for T in [IntTypes; Polymake.Integer] V = Polymake.Vector{Polymake.Integer}(jl_v) # local copy @test setindex!(V, T(5), 1) isa Polymake.Vector{Polymake.Integer} - @test V[T(1)] isa Polymake.Polymake.Integer + @test V[T(1)] isa Polymake.Polymake.IntegerAllocated @test V[T(1)] == 5 # testing the return value of brackets operator @test V[2] = T(10) isa T @@ -154,7 +154,7 @@ using Polymake.CxxWrap for T in [IntTypes; Polymake.Integer] @test setindex!(V, T(5)//T(3), 1) isa Polymake.Vector{Polymake.Rational} - @test V[T(1)] isa Polymake.Polymake.Rational + @test V[T(1)] isa Polymake.Polymake.RationalAllocated @test V[T(1)] == 5//3 # testing the return value of brackets operator if T != Polymake.Integer From 6b7d2267d3dacbebf8d8d4556e723b04516f99b1 Mon Sep 17 00:00:00 2001 From: Benjamin Lorenz Date: Fri, 31 May 2024 12:23:50 +0200 Subject: [PATCH 5/9] require new libpolymake --- src/Polymake.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Polymake.jl b/src/Polymake.jl index b6d521ce..8097b203 100644 --- a/src/Polymake.jl +++ b/src/Polymake.jl @@ -42,7 +42,7 @@ import TOPCOM_jll using libpolymake_julia_jll using polymake_oscarnumber_jll -const jlpolymake_version_range = (v"0.11.0", v"0.12") +const jlpolymake_version_range = (v"0.11.6", v"0.12") struct PolymakeError <: Exception msg From ee6c1684bac58b4346d0a9a80e0359e637f55203 Mon Sep 17 00:00:00 2001 From: Benjamin Lorenz Date: Fri, 31 May 2024 13:25:05 +0200 Subject: [PATCH 6/9] define eltype for type only --- src/arrays.jl | 2 +- src/incidencematrix.jl | 2 +- src/map.jl | 2 +- src/matrices.jl | 2 +- src/polydb.jl | 4 ++-- src/sets.jl | 2 +- src/sparsematrix.jl | 2 +- src/sparsevector.jl | 4 ++-- src/std/lists.jl | 4 ++-- src/std/pairs.jl | 2 +- src/vectors.jl | 2 +- 11 files changed, 14 insertions(+), 14 deletions(-) diff --git a/src/arrays.jl b/src/arrays.jl index c1fbc75c..efcac9e5 100644 --- a/src/arrays.jl +++ b/src/arrays.jl @@ -34,7 +34,7 @@ Array(vec::AbstractVector) = Array{convert_to_pm_type(eltype(vec))}(vec) Base.size(a::Array) = (length(a),) -Base.eltype(v::Array{T}) where T = to_jl_type(T) +Base.eltype(v::Type{<:Array{T}}) where T = to_jl_type(T) Base.@propagate_inbounds function getindex(A::Array{T}, n::Base.Integer) where T @boundscheck checkbounds(A, n) diff --git a/src/incidencematrix.jl b/src/incidencematrix.jl index 9d9f5b8f..5ca960ed 100644 --- a/src/incidencematrix.jl +++ b/src/incidencematrix.jl @@ -73,7 +73,7 @@ IncidenceMatrix(x...) = IncidenceMatrix{NonSymmetric}(x...) Base.size(m::IncidenceMatrix) = (nrows(m), ncols(m)) -Base.eltype(::IncidenceMatrix) = Bool +Base.eltype(::Type{<:IncidenceMatrix}) = Bool Base.@propagate_inbounds function Base.getindex(M::IncidenceMatrix , i::Base.Integer, j::Base.Integer) @boundscheck checkbounds(M, i, j) diff --git a/src/map.jl b/src/map.jl index ee3389cb..53e25e6f 100644 --- a/src/map.jl +++ b/src/map.jl @@ -25,7 +25,7 @@ end # Iterator -Base.eltype(M::Map{S,T}) where {S,T} = Pair{to_jl_type(S), to_jl_type(T)} +Base.eltype(::Type{<:Map{S,T}}) where {S,T} = Pair{to_jl_type(S), to_jl_type(T)} function Base.iterate(M::Map{S,T}) where {S,T} isempty(M) && return nothing diff --git a/src/matrices.jl b/src/matrices.jl index ce7fa873..18d359c3 100644 --- a/src/matrices.jl +++ b/src/matrices.jl @@ -18,7 +18,7 @@ Matrix(mat::AbstractMatrix{T}) where T = Base.size(m::Matrix) = (nrows(m), ncols(m)) -Base.eltype(v::Matrix{T}) where T = to_jl_type(T) +Base.eltype(v::Type{<:Matrix{T}}) where T = to_jl_type(T) function Base.vcat(M::Matrix...) all(==(ncols(first(M))), ncols.(M)) || throw(DimensionMismatch("matrices must have the same number of columns")) diff --git a/src/polydb.jl b/src/polydb.jl index e1ca1e89..b348c578 100644 --- a/src/polydb.jl +++ b/src/polydb.jl @@ -246,9 +246,9 @@ end # Iterator Base.IteratorSize(::Type{<:Cursor}) = Base.SizeUnknown() -Base.eltype(::Cursor{T}) where T = T +Base.eltype(::Type{Cursor{T}}) where T = T Base.IteratorSize(::Type{<:Collection}) = Base.SizeUnknown() -Base.eltype(::Collection{T}) where T = T +Base.eltype(::Type{Collection{T}}) where T = T # default iteration functions returning `Polymake.BigObject`s function Base.iterate(cursor::Polymake.Polydb.Cursor{Polymake.BigObject}, state::Nothing=nothing) diff --git a/src/sets.jl b/src/sets.jl index 31e5b272..429d8c4d 100644 --- a/src/sets.jl +++ b/src/sets.jl @@ -27,7 +27,7 @@ for (jlF, pmF) in ( end end -Base.eltype(::Set{T}) where T = to_jl_type(T) +Base.eltype(::Type{<:Set{T}}) where T = to_jl_type(T) ### convert FROM polymake object diff --git a/src/sparsematrix.jl b/src/sparsematrix.jl index 75e37aea..270bbcf4 100644 --- a/src/sparsematrix.jl +++ b/src/sparsematrix.jl @@ -38,7 +38,7 @@ SparseMatrix(mat::AbstractMatrix{T}) where T = Base.size(m::SparseMatrix) = (nrows(m), ncols(m)) -Base.eltype(m::SparseMatrix{T}) where T = to_jl_type(T) +Base.eltype(::Type{<:SparseMatrix{T}}) where T = to_jl_type(T) function Base.vcat(M::Union{SparseMatrix,Matrix}...) all(==(ncols(first(M))), ncols.(M)) || throw(DimensionMismatch("matrices must have the same number of columns")) diff --git a/src/sparsevector.jl b/src/sparsevector.jl index 88db5448..e4199e4f 100644 --- a/src/sparsevector.jl +++ b/src/sparsevector.jl @@ -29,7 +29,7 @@ SparseVector(vec::AbstractVector{T}) where T = Base.size(v::SparseVector) = (length(v),) -Base.eltype(m::SparseVector{T}) where T = to_jl_type(T) +Base.eltype(::Type{<:SparseVector{T}}) where T = to_jl_type(T) Base.@propagate_inbounds function Base.getindex(V::SparseVector, n::Base.Integer) @boundscheck checkbounds(V, n) @@ -83,7 +83,7 @@ end spzeros(::Type{Bool}, n::Base.Integer) = SparseVectorBool(n, Polymake.Set{to_cxx_type(Int64)}()) Base.size(v::SparseVector{Bool}) = (v.l,) -Base.eltype(::SparseVector{Bool}) = Bool +Base.eltype(::Type{<:SparseVector{Bool}}) = Bool Base.@propagate_inbounds function Base.getindex(V::SparseVector{Bool}, n::Base.Integer) @boundscheck checkbounds(V, n) diff --git a/src/std/lists.jl b/src/std/lists.jl index cbfc0ade..fdd8eccc 100644 --- a/src/std/lists.jl +++ b/src/std/lists.jl @@ -1,8 +1,8 @@ -Base.eltype(::StdList{StdPair{S, T}}) where {S, T} = Pair{S,T} +Base.eltype(::Type{<:StdList{<:StdPair{S, T}}}) where {S, T} = Pair{S,T} Base.push!(L::StdList{<:StdPair}, a::Pair) = push!(L, StdPair(a)) -Base.eltype(::StdList{T}) where T = T +Base.eltype(::Type{<:StdList{T}}) where T = T function Base.iterate(L::StdList) isempty(L) && return nothing diff --git a/src/std/pairs.jl b/src/std/pairs.jl index 848812ad..984ca6e1 100644 --- a/src/std/pairs.jl +++ b/src/std/pairs.jl @@ -8,7 +8,7 @@ Base.Pair(p::StdPair) = Pair(first(p), last(p)) Base.Pair{S, T}(p::StdPair) where {S, T} = Pair{S, T}(first(p), last(p)) Base.length(p::StdPair) = 2 -Base.eltype(p::StdPair{S,T}) where {S, T} = Union{S,T} +Base.eltype(::Type{<:StdPair{S,T}}) where {S, T} = Union{S,T} Base.iterate(p::StdPair) = first(p), Val{:first}() Base.iterate(p::StdPair, ::Val{:first}) = last(p), Val{:last}() Base.iterate(p::StdPair, ::Val{:last}) = nothing diff --git a/src/vectors.jl b/src/vectors.jl index cf6fa27e..40519f05 100644 --- a/src/vectors.jl +++ b/src/vectors.jl @@ -17,7 +17,7 @@ Vector(vec::AbstractVector{T}) where T = Vector{promote_to_pm_type(Vector, T)}(v Base.size(v::Vector) = (length(v),) -Base.eltype(v::Vector{T}) where T = to_jl_type(T) +Base.eltype(v::Type{<:Vector{T}}) where T = to_jl_type(T) Base.@propagate_inbounds function Base.getindex(V::Vector, n::Base.Integer) @boundscheck checkbounds(V, n) From 05aa13a0cc084855285c9e8bcdb9fc7f63a5c4dc Mon Sep 17 00:00:00 2001 From: Benjamin Lorenz Date: Fri, 31 May 2024 14:30:51 +0200 Subject: [PATCH 7/9] ceil,floor,is_rational --- src/oscarnumber.jl | 52 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 51 insertions(+), 1 deletion(-) diff --git a/src/oscarnumber.jl b/src/oscarnumber.jl index de2bf311..825328ad 100644 --- a/src/oscarnumber.jl +++ b/src/oscarnumber.jl @@ -64,8 +64,11 @@ mutable struct oscar_number_dispatch_helper hash::Ptr{Cvoid} to_rational::Ptr{Cvoid} to_float::Ptr{Cvoid} + is_rational::Ptr{Cvoid} + to_ceil::Ptr{Cvoid} + to_floor::Ptr{Cvoid} end -oscar_number_dispatch_helper() = oscar_number_dispatch_helper(-1, repeat([C_NULL], 22)...) +oscar_number_dispatch_helper() = oscar_number_dispatch_helper(-1, repeat([C_NULL], 25)...) const _on_gc_refs = IdDict() @@ -150,6 +153,14 @@ end @cfunction(_on_to_float, Float64, (Ref{ArgT},)) end +function _fieldelem_to_ceil(e::T) where T + return BigInt(ceil(e)) +end + +function _fieldelem_to_floor(e::T) where T + return BigInt(floor(e)) +end + function _fieldelem_to_rational(e::T) where T Polymake._fieldelem_is_rational(e) || error("not a rational number") return Base.Rational{BigInt}(e) @@ -174,6 +185,39 @@ function _fieldelem_is_rational(e::T) where T error("OscarNumber: cannot check is_rational, please define 'Polymake._fieldelem_is_rational(e::$T)::Bool'") end +@generated _on_gen_is_rational(::Type{ArgT}) where ArgT = + quote + @cfunction(_fieldelem_is_rational, Bool, (Ref{ArgT},)) + end + +function _on_to_ceil(e::ArgT)::Ptr{BigInt} where ArgT + i = try + _fieldelem_to_ceil(e) + catch e + return C_NULL + end + return pointer_from_objref(i) +end + +@generated _on_gen_to_ceil(::Type{ArgT}) where ArgT = + quote + @cfunction(_on_to_ceil, Ptr{BigInt}, (Ref{ArgT},)) + end + +function _on_to_floor(e::ArgT)::Ptr{BigInt} where ArgT + i = try + _fieldelem_to_floor(e) + catch e + return C_NULL + end + return pointer_from_objref(i) +end + +@generated _on_gen_to_floor(::Type{ArgT}) where ArgT = + quote + @cfunction(_on_to_floor, Ptr{BigInt}, (Ref{ArgT},)) + end + function _on_hash(e::T) where T if !_fieldelem_is_rational(e) return hash(e) @@ -184,6 +228,7 @@ function _on_hash(e::T) where T end end + @generated _on_gen_hash(::Type{ArgT}) where ArgT = quote @cfunction(_on_hash, Csize_t, (Ref{ArgT},)) @@ -307,6 +352,11 @@ function register_julia_element(e, p, t::Type) dispatch.cmp = _on_gen_cmp(t) dispatch.to_string = _on_gen_to_string(t) + + dispatch.is_rational = _on_gen_is_rational(t) + + dispatch.to_ceil = _on_gen_to_ceil(t) + dispatch.to_floor = _on_gen_to_floor(t) # later: # from_string::Ptr{Cvoid} From 38c1fc423cf3ec8d7ea4c394f9b8a0cd4739c879 Mon Sep 17 00:00:00 2001 From: Benjamin Lorenz Date: Fri, 31 May 2024 14:48:54 +0200 Subject: [PATCH 8/9] require new binaries --- Project.toml | 6 +++--- src/Polymake.jl | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Project.toml b/Project.toml index 2c4af578..d47d4cb0 100644 --- a/Project.toml +++ b/Project.toml @@ -44,6 +44,6 @@ SparseArrays = "^1.6" TOPCOM_jll = "~0.17.8" julia = "^1.6" lib4ti2_jll = "^1.6.10" -libpolymake_julia_jll = "~0.11.1" -polymake_jll = "^400.1100.1" -polymake_oscarnumber_jll = "~0.2.7" +libpolymake_julia_jll = "~0.12.0" +polymake_jll = "^400.1200.0" +polymake_oscarnumber_jll = "~0.3.0" diff --git a/src/Polymake.jl b/src/Polymake.jl index 8097b203..ad373ce8 100644 --- a/src/Polymake.jl +++ b/src/Polymake.jl @@ -42,7 +42,7 @@ import TOPCOM_jll using libpolymake_julia_jll using polymake_oscarnumber_jll -const jlpolymake_version_range = (v"0.11.6", v"0.12") +const jlpolymake_version_range = (v"0.12.0", v"0.13") struct PolymakeError <: Exception msg From 3dfa9a9de882ef82bd2b7ce09817a107b8434e6c Mon Sep 17 00:00:00 2001 From: Benjamin Lorenz Date: Sun, 2 Jun 2024 11:39:04 +0200 Subject: [PATCH 9/9] OscarCI: remove aqua tests for oscar these fail due to not using the correct environments and package versions --- .github/workflows/oscar.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/oscar.yml b/.github/workflows/oscar.yml index bd73597b..992ff96b 100644 --- a/.github/workflows/oscar.yml +++ b/.github/workflows/oscar.yml @@ -100,6 +100,9 @@ jobs: - name: "Inject Test-Dependency for Oscar" run: | sed -i -e "s/Test =/Oscar = \"f1435218-dba5-11e9-1e4d-f1a5fab5fc13\"\nTest =/" test/Project.toml + - name: "Remove Oscar/Aqua test" + run: | + rm -f oscar-dev/Oscar/test/Aqua.jl - name: "Run tests" run: | echo '${{ env.oscar_run_tests }}'