reduce invalidations

.github/workflows/runtests.yml

@@ -21,13 +21,14 @@ jobs:
  # github services (for mongodb service) only works on linux
  test-with-mongodb:
  runs-on: ${{ matrix.os }}
- continue-on-error: ${{ matrix.julia-version == 'nightly' }}
+ continue-on-error: ${{ matrix.julia-version == 'nightly' || matrix.julia-version == '~1.10.0-0' }}
  strategy:
  matrix:
  julia-version:
  - '~1.6.0-0'
  - '~1.8.0-0'
  - '~1.9.0-0'
+ - '~1.10.0-0'
  - 'nightly'
  os: ['ubuntu-latest']
  fail-fast: false
@@ -72,14 +73,15 @@ jobs:
  # this one is only for macos, ubuntu is run with mongodb in the other job
  test:
  runs-on: ${{ matrix.os }}
- continue-on-error: ${{ matrix.julia-version == 'nightly' }}
+ continue-on-error: ${{ matrix.julia-version == 'nightly' || matrix.julia-version == '~1.10.0-0' }}
  env:
  JULIA_PKG_SERVER: ""
  strategy:
  matrix:
  julia-version:
  - '~1.6.0-0'
  - '~1.9.0-0'
+ - '~1.10.0-0'
  - 'nightly'
  os: ['macOS-latest']
  fail-fast: false

OscarCI.toml

@@ -19,3 +19,9 @@ julia-version = [ "~1.6.0-0", "~1.9.0-0"]
  Polymake = ""
  julia-version = "nightly"
  os = "ubuntu-latest"
+
+ [include.julia_1_10]
+ Oscar = "<matching>"
+ Polymake = ""
+ julia-version = "~1.10.0-0"
+ os = "ubuntu-latest"

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.0"
+version = "0.11.1"
 
 [deps]
 BinaryWrappers = "f01c122e-0ea1-4f85-ad8f-907073ad7a9f"

src/integers.jl

@@ -1,14 +1,15 @@
 # One arguments constructors used by convert:
 # specialized Int64 constructors handled by Cxx side
+(::Type{<:Integer})(int::BigInt) = new_integer_from_bigint(int)
+(::Type{<:Integer})(int::Number) = Integer(BigInt(int))
+# to avoid ambiguities:
+(::Type{<:Integer})(rat::Base.Rational) = Integer(BigInt(rat))
+(::Type{<:Integer})(flt::BigFloat) = Integer(BigInt(flt))
 Integer(int::BigInt) = new_integer_from_bigint(int)
 Integer(int::Number) = Integer(BigInt(int))
-# to avoid ambiguities:
 Integer(rat::Base.Rational) = Integer(BigInt(rat))
 Integer(flt::BigFloat) = Integer(BigInt(flt))
 
-# we need thie to make the fallbacks like Base.one work
-IntegerAllocated(int::Union{BigInt,Base.Rational,BigFloat,<:Number}) = Integer(int)
-
 import Base: ==, <, <=
 # These are operations we delegate to gmp
 for op in (:(==), :(<), :(<=))
@@ -37,22 +38,24 @@
  @eval Base.$T(int::Integer) = $T(BigInt(int))
 end
 
-Base.Int64(int::Integer) = convert(Int64, new_int_from_integer(int))
+Base.Int64(int::Integer) = Int64(new_int_from_integer(int))
 
 for T in [:Int8, :Int16, :Int32, :UInt8, :UInt16, :UInt32]
  @eval Base.$T(int::Integer) = $T(Int64(int))
 end
 
+(::Type{<:Rational})(int::Integer) = new_rational_from_integer(int)
 Rational(int::Integer) = new_rational_from_integer(int)
-(::Type{T})(int::Integer) where {T<:Number} = convert(T, BigInt(int))
-(::Type{T})(int::Integer) where {T<:AbstractFloat} = convert(T, Float64(int))
+(::Type{T})(int::Integer) where T <: Number = convert(T, BigInt(int))
+(::Type{T})(int::Integer) where T <: AbstractFloat = convert(T, Float64(int))
 # to avoid ambiguity
 Float64(int::Integer) = Float64(CxxWrap.CxxRef(int))
 BigFloat(int::Integer) = BigFloat(BigInt(int))
 Base.float(int::Integer) = Float64(int)
 
 # no-copy converts
-convert(::Type{<:Integer}, int::T) where T <: Integer = int
+(::Type{<:Integer})(int::Integer) = int
+Integer(int::Integer) = int
 Base.Integer(int::Integer) = int
 
 Base.trailing_zeros(int::Integer) = trailing_zeros(BigInt(int))

src/oscarnumber.jl

@@ -3,9 +3,13 @@
  return OscarNumber
 end
 
