Nemocas · thofma · Jan 23, 2024 · Jan 18, 2024 · Jan 18, 2024 · Jan 22, 2024
diff --git a/docs/src/free_associative_algebra.md b/docs/src/free_associative_algebra.md
@@ -100,7 +100,7 @@ multivariate polynomial interface are provided.
 
 ```julia
 symbols(S::FreeAssAlgebra)
-nvars(f::FreeAssAlgebra)
+number_of_variables(f::FreeAssAlgebra)
 gens(S::FreeAssAlgebra)
 gen(S::FreeAssAlgebra, i::Int)
 is_gen(x::FreeAssAlgElem)

diff --git a/docs/src/laurent_mpolynomial.md b/docs/src/laurent_mpolynomial.md
@@ -61,7 +61,7 @@ finish(M::LaurentMPolyBuildCtx)
 
 ```julia
 symbols(S::LaurentMPolyRing)
-nvars(f::LaurentMPolyRing)
+number_of_variables(f::LaurentMPolyRing)
 gens(S::LaurentMPolyRing)
 gen(S::LaurentMPolyRing, i::Int)
 is_gen(x::LaurentMPolyRingElem)

diff --git a/docs/src/laurent_polynomial.md b/docs/src/laurent_polynomial.md
@@ -51,7 +51,7 @@ julia> symbols(R)
 1-element Vector{Symbol}:
  :x
 
-julia> nvars(R)
+julia> number_of_variables(R)
 1
 
 julia> f = x^-2 + 2x

diff --git a/docs/src/matrix.md b/docs/src/matrix.md
@@ -395,13 +395,13 @@ dense_matrix_type(::Ring)
 ```
 
 ```@docs
-nrows(::MatSpace)
-ncols(::MatSpace)
+number_of_rows(::MatSpace)
+number_of_columns(::MatSpace)
 ```
 
 ```@docs
-nrows(::MatrixElem{T}) where T <: RingElement
-ncols(::MatrixElem{T}) where T <: RingElement
+number_of_rows(::MatrixElem{T}) where T <: RingElement
+number_of_columns(::MatrixElem{T}) where T <: RingElement
 ```
 
 ```@docs
@@ -501,10 +501,10 @@ julia> B = S([R(2) R(3) R(1); t t + 1 t + 2; R(-1) t^2 t^3])
 julia> T = dense_matrix_type(R)
 AbstractAlgebra.Generic.MatSpaceElem{AbstractAlgebra.Generic.Poly{Rational{BigInt}}}
 
-julia> r = nrows(B)
+julia> r = number_of_rows(B)
 3
 
-julia> c = ncols(B)
+julia> c = number_of_columns(B)
 3
 
 julia> length(B)

diff --git a/docs/src/matrix_interface.md b/docs/src/matrix_interface.md
@@ -170,27 +170,27 @@ E.g. in Nemo, which depends on AbstractAlgebra, we define
 `dense_matrix_type(::Type{ZZRingElem}) = ZZMatrix`.
 
 ```julia
-nrows(M::MyMatSpace{T}) where T <: RingElem
-nrows(M::MyMatAlgebra{T}) where T <: RingElem
+number_of_rows(M::MyMatSpace{T}) where T <: RingElem
+number_of_rows(M::MyMatAlgebra{T}) where T <: RingElem
 ```
 
 Return the number of rows of matrices in the matrix space.
 
 ```julia
-ncols(M:MyMatSpace{T}) where T <: RingElem
-ncols(M:MyMatAlgebra{T}) where T <: RingElem
+number_of_columns(M:MyMatSpace{T}) where T <: RingElem
+number_of_columns(M:MyMatAlgebra{T}) where T <: RingElem
 ```
 
 Return the number of columns of matrices in the matrix space.
 
 ```julia
-nrows(f::MyMat{T}) where T <: RingElem
+number_of_rows(f::MyMat{T}) where T <: RingElem
 ```
 
 Return the number of rows of the given matrix.
 
 ```julia
-ncols(f::MyMat{T}) where T <: RingElem
+number_of_columns(f::MyMat{T}) where T <: RingElem
 ```
 
 Return the number of columns of the given matrix.

