Merge pull request #21 from fingolfin/mh/obsolete

Avoid obsolete names for functions and types

Author: ederc

docs/src/groebner-bases.md

@@ -27,7 +27,7 @@ At the moment different variants of Faugère's F4 Algorithm are implemented.
 
 ```@docs
     groebner_basis(
-        I::Ideal{T} where T <: MPolyElem;
+        I::Ideal{T} where T <: MPolyRingElem;
         initial_hts::Int=17,
         nr_thrds::Int=1,
         max_nr_pairs::Int=0,
@@ -46,7 +46,7 @@ variables of the first block via the `eliminate` parameter in the
 
 ```@docs
     eliminate(
-        I::Ideal{T} where T <: MPolyElem,
+        I::Ideal{T} where T <: MPolyRingElem,
         eliminate::Int;
         initial_hts::Int=17,
         nr_thrds::Int=1,

docs/src/solvers.md

@@ -26,7 +26,7 @@ The underlying engine is provided by msolve.
 
 ```@docs
     rational_parametrization(
-        I::Ideal{T} where T <: MPolyElem;
+        I::Ideal{T} where T <: MPolyRingElem;
         initial_hts::Int=17,
         nr_thrds::Int=1,
         max_nr_pairs::Int=0,
@@ -36,7 +36,7 @@ The underlying engine is provided by msolve.
         )
 
     real_solutions(
-        I::Ideal{T} where T <: MPolyElem;
+        I::Ideal{T} where T <: MPolyRingElem;
         initial_hts::Int=17,
         nr_thrds::Int=1,
         max_nr_pairs::Int=0,
@@ -45,7 +45,7 @@ The underlying engine is provided by msolve.
         precision::Int=32
         )
     rational_solutions(
-        I::Ideal{T} where T <: MPolyElem;
+        I::Ideal{T} where T <: MPolyRingElem;
         initial_hts::Int=17,
         nr_thrds::Int=1,
         max_nr_pairs::Int=0,

docs/src/types.md

@@ -26,15 +26,15 @@ We use [Nemo](https://www.nemocas.org/index.html)'s multivariate polynomial
 ring structures:
 
 ```@repl
-R, (x,y,z) = PolynomialRing(QQ, ["x", "y", "z"], ordering=:degrevlex)
+R, (x,y,z) = polynomial_ring(QQ, ["x", "y", "z"], ordering=:degrevlex)
 ```
 The above example defines a multivariate polynomial ring in three variables `x`, 
 `y`, and `z` over the rationals using the dgree reverse lexicographical ordering 
 for printing polynomials in the following. One can also define polynomial rings 
 over finite fields:
 
 ```@repl
-R, (x,y,z) = PolynomialRing(GF(101), ["x", "y", "z"], ordering=:degrevlex)
+R, (x,y,z) = polynomial_ring(GF(101), ["x", "y", "z"], ordering=:degrevlex)
 ```
 
 ## Ideals
@@ -44,7 +44,7 @@ data structures connected to ideals in order to make computational algebra more
 effective:
 
 ```@repl
-R, (x,y,z) = PolynomialRing(QQ, ["x", "y", "z"], ordering=:degrevlex)
+R, (x,y,z) = polynomial_ring(QQ, ["x", "y", "z"], ordering=:degrevlex)
 I = Ideal([x+y+1, y*z^2-13*y^2])
 ```
 

src/algorithms/groebner-bases.jl

@@ -3,7 +3,7 @@ import msolve_jll: libneogb
 export groebner_basis, eliminate
 
 @doc Markdown.doc"""
-    eliminate(I::Ideal{T} where T <: MPolyElem, eliminate::Int,  <keyword arguments>)
+    eliminate(I::Ideal{T} where T <: MPolyRingElem, eliminate::Int,  <keyword arguments>)
 
 Compute a Groebner basis of the ideal `I` w.r.t. to the product monomial ordering defined by two blocks
 w.r.t. the degree reverse lexicographical monomial ordering using Faugère's F4 algorithm. Hereby the first block includes
@@ -14,7 +14,7 @@ At the moment the underlying algorithm is based on variants of Faugère's F4 Alg
 **Note**: At the moment only ground fields of characteristic `p`, `p` prime, `p < 2^{31}` are supported.
 
 # Arguments
-- `I::Ideal{T} where T <: MPolyElem`: input generators.
+- `I::Ideal{T} where T <: MPolyRingElem`: input generators.
 - `initial_hts::Int=17`: initial hash table size `log_2`.
 - `nr_thrds::Int=1`: number of threads for parallel linear algebra.
 - `max_nr_pairs::Int=0`: maximal number of pairs per matrix, only bounded by minimal degree if `0`.
@@ -26,19 +26,19 @@ At the moment the underlying algorithm is based on variants of Faugère's F4 Alg
 ```jldoctest
 julia> using AlgebraicSolving
 
-julia> R, (x,y,z) = PolynomialRing(GF(101),["x","y","z"], ordering=:degrevlex)
-(Multivariate polynomial ring in 3 variables over GF(101), Nemo.fpMPolyRingElem[x, y, z])
+julia> R, (x,y,z) = polynomial_ring(GF(101),["x","y","z"], ordering=:degrevlex)
+(Multivariate polynomial ring in 3 variables over GF(101), fpMPolyRingElem[x, y, z])
 
 julia> I = Ideal([x+2*y+2*z-1, x^2+2*y^2+2*z^2-x, 2*x*y+2*y*z-y])
-Nemo.fpMPolyRingElem[x + 2*y + 2*z + 100, x^2 + 2*y^2 + 2*z^2 + 100*x, 2*x*y + 2*y*z + 100*y]
+fpMPolyRingElem[x + 2*y + 2*z + 100, x^2 + 2*y^2 + 2*z^2 + 100*x, 2*x*y + 2*y*z + 100*y]
 
 julia> eliminate(I, 2)
-1-element Vector{Nemo.fpMPolyRingElem}:
+1-element Vector{fpMPolyRingElem}:
  z^4 + 38*z^3 + 95*z^2 + 95*z
 ```
 """
 function eliminate(
-        I::Ideal{T} where T <: MPolyElem,
+        I::Ideal{T} where T <: MPolyRingElem,
         eliminate::Int;
         initial_hts::Int=17,
         nr_thrds::Int=1,
@@ -59,15 +59,15 @@ function eliminate(
 end
 
 @doc Markdown.doc"""
-    groebner_basis(I::Ideal{T} where T <: MPolyElem, <keyword arguments>)
+    groebner_basis(I::Ideal{T} where T <: MPolyRingElem, <keyword arguments>)
 
 Compute a Groebner basis of the ideal `I` w.r.t. to the degree reverse lexicographical monomial ordering using Faugère's F4 algorithm.
 At the moment the underlying algorithm is based on variants of Faugère's F4 Algorithm.
 
 **Note**: At the moment only ground fields of characteristic `p`, `p` prime, `p < 2^{31}` are supported.
 
 # Arguments
-- `I::Ideal{T} where T <: MPolyElem`: input generators.
+- `I::Ideal{T} where T <: MPolyRingElem`: input generators.
 - `initial_hts::Int=17`: initial hash table size `log_2`.
 - `nr_thrds::Int=1`: number of threads for parallel linear algebra.
 - `max_nr_pairs::Int=0`: maximal number of pairs per matrix, only bounded by minimal degree if `0`.
@@ -80,26 +80,26 @@ At the moment the underlying algorithm is based on variants of Faugère's F4 Alg
 ```jldoctest
 julia> using AlgebraicSolving
 
-julia> R, (x,y,z) = PolynomialRing(GF(101),["x","y","z"], ordering=:degrevlex)
-(Multivariate polynomial ring in 3 variables over GF(101), Nemo.fpMPolyRingElem[x, y, z])
+julia> R, (x,y,z) = polynomial_ring(GF(101),["x","y","z"], ordering=:degrevlex)
+(Multivariate polynomial ring in 3 variables over GF(101), fpMPolyRingElem[x, y, z])
 
 julia> I = Ideal([x+2*y+2*z-1, x^2+2*y^2+2*z^2-x, 2*x*y+2*y*z-y])
-Nemo.fpMPolyRingElem[x + 2*y + 2*z + 100, x^2 + 2*y^2 + 2*z^2 + 100*x, 2*x*y + 2*y*z + 100*y]
+fpMPolyRingElem[x + 2*y + 2*z + 100, x^2 + 2*y^2 + 2*z^2 + 100*x, 2*x*y + 2*y*z + 100*y]
 
 julia> groebner_basis(I)
-4-element Vector{Nemo.fpMPolyRingElem}:
+4-element Vector{fpMPolyRingElem}:
  x + 2*y + 2*z + 100
  y*z + 82*z^2 + 10*y + 40*z
  y^2 + 60*z^2 + 20*y + 81*z
  z^3 + 28*z^2 + 64*y + 13*z
 
 julia> groebner_basis(I, eliminate=2)
-1-element Vector{Nemo.fpMPolyRingElem}:
+1-element Vector{fpMPolyRingElem}:
  z^4 + 38*z^3 + 95*z^2 + 95*z
 ```
 """
 function groebner_basis(
-        I::Ideal{T} where T <: MPolyElem;
+        I::Ideal{T} where T <: MPolyRingElem;
         initial_hts::Int=17,
         nr_thrds::Int=1,
         max_nr_pairs::Int=0,
@@ -119,7 +119,7 @@ function groebner_basis(
 end
 
 function _core_groebner_basis(
-        I::Ideal{T} where T <: MPolyElem;
+        I::Ideal{T} where T <: MPolyRingElem;
         initial_hts::Int=17,
         nr_thrds::Int=1,
         max_nr_pairs::Int=0,