-OscarNumber(a::Union{Base.Integer, Base.Rational{<:Base.Integer}}) = OscarNumber(Rational(a))
+(::Type{<:OscarNumber})(a::Union{Base.Integer, Base.Rational{<:Base.Integer}}) = OscarNumber(Rational(a))
 # this needs to be separate to avoid ambiguities
+OscarNumber(a::Union{Base.Integer, Base.Rational{<:Base.Integer}}) = OscarNumber(Rational(a))
+(::Type{<:OscarNumber})(a::Integer) = OscarNumber(Rational(a))
 OscarNumber(a::Integer) = OscarNumber(Rational(a))
+(::Type{<:OscarNumber})(a::Rational) = OscarNumber(CxxWrap.ConstCxxRef(a))
+OscarNumber(a::Rational) = OscarNumber(CxxWrap.ConstCxxRef(a))
 
 Base.zero(::Type{<:OscarNumber}) = OscarNumber(0)
 Base.zero(::OscarNumber) = OscarNumber(0)
@@ -299,6 +303,17 @@
  return field_count
 end
 
-convert(::Type{T}, on::OscarNumber) where T<:Number = convert(T, unwrap(on))
+(::Type{T})(on::OscarNumber) where T<:Number = convert(T, unwrap(on))
+(::Type{<:Integer})(on::OscarNumber) = convert(Integer, unwrap(on))
+(::Type{<:Rational})(on::OscarNumber) = convert(Rational, unwrap(on))
+Integer(on::OscarNumber) = convert(Integer, unwrap(on))
+Rational(on::OscarNumber) = convert(Rational, unwrap(on))
+
+# we don't support conversion for concrete types inside the OscarNumber here
+(::Type{<:QuadraticExtension{<:Rational}})(on::OscarNumber) = QuadraticExtension{Rational}(Rational(on))
+QuadraticExtension{<:Rational}(on::OscarNumber) = QuadraticExtension{Rational}(Rational(on))
+QuadraticExtension{Rational}(on::OscarNumber) = QuadraticExtension{Rational}(Rational(on))
+(::Type{<:OscarNumber})(qe::QuadraticExtension) = OscarNumber(Rational(qe))
+OscarNumber(qe::QuadraticExtension) = OscarNumber(Rational(qe))
 
 Base.float(on::OscarNumber) = float(unwrap(on))

src/quadraticextension.jl

@@ -4,12 +4,18 @@
  QuadraticExtension{T}(convert(T, a), convert(T, b), convert(T, r))
 
 QuadraticExtension{T}(a::Number) where T<:qe_suppT = QuadraticExtension{T}(a, 0, 0)
+(::Type{<:QuadraticExtension{T}})(a::Number) where T<:qe_suppT = QuadraticExtension{T}(a, 0, 0)
 
 QuadraticExtension(x...) = QuadraticExtension{Rational}(x...)
+(::Type{<:QuadraticExtension})(x...) = QuadraticExtension{Rational}(x...)
 
 # needed to avoid ambiguities
 QuadraticExtension{T}(a::Integer) where T<:qe_suppT = QuadraticExtension{T}(a, 0, 0)
+(::Type{<:QuadraticExtension{T}})(a::Integer) where T<:qe_suppT = QuadraticExtension{T}(a, 0, 0)
 QuadraticExtension(x::Integer) = QuadraticExtension{Rational}(x)
+QuadraticExtension{T}(a::Rational) where T<:qe_suppT = QuadraticExtension{T}(a, 0, 0)
+(::Type{<:QuadraticExtension{T}})(a::Rational) where T<:qe_suppT = QuadraticExtension{T}(a, 0, 0)
+QuadraticExtension(a::Rational) = QuadraticExtension{Rational}(a, 0, 0)
 
 Base.zero(::Type{<:QuadraticExtension{T}}) where T<:qe_suppT = QuadraticExtension{T}(0)
 Base.zero(::QuadraticExtension{T}) where T<:qe_suppT = QuadraticExtension{T}(0)
@@ -37,14 +43,23 @@
 
 # no-copy convert
 convert(::Type{<:QuadraticExtension{T}}, qe::QuadraticExtension{T}) where T<:qe_suppT = qe
+(::Type{<:QuadraticExtension{T}})(qe::QuadraticExtension{T}) where T<:qe_suppT = qe
+(QuadraticExtension{T})(qe::QuadraticExtension{T}) where T<:qe_suppT = qe
 
-function convert(to::Type{<:Number}, qe::QuadraticExtension)
+function _qe_to_rational(::Type{T}, qe::QuadraticExtension) where T<:Number
  !iszero(_b(qe)) && !iszero(_r(qe)) && throw(DomainError("Given QuadraticExtension not trivial."))