diff --git a/docs/src/module.md b/docs/src/module.md
@@ -47,7 +47,7 @@ iszero(m::FPModuleElem{T}) where T <: RingElement
 Return `true` if the given module element is zero.
 
 ```julia
-ngens(M::FPModule{T}) where T <: RingElement
+number_of_generators(M::FPModule{T}) where T <: RingElement
 ```
 
 Return the number of generators of the module $M$ in its current representation.
@@ -77,7 +77,7 @@ relation is given as an AbstractAlgebra row matrix.
 julia> M = FreeModule(QQ, 2)
 Vector space of dimension 2 over rationals
 
-julia> n = ngens(M)
+julia> n = number_of_generators(M)
 2
 
 julia> G = gens(M)

diff --git a/docs/src/module_interface.md b/docs/src/module_interface.md
@@ -71,7 +71,7 @@ iszero(m::MyModuleElem{T}) where T <: RingElement
 Return `true` if the given module element is zero.
 
 ```julia
-ngens(M::MyModule{T}) where T <: RingElement
+number_of_generators(M::MyModule{T}) where T <: RingElement
 ```
 
 Return the number of generators of the module $M$ in its current representation.

diff --git a/docs/src/mpoly_interface.md b/docs/src/mpoly_interface.md
@@ -120,7 +120,7 @@ ring. Note that these are `Symbol`s not `String`s, though their string values wi
 usually be used when printing polynomials.
 
 ```julia
-nvars(f::MyMPolyRing{T}) where T <: RingElem
+number_of_variables(f::MyMPolyRing{T}) where T <: RingElem
 ```
 
 Return the number of variables of the polynomial ring.

diff --git a/docs/src/mpolynomial.md b/docs/src/mpolynomial.md
@@ -225,7 +225,7 @@ All basic functions from the Multivariate Polynomial interface are provided.
 
 ```julia
 symbols(S::MPolyRing)
-nvars(f::MPolyRing)
+number_of_variables(f::MPolyRing)
 gens(S::MPolyRing)
 gen(S::MPolyRing, i::Int)
 ```
@@ -458,7 +458,7 @@ julia> n = length(f)
 julia> is_gen(y)
 true
 
-julia> nvars(S) == 2
+julia> number_of_variables(S) == 2
 true
 
 julia> d = total_degree(f)

