From 161dde83cfadbba5bef46291548b55f8662e7c43 Mon Sep 17 00:00:00 2001 From: Alexej Jordan Date: Tue, 1 Feb 2022 21:48:35 +0100 Subject: [PATCH 1/2] added QuadraticExtension{Rational}, derived container types and the corresponding tests --- src/Polymake.jl | 1 + src/arrays.jl | 2 +- src/convert.jl | 4 +- src/quadraticextension.jl | 46 ++++++++++ src/setup_types.jl | 3 +- test/arrays.jl | 1 + test/convert.jl | 2 +- test/matrices.jl | 84 +++++++++++++++-- test/polynomial.jl | 10 +- test/quadraticextension.jl | 181 +++++++++++++++++++++++++++++++++++++ test/sparsematrix.jl | 67 ++++++++++++-- test/sparsevector.jl | 33 +++++-- test/vectors.jl | 56 +++++++++++- 13 files changed, 457 insertions(+), 33 deletions(-) create mode 100644 src/quadraticextension.jl create mode 100644 test/quadraticextension.jl diff --git a/src/Polymake.jl b/src/Polymake.jl index ac04a53c..f07d440c 100644 --- a/src/Polymake.jl +++ b/src/Polymake.jl @@ -161,6 +161,7 @@ include("convert.jl") include("integers.jl") include("rationals.jl") +include("quadraticextension.jl") include("sets.jl") include("std/lists.jl") include("std/pairs.jl") diff --git a/src/arrays.jl b/src/arrays.jl index 7e8cab91..8689bdf1 100644 --- a/src/arrays.jl +++ b/src/arrays.jl @@ -1,5 +1,5 @@ const Array_suppT = Union{Int64, CxxWrap.CxxLong, - Integer, Rational, + Integer, Rational, QuadraticExtension{Rational}, String, CxxWrap.StdString, StdPair{CxxWrap.CxxLong,CxxWrap.CxxLong}, StdList{StdPair{CxxWrap.CxxLong,CxxWrap.CxxLong}}, diff --git a/src/convert.jl b/src/convert.jl index d64bacea..f9f5db48 100644 --- a/src/convert.jl +++ b/src/convert.jl @@ -81,6 +81,7 @@ convert_to_pm_type(::Type{<:Array}) = Array convert_to_pm_type(::Type{<:Union{Pair, <:StdPair}}) = StdPair convert_to_pm_type(::Type{<:Graph{T}}) where T<:Union{Directed,Undirected} = Graph{T} convert_to_pm_type(::Type{HomologyGroup{T}}) where T<:Integer = HomologyGroup{T} +convert_to_pm_type(::Type{<:QuadraticExtension{T}}) where T<:Rational = QuadraticExtension{Rational} # convert_to_pm_type(::Type{<:Union{AbstractSet, Set}}) = Set # specific converts for container types we wrap: @@ -88,7 +89,8 @@ convert_to_pm_type(::Type{<:Set{<:Base.Integer}}) = Set{Int64} convert_to_pm_type(::Type{<:Base.AbstractSet{<:Base.Integer}}) = Set{Int64} for (pmT, jlT) in [(Integer, Base.Integer), - (Rational, Union{Base.Rational, Rational})] + (Rational, Union{Base.Rational, Rational}), + (QuadraticExtension{Polymake.Rational}, QuadraticExtension{Polymake.Rational})] @eval begin convert_to_pm_type(::Type{<:AbstractMatrix{T}}) where T<:$jlT = Matrix{$pmT} convert_to_pm_type(::Type{<:AbstractVector{T}}) where T<:$jlT = Vector{$pmT} diff --git a/src/quadraticextension.jl b/src/quadraticextension.jl new file mode 100644 index 00000000..fa6c0812 --- /dev/null +++ b/src/quadraticextension.jl @@ -0,0 +1,46 @@ +const qe_suppT = Union{Polymake.Rational} + +QuadraticExtension{T}(a::Number, b::Number, r::Number) where T<:qe_suppT = + QuadraticExtension{T}(convert(T, a), convert(T, b), convert(T, r)) + +QuadraticExtension{T}(a::Number) where T<:qe_suppT = QuadraticExtension{T}(a, 0, 0) + +QuadraticExtension(x...) = QuadraticExtension{Rational}(x...) + +Base.zero(::Type{<:QuadraticExtension{T}}) where T<:qe_suppT = QuadraticExtension{T}(0) +Base.zero(::QuadraticExtension{T}) where T<:qe_suppT = QuadraticExtension{T}(0) +Base.one(::Type{<:QuadraticExtension{T}}) where T<:qe_suppT = QuadraticExtension{T}(1) +Base.one(::QuadraticExtension{T}) where T<:qe_suppT = QuadraticExtension{T}(1) + +generating_field_elements(qe::QuadraticExtension{T}) where T<:qe_suppT = (a = _a(qe), b = _b(qe), r =_r(qe)) + +# we might need to split this up +# if we should wrap `QuadraticExtension` with another scalar than `Rational` +function Base.promote_rule(::Type{<:QuadraticExtension{T}}, + ::Type{<:Union{T, Base.Integer, Base.Rational{<:Base.Integer}}}) where T<:qe_suppT + return QuadraticExtension{T} +end + +import Base: <, //, <= +# defining for `Real` to avoid disambiguities +Base.:<(x::Real, y::QuadraticExtension{T}) where T<:qe_suppT = convert(QuadraticExtension{T}, x) < y +Base.:<(x::QuadraticExtension{T}, y::Real) where T<:qe_suppT = x < convert(QuadraticExtension{T}, y) +Base.://(x::Real, y::QuadraticExtension{T}) where T<:qe_suppT = convert(QuadraticExtension{T}, x) // y +Base.://(x::QuadraticExtension{T}, y::Real) where T<:qe_suppT = x // convert(QuadraticExtension{T}, y) + +Base.:<=(x::QuadraticExtension{T}, y::QuadraticExtension{T}) where T<:qe_suppT = x < y || x == y +Base.:/(x::QuadraticExtension{T}, y::QuadraticExtension{T}) where T<:qe_suppT = x // y + +# no-copy convert +convert(::Type{<:QuadraticExtension{T}}, qe::QuadraticExtension{T}) where T<:qe_suppT = qe + +function convert(to::Type{<:Number}, qe::QuadraticExtension) + !iszero(_b(qe)) && !iszero(_r(qe)) && throw(DomainError("Given QuadraticExtension not trivial.")) + return convert(to, _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)) diff --git a/src/setup_types.jl b/src/setup_types.jl index 96072741..bfe50292 100644 --- a/src/setup_types.jl +++ b/src/setup_types.jl @@ -15,8 +15,9 @@ const SmallObject = Union{ Map, Graph, HomologyGroup, + QuadraticExtension, } -const VecOrMat_eltypes = Union{Int64, Integer, Rational, Float64, CxxWrap.CxxLong} +const VecOrMat_eltypes = Union{Int64, Integer, Rational, Float64, QuadraticExtension{Rational}, CxxWrap.CxxLong} const TypeConversionFunctions = Dict( Symbol("Int") => to_int, diff --git a/test/arrays.jl b/test/arrays.jl index 78c85465..bb903360 100644 --- a/test/arrays.jl +++ b/test/arrays.jl @@ -3,6 +3,7 @@ (Int64, 2), (Polymake.Integer, Polymake.Integer(2)), (Polymake.Rational, Polymake.Rational(2 //3)), + (Polymake.QuadraticExtension{Polymake.Rational}, Polymake.QuadraticExtension{Polymake.Rational}(1, 2, 3)), (String, "a"), (Polymake.Set{Polymake.to_cxx_type(Int)}, Polymake.Set{Int64}([1,2,1])), (Polymake.Matrix{Polymake.Integer}, Polymake.Matrix{Polymake.Integer}([1 0; 2 1])), diff --git a/test/convert.jl b/test/convert.jl index f417f48f..0930a114 100644 --- a/test/convert.jl +++ b/test/convert.jl @@ -21,7 +21,7 @@ @testset "convert_to_pm_type(PolymakeType)" begin for T in [Polymake.Integer, Polymake.Rational, Polymake.Array, Polymake.IncidenceMatrix, - Polymake.Matrix, Polymake.Set{Int64}, Polymake.SparseMatrix, Polymake.TropicalNumber, Polymake.Vector] + Polymake.Matrix, Polymake.Set{Int64}, Polymake.SparseMatrix, Polymake.TropicalNumber, Polymake.Vector, Polymake.QuadraticExtension{Polymake.Rational}] @test T == Polymake.convert_to_pm_type(T) end end diff --git a/test/matrices.jl b/test/matrices.jl index ca8390bf..233461a6 100644 --- a/test/matrices.jl +++ b/test/matrices.jl @@ -2,7 +2,7 @@ IntTypes = [Int32, Int64, UInt64, BigInt] FloatTypes = [Float32, Float64, BigFloat] - for T in [Int64, Polymake.Integer, Polymake.Rational, Float64] + for T in [Int64, Polymake.Integer, Polymake.Rational, Float64, Polymake.QuadraticExtension{Polymake.Rational}] @test Polymake.Matrix{T} <: AbstractMatrix @test Polymake.Matrix{T}(undef, 3,4) isa AbstractMatrix @test Polymake.Matrix{T}(undef, 3,4) isa Polymake.Matrix @@ -26,7 +26,7 @@ @test Polymake.Matrix(T.(jl_m)) isa Polymake.Matrix{T<:Union{Int32,Int64} ? Polymake.to_cxx_type(Int64) : Polymake.Integer} - for ElType in [Polymake.Integer, Polymake.Rational, Float64] + for ElType in [Polymake.Integer, Polymake.Rational, Float64, Polymake.QuadraticExtension{Polymake.Rational}] for m in [jl_m, jl_m//T(1), jl_m/T(1)] @test Polymake.Matrix{ElType}(m) isa Polymake.Matrix{ElType} @test convert(Polymake.Matrix{ElType}, m) isa Polymake.Matrix{ElType} @@ -150,6 +150,34 @@ @test string(V) == "pm::Matrix\n5/3 2 3\n10/3 5 6\n" end end + + @testset "Polymake.Matrix{Polymake.QuadraticExtension{Polymake.Rational}}" begin + V = Polymake.Matrix{Polymake.QuadraticExtension{Polymake.Rational}}(jl_m) + # linear indexing: + @test V[1] == 1//1 + @test V[2] == 4//1 + + @test eltype(V) == Polymake.QuadraticExtension{Polymake.Rational} + + @test_throws BoundsError V[0, 1] + @test_throws BoundsError V[2, 5] + @test_throws BoundsError V[3, 1] + + @test length(V) == 6 + @test size(V) == (2,3) + + for T in [IntTypes; Polymake.Integer] + V = Polymake.Matrix{Polymake.QuadraticExtension{Polymake.Rational}}(jl_m) # local copy + @test setindex!(V, T(5)//T(3), 1, 1) isa Polymake.Matrix{Polymake.QuadraticExtension{Polymake.Rational}} + @test V[T(1), 1] isa Polymake.QuadraticExtension{Polymake.Rational} + @test V[1, T(1)] == 5//3 + # testing the return value of brackets operator + @test V[2] = T(10)//T(3) isa typeof(T(10)//T(3)) + V[2] = T(10)//T(3) + @test V[2] == 10//3 + @test string(V) == "pm::Matrix >\n5/3 2 3\n10/3 5 6\n" + end + end @testset "Polymake.Matrix{Float64}" begin V = Polymake.Matrix{Float64}(jl_m) @@ -187,6 +215,7 @@ V = Polymake.Matrix{Polymake.Integer}(undef, 2, 3) W = Polymake.Matrix{Polymake.Rational}(undef, 2, 3) U = Polymake.Matrix{Float64}(undef, 2, 3) + Y = Polymake.Matrix{Polymake.QuadraticExtension{Polymake.Rational}}(undef, 2, 3) @test (X .= T.(jl_m)) isa Polymake.Matrix{Polymake.to_cxx_type(Int64)} @test (X .= T.(jl_m).//1) isa Polymake.Matrix{Polymake.to_cxx_type(Int64)} @@ -199,8 +228,11 @@ @test (U .= T.(jl_m)) isa Polymake.Matrix{Float64} @test (U .= T.(jl_m).//1) isa Polymake.Matrix{Float64} + + @test (Y .= T.(jl_m)) isa Polymake.Matrix{Polymake.QuadraticExtension{Polymake.Rational}} + @test (Y .= T.(jl_m).//1) isa Polymake.Matrix{Polymake.QuadraticExtension{Polymake.Rational}} - @test X == U == V == W + @test X == U == V == W == Y # TODO: # @test (V .== jl_m) isa BitPolymake.Array @@ -232,6 +264,9 @@ W = Polymake.Matrix{Polymake.Rational}(jl_w) jl_u = jl_m/4 U = Polymake.Matrix{Float64}(jl_u) + sr2 = Polymake.QuadraticExtension{Polymake.Rational}(0, 1, 2) + jl_y = sr2 * jl_m + Y = Polymake.Matrix{Polymake.QuadraticExtension{Polymake.Rational}}(jl_y) @test -X isa Polymake.Polymake.MatrixAllocated{Polymake.to_cxx_type(Int64)} @test -X == -jl_m @@ -244,6 +279,9 @@ @test -U isa Polymake.Polymake.MatrixAllocated{Float64} @test -U == -jl_u + + @test -Y isa Polymake.Matrix{Polymake.QuadraticExtension{Polymake.Rational}} + @test -Y == -jl_y int_scalar_types = [IntTypes; Polymake.Integer] rational_scalar_types = [[Base.Rational{T} for T in IntTypes]; Polymake.Rational] @@ -252,7 +290,7 @@ @test Int32(2)X isa Polymake.Matrix{Polymake.to_cxx_type(Int64)} for T in int_scalar_types - for (mat, ElType) in [(V, Polymake.Integer), (W, Polymake.Rational), (U, Float64)] + for (mat, ElType) in [(V, Polymake.Integer), (W, Polymake.Rational), (U, Float64), (Y, Polymake.QuadraticExtension{Polymake.Rational})] op = * @test op(T(2), mat) isa Polymake.Matrix{ElType} @test op(mat, T(2)) isa Polymake.Matrix{ElType} @@ -277,6 +315,13 @@ @test broadcast(op, mat, T(2)) isa Polymake.Matrix{ElType} end end + let (op, ElType) = (//, Polymake.QuadraticExtension{Polymake.Rational}) + + @test op(Y, T(2)) isa Polymake.Matrix{ElType} + @test broadcast(op, T(2), Y) isa Polymake.Matrix{ElType} + @test broadcast(op, Y, T(2)) isa Polymake.Matrix{ElType} + + end let (op, ElType) = (/, Float64) mat = U @test op(mat, T(2)) isa Polymake.Matrix{ElType} @@ -286,7 +331,7 @@ end for T in rational_scalar_types - for (mat, ElType) in [(V, Polymake.Rational), (W, Polymake.Rational), (U, Float64)] + for (mat, ElType) in [(V, Polymake.Rational), (W, Polymake.Rational), (U, Float64), (Y, Polymake.QuadraticExtension{Polymake.Rational})] op = * @test op(T(2), mat) isa Polymake.Matrix{ElType} @@ -340,12 +385,37 @@ @test broadcast(op, mat, T(2)) isa Polymake.Matrix{ElType} end end + + let T = Polymake.QuadraticExtension{Polymake.Rational}, mat = Y, ElType = Polymake.QuadraticExtension{Polymake.Rational} + op = * + @test op(T(2), mat) isa Polymake.Matrix{ElType} + @test op(mat, T(2)) isa Polymake.Matrix{ElType} + @test broadcast(op, T(2), mat) isa Polymake.Matrix{ElType} + @test broadcast(op, mat, T(2)) isa Polymake.Matrix{ElType} + + op = + + @test op(mat, T.(jl_m)) isa Polymake.Matrix{ElType} + @test op(T.(jl_m), mat) isa Polymake.Matrix{ElType} + + @test broadcast(op, mat, T.(jl_m)) isa Polymake.Matrix{ElType} + @test broadcast(op, T.(jl_m), mat) isa Polymake.Matrix{ElType} + + @test broadcast(op, T(2), mat) isa Polymake.Matrix{ElType} + @test broadcast(op, mat, T(2)) isa Polymake.Matrix{ElType} + + op = // + # @test op(T(2), mat) isa Polymake.Matrix{ElType} + @test op(mat, T(2)) isa Polymake.Matrix{ElType} + @test broadcast(op, T(2), mat) isa Polymake.Matrix{ElType} + @test broadcast(op, mat, T(2)) isa Polymake.Matrix{ElType} + end - for T in [int_scalar_types; rational_scalar_types; FloatTypes] + for T in [int_scalar_types; rational_scalar_types; FloatTypes; Polymake.QuadraticExtension{Polymake.Rational}] @test T(2)*X == X*T(2) == T(2) .* X == X .* T(2) == 2jl_m @test T(2)*V == V*T(2) == T(2) .* V == V .* T(2) == 2jl_m @test T(2)*W == W*T(2) == T(2) .* W == W .* T(2) == 2jl_w @test T(2)*U == U*T(2) == T(2) .* U == U .* T(2) == 2jl_u + @test T(2)*Y == Y*T(2) == T(2) .* Y == Y .* T(2) == 2jl_y @test X + T.(jl_m) == T.(jl_m) + X == X .+ T.(jl_m) == T.(jl_m) .+ X == 2jl_m @@ -354,6 +424,8 @@ @test W + T.(4jl_w) == T.(4jl_w) + W == W .+ T.(4jl_w) == T.(4jl_w) .+ W == 5jl_w @test U + T.(4jl_u) == T.(4jl_u) + U == U .+ T.(4jl_u) == T.(4jl_u) .+ U == 5jl_u + + @test Y + T.(2 * jl_m) == T.(2 * jl_m) + Y == Y .+ T.(2 * jl_m) == T.(2 * jl_m) .+ Y == (1 + sr2) * jl_y end end end diff --git a/test/polynomial.jl b/test/polynomial.jl index 68acdac7..8df4e868 100644 --- a/test/polynomial.jl +++ b/test/polynomial.jl @@ -4,7 +4,7 @@ using SparseArrays FloatTypes = [Float32, Float64, BigFloat] RationalTypes = [Rational{I} for I in IntTypes] - for C in [Int64, Polymake.Integer, Polymake.Rational, Float64] + for C in [Int64, Polymake.Integer, Polymake.Rational, Float64, Polymake.QuadraticExtension{Polymake.Rational}] @test Polymake.Polynomial{C,Int64} <: Any @test Polymake.Polynomial{C,Int64}([1, 2],[3 4 5; 6 7 8]) isa Any @test Polymake.Polynomial{C,Int64}([1, 2],[3 4 5; 6 7 8]) isa Polymake.Polynomial @@ -22,7 +22,7 @@ using SparseArrays end @testset "Low-level operations" begin - for (C,s) in [(Int64, "long"), (Polymake.Integer, "pm::Integer"), (Polymake.Rational, "pm::Rational"), (Float64, "double")] + for (C,s) in [(Int64, "long"), (Polymake.Integer, "pm::Integer"), (Polymake.Rational, "pm::Rational"), (Float64, "double"), (Polymake.QuadraticExtension{Polymake.Rational}, "pm::QuadraticExtension")] p = Polymake.Polynomial(C.(jl_v),jl_m) @test Polymake.nvars(p) == size(jl_m)[2] @test Polymake.nvars(p) isa Int @@ -48,7 +48,7 @@ using SparseArrays end @testset "Equality" begin - for C1 in [Int64, Polymake.Integer, Polymake.Rational, Float64], C2 in [Int64, Polymake.Integer, Polymake.Rational, Float64] + for C1 in [Int64, Polymake.Integer, Polymake.Rational, Float64, Polymake.QuadraticExtension{Polymake.Rational}], C2 in [Int64, Polymake.Integer, Polymake.Rational, Float64, Polymake.QuadraticExtension{Polymake.Rational}] @test Polymake.Polynomial{C1}(jl_v,jl_m) == Polymake.Polynomial{C2}(jl_v,jl_m) end end @@ -56,9 +56,9 @@ using SparseArrays @testset "Arithmetic" begin jl_v2 = [5, 6] jl_m2 = [3 4 5; 6 7 8] - for C1 in [Int64, Polymake.Integer, Polymake.Rational, Float64] + for C1 in [Int64, Polymake.Integer, Polymake.Rational, Float64, Polymake.QuadraticExtension{Polymake.Rational}] p = Polymake.Polynomial{C1}(jl_v,jl_m) - for C2 in [Int64, Polymake.Integer, Polymake.Rational, Float64] + for C2 in [Int64, Polymake.Integer, Polymake.Rational, Float64, Polymake.QuadraticExtension{Polymake.Rational}] q = Polymake.Polynomial{C2}(jl_v2,jl_m2) @test p + q isa Polymake.Polynomial{Polymake.to_cxx_type(promote_type(C1,C2))} @test p + q == Polymake.Polynomial([6, 2, 6],[3 4 5; 6 7 0; 6 7 8]) diff --git a/test/quadraticextension.jl b/test/quadraticextension.jl new file mode 100644 index 00000000..671ba261 --- /dev/null +++ b/test/quadraticextension.jl @@ -0,0 +1,181 @@ +@testset "Polymake.QuadraticExtension{Polymake.Rational}" begin + FloatTypes = [Float32, Float64, BigFloat] + MoreNumberTypes = [Int32, Int64, UInt64, BigInt, Polymake.Integer, Polymake.Rational] + + @testset "Constructors/Conversions" begin + + # constructors + for T in [FloatTypes; MoreNumberTypes] + @test Polymake.QuadraticExtension{Polymake.Rational}(T(1), T(2), T(3)) isa Polymake.QuadraticExtension + @test Polymake.QuadraticExtension{Polymake.Rational}(T(1), T(2), T(3)) isa Polymake.QuadraticExtension{Polymake.Rational} + @test Polymake.QuadraticExtension(T(1), T(2), T(3)) isa Polymake.QuadraticExtension{Polymake.Rational} + + @test Polymake.QuadraticExtension{Polymake.Rational}(T(1)) isa Polymake.QuadraticExtension{Polymake.Rational} + @test Polymake.QuadraticExtension(T(1)) isa Polymake.QuadraticExtension{Polymake.Rational} + end + + # example for different `Number` types + @test Polymake.QuadraticExtension{Polymake.Rational}(Int32(1), Float64(2), Polymake.Integer(3)) isa Polymake.QuadraticExtension{Polymake.Rational} + + a = Polymake.QuadraticExtension{Polymake.Rational}(5) + + # no copy conversion: + @test convert(Polymake.QuadraticExtension{Polymake.Rational}, a) === a + + for T in [FloatTypes; MoreNumberTypes] + t = T(7) + @test convert(Polymake.QuadraticExtension{Polymake.Rational}, t) isa Polymake.QuadraticExtension{Polymake.Rational} + tt = convert(Polymake.QuadraticExtension{Polymake.Rational}, t) + @test convert(T, tt) isa T + @test convert(T, tt) == t + end + + # julia arrays + @test Vector{Any}([a,1])[1] isa Polymake.QuadraticExtension{Polymake.Rational} + @test [a,a] isa Vector{Polymake.QuadraticExtensionAllocated{Polymake.Rational}} + end + + @testset "Arithmetic" begin + + @testset "(In-)Equality" begin + a = Polymake.QuadraticExtension{Polymake.Rational}(5) + for T in [FloatTypes; MoreNumberTypes], b in [Polymake.QuadraticExtension{Polymake.Rational}(T(5)), Polymake.QuadraticExtension{Polymake.Rational}(T(5), T(0), T(0)), Polymake.QuadraticExtension{Polymake.Rational}(T(5), T(1), T(0)), Polymake.QuadraticExtension{Polymake.Rational}(T(5), T(0), T(2))] + @test a == b + @test b == a + end + @test a == a + @test a <= a + @test a >= a + let b = Polymake.QuadraticExtension{Polymake.Rational}(4, 1, 3) + @test a != b + @test a <= b + @test a < b + @test b >= a + @test b > a + end + end + + @testset "Addition" begin + a = Polymake.QuadraticExtension{Polymake.Rational}(5) + b = Polymake.QuadraticExtension{Polymake.Rational}(17, 1, 5) + @test a + b isa Polymake.QuadraticExtension{Polymake.Rational} + @test a + b == b + a == Polymake.QuadraticExtension{Polymake.Rational}(22, 1, 5) + a += b + @test a == Polymake.QuadraticExtension{Polymake.Rational}(22, 1, 5) + b += a + @test b == Polymake.QuadraticExtension{Polymake.Rational}(39, 2, 5) + end + + @testset "Subtraction" begin + a = Polymake.QuadraticExtension{Polymake.Rational}(5) + b = Polymake.QuadraticExtension{Polymake.Rational}(17, 1, 5) + @test a - b isa Polymake.QuadraticExtension{Polymake.Rational} + @test a - b == -(b - a) == Polymake.QuadraticExtension{Polymake.Rational}(-12, -1, 5) + a -= b + @test a == Polymake.QuadraticExtension{Polymake.Rational}(-12, -1, 5) + b -= a + @test b == Polymake.QuadraticExtension{Polymake.Rational}(29, 2, 5) + end + + @testset "Multiplication" begin + a = Polymake.QuadraticExtension{Polymake.Rational}(5) + b = Polymake.QuadraticExtension{Polymake.Rational}(17, 1, 5) + @test a * b isa Polymake.QuadraticExtension{Polymake.Rational} + @test a * b == b * a == Polymake.QuadraticExtension{Polymake.Rational}(85, 5, 5) + a *= b + @test a == Polymake.QuadraticExtension{Polymake.Rational}(85, 5, 5) + end + + @testset "Division" begin + a = Polymake.QuadraticExtension{Polymake.Rational}(5) + b = Polymake.QuadraticExtension{Polymake.Rational}(17, 1, 5) + @test a // b isa Polymake.QuadraticExtension{Polymake.Rational} + @test a // b == Polymake.QuadraticExtension{Polymake.Rational}(85//284, -5//284, 5) + @test b // a == Polymake.QuadraticExtension{Polymake.Rational}(17//5, 1//5, 5) + @test a / b isa Polymake.QuadraticExtension{Polymake.Rational} + @test a / b == Polymake.QuadraticExtension{Polymake.Rational}(85//284, -5//284, 5) + @test b / a == Polymake.QuadraticExtension{Polymake.Rational}(17//5, 1//5, 5) + a //= b + @test a == Polymake.QuadraticExtension{Polymake.Rational}(85//284, -5//284, 5) + a /= b + @test a == Polymake.QuadraticExtension{Polymake.Rational}(735//40328, -85//40328, 5) + end + + end + + @testset "zero / one" begin + ZERO = Polymake.QuadraticExtension{Polymake.Rational}(0) + ONE = Polymake.QuadraticExtension{Polymake.Rational}(1) + + @test one(ZERO) isa Polymake.QuadraticExtension{Polymake.Rational} + @test zero(ZERO) isa Polymake.QuadraticExtension{Polymake.Rational} + @test one(Polymake.QuadraticExtension{Polymake.Rational}) isa Polymake.QuadraticExtension{Polymake.Rational} + @test zero(Polymake.QuadraticExtension{Polymake.Rational}) isa Polymake.QuadraticExtension{Polymake.Rational} + + @test zero(Polymake.QuadraticExtension{Polymake.Rational}) == zero(ONE) == ZERO + @test one(Polymake.QuadraticExtension{Polymake.Rational}) == one(ZERO) == ONE + end + + @testset "Promotion" begin + for T in MoreNumberTypes + a = Polymake.QuadraticExtension{Polymake.Rational}(5, 1, 3) + b = T(17) + c = Polymake.QuadraticExtension{Polymake.Rational}(17) + @test b == c + @test c == b + @test a != b + @test a <= b + @test a < b + @test b >= a + @test b > a + @test a + b isa Polymake.QuadraticExtension{Polymake.Rational} + @test b + a isa Polymake.QuadraticExtension{Polymake.Rational} + @test a + b == b + a == Polymake.QuadraticExtension{Polymake.Rational}(22, 1, 3) + @test a - b isa Polymake.QuadraticExtension{Polymake.Rational} + @test b - a isa Polymake.QuadraticExtension{Polymake.Rational} + @test a - b == -(b - a) == Polymake.QuadraticExtension{Polymake.Rational}(-12, 1, 3) + @test a * b isa Polymake.QuadraticExtension{Polymake.Rational} + @test b * a isa Polymake.QuadraticExtension{Polymake.Rational} + @test a * b == b * a == Polymake.QuadraticExtension{Polymake.Rational}(85, 17, 3) + @test a // b isa Polymake.QuadraticExtension{Polymake.Rational} + @test b // a isa Polymake.QuadraticExtension{Polymake.Rational} + @test a // b == 1//(b // a) == Polymake.QuadraticExtension{Polymake.Rational}(5//17, 1//17, 3) + end + for T in FloatTypes + a = Polymake.QuadraticExtension{Polymake.Rational}(5, 1, 3) + b = T(17) + c = Polymake.QuadraticExtension{Polymake.Rational}(17) + @test b == c + @test c == b + @test a != b + @test a <= b + @test a < b + @test b >= a + @test b > a + @test a + b isa AbstractFloat + @test b + a isa AbstractFloat + @test a + b == b + a ≈ Float64(Polymake.QuadraticExtension{Polymake.Rational}(22, 1, 3)) + @test a - b isa AbstractFloat + @test b - a isa AbstractFloat + @test a - b == -(b - a) ≈ Float64(Polymake.QuadraticExtension{Polymake.Rational}(-12, 1, 3)) + @test a * b isa AbstractFloat + @test b * a isa AbstractFloat + @test a * b == b * a ≈ Float64(Polymake.QuadraticExtension{Polymake.Rational}(85, 17, 3)) + @test a / b isa AbstractFloat + @test b / a isa AbstractFloat + @test a / b ≈ 1/(b / a) ≈ Float64(Polymake.QuadraticExtension{Polymake.Rational}(5//17, 1//17, 3)) + end + end + + @testset "precise access" begin + + a = Polymake.QuadraticExtension{Polymake.Rational}(5, 1, 3) + @test Polymake.generating_field_elements(a) isa NamedTuple{(:a, :b, :r), Tuple{Polymake.RationalAllocated, Polymake.RationalAllocated, Polymake.RationalAllocated}} + t = Polymake.generating_field_elements(a) + @test t.a == 5 + @test t.b == 1 + @test t.r == 3 + + end + +end diff --git a/test/sparsematrix.jl b/test/sparsematrix.jl index 704bc4ee..6603c59c 100644 --- a/test/sparsematrix.jl +++ b/test/sparsematrix.jl @@ -3,7 +3,7 @@ using SparseArrays IntTypes = [Int32, Int64, UInt64, BigInt] FloatTypes = [Float32, Float64, BigFloat] - for T in [Int64, Polymake.Integer, Polymake.Rational, Float64] + for T in [Int64, Polymake.Integer, Polymake.Rational, Float64, Polymake.QuadraticExtension{Polymake.Rational}] @test Polymake.SparseMatrix{T} <: AbstractSparseMatrix @test Polymake.spzeros(T, 3, 4) isa AbstractSparseMatrix @test Polymake.spzeros(T, 3, 4) isa Polymake.SparseMatrix @@ -26,7 +26,7 @@ using SparseArrays @test Polymake.SparseMatrix(jl_s//1) isa Polymake.SparseMatrix{Polymake.Rational} @test Polymake.SparseMatrix(jl_s/1) isa Polymake.SparseMatrix{Float64} - for ElType in [Polymake.Integer, Polymake.Rational, Float64] + for ElType in [Polymake.Integer, Polymake.Rational, Float64, Polymake.QuadraticExtension{Polymake.Rational}] for m in [jl_m, jl_m//T(1), jl_m/T(1)] @test Polymake.SparseMatrix{ElType}(m) isa Polymake.SparseMatrix{ElType} @test convert(Polymake.SparseMatrix{ElType}, m) isa Polymake.SparseMatrix{ElType} @@ -215,12 +215,49 @@ using SparseArrays @test string(Polymake.SparseMatrix{Float64}(jl_s)) == "pm::SparseMatrix\n(3)\n(3) (1 1)\n" end + + @testset "Polymake.SparseMatrix{Polymake.QuadraticExtension{Polymake.Rational}}" begin + V = Polymake.SparseMatrix{Polymake.QuadraticExtension{Polymake.Rational}}(jl_m) + # linear indexing: + @test V[1] == 1 + @test V[2] == 4 + + @test eltype(V) == Polymake.QuadraticExtension{Polymake.Rational} + + @test_throws BoundsError V[0, 1] + @test_throws BoundsError V[2, 5] + @test_throws BoundsError V[3, 1] + + @test length(V) == 6 + @test size(V) == (2,3) + + for T in [IntTypes; Polymake.Integer] + V = Polymake.SparseMatrix{Polymake.QuadraticExtension{Polymake.Rational}}(jl_m) # local copy + setindex!(V, T(5)//T(3), 1, 1) + @test V isa Polymake.SparseMatrix{Polymake.QuadraticExtension{Polymake.Rational}} + @test V[T(1), 1] isa Polymake.QuadraticExtension{Polymake.Rational} + @test V[1, T(1)] == 5//3 + # testing the return value of brackets operator + if T != Polymake.Integer + @test V[2] = T(10)//T(3) isa Base.Rational{T} + else + @test V[2] = T(10)//T(3) isa Polymake.Rational + end + V[2] = T(10)//T(3) + @test V[2] == 10//3 + @test string(V) == "pm::SparseMatrix, pm::NonSymmetric>\n5/3 2 3\n10/3 5 6\n" + end + + @test string(Polymake.SparseMatrix{Polymake.QuadraticExtension{Polymake.Rational}}(jl_s)) == "pm::SparseMatrix, pm::NonSymmetric>\n(3)\n(3) (1 1)\n" + + end @testset "Equality" begin for T in [IntTypes; Polymake.Integer] V = Polymake.SparseMatrix{Polymake.Integer}(2, 3) W = Polymake.SparseMatrix{Polymake.Rational}(2, 3) U = Polymake.SparseMatrix{Float64}(2, 3) + Y = Polymake.SparseMatrix{Polymake.QuadraticExtension{Polymake.Rational}}(2, 3) #TODO T.(jl_s) @test (V .= T.(jl_m)) isa Polymake.SparseMatrix{Polymake.Integer} @@ -231,8 +268,11 @@ using SparseArrays @test (U .= T.(jl_m)) isa Polymake.SparseMatrix{Float64} @test (U .= T.(jl_m).//1) isa Polymake.SparseMatrix{Float64} + + @test (Y .= T.(jl_m)) isa Polymake.SparseMatrix{Polymake.QuadraticExtension{Polymake.Rational}} + @test (Y .= T.(jl_m).//1) isa Polymake.SparseMatrix{Polymake.QuadraticExtension{Polymake.Rational}} - @test U == V == W + @test U == V == W == Y # TODO: # @test (V .== jl_m) isa BitPolymake.Array @@ -264,6 +304,9 @@ using SparseArrays W = Polymake.SparseMatrix{Polymake.Rational}(jl_w) jl_u = jl_m/4 U = Polymake.SparseMatrix{Float64}(jl_u) + sr2 = Polymake.QuadraticExtension{Polymake.Rational}(0, 1, 2) + jl_y = jl_m * sr2 + Y = Polymake.SparseMatrix{Polymake.QuadraticExtension{Polymake.Rational}}(jl_y) @test -X isa Polymake.SparseMatrixAllocated{Polymake.to_cxx_type(Int)} @test -X == -jl_m @@ -277,6 +320,9 @@ using SparseArrays @test -U isa Polymake.SparseMatrixAllocated{Float64} @test -U == -jl_u + @test -Y isa Polymake.SparseMatrix{Polymake.QuadraticExtension{Polymake.Rational}} + @test -Y == -jl_y + int_scalar_types = [IntTypes; Polymake.Integer] rational_scalar_types = [[Base.Rational{T} for T in IntTypes]; Polymake.Rational] @@ -284,7 +330,7 @@ using SparseArrays @test Int32(2)X isa Polymake.SparseMatrix{Polymake.to_cxx_type(Int)} for T in int_scalar_types - for (mat, ElType) in [(V, Polymake.Integer), (W, Polymake.Rational), (U, Float64)] + for (mat, ElType) in [(V, Polymake.Integer), (W, Polymake.Rational), (U, Float64), (Y, Polymake.QuadraticExtension{Polymake.Rational})] op = * @test op(T(2), mat) isa Polymake.SparseMatrix{ElType} @test op(mat, T(2)) isa Polymake.SparseMatrix{ElType} @@ -315,10 +361,16 @@ using SparseArrays @test broadcast(op, T(2), mat) isa Polymake.SparseMatrix{ElType} @test broadcast(op, mat, T(2)) isa Polymake.SparseMatrix{ElType} end + let (op, ElType) = (//, Polymake.QuadraticExtension{Polymake.Rational}) + mat = Y + @test op(mat, T(2)) isa Polymake.SparseMatrix{ElType} + @test broadcast(op, T(2), mat) isa Polymake.SparseMatrix{ElType} + @test broadcast(op, mat, T(2)) isa Polymake.SparseMatrix{ElType} + end end for T in rational_scalar_types - for (mat, ElType) in [(V, Polymake.Rational), (W, Polymake.Rational), (U, Float64)] + for (mat, ElType) in [(V, Polymake.Rational), (W, Polymake.Rational), (U, Float64), (Y, Polymake.QuadraticExtension{Polymake.Rational})] op = * @test op(T(2), mat) isa Polymake.SparseMatrix{ElType} @@ -373,11 +425,12 @@ using SparseArrays end end - for T in [int_scalar_types; rational_scalar_types; FloatTypes] + for T in [int_scalar_types; rational_scalar_types; FloatTypes; Polymake.QuadraticExtension{Polymake.Rational}] @test T(2)*X == X*T(2) == T(2) .* X == X .* T(2) == 2jl_m @test T(2)*V == V*T(2) == T(2) .* V == V .* T(2) == 2jl_m @test T(2)*W == W*T(2) == T(2) .* W == W .* T(2) == 2jl_w @test T(2)*U == U*T(2) == T(2) .* U == U .* T(2) == 2jl_u + @test T(2)*Y == Y*T(2) == T(2) .* Y == Y .* T(2) == 2jl_y @test X + T.(jl_m) == T.(jl_m) + X == X .+ T.(jl_m) == T.(jl_m) .+ X == 2jl_m @@ -386,6 +439,8 @@ using SparseArrays @test W + T.(4jl_w) == T.(4jl_w) + W == W .+ T.(4jl_w) == T.(4jl_w) .+ W == 5jl_w @test U + T.(4jl_u) == T.(4jl_u) + U == U .+ T.(4jl_u) == T.(4jl_u) .+ U == 5jl_u + + @test Y + T.(2 * jl_m) == T.(2 * jl_m) + Y == Y .+ T.(2 * jl_m) == T.(2 * jl_m) .+ Y == (1 + sr2) * jl_y end end diff --git a/test/sparsevector.jl b/test/sparsevector.jl index 4c3ecdec..1ccb7749 100644 --- a/test/sparsevector.jl +++ b/test/sparsevector.jl @@ -3,7 +3,7 @@ using SparseArrays IntTypes = [Int32, Int64, UInt64, BigInt] FloatTypes = [Float32, Float64, BigFloat] - for T in [Int64, Polymake.Integer, Polymake.Rational, Float64] + for T in [Int64, Polymake.Integer, Polymake.Rational, Float64, Polymake.QuadraticExtension{Polymake.Rational}] @test Polymake.SparseVector{T} <: AbstractSparseVector @test Polymake.spzeros(T, 3) isa AbstractSparseVector @test Polymake.spzeros(T, 3) isa Polymake.SparseVector @@ -29,7 +29,7 @@ using SparseArrays @test Polymake.SparseVector(jl_s//1) isa Polymake.SparseVector{Polymake.Rational} @test Polymake.SparseVector(jl_s/1) isa Polymake.SparseVector{Float64} - for ElType in [Polymake.Integer, Polymake.Rational, Float64] + for ElType in [Polymake.Integer, Polymake.Rational, Float64, Polymake.QuadraticExtension{Polymake.Rational}] for v in [jl_v, jl_v//T(1), jl_v/T(1)] @test Polymake.SparseVector{ElType}(v) isa Polymake.SparseVector{ElType} @test convert(Polymake.SparseVector{ElType}, v) isa Polymake.SparseVector{ElType} @@ -88,7 +88,7 @@ using SparseArrays end @testset "Low-level operations" begin - for (E,s) in [(Int64, "long"), (Polymake.Integer, "pm::Integer"), (Polymake.Rational, "pm::Rational"), (Float64, "double")] + for (E,s) in [(Int64, "long"), (Polymake.Integer, "pm::Integer"), (Polymake.Rational, "pm::Rational"), (Float64, "double"), (Polymake.QuadraticExtension{Polymake.Rational}, "pm::QuadraticExtension ")] @testset "Polymake.SparseVector{$E}" begin V = Polymake.SparseVector{E}(jl_v) @@ -122,6 +122,7 @@ using SparseArrays V = Polymake.SparseVector{Polymake.Integer}(3) W = Polymake.SparseVector{Polymake.Rational}(3) U = Polymake.SparseVector{Float64}(3) + Y = Polymake.SparseVector{Polymake.QuadraticExtension{Polymake.Rational}}(3) #TODO T.(jl_s) @test (V .= T.(jl_v)) isa Polymake.SparseVector{Polymake.Integer} @@ -132,8 +133,11 @@ using SparseArrays @test (U .= T.(jl_v)) isa Polymake.SparseVector{Float64} @test (U .= T.(jl_v).//1) isa Polymake.SparseVector{Float64} + + @test (Y .= T.(jl_v)) isa Polymake.SparseVector{Polymake.QuadraticExtension{Polymake.Rational}} + @test (Y .= T.(jl_v).//1) isa Polymake.SparseVector{Polymake.QuadraticExtension{Polymake.Rational}} - @test U == V == W + @test U == V == W == Y # TODO: # @test (V .== jl_v) isa BitArray @@ -166,6 +170,9 @@ using SparseArrays W = Polymake.SparseVector{Polymake.Rational}(jl_w) jl_u = jl_v/4 U = Polymake.SparseVector{Float64}(jl_u) + sr2 = Polymake.QuadraticExtension{Polymake.Rational}(0, 1, 2) + jl_y = sr2 * jl_v + Y = Polymake.SparseVector{Polymake.QuadraticExtension{Polymake.Rational}}(jl_y) @test -X isa Polymake.SparseVectorAllocated{Polymake.to_cxx_type(Int64)} @test -X == -jl_v @@ -178,6 +185,9 @@ using SparseArrays @test -U isa Polymake.SparseVectorAllocated{Float64} @test -U == -jl_u + + @test -Y isa Polymake.SparseVector{Polymake.QuadraticExtension{Polymake.Rational}} + @test -Y == -jl_y int_scalar_types = [IntTypes; Polymake.Integer] rational_scalar_types = [[Base.Rational{T} for T in IntTypes]; Polymake.Rational] @@ -186,7 +196,7 @@ using SparseArrays @test Int32(2)X isa Polymake.SparseVector{Polymake.to_cxx_type(Int64)} for T in int_scalar_types - for (vec, ElType) in [(V, Polymake.Integer), (W, Polymake.Rational), (U, Float64)] + for (vec, ElType) in [(V, Polymake.Integer), (W, Polymake.Rational), (U, Float64), (Y, Polymake.QuadraticExtension{Polymake.Rational})] op = * @test op(T(2), vec) isa Polymake.SparseVector{ElType} @test op(vec, T(2)) isa Polymake.SparseVector{ElType} @@ -217,10 +227,16 @@ using SparseArrays @test broadcast(op, T(2), vec) isa Polymake.SparseVector{ElType} @test broadcast(op, vec, T(2)) isa Polymake.SparseVector{ElType} end + let (op, ElType) = (//, Polymake.QuadraticExtension{Polymake.Rational}) + vec = Y + @test op(vec, T(2)) isa Polymake.SparseVector{ElType} + @test broadcast(op, T(2), vec) isa Polymake.SparseVector{ElType} + @test broadcast(op, vec, T(2)) isa Polymake.SparseVector{ElType} + end end for T in rational_scalar_types - for (vec, ElType) in [(V, Polymake.Rational), (W, Polymake.Rational), (U, Float64)] + for (vec, ElType) in [(V, Polymake.Rational), (W, Polymake.Rational), (U, Float64), (Y, Polymake.QuadraticExtension{Polymake.Rational})] op = * @test op(T(2), vec) isa Polymake.SparseVector{ElType} @@ -275,11 +291,12 @@ using SparseArrays end end - for T in [int_scalar_types; rational_scalar_types; FloatTypes] + for T in [int_scalar_types; rational_scalar_types; FloatTypes; Polymake.QuadraticExtension{Polymake.Rational}] @test T(2)*X == X*T(2) == T(2) .* X == X .* T(2) == 2jl_v @test T(2)*V == V*T(2) == T(2) .* V == V .* T(2) == 2jl_v @test T(2)*W == W*T(2) == T(2) .* W == W .* T(2) == 2jl_w @test T(2)*U == U*T(2) == T(2) .* U == U .* T(2) == 2jl_u + @test T(2)*Y == Y*T(2) == T(2) .* Y == Y .* T(2) == 2jl_y @test X + T.(jl_v) == T.(jl_v) + X == X .+ T.(jl_v) == T.(jl_v) .+ X == 2jl_v @@ -288,6 +305,8 @@ using SparseArrays @test W + T.(4jl_w) == T.(4jl_w) + W == W .+ T.(4jl_w) == T.(4jl_w) .+ W == 5jl_w @test U + T.(4jl_u) == T.(4jl_u) + U == U .+ T.(4jl_u) == T.(4jl_u) .+ U == 5jl_u + + @test Y + T.(2 * jl_v) == T.(2 * jl_v) + Y == Y .+ T.(2 * jl_v) == T.(2 * jl_v) .+ Y == (1 + sr2) * jl_y end end diff --git a/test/vectors.jl b/test/vectors.jl index 742a051b..dbce19ea 100644 --- a/test/vectors.jl +++ b/test/vectors.jl @@ -2,7 +2,7 @@ IntTypes = [Int32, Int64, UInt64, BigInt] FloatTypes = [Float32, Float64, BigFloat] - for T in [Int64, Polymake.Integer, Polymake.Rational, Float64] + for T in [Int64, Polymake.Integer, Polymake.Rational, Float64, Polymake.QuadraticExtension{Polymake.Rational}] @test Polymake.Vector{T} <: AbstractVector @test Polymake.Vector{T}(undef, 3) isa AbstractVector @test Polymake.Vector{T}(undef, 3) isa Polymake.Vector @@ -161,6 +161,33 @@ @test V[2] ≈ 10/3 @test string(V) == "pm::Vector\n1.66667 3.33333 3" end + + @testset "Polymake.Vector{Polymake.QuadraticExtension{Polymake.Rational}}" begin + V = Polymake.Vector{Polymake.QuadraticExtension{Polymake.Rational}}(jl_v) + + @test eltype(V) == Polymake.QuadraticExtension{Polymake.Rational} + + @test_throws BoundsError V[0] + @test_throws BoundsError V[5] + + @test length(V) == 3 + @test size(V) == (3,) + + for T in [IntTypes; Polymake.Integer] + @test setindex!(V, T(5)//T(3), 1) isa Polymake.Vector{Polymake.QuadraticExtension{Polymake.Rational}} + @test V[T(1)] isa Polymake.QuadraticExtension{Polymake.Rational} + @test V[T(1)] == 5//3 + # testing the return value of brackets operator + if T != Polymake.Integer + @test V[2] = T(10)//T(3) isa Base.Rational{T} + else + @test V[2] = T(10)//T(3) isa Polymake.Rational + end + V[2] = T(10)//T(3) + @test V[2] == 10//3 + @test string(V) == "pm::Vector >\n5/3 10/3 3" + end + end end @testset "Equality" begin @@ -168,6 +195,7 @@ V = Polymake.Vector{Polymake.Integer}(undef, 3) W = Polymake.Vector{Polymake.Rational}(undef, 3) U = Polymake.Vector{Float64}(undef, 3) + Y = Polymake.Vector{Polymake.QuadraticExtension{Polymake.Rational}}(undef, 3) for T in [IntTypes; Polymake.Integer] @test (X .= T.(jl_v)) isa Polymake.Vector{Polymake.to_cxx_type(Int64)} @@ -181,8 +209,11 @@ @test (U .= T.(jl_v)) isa Polymake.Vector{Float64} @test (U .= T.(jl_v).//1) isa Polymake.Vector{Float64} + + @test (Y .= T.(jl_v)) isa Polymake.Vector{Polymake.QuadraticExtension{Polymake.Rational}} + @test (Y .= T.(jl_v).//1) isa Polymake.Vector{Polymake.QuadraticExtension{Polymake.Rational}} - @test X == U == V == W + @test X == U == V == W == Y # TODO: # @test (V .== jl_v) isa BitPolymake.Array @@ -205,6 +236,9 @@ W = Polymake.Vector{Polymake.Rational}(jl_w) jl_u = jl_v/4 U = Polymake.Vector{Float64}(jl_u) + sr2 = Polymake.QuadraticExtension{Polymake.Rational}(0, 1, 2) + jl_y = sr2 * jl_v + Y = Polymake.Vector{Polymake.QuadraticExtension{Polymake.Rational}}(jl_y) @test similar(V, Float64) isa Polymake.Polymake.VectorAllocated{Float64} @test similar(V, Float64, 10) isa Polymake.Polymake.VectorAllocated{Float64} @@ -224,6 +258,9 @@ @test -U isa Polymake.Polymake.VectorAllocated{Float64} @test -U == -jl_u + + @test -Y isa Polymake.Polymake.Vector{Polymake.QuadraticExtension{Polymake.Rational}} + @test -Y == -jl_y int_scalar_types = [IntTypes; Polymake.Integer] rational_scalar_types = [[Base.Rational{T} for T in IntTypes]; Polymake.Rational] @@ -232,7 +269,7 @@ @test Int32(2)X isa Polymake.Vector{Polymake.to_cxx_type(Int64)} for T in int_scalar_types - for (vec, ElType) in [(V, Polymake.Integer), (W, Polymake.Rational), (U, Float64)] + for (vec, ElType) in [(V, Polymake.Integer), (W, Polymake.Rational), (U, Float64), (Y, Polymake.QuadraticExtension{Polymake.Rational})] op = * @test op(T(2), vec) isa Polymake.Vector{ElType} @test op(vec, T(2)) isa Polymake.Vector{ElType} @@ -262,10 +299,16 @@ @test broadcast(op, T(2), vec) isa Polymake.Vector{ElType} @test broadcast(op, vec, T(2)) isa Polymake.Vector{ElType} end + let (op, ElType) = (//, Polymake.QuadraticExtension{Polymake.Rational}) + vec = Y + @test op(vec, T(2)) isa Polymake.Vector{ElType} + @test broadcast(op, T(2), vec) isa Polymake.Vector{ElType} + @test broadcast(op, vec, T(2)) isa Polymake.Vector{ElType} + end end for T in rational_scalar_types - for (vec, ElType) in [(V, Polymake.Rational), (W, Polymake.Rational), (U, Float64)] + for (vec, ElType) in [(V, Polymake.Rational), (W, Polymake.Rational), (U, Float64), (Y, Polymake.QuadraticExtension{Polymake.Rational})] op = * @test op(T(2), vec) isa Polymake.Vector{ElType} @test op(vec, T(2)) isa Polymake.Vector{ElType} @@ -321,11 +364,12 @@ end end - for T in [int_scalar_types; rational_scalar_types; FloatTypes] + for T in [int_scalar_types; rational_scalar_types; FloatTypes; Polymake.QuadraticExtension{Polymake.Rational}] @test T(2)*X == X*T(2) == T(2) .* X == X .* T(2) == 2jl_v @test T(2)*V == V*T(2) == T(2) .* V == V .* T(2) == 2jl_v @test T(2)*W == W*T(2) == T(2) .* W == W .* T(2) == 2jl_w @test T(2)*U == U*T(2) == T(2) .* U == U .* T(2) == 2jl_u + @test T(2)*Y == Y*T(2) == T(2) .* Y == Y .* T(2) == 2jl_y @test X + T.(jl_v) == T.(jl_v) + X == X .+ T.(jl_v) == T.(jl_v) .+ X == 2jl_v @@ -334,6 +378,8 @@ @test W + T.(4jl_w) == T.(4jl_w) + W == W .+ T.(4jl_w) == T.(4jl_w) .+ W == 5jl_w @test U + T.(4jl_u) == T.(4jl_u) + U == U .+ T.(4jl_u) == T.(4jl_u) .+ U == 5jl_u + + @test Y + T.(2 * jl_v) == T.(2 * jl_v) + Y == Y .+ T.(2 * jl_v) == T.(2 * jl_v) .+ Y == (1 + sr2) * jl_y end end From 470b1272c4c8323b2498f88c86caa46b61f33b89 Mon Sep 17 00:00:00 2001 From: Alexej Jordan Date: Tue, 8 Feb 2022 17:48:42 +0100 Subject: [PATCH 2/2] extended meta file for type detection, included new testfile, added tests for accessing big objects --- src/meta.jl | 3 ++- test/perlobj.jl | 4 ++++ test/runtests.jl | 1 + 3 files changed, 7 insertions(+), 1 deletion(-) diff --git a/src/meta.jl b/src/meta.jl index e97d1bd0..b2868267 100644 --- a/src/meta.jl +++ b/src/meta.jl @@ -1,7 +1,7 @@ module Meta import JSON import Polymake: appname_module_dict, module_appname_dict, shell_context_help -import Polymake: Rational, PolymakeType, PropertyValue, OptionSet +import Polymake: Rational, PolymakeType, PropertyValue, OptionSet, QuadraticExtension struct UnparsablePolymakeFunction <: Exception msg::String @@ -33,6 +33,7 @@ translate_type_to_pm_string(::Type{<:Base.Rational}) = "Rational" translate_type_to_pm_string(::Type{<:Base.Integer}) = "Integer" translate_type_to_pm_string(::typeof(min)) = "Min" translate_type_to_pm_string(::typeof(max)) = "Max" +translate_type_to_pm_string(::Type{<:QuadraticExtension{T}}) where T = string("QuadraticExtension<", translate_type_to_pm_string(T), ">") translate_type_to_pm_string(T) = throw(DomainError(T, "$T has been passed as a type parameter but no translation to a C++ template was defined. You may define such translation by appropriately extending `Polymake.Meta.translate_type_to_pm_string`.")) diff --git a/test/perlobj.jl b/test/perlobj.jl index cf996609..c2276fe8 100644 --- a/test/perlobj.jl +++ b/test/perlobj.jl @@ -136,6 +136,10 @@ c = polytope.cube(3, 1//4, -1//4) @test c.VERTICES[1,2] == -1//4 + + i = Polymake.polytope.icosahedron() + @test i.VERTICES[1, :] == [1, 0, Polymake.QuadraticExtension{Polymake.Rational}(1//4, 1//4, 5), 1//2] + @test i.VOLUME == Polymake.QuadraticExtension{Polymake.Rational}(5//4, 5//12, 5) end @testset "attachments" begin diff --git a/test/runtests.jl b/test/runtests.jl index 924b9db4..4e8261d5 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -12,6 +12,7 @@ struct MyInt x::Int end # needed in test/convert.jl @testset "Polymake" begin include("integers.jl") include("rationals.jl") + include("quadraticextension.jl") include("vectors.jl") include("sparsevector.jl") include("matrices.jl")