- return convert(to, _a(qe))
+ return convert(T, _a(qe))
 end
 
 # compatibility with Float64
 Float64(x::QuadraticExtension{T}) where T<:qe_suppT = Float64(_a(x)) + Float64(_b(x)) * sqrt(Float64(_r(x)))
 Base.promote_rule(::Type{<:QuadraticExtension{Rational}}, ::Type{<:AbstractFloat}) = Float64
 
-convert(to::Type{<:AbstractFloat}, qe::QuadraticExtension) = convert(to, Float64(qe))
+(::Type{T})(qe::QuadraticExtension) where {T<:AbstractFloat} = convert(T, Float64(qe))
+
+# avoid ambiguities
+(::Type{<:Rational})(qe::QuadraticExtension) = _qe_to_rational(Rational,qe)
+(::Type{<:Integer})(qe::QuadraticExtension) = _qe_to_rational(Integer,qe)
+Rational(qe::QuadraticExtension) = _qe_to_rational(Rational,qe)
+Integer(qe::QuadraticExtension) = _qe_to_rational(Integer,qe)
+(::Type{T})(qe::QuadraticExtension) where {T<:Base.Integer} = _qe_to_rational(T,qe)

src/rationals.jl

@@ -1,16 +1,23 @@
+(::Type{<:Rational})(num::Int64, den::Int64) =
+ rational_si_si(convert(CxxLong, num), convert(CxxLong, den))
 Rational(num::Int64, den::Int64) =
  rational_si_si(convert(CxxLong, num), convert(CxxLong, den))
 
-function Rational(num::T, den::S) where {T<:Base.Integer, S<:Base.Integer}
+function (::Type{<:Rational})(num::T, den::S) where {T<:Base.Integer, S<:Base.Integer}
  R = promote_type(promote_type(T, Int64), promote_type(S, Int64))
  R == Int64 && return Rational(convert(Int64, num), convert(Int64, den))
  return Rational(Integer(convert(BigInt, num)), Integer(convert(BigInt, den)))
 end
 
+(::Type{<:Rational})(x::Base.Rational) = Rational(numerator(x), denominator(x))
 Rational(x::Base.Rational) = Rational(numerator(x), denominator(x))
+
 @inline function Rational(x::Base.Rational{BigInt})
  GC.@preserve x new_rational_from_baserational(pointer_from_objref(numerator(x)), pointer_from_objref(denominator(x)))
 end
+
+(::Type{<:Rational})(int::Base.Integer) = Rational(int, one(int))
+(::Type{<:Rational})(x::Number) = Rational(Base.Rational(x))
 Rational(int::Base.Integer) = Rational(int, one(int))
 Rational(x::Number) = Rational(Base.Rational(x))
 
@@ -51,13 +58,17 @@
 Base.Rational(rat::Rational) = Base.Rational{BigInt}(rat)
 Base.big(rat::Rational) = Base.Rational{BigInt}(rat)
 
-convert(::Type{Integer}, rat::Rational) = new_integer_from_rational(rat)
-convert(::Type{T}, rat::Rational) where T<:Number = convert(T, big(rat))
-convert(::Type{T}, rat::Rational) where T<:AbstractFloat = convert(T, Float64(rat))
+(::Type{<:Integer})(rat::Rational) = new_integer_from_rational(rat)
+Integer(rat::Rational) = new_integer_from_rational(rat)
+(::Type{T})(rat::Rational) where T<:Number = convert(T, big(rat))
+(::Type{T})(rat::Rational) where T<:AbstractFloat = convert(T, Float64(rat))
 Base.float(rat::Rational) = Float64(rat)
+# to avoid ambiguities...
+Float64(rat::Rational) = Float64(CxxWrap.CxxRef(rat))
 
 # no-copy convert
-convert(::Type{<:Rational}, rat::T) where T <: Rational = rat
+(::Type{<:Rational})(rat::Rational) = rat
+Rational(rat::Rational) = rat
 
 # Rational division:
 

src/sets.jl

@@ -41,8 +41,6 @@ end
 
 Base.Vector(s::Set) = collect(s)
 
-Base.Set(s::Set{T}) where T = Base.Set{to_jl_type(T)}(Base.Vector(s))
-
 function Base.Set{T}(s::Set{S}) where {T, S}
  jls = Base.Set{T}()
  sizehint!(jls, length(s))

src/tropicalnumber.jl

