From 70364d8af2ac176b3d58c6cf6b330d1ae244140e Mon Sep 17 00:00:00 2001 From: Hans Schoenemann Date: Mon, 5 Feb 2024 16:09:33 +0100 Subject: [PATCH 01/13] create correct Singular coeffs with create_ring_from_singular_ring --- deps/src/coeffs.cpp | 24 ++++++++++++++++++++++++ src/caller.jl | 6 ++++++ 2 files changed, 30 insertions(+) diff --git a/deps/src/coeffs.cpp b/deps/src/coeffs.cpp index 14c7e0667..1fbe7c1c0 100644 --- a/deps/src/coeffs.cpp +++ b/deps/src/coeffs.cpp @@ -236,6 +236,30 @@ void singular_define_coeffs(jlcxx::Module & Singular) return bool(nCoeff_is_algExt(n)); }); + Singular.method("nCoeff_is_Nemo_AnticNumberField", [](coeffs n) { + return n->type==n_Nemo_AnticNumberField; + }); + + Singular.method("nCoeff_is_Nemo_QQField", [](coeffs n) { + return n->type==n_Nemo_QQField; + }); + + Singular.method("nCoeff_is_Nemo_ZZRing", [](coeffs n) { + return n->type==n_Nemo_ZZRing; + }); + + Singular.method("nCoeff_is_Nemo_FqPolyRepField", [](coeffs n) { + return n->type==n_Nemo_FqPolyRepField; + }); + + Singular.method("nCoeff_is_Nemo_fqPolyRepField", [](coeffs n) { + return n->type==n_Nemo_fqPolyRepField; + }); + + Singular.method("nCoeff_is_Nemo_Field", [](coeffs n) { + return n->type==n_Nemo_Field; + }); + /* make a copy of a coefficient domain (actually just increments a * reference count) */ Singular.method("nCopyCoeff", &nCopyCoeff); diff --git a/src/caller.jl b/src/caller.jl index ae23e0502..b7b105fc1 100644 --- a/src/caller.jl +++ b/src/caller.jl @@ -192,6 +192,12 @@ function create_ring_from_singular_ring(r::libSingular.ring_ptr) minpoly = F(libSingular.algExt_GetMinpoly(c, F.ptr)) basering = N_AlgExtField(libSingular.nCopyCoeff(c), minpoly) T = n_algExt + elseif libSingular.nCoeff_is_Nemo_Field(c) + basering = N_Field(libSingular.nCopyCoeff(c)) + T = Nemo.Field + elseif libSingular.nCoeff_is_Nemo_Ring(c) + basering = N_Ring(libSingular.nCopyCoeff(c)) + T = Nemo.Ring else basering = N_UnknownSingularCoefficientRing(libSingular.nCopyCoeff(c)) T = n_unknownsingularcoefficient From b5954e6a20382971a5378e4be5d3c535e594fc20 Mon Sep 17 00:00:00 2001 From: Hans Schoenemann Date: Mon, 5 Feb 2024 16:19:35 +0100 Subject: [PATCH 02/13] add nCoeff_is_Nemo_Ring --- deps/src/coeffs.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/deps/src/coeffs.cpp b/deps/src/coeffs.cpp index 1fbe7c1c0..83b09a390 100644 --- a/deps/src/coeffs.cpp +++ b/deps/src/coeffs.cpp @@ -260,6 +260,10 @@ void singular_define_coeffs(jlcxx::Module & Singular) return n->type==n_Nemo_Field; }); + Singular.method("nCoeff_is_Nemo_Ring", [](coeffs n) { + return n->type==n_Nemo_Ring; + }); + /* make a copy of a coefficient domain (actually just increments a * reference count) */ Singular.method("nCopyCoeff", &nCopyCoeff); From 1a1737430a4ed8ecf229929ca419ad0825d90688 Mon Sep 17 00:00:00 2001 From: Hans Schoenemann Date: Tue, 6 Feb 2024 11:25:08 +0100 Subject: [PATCH 03/13] use data filed for ref to basering --- deps/src/coeffs.cpp | 4 ++++ src/caller.jl | 8 ++++++-- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/deps/src/coeffs.cpp b/deps/src/coeffs.cpp index 83b09a390..f00ed7de7 100644 --- a/deps/src/coeffs.cpp +++ b/deps/src/coeffs.cpp @@ -264,6 +264,10 @@ void singular_define_coeffs(jlcxx::Module & Singular) return n->type==n_Nemo_Ring; }); + Singular.method("nGetData", [](coeffs n) { + return n->data; + }); + /* make a copy of a coefficient domain (actually just increments a * reference count) */ Singular.method("nCopyCoeff", &nCopyCoeff); diff --git a/src/caller.jl b/src/caller.jl index b7b105fc1..72cfb3449 100644 --- a/src/caller.jl +++ b/src/caller.jl @@ -193,10 +193,14 @@ function create_ring_from_singular_ring(r::libSingular.ring_ptr) basering = N_AlgExtField(libSingular.nCopyCoeff(c), minpoly) T = n_algExt elseif libSingular.nCoeff_is_Nemo_Field(c) - basering = N_Field(libSingular.nCopyCoeff(c)) + cf = libSingular.nCopyCoeff(c) + Rcf = libSingular.nGetData(c) + basering = N_Field(Ref{Neomo.Field}(Rcf)) T = Nemo.Field elseif libSingular.nCoeff_is_Nemo_Ring(c) - basering = N_Ring(libSingular.nCopyCoeff(c)) + cf = libSingular.nCopyCoeff(c) + Rcf = libSingular.nGetData(c) + basering = N_Ring(Ref{Nemo.Ring}(Rcf)) T = Nemo.Ring else basering = N_UnknownSingularCoefficientRing(libSingular.nCopyCoeff(c)) From 267ce030e89e6c43ff0eefca5c9d83bd51acef62 Mon Sep 17 00:00:00 2001 From: Hans Schoenemann Date: Tue, 6 Feb 2024 12:04:15 +0100 Subject: [PATCH 04/13] fix typo --- src/caller.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/caller.jl b/src/caller.jl index 72cfb3449..6c716e954 100644 --- a/src/caller.jl +++ b/src/caller.jl @@ -195,7 +195,7 @@ function create_ring_from_singular_ring(r::libSingular.ring_ptr) elseif libSingular.nCoeff_is_Nemo_Field(c) cf = libSingular.nCopyCoeff(c) Rcf = libSingular.nGetData(c) - basering = N_Field(Ref{Neomo.Field}(Rcf)) + basering = N_Field(Ref{Nemo.Field}(Rcf)) T = Nemo.Field elseif libSingular.nCoeff_is_Nemo_Ring(c) cf = libSingular.nCopyCoeff(c) From f16e0f3b3f5eefa634479fd763814702699a2410 Mon Sep 17 00:00:00 2001 From: Hans Schoenemann Date: Tue, 6 Feb 2024 13:47:51 +0100 Subject: [PATCH 05/13] use get_coeff_data_void --- deps/src/coeffs.cpp | 4 ---- src/caller.jl | 10 ++++++---- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/deps/src/coeffs.cpp b/deps/src/coeffs.cpp index f00ed7de7..83b09a390 100644 --- a/deps/src/coeffs.cpp +++ b/deps/src/coeffs.cpp @@ -264,10 +264,6 @@ void singular_define_coeffs(jlcxx::Module & Singular) return n->type==n_Nemo_Ring; }); - Singular.method("nGetData", [](coeffs n) { - return n->data; - }); - /* make a copy of a coefficient domain (actually just increments a * reference count) */ Singular.method("nCopyCoeff", &nCopyCoeff); diff --git a/src/caller.jl b/src/caller.jl index 6c716e954..bd9072afb 100644 --- a/src/caller.jl +++ b/src/caller.jl @@ -194,13 +194,15 @@ function create_ring_from_singular_ring(r::libSingular.ring_ptr) T = n_algExt elseif libSingular.nCoeff_is_Nemo_Field(c) cf = libSingular.nCopyCoeff(c) - Rcf = libSingular.nGetData(c) - basering = N_Field(Ref{Nemo.Field}(Rcf)) + data_ptr = get_coeff_data_void(cf) + R = unsafe_pointer_to_objref(data_ptr) + basering = N_Field(R) T = Nemo.Field elseif libSingular.nCoeff_is_Nemo_Ring(c) cf = libSingular.nCopyCoeff(c) - Rcf = libSingular.nGetData(c) - basering = N_Ring(Ref{Nemo.Ring}(Rcf)) + data_ptr = get_coeff_data_void(cf) + R = unsafe_pointer_to_objref(data_ptr) + basering = N_Ring(R) T = Nemo.Ring else basering = N_UnknownSingularCoefficientRing(libSingular.nCopyCoeff(c)) From e566cff81dbefc699b47ee52dc7ffced933e9945 Mon Sep 17 00:00:00 2001 From: Hans Schoenemann Date: Tue, 6 Feb 2024 14:50:29 +0100 Subject: [PATCH 06/13] use libSingular.get_coeff_data_void --- src/caller.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/caller.jl b/src/caller.jl index bd9072afb..654848b6f 100644 --- a/src/caller.jl +++ b/src/caller.jl @@ -194,13 +194,13 @@ function create_ring_from_singular_ring(r::libSingular.ring_ptr) T = n_algExt elseif libSingular.nCoeff_is_Nemo_Field(c) cf = libSingular.nCopyCoeff(c) - data_ptr = get_coeff_data_void(cf) + data_ptr = libSingular.get_coeff_data_void(cf) R = unsafe_pointer_to_objref(data_ptr) basering = N_Field(R) T = Nemo.Field elseif libSingular.nCoeff_is_Nemo_Ring(c) cf = libSingular.nCopyCoeff(c) - data_ptr = get_coeff_data_void(cf) + data_ptr = libSingular.get_coeff_data_void(cf) R = unsafe_pointer_to_objref(data_ptr) basering = N_Ring(R) T = Nemo.Ring From 7c38a7a14ff690e1eae9a1db98f42a6b531356da Mon Sep 17 00:00:00 2001 From: Hans Schoenemann Date: Tue, 6 Feb 2024 15:26:54 +0100 Subject: [PATCH 07/13] nGetCoeffData --- deps/src/coeffs.cpp | 4 ++++ src/caller.jl | 4 ++-- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/deps/src/coeffs.cpp b/deps/src/coeffs.cpp index 83b09a390..2fd489e8e 100644 --- a/deps/src/coeffs.cpp +++ b/deps/src/coeffs.cpp @@ -264,6 +264,10 @@ void singular_define_coeffs(jlcxx::Module & Singular) return n->type==n_Nemo_Ring; }); + Singular.method("nGetCoeffData", [](coeffs n) { + return n->data; + }); + /* make a copy of a coefficient domain (actually just increments a * reference count) */ Singular.method("nCopyCoeff", &nCopyCoeff); diff --git a/src/caller.jl b/src/caller.jl index 654848b6f..bfef8226a 100644 --- a/src/caller.jl +++ b/src/caller.jl @@ -194,13 +194,13 @@ function create_ring_from_singular_ring(r::libSingular.ring_ptr) T = n_algExt elseif libSingular.nCoeff_is_Nemo_Field(c) cf = libSingular.nCopyCoeff(c) - data_ptr = libSingular.get_coeff_data_void(cf) + data_ptr = libSingular.nGetCoeffData(cf) R = unsafe_pointer_to_objref(data_ptr) basering = N_Field(R) T = Nemo.Field elseif libSingular.nCoeff_is_Nemo_Ring(c) cf = libSingular.nCopyCoeff(c) - data_ptr = libSingular.get_coeff_data_void(cf) + data_ptr = libSingular.nGetCoeffData(cf) R = unsafe_pointer_to_objref(data_ptr) basering = N_Ring(R) T = Nemo.Ring From 6ef5fb457b4a69939865d3d6404b8feb861176bb Mon Sep 17 00:00:00 2001 From: Max Horn Date: Fri, 16 Feb 2024 16:31:23 +0100 Subject: [PATCH 08/13] fix --- src/caller.jl | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/caller.jl b/src/caller.jl index bfef8226a..107d2945b 100644 --- a/src/caller.jl +++ b/src/caller.jl @@ -196,14 +196,14 @@ function create_ring_from_singular_ring(r::libSingular.ring_ptr) cf = libSingular.nCopyCoeff(c) data_ptr = libSingular.nGetCoeffData(cf) R = unsafe_pointer_to_objref(data_ptr) - basering = N_Field(R) - T = Nemo.Field + T = elem_type(R) + basering = N_Field{T}(R) elseif libSingular.nCoeff_is_Nemo_Ring(c) cf = libSingular.nCopyCoeff(c) data_ptr = libSingular.nGetCoeffData(cf) R = unsafe_pointer_to_objref(data_ptr) - basering = N_Ring(R) - T = Nemo.Ring + T = elem_type(R) + basering = N_Ring{T}(R) else basering = N_UnknownSingularCoefficientRing(libSingular.nCopyCoeff(c)) T = n_unknownsingularcoefficient From 040f08c5e1c7b7a9b5453bdb86d26a74681926d6 Mon Sep 17 00:00:00 2001 From: Hans Schoenemann Date: Tue, 20 Feb 2024 11:27:32 +0100 Subject: [PATCH 09/13] simple test --- src/poly/poly.jl | 2 ++ test/caller-test.jl | 8 ++++++++ 2 files changed, 10 insertions(+) diff --git a/src/poly/poly.jl b/src/poly/poly.jl index e91b89a2d..6db1e0a81 100644 --- a/src/poly/poly.jl +++ b/src/poly/poly.jl @@ -31,6 +31,8 @@ export ordering_lp, ordering_ip, ordering_dp, ordering_Dp, ordering_wp, ordering parent(p::SPolyUnion) = p.parent base_ring(R::PolyRing{T}) where T <: Nemo.RingElem = R.base_ring::parent_type(T) +base_ring(R::PolyRing{N_Field{T}}) where T <: Nemo.RingElem = R.base_ring::parent_type(T) +base_ring(R::PolyRing{N_Ring{T}}) where T <: Nemo.RingElem = R.base_ring::parent_type(T) base_ring(p::spoly) = base_ring(parent(p)) diff --git a/test/caller-test.jl b/test/caller-test.jl index d47d44aa4..7039a0e2d 100644 --- a/test/caller-test.jl +++ b/test/caller-test.jl @@ -249,3 +249,11 @@ end @test Singular.libSingular.random() == 16807 @test Singular.libSingular.random() == 282475249 end + +@testset "Nemo coeffs" begin + import Pkg; Pkg.add("Nemo") + F = Nemo.fraction_field(Nemo.polynomial_ring(Nemo.ZZ)[1]) + R, x = Singular.polynomial_ring(F, [:x]) + S = Singular.create_ring_from_singular_ring(Singular.libSingular.rCopy(R.ptr)) + @test R.base_ring == S.base_ring +end From a731e8f2c08e7cb51d2f7f10d3f9643eaa58845b Mon Sep 17 00:00:00 2001 From: Hans Schoenemann Date: Tue, 20 Feb 2024 11:52:12 +0100 Subject: [PATCH 10/13] fix use of Pkg --- test/caller-test.jl | 1 - 1 file changed, 1 deletion(-) diff --git a/test/caller-test.jl b/test/caller-test.jl index 7039a0e2d..474e6f443 100644 --- a/test/caller-test.jl +++ b/test/caller-test.jl @@ -251,7 +251,6 @@ end end @testset "Nemo coeffs" begin - import Pkg; Pkg.add("Nemo") F = Nemo.fraction_field(Nemo.polynomial_ring(Nemo.ZZ)[1]) R, x = Singular.polynomial_ring(F, [:x]) S = Singular.create_ring_from_singular_ring(Singular.libSingular.rCopy(R.ptr)) From 5283b458f33a532ea19f9e5bb318504118e9ccbf Mon Sep 17 00:00:00 2001 From: Max Horn Date: Thu, 22 Feb 2024 11:01:54 +0100 Subject: [PATCH 11/13] Fix --- src/caller.jl | 8 ++++---- test/caller-test.jl | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/caller.jl b/src/caller.jl index 107d2945b..ab77ed708 100644 --- a/src/caller.jl +++ b/src/caller.jl @@ -196,14 +196,14 @@ function create_ring_from_singular_ring(r::libSingular.ring_ptr) cf = libSingular.nCopyCoeff(c) data_ptr = libSingular.nGetCoeffData(cf) R = unsafe_pointer_to_objref(data_ptr) - T = elem_type(R) - basering = N_Field{T}(R) + basering = N_Field{elem_type(R)}(R) + T = elem_type(basering) elseif libSingular.nCoeff_is_Nemo_Ring(c) cf = libSingular.nCopyCoeff(c) data_ptr = libSingular.nGetCoeffData(cf) R = unsafe_pointer_to_objref(data_ptr) - T = elem_type(R) - basering = N_Ring{T}(R) + basering = N_Ring{elem_type(R)}(R) + T = elem_type(basering) else basering = N_UnknownSingularCoefficientRing(libSingular.nCopyCoeff(c)) T = n_unknownsingularcoefficient diff --git a/test/caller-test.jl b/test/caller-test.jl index 474e6f443..5b35bb047 100644 --- a/test/caller-test.jl +++ b/test/caller-test.jl @@ -254,5 +254,5 @@ end F = Nemo.fraction_field(Nemo.polynomial_ring(Nemo.ZZ)[1]) R, x = Singular.polynomial_ring(F, [:x]) S = Singular.create_ring_from_singular_ring(Singular.libSingular.rCopy(R.ptr)) - @test R.base_ring == S.base_ring + @test base_ring(R) == base_ring(S) end From f961939792b212aff1712b9bb6b25bf109ffb49c Mon Sep 17 00:00:00 2001 From: Max Horn Date: Thu, 22 Feb 2024 11:05:26 +0100 Subject: [PATCH 12/13] Remove bad base_ring methods again --- src/poly/poly.jl | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/poly/poly.jl b/src/poly/poly.jl index 6db1e0a81..e91b89a2d 100644 --- a/src/poly/poly.jl +++ b/src/poly/poly.jl @@ -31,8 +31,6 @@ export ordering_lp, ordering_ip, ordering_dp, ordering_Dp, ordering_wp, ordering parent(p::SPolyUnion) = p.parent base_ring(R::PolyRing{T}) where T <: Nemo.RingElem = R.base_ring::parent_type(T) -base_ring(R::PolyRing{N_Field{T}}) where T <: Nemo.RingElem = R.base_ring::parent_type(T) -base_ring(R::PolyRing{N_Ring{T}}) where T <: Nemo.RingElem = R.base_ring::parent_type(T) base_ring(p::spoly) = base_ring(parent(p)) From de8f87dd436700c73486be662f443f470883c62d Mon Sep 17 00:00:00 2001 From: Max Horn Date: Thu, 22 Feb 2024 11:08:53 +0100 Subject: [PATCH 13/13] Simplify by using CoefficientRing --- src/caller.jl | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/src/caller.jl b/src/caller.jl index ab77ed708..c8a097b3e 100644 --- a/src/caller.jl +++ b/src/caller.jl @@ -192,17 +192,11 @@ function create_ring_from_singular_ring(r::libSingular.ring_ptr) minpoly = F(libSingular.algExt_GetMinpoly(c, F.ptr)) basering = N_AlgExtField(libSingular.nCopyCoeff(c), minpoly) T = n_algExt - elseif libSingular.nCoeff_is_Nemo_Field(c) + elseif libSingular.nCoeff_is_Nemo_Field(c) || libSingular.nCoeff_is_Nemo_Ring(c) cf = libSingular.nCopyCoeff(c) data_ptr = libSingular.nGetCoeffData(cf) R = unsafe_pointer_to_objref(data_ptr) - basering = N_Field{elem_type(R)}(R) - T = elem_type(basering) - elseif libSingular.nCoeff_is_Nemo_Ring(c) - cf = libSingular.nCopyCoeff(c) - data_ptr = libSingular.nGetCoeffData(cf) - R = unsafe_pointer_to_objref(data_ptr) - basering = N_Ring{elem_type(R)}(R) + basering = CoefficientRing(R) # FIXME: should we set cache=false ? T = elem_type(basering) else basering = N_UnknownSingularCoefficientRing(libSingular.nCopyCoeff(c))