diff --git a/docs/src/mseries.md b/docs/src/mseries.md
@@ -226,7 +226,7 @@ for absolute series over any commutative ring.
 The following are provided for weighted and unweighted series:
 
 ```@docs
-nvars(::Generic.AbsMSeriesRing)
+number_of_variables(::Generic.AbsMSeriesRing)
 ```
 
 ```@docs

diff --git a/src/AbstractAlgebra.jl b/src/AbstractAlgebra.jl
@@ -312,6 +312,7 @@ export is_real
 export is_subset
 export is_valid
 export is_zero
+export number_of_digits
 
 @alias is_empty isempty
 @alias is_even iseven
@@ -326,6 +327,7 @@ export is_zero
 @alias is_subset issubset
 @alias is_valid isvalid
 @alias is_zero iszero
+@alias number_of_digits ndigits
 
 function order end
 
@@ -338,6 +340,20 @@ const is_symmetric = issymmetric
 const is_lower_triangular = istril
 const is_upper_triangular = istriu
 
+# alternative names for some of our own functions
+function number_of_columns end
+function number_of_generators end
+function number_of_rows end
+function number_of_variables end
+export number_of_columns
+export number_of_generators
+export number_of_rows
+export number_of_variables
+@alias ncols number_of_columns
+@alias ngens number_of_generators
+@alias nrows number_of_rows
+@alias nvars number_of_variables
+
 ###############################################################################
 # Macros for fancy printing. to use, enable attribute storage for your struct,
 # i.e.m change
@@ -719,7 +735,6 @@ import .Generic: monomial!
 import .Generic: monomials
 import .Generic: MPolyBuildCtx
 import .Generic: mullow_karatsuba
-import .Generic: ngens
 import .Generic: norm
 import .Generic: normal_form
 import .Generic: normalise
@@ -1053,16 +1068,12 @@ export multiply_column
 export multiply_column!
 export multiply_row
 export multiply_row!
-export ncols
 export newton_to_monomial!
-export ngens
 export norm
 export normal_form
 export normalise
-export nrows
 export nullspace
 export num_coeff
-export nvars
 export O
 export one
 export order

diff --git a/src/Generic.jl b/src/Generic.jl
@@ -67,7 +67,6 @@ import Base: length
 import Base: log1p
 import Base: Matrix
 import Base: mod
-import Base: ndigits
 import Base: oct
 import Base: one
 import Base: parent
@@ -205,13 +204,14 @@ import ..AbstractAlgebra: mul_classical
 import ..AbstractAlgebra: mul_karatsuba
 import ..AbstractAlgebra: mul!
 import ..AbstractAlgebra: mullow
-import ..AbstractAlgebra: ncols
+import ..AbstractAlgebra: number_of_columns
+import ..AbstractAlgebra: number_of_digits
+import ..AbstractAlgebra: number_of_generators
 import ..AbstractAlgebra: NCRing
 import ..AbstractAlgebra: NCRingElem
-import ..AbstractAlgebra: ngens
-import ..AbstractAlgebra: nrows
+import ..AbstractAlgebra: number_of_rows
 import ..AbstractAlgebra: numerator
-import ..AbstractAlgebra: nvars
+import ..AbstractAlgebra: number_of_variables
 import ..AbstractAlgebra: O
 import ..AbstractAlgebra: order
 import ..AbstractAlgebra: parent_type

diff --git a/src/Groups.jl b/src/Groups.jl
@@ -138,7 +138,7 @@
 has_gens(G::Group) = true
 
 gens(G::Group) = throw(NotImplementedError(:gens, G))
-ngens(G::Group) = throw(NotImplementedError(:ngens, G))
+number_of_generators(G::Group) = throw(NotImplementedError(:number_of_generators, G))
 
 ###############################################################################
 #

diff --git a/src/MPoly.jl b/src/MPoly.jl
@@ -80,11 +80,11 @@
 end
 
 @doc raw"""
-    ngens(R::MPolyRing)
+    number_of_generators(R::MPolyRing)
 
 Return the number of variables in `R`.
 """
-ngens(R::MPolyRing) = nvars(R)
+number_of_generators(R::MPolyRing) = number_of_variables(R)
 
 @doc raw"""
     vars(p::MPolyRingElem{T}) where {T <: RingElement}

diff --git a/src/Matrix.jl b/src/Matrix.jl
@@ -89,18 +89,18 @@
 ###############################################################################
 
 @doc raw"""
-    nrows(a::MatSpace)
+    number_of_rows(a::MatSpace)
 
 Return the number of rows of the given matrix space.
 """
-nrows(a::MatSpace) = a.nrows
+number_of_rows(a::MatSpace) = a.nrows
 
 @doc raw"""
-    ncols(a::MatSpace)
+    number_of_columns(a::MatSpace)
 
 Return the number of columns of the given matrix space.
 """
-ncols(a::MatSpace) = a.ncols
+number_of_columns(a::MatSpace) = a.ncols
 
 function Base.hash(a::MatElem, h::UInt)
    b = 0x3e4ea81eb31d94f4%UInt
@@ -114,18 +114,18 @@
 end
 
 @doc raw"""
-    nrows(a::MatrixElem{T}) where T <: NCRingElement
+    number_of_rows(a::MatrixElem{T}) where T <: NCRingElement
 
 Return the number of rows of the given matrix.
 """
-nrows(a::MatrixElem{T}) where T <: NCRingElement
+number_of_rows(a::MatrixElem{T}) where T <: NCRingElement
 
 @doc raw"""
-    ncols(a::MatrixElem{T}) where T <: NCRingElement
+    number_of_columns(a::MatrixElem{T}) where T <: NCRingElement
 
 Return the number of columns of the given matrix.
 """
-ncols(a::MatrixElem{T}) where T <: NCRingElement
+number_of_columns(a::MatrixElem{T}) where {T<:NCRingElement}
 
 @doc raw"""
     length(a::MatrixElem{T}) where T <: NCRingElement
@@ -373,7 +373,7 @@
 for `i=1,...,length(rows)` and `j=1,...,length(cols)`.
 Instead of a vector, `rows` and `cols` can also be:
 * an integer `i`, which is  interpreted as `i:i`, or
-* `:`, which is interpreted as `1:nrows(M)` or `1:ncols(M)` respectively.
+* `:`, which is interpreted as `1:number_of_rows(M)` or `1:number_of_columns(M)` respectively.
 """
 function getindex(M::MatElem, rows::AbstractVector{Int}, cols::AbstractVector{Int})
    _checkbounds(M, rows, cols)

diff --git a/src/MatrixAlgebra.jl b/src/MatrixAlgebra.jl
@@ -39,8 +39,8 @@ function Base.hash(a::MatAlgElem, h::UInt)
    return b
 end
 
-nrows(a::MatAlgebra) = a.n
-ncols(a::MatAlgebra) = nrows(a)
+number_of_rows(a::MatAlgebra) = a.n
+number_of_columns(a::MatAlgebra) = number_of_rows(a)
 
 @doc raw"""
     degree(a::MatAlgebra)

diff --git a/src/NemoStuff.jl b/src/NemoStuff.jl
@@ -187,7 +187,7 @@
     end
 end
 
-ngens(L::SimpleNumField{T}) where {T} = 1
+number_of_generators(L::SimpleNumField{T}) where {T} = 1
 
 is_unit(a::NumFieldElem) = !iszero(a)
 

diff --git a/src/Poly.jl b/src/Poly.jl
@@ -45,11 +45,11 @@ this is returned as an array of `Symbol` not `String`.
 symbols(a::PolyRing) = [a.S]
 
 @doc raw"""
-    nvars(a::PolyRing)
+    number_of_variables(a::PolyRing)
 
 Return the number of variables of the polynomial ring, which is 1.
 """
-nvars(a::PolyRing) = 1
+number_of_variables(a::PolyRing) = 1
 
 function check_parent(a::PolynomialElem, b::PolynomialElem, throw::Bool = true)
    c = parent(a) != parent(b)

diff --git a/src/generic/AbsMSeries.jl b/src/generic/AbsMSeries.jl
@@ -62,13 +62,13 @@
 length(a::AbsMSeries) = length(poly(a))
 
 @doc raw"""
-    nvars(R::AbsMSeriesRing)
+    number_of_variables(R::AbsMSeriesRing)
 
 Return the number of variables in the series ring.
 """
-nvars(R::AbsMSeriesRing) = nvars(poly_ring(R))
+number_of_variables(R::AbsMSeriesRing) = number_of_variables(poly_ring(R))
 
-ngens(R::AbsMSeriesRing) = ngens(poly_ring(R))
+number_of_generators(R::AbsMSeriesRing) = number_of_generators(poly_ring(R))
 
 @doc raw"""
     precision(a::AbsMSeries)

diff --git a/src/generic/DirectSum.jl b/src/generic/DirectSum.jl
@@ -20,7 +20,7 @@ base_ring(N::DirectSumModule{T}) where T <: RingElement = base_ring(N.m[1])
 
 base_ring(v::DirectSumModuleElem{T}) where T <: RingElement = base_ring(v.parent)
 
-ngens(N::DirectSumModule{T}) where T <: RingElement = sum(ngens(M) for M in N.m)
+number_of_generators(N::DirectSumModule{T}) where T <: RingElement = sum(ngens(M) for M in N.m)
 
 gens(N::DirectSumModule{T}) where T <: RingElement = [gen(N, i) for i = 1:ngens(N)]
 

diff --git a/src/generic/Fraction.jl b/src/generic/Fraction.jl
@@ -45,7 +45,7 @@
    return v
 end
 
-ngens(F::FracField) = ngens(base_ring(F))
+number_of_generators(F::FracField) = number_of_generators(base_ring(F))
 
 gen(F::FracField) = F(gen(base_ring(F)))