@@ -8,14 +8,20 @@ TropicalNumber{A,S}(scalar::Union{Real, TropicalNumber}) where {A <: TropicalNum
 TropicalNumber{A}(scalar::Union{Real, TropicalNumber}) where A = TropicalNumber{A,Rational}(scalar)
 TropicalNumber{A}() where A = TropicalNumber{A, Rational}()
 
+
 #polymake requires an explicit statement what kind of tropical number (i.e. min or max) we want to construct
 TropicalNumber(x...) = throw(ArgumentError("TropicalNumber needs to be called with type parameter 'Max' or 'Min'."))
 TropicalNumber(::TropicalNumber) = TropicalNumber()
+TropicalNumber(::Rational) = TropicalNumber()
+
+# to avoid ambiguities
+TropicalNumber{Min, Rational}(r::Rational) = TropicalNumber{Min, Rational}(CxxWrap.ConstCxxRef(r))
+TropicalNumber{Max, Rational}(r::Rational) = TropicalNumber{Max, Rational}(CxxWrap.ConstCxxRef(r))
 
-# to avoid ambiguities with rather generic constructors for Polymake.Integer
 TropicalNumber{A,S}(scalar::Integer) where {A <: TropicalNumber_suppAddition, S <: TropicalNumber_suppScalar} = TropicalNumber{A,S}(convert(S,scalar))
 TropicalNumber{A}(scalar::Integer) where A = TropicalNumber{A,Rational}(scalar)
 TropicalNumber(::Integer) = TropicalNumber()
+TropicalNumber{A}(a::Rational) where A = TropicalNumber{A,Rational}(a)
 
 # workaround for https://github.com/JuliaInterop/CxxWrap.jl/issues/199
 for (jlF, pmF) in (

test/integers.jl

@@ -39,8 +39,16 @@
  @testset verbose=true "Arithmetic" begin
  a = Polymake.Integer(2)
  @test -a == -2
- # for T in [IntTypes; Polymake.Integer]
- for T in IntTypes
+
+ @test sign(a) == 1
+ @test sign(-a) == -1
+ @test sign(a-a) == 0
+
+ @test abs(a) * sign(a) == a
+ @test abs(-a) * -sign(a) == -a
+
+ #for T in IntTypes
+ for T in [IntTypes; Polymake.Integer]
  b = T(5)
  # Equality
  @test a == T(2)

test/matrices.jl

@@ -281,7 +281,8 @@
 
  @test (Z .= T.(jl_m)) isa Polymake.Matrix{Polymake.OscarNumber}
 
- @test X == U == V == W == Y == Z
+ @test X == U == V == W == Y
+ @test W == Z
 
  # TODO:
  # @test (V .== jl_m) isa BitPolymake.Array

test/quadraticextension.jl

@@ -100,7 +100,18 @@
  a /= b
  @test a == Polymake.QuadraticExtension{Polymake.Rational}(735//40328, -85//40328, 5)
  end
-
+
+ @testset verbose=true "sign abs" begin
+ a = Polymake.QuadraticExtension{Polymake.Rational}(5)
+ b = Polymake.QuadraticExtension{Polymake.Rational}(17, 1, 5)
+ @test sign(a) == 1
+ @test sign(b) == 1
+ @test sign(-b) == -1
+ @test sign(b-b) == 0
+
+ @test abs(a) * sign(a) == a
+ @test abs(-a) * -sign(a) == -a
+ end
  end
 
  @testset verbose=true "zero / one" begin

test/rationals.jl

@@ -121,6 +121,16 @@
  end
  end
 
+ @testset verbose=true "sign abs" begin
+ a = Polymake.Rational(2, 3)
+ @test sign(a) == 1
+ @test sign(-a) == -1
+ @test sign(a-a) == 0
+
+ @test abs(a) * sign(a) == a
+ @test abs(-a) * -sign(a) == -a
+ end
+
  @testset verbose=true "zero / one" begin
  ZERO = Polymake.Rational(0)
  ONE = Polymake.Rational(1)

test/sparsematrix.jl

@@ -336,7 +336,8 @@ using Polymake.SparseArrays
 
  @test (Z .= T.(jl_m)) isa Polymake.SparseMatrix{Polymake.OscarNumber}
 
- @test U == V == W == Y == Z
+ @test U == V == W == Y
+ @test W == Z
 
  # TODO:
  # @test (V .== jl_m) isa BitPolymake.Array

test/sparsevector.jl

@@ -167,7 +167,8 @@ using Polymake.SparseArrays
 
  @test (Z .= T.(jl_v)) isa Polymake.SparseVector{Polymake.OscarNumber}
 
- @test U == V == W == Y == Z
+ @test U == V == W == Y
+ @test W == Z
 
  # TODO:
  # @test (V .== jl_v) isa BitArray

test/vectors.jl

@@ -263,7 +263,8 @@
  @test (Z .= T.(jl_v)) isa Polymake.Vector{Polymake.OscarNumber}
  @test (Z .= T.(jl_v).//1) isa Polymake.Vector{Polymake.OscarNumber}
 
- @test X == U == V == W == Y == Z
+ @test X == U == V == W == Y
+ @test W == Z
 
  # TODO:
  # @test (V .== jl_v) isa BitPolymake.Array