Ticket #3232: bkz.patch

a/c_lib/include/ntl_wrap.h

@@ -17 +17 @@
-#include <NTL/GF2EX.h>
-#include <NTL/mat_GF2E.h>
-#include <NTL/HNF.h>
+#include <NTL/LLL.h>
-#include <gmp.h>
-using namespace NTL;
-#endif

a/sage/libs/ntl/decl.pxi

@@ -737 +737 @@
-    ZZ_c* mat_ZZ_determinant(mat_ZZ_c* x, long deterministic)
-    mat_ZZ_c* mat_ZZ_HNF(mat_ZZ_c* A, ZZ_c* D)
-    ZZX_c* mat_ZZ_charpoly(mat_ZZ_c* A)
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    #### GF2_c
-    ctypedef struct GF2_c "struct GF2":
@@ -947 +988 @@
-cdef extern from "ZZ_pylong.h":
-    object ZZ_get_pylong(ZZ_c z)
-    int ZZ_set_pylong(ZZ_c z, object ll)
+
+

a/sage/libs/ntl/ntl_mat_ZZ.pyx

@@ -17 +17 @@
-include "../../ext/stdsage.pxi"
-include 'misc.pxi'
-include 'decl.pxi'
-
-cdef extern from "NTL/LLL.h":
-    cdef long mat_ZZ_LLL_FP   "LLL_FP"(mat_ZZ_c B, double delta, int deep, int check , int verbose)
-    cdef long mat_ZZ_LLL_FP_U "LLL_FP"(mat_ZZ_c B, mat_ZZ_c U, double delta, int deep, int check , int verbose)
-    cdef long mat_ZZ_LLL_QP   "LLL_QP"(mat_ZZ_c B, double delta, int deep, int check , int verbose)
-    cdef long mat_ZZ_LLL_QP_U "LLL_QP"(mat_ZZ_c B, mat_ZZ_c U, double delta, int deep, int check , int verbose)
-    cdef long mat_ZZ_LLL_XD   "LLL_XD"(mat_ZZ_c B, double delta, int deep, int check , int verbose)
-    cdef long mat_ZZ_LLL_XD_U "LLL_XD"(mat_ZZ_c B, mat_ZZ_c U, double delta, int deep, int check , int verbose)
-    cdef long mat_ZZ_LLL_RR   "LLL_RR"(mat_ZZ_c B, double delta, int deep, int check , int verbose)
-    cdef long mat_ZZ_LLL_RR_U "LLL_RR"(mat_ZZ_c B, mat_ZZ_c U, double delta, int deep, int check , int verbose)
-
-    cdef long mat_ZZ_G_LLL_FP   "G_LLL_FP"(mat_ZZ_c B, double delta, int deep, int check , int verbose)
-    cdef long mat_ZZ_G_LLL_FP_U "G_LLL_FP"(mat_ZZ_c B, mat_ZZ_c U, double delta, int deep, int check , int verbose)
-    cdef long mat_ZZ_G_LLL_QP   "G_LLL_QP"(mat_ZZ_c B, double delta, int deep, int check , int verbose)
-    cdef long mat_ZZ_G_LLL_QP_U "G_LLL_QP"(mat_ZZ_c B, mat_ZZ_c U, double delta, int deep, int check , int verbose)
-    cdef long mat_ZZ_G_LLL_XD   "G_LLL_XD"(mat_ZZ_c B, double delta, int deep, int check , int verbose)
-    cdef long mat_ZZ_G_LLL_XD_U "G_LLL_XD"(mat_ZZ_c B, mat_ZZ_c U, double delta, int deep, int check , int verbose)
-    cdef long mat_ZZ_G_LLL_RR   "G_LLL_RR"(mat_ZZ_c B, double delta, int deep, int check , int verbose)
-    cdef long mat_ZZ_G_LLL_RR_U "G_LLL_RR"(mat_ZZ_c B, mat_ZZ_c U, double delta, int deep, int check , int verbose)
-
-
-from sage.libs.ntl.ntl_ZZ cimport ntl_ZZ
@@ -441 +422 @@
-        _sig_off
-        return r
-
+    def BKZ_FP(self, U=None, delta=0.99, BlockSize=10, prune=0, verbose=False):
+        r"""
+        All BKZ methods are equivalent to the LLL routines,
+        except that Block Korkin-Zolotarev reduction is applied. We
+        describe here only the differences in the calling syntax.
+
+        * The optional parameter "BlockSize" specifies the size of the
+        blocks in the reduction. High values yield shorter vectors,
+        but the running time increases exponentially with BlockSize.
+        BlockSize should be between 2 and the number of rows of B.
+
+        * The optional parameter "prune" can be set to any positive
+        number to invoke the Volume Heuristic from [Schnorr and
+        Horner, Eurocrypt '95].  This can significantly reduce the
+        running time, and hence allow much bigger block size, but the
+        quality of the reduction is of course not as good in general.
+        Higher values of prune mean better quality, and slower running
+        time.  When prune == 0, pruning is disabled.  Recommended
+        usage: for BlockSize >= 30, set 10 <= prune <= 15.
+
+        * The QP1 variant uses quad_float precision to compute
+        Gram-Schmidt, but uses double precision in the search phase
+        of the block reduction algorithm.  This seems adequate for
+        most purposes, and is faster than QP, which uses quad_float
+        precision uniformly throughout.
+
+        INPUT:
+            U -- optional permutation matrix (see LLL, default: None)
+            delta -- reduction parameter (default: 0.99)
+            BlockSize -- see above (default: 10)
+            prune -- see above (default: 0)
+            verbose -- print verbose output (default: False)
+
+        EXAMPLE:
+            sage: A = Matrix(ZZ,5,5,range(25))
+            sage: a = A._ntl_()
+            sage: a.BKZ_FP(); a
+            2
+            [
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 1 2 3 4]
+            [5 3 1 -1 -3]
+            ]
+
+            sage: U = ntl.mat_ZZ(2,2) # note that the dimension doesn't matter
+            sage: r = a.BKZ_FP(U=U); U
+            [
+            [0 1 0 0 0]
+            [1 0 0 0 0]
+            [0 0 1 0 0]
+            [0 0 0 1 0]
+            [0 0 0 0 1]
+            ]
+        """
+        if U is None:
+            _sig_on
+            rank = mat_ZZ_BKZ_FP(self.x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        elif PY_TYPE_CHECK(U, ntl_mat_ZZ):
+            _sig_on
+            rank = mat_ZZ_BKZ_FP_U(self.x, (<ntl_mat_ZZ>U).x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        else:
+            raise TypeError, "parameter U has wrong type."
+
+    def BKZ_QP(self, U=None, delta=0.99, BlockSize=10, prune=0, verbose=False):
+        r"""
+        All BKZ methods are equivalent to the LLL routines,
+        except that Block Korkin-Zolotarev reduction is applied. We
+        describe here only the differences in the calling syntax.
+
+        * The optional parameter "BlockSize" specifies the size of the
+        blocks in the reduction. High values yield shorter vectors,
+        but the running time increases exponentially with BlockSize.
+        BlockSize should be between 2 and the number of rows of B.
+
+        * The optional parameter "prune" can be set to any positive
+        number to invoke the Volume Heuristic from [Schnorr and
+        Horner, Eurocrypt '95].  This can significantly reduce the
+        running time, and hence allow much bigger block size, but the
+        quality of the reduction is of course not as good in general.
+        Higher values of prune mean better quality, and slower running
+        time.  When prune == 0, pruning is disabled.  Recommended
+        usage: for BlockSize >= 30, set 10 <= prune <= 15.
+
+        * The QP1 variant uses quad_float precision to compute
+        Gram-Schmidt, but uses double precision in the search phase
+        of the block reduction algorithm.  This seems adequate for
+        most purposes, and is faster than QP, which uses quad_float
+        precision uniformly throughout.
+
+        INPUT:
+            U -- optional permutation matrix (see LLL, default: None)
+            delta -- reduction parameter (default: 0.99)
+            BlockSize -- see above (default: 10)
+            prune -- see above (default: 0)
+            verbose -- print verbose output (default: False)
+
+        EXAMPLE:
+            sage: A = Matrix(ZZ,5,5,range(25))
+            sage: a = A._ntl_()
+            sage: a.BKZ_QP(); a
+            2
+            [
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 1 2 3 4]
+            [5 3 1 -1 -3]
+            ]
+
+            sage: U = ntl.mat_ZZ(2,2) # note that the dimension doesn't matter
+            sage: r = a.BKZ_QP(U=U); U
+            [
+            [0 1 0 0 0]
+            [1 0 0 0 0]
+            [0 0 1 0 0]
+            [0 0 0 1 0]
+            [0 0 0 0 1]
+            ]
+        """
+        if U is None:
+            _sig_on
+            rank = mat_ZZ_BKZ_QP(self.x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        elif PY_TYPE_CHECK(U, ntl_mat_ZZ):
+            _sig_on
+            rank = mat_ZZ_BKZ_QP_U(self.x, (<ntl_mat_ZZ>U).x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        else:
+            raise TypeError, "parameter U has wrong type."
+
+    def BKZ_QP1(self, U=None, delta=0.99, BlockSize=10, prune=0, verbose=False):
+        r"""
+        All BKZ methods are equivalent to the LLL routines,
+        except that Block Korkin-Zolotarev reduction is applied. We
+        describe here only the differences in the calling syntax.
+
+        * The optional parameter "BlockSize" specifies the size of the
+        blocks in the reduction. High values yield shorter vectors,
+        but the running time increases exponentially with BlockSize.
+        BlockSize should be between 2 and the number of rows of B.
+
+        * The optional parameter "prune" can be set to any positive
+        number to invoke the Volume Heuristic from [Schnorr and
+        Horner, Eurocrypt '95].  This can significantly reduce the
+        running time, and hence allow much bigger block size, but the
+        quality of the reduction is of course not as good in general.
+        Higher values of prune mean better quality, and slower running
+        time.  When prune == 0, pruning is disabled.  Recommended
+        usage: for BlockSize >= 30, set 10 <= prune <= 15.
+
+        * The QP1 variant uses quad_float precision to compute
+        Gram-Schmidt, but uses double precision in the search phase
+        of the block reduction algorithm.  This seems adequate for
+        most purposes, and is faster than QP, which uses quad_float
+        precision uniformly throughout.
+
+        INPUT:
+            U -- optional permutation matrix (see LLL, default: None)
+            delta -- reduction parameter (default: 0.99)
+            BlockSize -- see above (default: 10)
+            prune -- see above (default: 0)
+            verbose -- print verbose output (default: False)
+
+        EXAMPLE:
+            sage: A = Matrix(ZZ,5,5,range(25))
+            sage: a = A._ntl_()
+            sage: a.BKZ_QP1(); a
+            2
+            [
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 1 2 3 4]
+            [5 3 1 -1 -3]
+            ]
+
+            sage: U = ntl.mat_ZZ(2,2) # note that the dimension doesn't matter
+            sage: r = a.BKZ_QP1(U=U); U
+            [
+            [0 1 0 0 0]
+            [1 0 0 0 0]
+            [0 0 1 0 0]
+            [0 0 0 1 0]
+            [0 0 0 0 1]
+            ]
+        """
+        if U is None:
+            _sig_on
+            rank = mat_ZZ_BKZ_QP1(self.x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        elif PY_TYPE_CHECK(U, ntl_mat_ZZ):
+            _sig_on
+            rank = mat_ZZ_BKZ_QP1_U(self.x, (<ntl_mat_ZZ>U).x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        else:
+            raise TypeError, "parameter U has wrong type."
+
+    def BKZ_XD(self, U=None, delta=0.99, BlockSize=10, prune=0, verbose=False):
+        r"""
+        All BKZ methods are equivalent to the LLL routines,
+        except that Block Korkin-Zolotarev reduction is applied. We
+        describe here only the differences in the calling syntax.
+
+        * The optional parameter "BlockSize" specifies the size of the
+        blocks in the reduction. High values yield shorter vectors,
+        but the running time increases exponentially with BlockSize.
+        BlockSize should be between 2 and the number of rows of B.
+
+        * The optional parameter "prune" can be set to any positive
+        number to invoke the Volume Heuristic from [Schnorr and
+        Horner, Eurocrypt '95].  This can significantly reduce the
+        running time, and hence allow much bigger block size, but the
+        quality of the reduction is of course not as good in general.
+        Higher values of prune mean better quality, and slower running
+        time.  When prune == 0, pruning is disabled.  Recommended
+        usage: for BlockSize >= 30, set 10 <= prune <= 15.
+
+        * The QP1 variant uses quad_float precision to compute
+        Gram-Schmidt, but uses double precision in the search phase
+        of the block reduction algorithm.  This seems adequate for
+        most purposes, and is faster than QP, which uses quad_float
+        precision uniformly throughout.
+
+        INPUT:
+            U -- optional permutation matrix (see LLL, default: None)
+            delta -- reduction parameter (default: 0.99)
+            BlockSize -- see above (default: 10)
+            prune -- see above (default: 0)
+            verbose -- print verbose output (default: False)
+
+        EXAMPLE:
+            sage: A = Matrix(ZZ,5,5,range(25))
+            sage: a = A._ntl_()
+            sage: a.BKZ_XD(); a
+            2
+            [
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 1 2 3 4]
+            [5 3 1 -1 -3]
+            ]
+
+            sage: U = ntl.mat_ZZ(2,2) # note that the dimension doesn't matter
+            sage: r = a.BKZ_XD(U=U); U
+            [
+            [0 1 0 0 0]
+            [1 0 0 0 0]
+            [0 0 1 0 0]
+            [0 0 0 1 0]
+            [0 0 0 0 1]
+            ]
+        """
+        if U is None:
+            _sig_on
+            rank = mat_ZZ_BKZ_XD(self.x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        elif PY_TYPE_CHECK(U, ntl_mat_ZZ):
+            _sig_on
+            rank = mat_ZZ_BKZ_XD_U(self.x, (<ntl_mat_ZZ>U).x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        else:
+            raise TypeError, "parameter U has wrong type."
+
+    def BKZ_RR(self, U=None, delta=0.99, BlockSize=10, prune=0, verbose=False):
+        r"""
+        All BKZ methods are equivalent to the LLL routines,
+        except that Block Korkin-Zolotarev reduction is applied. We
+        describe here only the differences in the calling syntax.
+
+        * The optional parameter "BlockSize" specifies the size of the
+        blocks in the reduction. High values yield shorter vectors,
+        but the running time increases exponentially with BlockSize.
+        BlockSize should be between 2 and the number of rows of B.
+
+        * The optional parameter "prune" can be set to any positive
+        number to invoke the Volume Heuristic from [Schnorr and
+        Horner, Eurocrypt '95].  This can significantly reduce the
+        running time, and hence allow much bigger block size, but the
+        quality of the reduction is of course not as good in general.
+        Higher values of prune mean better quality, and slower running
+        time.  When prune == 0, pruning is disabled.  Recommended
+        usage: for BlockSize >= 30, set 10 <= prune <= 15.
+
+        * The QP1 variant uses quad_float precision to compute
+        Gram-Schmidt, but uses double precision in the search phase
+        of the block reduction algorithm.  This seems adequate for
+        most purposes, and is faster than QP, which uses quad_float
+        precision uniformly throughout.
+
+        INPUT:
+            U -- optional permutation matrix (see LLL, default: None)
+            delta -- reduction parameter (default: 0.99)
+            BlockSize -- see above (default: 10)
+            prune -- see above (default: 0)
+            verbose -- print verbose output (default: False)
+
+        EXAMPLE:
+            sage: A = Matrix(ZZ,5,5,range(25))
+            sage: a = A._ntl_()
+            sage: a.BKZ_RR(); a
+            2
+            [
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 1 2 3 4]
+            [5 3 1 -1 -3]
+            ]
+
+            sage: U = ntl.mat_ZZ(2,2) # note that the dimension doesn't matter
+            sage: r = a.BKZ_RR(U=U); U
+            [
+            [0 1 0 0 0]
+            [1 0 0 0 0]
+            [0 0 1 0 0]
+            [0 0 0 1 0]
+            [0 0 0 0 1]
+            ]
+        """
+        if U is None:
+            _sig_on
+            rank = mat_ZZ_BKZ_RR(self.x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        elif PY_TYPE_CHECK(U, ntl_mat_ZZ):
+            _sig_on
+            rank = mat_ZZ_BKZ_RR_U(self.x, (<ntl_mat_ZZ>U).x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        else:
+            raise TypeError, "parameter U has wrong type."
+
+    def G_BKZ_FP(self, U=None, delta=0.99, BlockSize=10, prune=0, verbose=False):
+        r"""
+        All BKZ methods are equivalent to the LLL routines,
+        except that Block Korkin-Zolotarev reduction is applied. We
+        describe here only the differences in the calling syntax.
+
+        * The optional parameter "BlockSize" specifies the size of the
+        blocks in the reduction. High values yield shorter vectors,
+        but the running time increases exponentially with BlockSize.
+        BlockSize should be between 2 and the number of rows of B.
+
+        * The optional parameter "prune" can be set to any positive
+        number to invoke the Volume Heuristic from [Schnorr and
+        Horner, Eurocrypt '95].  This can significantly reduce the
+        running time, and hence allow much bigger block size, but the
+        quality of the reduction is of course not as good in general.
+        Higher values of prune mean better quality, and slower running
+        time.  When prune == 0, pruning is disabled.  Recommended
+        usage: for BlockSize >= 30, set 10 <= prune <= 15.
+
+        * The QP1 variant uses quad_float precision to compute
+        Gram-Schmidt, but uses double precision in the search phase
+        of the block reduction algorithm.  This seems adequate for
+        most purposes, and is faster than QP, which uses quad_float
+        precision uniformly throughout.
+
+        INPUT:
+            U -- optional permutation matrix (see LLL, default: None)
+            delta -- reduction parameter (default: 0.99)
+            BlockSize -- see above (default: 10)
+            prune -- see above (default: 0)
+            verbose -- print verbose output (default: False)
+
+        EXAMPLE:
+            sage: A = Matrix(ZZ,5,5,range(25))
+            sage: a = A._ntl_()
+            sage: a.G_BKZ_FP(); a
+            2
+            [
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 1 2 3 4]
+            [5 3 1 -1 -3]
+            ]
+
+            sage: U = ntl.mat_ZZ(2,2) # note that the dimension doesn't matter
+            sage: r = a.G_BKZ_FP(U=U); U
+            [
+            [0 1 0 0 0]
+            [1 0 0 0 0]
+            [0 0 1 0 0]
+            [0 0 0 1 0]
+            [0 0 0 0 1]
+            ]
+        """
+        if U is None:
+            _sig_on
+            rank = mat_ZZ_G_BKZ_FP(self.x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        elif PY_TYPE_CHECK(U, ntl_mat_ZZ):
+            _sig_on
+            rank = mat_ZZ_G_BKZ_FP_U(self.x, (<ntl_mat_ZZ>U).x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        else:
+            raise TypeError, "parameter U has wrong type."
+
+    def G_BKZ_QP(self, U=None, delta=0.99, BlockSize=10, prune=0, verbose=False):
+        r"""
+        All BKZ methods are equivalent to the LLL routines,
+        except that Block Korkin-Zolotarev reduction is applied. We
+        describe here only the differences in the calling syntax.
+
+        * The optional parameter "BlockSize" specifies the size of the
+        blocks in the reduction. High values yield shorter vectors,
+        but the running time increases exponentially with BlockSize.
+        BlockSize should be between 2 and the number of rows of B.
+
+        * The optional parameter "prune" can be set to any positive
+        number to invoke the Volume Heuristic from [Schnorr and
+        Horner, Eurocrypt '95].  This can significantly reduce the
+        running time, and hence allow much bigger block size, but the
+        quality of the reduction is of course not as good in general.
+        Higher values of prune mean better quality, and slower running
+        time.  When prune == 0, pruning is disabled.  Recommended
+        usage: for BlockSize >= 30, set 10 <= prune <= 15.
+
+        * The QP1 variant uses quad_float precision to compute
+        Gram-Schmidt, but uses double precision in the search phase
+        of the block reduction algorithm.  This seems adequate for
+        most purposes, and is faster than QP, which uses quad_float
+        precision uniformly throughout.
+
+        INPUT:
+            U -- optional permutation matrix (see LLL, default: None)
+            delta -- reduction parameter (default: 0.99)
+            BlockSize -- see above (default: 10)
+            prune -- see above (default: 0)
+            verbose -- print verbose output (default: False)
+
+        EXAMPLE:
+            sage: A = Matrix(ZZ,5,5,range(25))
+            sage: a = A._ntl_()
+            sage: a.G_BKZ_QP(); a
+            2
+            [
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 1 2 3 4]
+            [5 3 1 -1 -3]
+            ]
+
+            sage: U = ntl.mat_ZZ(2,2) # note that the dimension doesn't matter
+            sage: r = a.G_BKZ_QP(U=U); U
+            [
+            [0 1 0 0 0]
+            [1 0 0 0 0]
+            [0 0 1 0 0]
+            [0 0 0 1 0]
+            [0 0 0 0 1]
+            ]
+        """
+        if U is None:
+            _sig_on
+            rank = mat_ZZ_G_BKZ_QP(self.x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        elif PY_TYPE_CHECK(U, ntl_mat_ZZ):
+            _sig_on
+            rank = mat_ZZ_G_BKZ_QP_U(self.x, (<ntl_mat_ZZ>U).x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        else:
+            raise TypeError, "parameter U has wrong type."
+
+    def G_BKZ_QP1(self, U=None, delta=0.99, BlockSize=10, prune=0, verbose=False):
+        r"""
+        All BKZ methods are equivalent to the LLL routines,
+        except that Block Korkin-Zolotarev reduction is applied. We
+        describe here only the differences in the calling syntax.
+
+        * The optional parameter "BlockSize" specifies the size of the
+        blocks in the reduction. High values yield shorter vectors,
+        but the running time increases exponentially with BlockSize.
+        BlockSize should be between 2 and the number of rows of B.
+
+        * The optional parameter "prune" can be set to any positive
+        number to invoke the Volume Heuristic from [Schnorr and
+        Horner, Eurocrypt '95].  This can significantly reduce the
+        running time, and hence allow much bigger block size, but the
+        quality of the reduction is of course not as good in general.
+        Higher values of prune mean better quality, and slower running
+        time.  When prune == 0, pruning is disabled.  Recommended
+        usage: for BlockSize >= 30, set 10 <= prune <= 15.
+
+        * The QP1 variant uses quad_float precision to compute
+        Gram-Schmidt, but uses double precision in the search phase
+        of the block reduction algorithm.  This seems adequate for
+        most purposes, and is faster than QP, which uses quad_float
+        precision uniformly throughout.
+
+        INPUT:
+            U -- optional permutation matrix (see LLL, default: None)
+            delta -- reduction parameter (default: 0.99)
+            BlockSize -- see above (default: 10)
+            prune -- see above (default: 0)
+            verbose -- print verbose output (default: False)
+
+        EXAMPLE:
+            sage: A = Matrix(ZZ,5,5,range(25))
+            sage: a = A._ntl_()
+            sage: a.G_BKZ_QP1(); a
+            2
+            [
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 1 2 3 4]
+            [5 3 1 -1 -3]
+            ]
+
+            sage: U = ntl.mat_ZZ(2,2) # note that the dimension doesn't matter
+            sage: r = a.G_BKZ_QP1(U=U); U
+            [
+            [0 1 0 0 0]
+            [1 0 0 0 0]
+            [0 0 1 0 0]
+            [0 0 0 1 0]
+            [0 0 0 0 1]
+            ]
+        """
+        if U is None:
+            _sig_on
+            rank = mat_ZZ_G_BKZ_QP1(self.x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        elif PY_TYPE_CHECK(U, ntl_mat_ZZ):
+            _sig_on
+            rank = mat_ZZ_G_BKZ_QP1_U(self.x, (<ntl_mat_ZZ>U).x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        else:
+            raise TypeError, "parameter U has wrong type."
+
+    def G_BKZ_XD(self, U=None, delta=0.99, BlockSize=10, prune=0, verbose=False):
+        r"""
+        All BKZ methods are equivalent to the LLL routines,
+        except that Block Korkin-Zolotarev reduction is applied. We
+        describe here only the differences in the calling syntax.
+
+        * The optional parameter "BlockSize" specifies the size of the
+        blocks in the reduction. High values yield shorter vectors,
+        but the running time increases exponentially with BlockSize.
+        BlockSize should be between 2 and the number of rows of B.
+
+        * The optional parameter "prune" can be set to any positive
+        number to invoke the Volume Heuristic from [Schnorr and
+        Horner, Eurocrypt '95].  This can significantly reduce the
+        running time, and hence allow much bigger block size, but the
+        quality of the reduction is of course not as good in general.
+        Higher values of prune mean better quality, and slower running
+        time.  When prune == 0, pruning is disabled.  Recommended
+        usage: for BlockSize >= 30, set 10 <= prune <= 15.
+
+        * The QP1 variant uses quad_float precision to compute
+        Gram-Schmidt, but uses double precision in the search phase
+        of the block reduction algorithm.  This seems adequate for
+        most purposes, and is faster than QP, which uses quad_float
+        precision uniformly throughout.
+
+        INPUT:
+            U -- optional permutation matrix (see LLL, default: None)
+            delta -- reduction parameter (default: 0.99)
+            BlockSize -- see above (default: 10)
+            prune -- see above (default: 0)
+            verbose -- print verbose output (default: False)
+
+        EXAMPLE:
+            sage: A = Matrix(ZZ,5,5,range(25))
+            sage: a = A._ntl_()
+            sage: a.G_BKZ_XD(); a
+            2
+            [
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 1 2 3 4]
+            [5 3 1 -1 -3]
+            ]
+
+            sage: U = ntl.mat_ZZ(2,2) # note that the dimension doesn't matter
+            sage: r = a.G_BKZ_XD(U=U); U
+            [
+            [0 1 0 0 0]
+            [1 0 0 0 0]
+            [0 0 1 0 0]
+            [0 0 0 1 0]
+            [0 0 0 0 1]
+            ]
+        """
+        if U is None:
+            _sig_on
+            rank = mat_ZZ_G_BKZ_XD(self.x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        elif PY_TYPE_CHECK(U, ntl_mat_ZZ):
+            _sig_on
+            rank = mat_ZZ_G_BKZ_XD_U(self.x, (<ntl_mat_ZZ>U).x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        else:
+            raise TypeError, "parameter U has wrong type."
+
+    def G_BKZ_RR(self, U=None, delta=0.99, BlockSize=10, prune=0, verbose=False):
+        r"""
+        All BKZ methods are equivalent to the LLL routines,
+        except that Block Korkin-Zolotarev reduction is applied. We
+        describe here only the differences in the calling syntax.
+
+        * The optional parameter "BlockSize" specifies the size of the
+        blocks in the reduction. High values yield shorter vectors,
+        but the running time increases exponentially with BlockSize.
+        BlockSize should be between 2 and the number of rows of B.
+
+        * The optional parameter "prune" can be set to any positive
+        number to invoke the Volume Heuristic from [Schnorr and
+        Horner, Eurocrypt '95].  This can significantly reduce the
+        running time, and hence allow much bigger block size, but the
+        quality of the reduction is of course not as good in general.
+        Higher values of prune mean better quality, and slower running
+        time.  When prune == 0, pruning is disabled.  Recommended
+        usage: for BlockSize >= 30, set 10 <= prune <= 15.
+
+        * The QP1 variant uses quad_float precision to compute
+        Gram-Schmidt, but uses double precision in the search phase
+        of the block reduction algorithm.  This seems adequate for
+        most purposes, and is faster than QP, which uses quad_float
+        precision uniformly throughout.
+
+        INPUT:
+            U -- optional permutation matrix (see LLL, default: None)
+            delta -- reduction parameter (default: 0.99)
+            BlockSize -- see above (default: 10)
+            prune -- see above (default: 0)
+            verbose -- print verbose output (default: False)
+
+        EXAMPLE:
+            sage: A = Matrix(ZZ,5,5,range(25))
+            sage: a = A._ntl_()
+            sage: a.G_BKZ_RR(); a
+            2
+            [
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 0 0 0 0]
+            [0 1 2 3 4]
+            [5 3 1 -1 -3]
+            ]
+
+            sage: U = ntl.mat_ZZ(2,2) # note that the dimension doesn't matter
+            sage: r = a.G_BKZ_RR(U=U); U
+            [
+            [0 1 0 0 0]
+            [1 0 0 0 0]
+            [0 0 1 0 0]
+            [0 0 0 1 0]
+            [0 0 0 0 1]
+            ]
+        """
+        if U is None:
+            _sig_on
+            rank = mat_ZZ_G_BKZ_RR(self.x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        elif PY_TYPE_CHECK(U, ntl_mat_ZZ):
+            _sig_on
+            rank = mat_ZZ_G_BKZ_RR_U(self.x, (<ntl_mat_ZZ>U).x, float(delta), int(BlockSize), int(prune), 0, int(verbose));
+            _sig_off
+            return rank
+        else:
+            raise TypeError, "parameter U has wrong type."
+
-    def LLL(self, a=3, b=4, return_U=False, verbose=False):
-        r"""
-self
+\code{self}
-
-
-
-
-
-
+
+
+
+
+
+
-
-        More specifically, elementary row transformations are
-self so that the non-zero rows of new-self form
-an LLL-reduced basis for the lattice spanned by the rows of
-old-self.  The default reduction parameter is $\delta=3/4$,
-which means that the squared length of the first non-zero
-basis vector is no more than $2^{r-1}$ times that of the
-
+\code{self} so that the non-zero rows of
+new-\code{self} form an LLL-reduced basis for the lattice
+spanned by the rows of old-\code{self}.  The default reduction
+parameter is $\delta=3/4$, which means that the squared length
+of the first non-zero basis vector is no more than $2^{r-1}$
+times that of the 
-
-        det2 is calculated as the \emph{square} of the determinant of
-        the lattice---note that sqrt(det2) is in general an integer
@@ -465 +1137 @@
-
-        If return_U is True, a value U is returned which is the
-        transformation matrix, so that U is a unimodular m x m matrix
-
-
+
+
+
-        
-        The parameters a and b allow an arbitrary reduction parameter
-        $\delta=a/b$, where $1/4 < a/b \leq 1$, where a and b are positive
@@ -518 +1191 @@
-            [0 -1 -7 5]
-            ]
-
-self. So after applying this method your matrix
-
+\code{self}. So after applying
+this method your matrix 
-        """
-        cdef ZZ_c *det2
-        cdef ntl_mat_ZZ U
@@ -537 +1210 @@
-
-    def LLL_FP(self, delta=0.75 , return_U=False, verbose=False):
-        r"""
-
-
+
+
+
-
-        The precision is double.
-        
-        The return value is the rank of B.
-
-m
+
-
-        This choice uses classical methods for computing the
-m
+
-        stability problems.  This strategy was first proposed by
-        Schnorr and Euchner [C. P. Schnorr and M. Euchner,
-        Proc. Fundamentals of Computation Theory, LNCS 529, pp. 68-85,
@@ -604 +1278 @@
-            [0 -1 -7 5]
-            ]
-
-self
+\code{self}
-        method your matrix will be a vector of vectors.
-        """
-        cdef ntl_mat_ZZ U
@@ -622 +1296 @@
-
-    def LLL_QP(self, delta, return_U=False, verbose=False):
-        r"""
-
-
+
+
+
+
+
+
+
-        """
-        cdef ntl_mat_ZZ U
-        if return_U:
@@ -640 +1319 @@
-
-    def LLL_XD(self, delta, return_U=False, verbose=False):
-        r"""
-self.LLL_FP using the sam
-
+\code{self.LLL_FP} using th
+same 
-        precision.
+
+        EXAMPLE:
+            sage: M=ntl.mat_ZZ(3,3,[1,2,3,4,5,6,7,8,9])
+            sage: M.LLL_XD(delta=0.75)
+            2
-        """
-        cdef ntl_mat_ZZ U
-        if return_U:
@@ -658 +1342 @@
-            return rank
-
-    def LLL_RR(self, delta, return_U=False, verbose=False):
-
-self.LLL_FP using the sam
-
+ 
+\code{self.LLL_FP} using th
+same 
-        point numbers.
+