Here we compare Groebner.jl vs Singular.jl groebner implementations over fields of characteristic zero. The table below lists runtimes for several standard benchmark systems in seconds
diff --git a/developer/index.html b/developer/index.html index 5d11f1c5..4458b1de 100644 --- a/developer/index.html +++ b/developer/index.html @@ -59,7 +59,7 @@Groebner.jl is a package for fast and generic Gröbner bases computations based on Faugère's F4 algorithm written in Julia.
+Groebner.jl is a package for Gröbner bases computations based on the Faugère's F4 algorithm written in Julia.
To install Groebner.jl, run the following in the Julia REPL:
using Pkg; Pkg.add("Groebner")
See Interface for a description of all exported functions. For a quick introduction to Groebner bases we refer to Tutorials. Meanwhile, below are simple examples.
+Groebner.jl features:
+Gröbner basis computation over integers modulo a prime and over the rationals
+Gröbner trace algorithms
+Multi-threading by default
+See Interface page for a list of all exported functions.
Currently, polynomials from AbstractAlgebra.jl, DynamicPolynomials.jl, and Nemo.jl are supported as input.
+As input, Groebner.jl supports polynomials from AbstractAlgebra.jl, DynamicPolynomials.jl, and Nemo.jl.
First, import AbstractAlgebra.jl. Then, we can create an array of polynomials over a finite field
diff --git a/interface/index.html b/interface/index.html index 91ed0141..65ab09d2 100644 --- a/interface/index.html +++ b/interface/index.html @@ -59,7 +59,7 @@Using groebner_apply!
in batches (works only in :degrevlex
at the moment):
Using groebner_apply!
in batches:
using Groebner, AbstractAlgebra
R, (x, y) = polynomial_ring(GF(2^31-1), ["x", "y"], internal_ordering=:degrevlex)
@@ -622,6 +625,19 @@ Notes
Some functions in the interface have a low-level entry point. Low-level functions accept and output ''raw'' exponent vectors and coefficients. This could be convenient when one does not want to depend on a frontend.
+For example,
+using Groebner
+# define {x y - 1, x^3 + 7 y^2} modulo 65537 in DRL
+ring = Groebner.PolyRing(2, Groebner.DegRevLex(), 65537)
+monoms = [ [[1, 1], [0, 0]], [[3, 0], [0, 2]] ]
+coeffs = [ [1, -1], [1, 7] ]
+# compute a GB
+gb_monoms, gb_coeffs = Groebner.groebner(ring, monoms, coeffs)
(Vector{Vector{UInt32}}[[[0x00000001, 0x00000001], [0x00000000, 0x00000000]], [[0x00000000, 0x00000003], [0x00000002, 0x00000000]], [[0x00000003, 0x00000000], [0x00000000, 0x00000002]]], Vector{UInt32}[[0x00000001, 0x00010000], [0x00000001, 0x00004925], [0x00000001, 0x00000007]])
+The list of functions that provide a low-level entry point: groebner
, normalform
, isgroebner
, groebner_learn
, groebner_apply
.
The low-level functions may be faster than their user-facing analogues since they bypass internal checks and conversions. Low-level functions do not make any specific assumptions, that is, all of these are correctly handled in the input: unsorted monomials, nonnormalized coefficients, duplicate terms, aliasing memory.
81.782 μs (1669 allocations: 64.62 KiB)
+@btime gcd(gcd($f, $g), $h)
84.277 μs (1669 allocations: 64.62 KiB)
3 + x
With Groebner.jl:
F = [f, g, h]
-@btime groebner($F)
151.401 μs (2706 allocations: 160.52 KiB)
+@btime groebner($F)
152.125 μs (2706 allocations: 160.52 KiB)
1-element Vector{DynamicPolynomials.Polynomial{DynamicPolynomials.Commutative{DynamicPolynomials.CreationOrder}, MultivariatePolynomials.Graded{MultivariatePolynomials.LexOrder}, Rational{BigInt}}}:
3//1 + x