ALL: Add flint

external/flint-2.4.3/fmpz_mod_poly_factor/test/t-factor.c

@@ -0,0 +1,142 @@
+/*=============================================================================
+
+    This file is part of FLINT.
+
+    FLINT is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    FLINT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with FLINT; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+=============================================================================*/
+/******************************************************************************
+
+    Copyright (C) 2007 David Howden
+    Copyright (C) 2007, 2008, 2009, 2010 William Hart
+    Copyright (C) 2008 Richard Howell-Peak
+    Copyright (C) 2011 Fredrik Johansson
+    Copyright (C) 2012 Lina Kulakova
+
+******************************************************************************/
+
+#include <stdlib.h>
+#include "fmpz_mod_poly.h"
+#include "ulong_extras.h"
+
+int
+main(void)
+{
+    int iter;
+    FLINT_TEST_INIT(state);
+    
+
+    flint_printf("factor....");
+    fflush(stdout);
+
+    for (iter = 0; iter < 200; iter++)
+    {
+        fmpz_mod_poly_t poly1, poly, q, r, product;
+        fmpz_mod_poly_factor_t res;
+        fmpz_t modulus;
+        slong i, j, length, num;
+        slong exp[5];
+
+        fmpz_init_set_ui(modulus, n_randtest_prime(state, 0));
+
+        fmpz_mod_poly_init(poly1, modulus);
+        fmpz_mod_poly_init(poly, modulus);
+        fmpz_mod_poly_init(q, modulus);
+        fmpz_mod_poly_init(r, modulus);
+
+        fmpz_mod_poly_zero(poly1);
+        fmpz_mod_poly_set_coeff_ui(poly1, 0, 1);
+
+        length = n_randint(state, 7) + 2;
+        do
+        {
+            fmpz_mod_poly_randtest(poly, state, length);
+            if (poly->length)
+                fmpz_mod_poly_make_monic(poly, poly);
+        }
+        while ((poly->length < 2) || (!fmpz_mod_poly_is_irreducible(poly)));
+
+        exp[0] = n_randint(state, 30) + 1;
+        for (i = 0; i < exp[0]; i++)
+            fmpz_mod_poly_mul(poly1, poly1, poly);
+
+        num = n_randint(state, 5) + 1;
+
+        for (i = 1; i < num; i++)
+        {
+            do
+            {
+                length = n_randint(state, 7) + 2;
+                fmpz_mod_poly_randtest(poly, state, length);
+                if (poly->length)
+                {
+                    fmpz_mod_poly_make_monic(poly, poly);
+                    fmpz_mod_poly_divrem(q, r, poly1, poly);
+                }
+            }
+            while ((poly->length < 2) || (!fmpz_mod_poly_is_irreducible(poly))
+                   || (r->length == 0));
+
+            exp[i] = n_randint(state, 30) + 1;
+            for (j = 0; j < exp[i]; j++)
+                fmpz_mod_poly_mul(poly1, poly1, poly);
+        }
+
+        fmpz_mod_poly_factor_init(res);
+        fmpz_mod_poly_factor(res, poly1);
+
+        if (res->num != num)
+        {
+            flint_printf("Error: number of factors incorrect: %wd != %wd\n",
+                   res->num, num);
+            abort();
+        }
+
+        fmpz_mod_poly_init(product, &poly1->p);
+        fmpz_mod_poly_set_coeff_ui(product, 0, 1);
+        for (i = 0; i < res->num; i++)
+            for (j = 0; j < res->exp[i]; j++)
+                fmpz_mod_poly_mul(product, product, res->poly + i);
+
+        fmpz_mod_poly_scalar_mul_fmpz(product, product,
+                                      &(poly1->coeffs[poly1->length - 1]));
+
+        if (!fmpz_mod_poly_equal(poly1, product))
+        {
+            flint_printf
+                ("Error: product of factors does not equal to the original polynomial\n");
+            flint_printf("poly:\n");
+            fmpz_mod_poly_print(poly1);
+            flint_printf("\n");
+            flint_printf("product:\n");
+            fmpz_mod_poly_print(product);
+            flint_printf("\n");
+            abort();
+        }
+
+        fmpz_clear(modulus);
+        fmpz_mod_poly_clear(product);
+        fmpz_mod_poly_clear(q);
+        fmpz_mod_poly_clear(r);
+        fmpz_mod_poly_clear(poly1);
+        fmpz_mod_poly_clear(poly);
+        fmpz_mod_poly_factor_clear(res);
+    }
+
+    FLINT_TEST_CLEANUP(state);
+    
+    flint_printf("PASS\n");
+    return 0;
+}

external/flint-2.4.3/fmpz_mod_poly_factor/test/t-factor_berlekamp.c

@@ -0,0 +1,142 @@
+/*=============================================================================
+
+    This file is part of FLINT.
+
+    FLINT is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    FLINT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with FLINT; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+=============================================================================*/
+/******************************************************************************
+
+    Copyright (C) 2007 David Howden
+    Copyright (C) 2007, 2008, 2009, 2010 William Hart
+    Copyright (C) 2008 Richard Howell-Peak
+    Copyright (C) 2011 Fredrik Johansson
+    Copyright (C) 2012 Lina Kulakova
+
+******************************************************************************/
+
+#include <stdlib.h>
+#include "fmpz_mod_poly.h"
+#include "ulong_extras.h"
+
+int
+main(void)
+{
+    int iter;
+    FLINT_TEST_INIT(state);
+    
+
+    flint_printf("factor_berlekamp....");
+    fflush(stdout);
+
+    for (iter = 0; iter < 200; iter++)
+    {
+        fmpz_mod_poly_t poly1, poly, q, r, product;
+        fmpz_mod_poly_factor_t res;
+        fmpz_t modulus;
+        slong i, j, length, num;
+        slong exp[5];
+
+        fmpz_init_set_ui(modulus, n_randtest_prime(state, 0));
+
+        fmpz_mod_poly_init(poly1, modulus);
+        fmpz_mod_poly_init(poly, modulus);
+        fmpz_mod_poly_init(q, modulus);
+        fmpz_mod_poly_init(r, modulus);
+
+        fmpz_mod_poly_zero(poly1);
+        fmpz_mod_poly_set_coeff_ui(poly1, 0, 1);
+
+        length = n_randint(state, 7) + 2;
+        do
+        {
+            fmpz_mod_poly_randtest(poly, state, length);
+            if (poly->length)
+                fmpz_mod_poly_make_monic(poly, poly);
+        }
+        while ((poly->length < 2) || (!fmpz_mod_poly_is_irreducible(poly)));
+
+        exp[0] = n_randint(state, 30) + 1;
+        for (i = 0; i < exp[0]; i++)
+            fmpz_mod_poly_mul(poly1, poly1, poly);
+
+        num = n_randint(state, 5) + 1;
+
+        for (i = 1; i < num; i++)
+        {
+            do
+            {
+                length = n_randint(state, 7) + 2;
+                fmpz_mod_poly_randtest(poly, state, length);
+                if (poly->length)
+                {
+                    fmpz_mod_poly_make_monic(poly, poly);
+                    fmpz_mod_poly_divrem(q, r, poly1, poly);
+                }
+            }
+            while ((poly->length < 2) || (!fmpz_mod_poly_is_irreducible(poly))
+                   || (r->length == 0));
+
+            exp[i] = n_randint(state, 30) + 1;
+            for (j = 0; j < exp[i]; j++)
+                fmpz_mod_poly_mul(poly1, poly1, poly);
+        }
+
+        fmpz_mod_poly_factor_init(res);
+        fmpz_mod_poly_factor_berlekamp(res, poly1);
+
+        if (res->num != num)
+        {
+            flint_printf("Error: number of factors incorrect: %wd != %wd\n",
+                   res->num, num);
+            abort();
+        }
+
+        fmpz_mod_poly_init(product, &poly1->p);
+        fmpz_mod_poly_set_coeff_ui(product, 0, 1);
+        for (i = 0; i < res->num; i++)
+            for (j = 0; j < res->exp[i]; j++)
+                fmpz_mod_poly_mul(product, product, res->poly + i);
+
+        fmpz_mod_poly_scalar_mul_fmpz(product, product,
+                                      &(poly1->coeffs[poly1->length - 1]));
+
+        if (!fmpz_mod_poly_equal(poly1, product))
+        {
+            flint_printf
+                ("Error: product of factors does not equal to the original polynomial\n");
+            flint_printf("poly:\n");
+            fmpz_mod_poly_print(poly1);
+            flint_printf("\n");
+            flint_printf("product:\n");
+            fmpz_mod_poly_print(product);
+            flint_printf("\n");
+            abort();
+        }
+
+        fmpz_clear(modulus);
+        fmpz_mod_poly_clear(product);
+        fmpz_mod_poly_clear(q);
+        fmpz_mod_poly_clear(r);
+        fmpz_mod_poly_clear(poly1);
+        fmpz_mod_poly_clear(poly);
+        fmpz_mod_poly_factor_clear(res);
+    }
+
+    FLINT_TEST_CLEANUP(state);
+    
+    flint_printf("PASS\n");
+    return 0;
+}

external/flint-2.4.3/fmpz_mod_poly_factor/test/t-factor_cantor_zassenhaus.c

@@ -0,0 +1,142 @@
+/*=============================================================================
+
+    This file is part of FLINT.
+
+    FLINT is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    FLINT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with FLINT; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+=============================================================================*/
+/******************************************************************************
+
+    Copyright (C) 2007 David Howden
+    Copyright (C) 2007, 2008, 2009, 2010 William Hart
+    Copyright (C) 2008 Richard Howell-Peak
+    Copyright (C) 2011 Fredrik Johansson
+    Copyright (C) 2012 Lina Kulakova
+
+******************************************************************************/
+
+#include <stdlib.h>
+#include "fmpz_mod_poly.h"
+#include "ulong_extras.h"
+
+int
+main(void)
+{
+    int iter;
+    FLINT_TEST_INIT(state);
+    
+
+    flint_printf("factor_cantor_zassenhaus....");
+    fflush(stdout);
+
+    for (iter = 0; iter < 200; iter++)
+    {
+        fmpz_mod_poly_t poly1, poly, q, r, product;
+        fmpz_mod_poly_factor_t res;
+        fmpz_t modulus;
+        slong i, j, length, num;
+        slong exp[5];
+
+        fmpz_init_set_ui(modulus, n_randtest_prime(state, 0));
+
+        fmpz_mod_poly_init(poly1, modulus);
+        fmpz_mod_poly_init(poly, modulus);
+        fmpz_mod_poly_init(q, modulus);
+        fmpz_mod_poly_init(r, modulus);
+
+        fmpz_mod_poly_zero(poly1);
+        fmpz_mod_poly_set_coeff_ui(poly1, 0, 1);
+
+        length = n_randint(state, 7) + 2;
+        do
+        {
+            fmpz_mod_poly_randtest(poly, state, length);
+            if (poly->length)
+                fmpz_mod_poly_make_monic(poly, poly);
+        }
+        while ((poly->length < 2) || (!fmpz_mod_poly_is_irreducible(poly)));
+
+        exp[0] = n_randint(state, 30) + 1;
+        for (i = 0; i < exp[0]; i++)
+            fmpz_mod_poly_mul(poly1, poly1, poly);
+
+        num = n_randint(state, 5) + 1;
+
+        for (i = 1; i < num; i++)
+        {
+            do
+            {
+                length = n_randint(state, 7) + 2;
+                fmpz_mod_poly_randtest(poly, state, length);
+                if (poly->length)
+                {
+                    fmpz_mod_poly_make_monic(poly, poly);
+                    fmpz_mod_poly_divrem(q, r, poly1, poly);
+                }
+            }
+            while ((poly->length < 2) || (!fmpz_mod_poly_is_irreducible(poly))
+                   || (r->length == 0));
+
+            exp[i] = n_randint(state, 30) + 1;
+            for (j = 0; j < exp[i]; j++)
+                fmpz_mod_poly_mul(poly1, poly1, poly);
+        }
+
+        fmpz_mod_poly_factor_init(res);
+        fmpz_mod_poly_factor_cantor_zassenhaus(res, poly1);
+
+        if (res->num != num)
+        {
+            flint_printf("Error: number of factors incorrect: %wd != %wd\n",
+                   res->num, num);
+            abort();
+        }
+
+        fmpz_mod_poly_init(product, &poly1->p);
+        fmpz_mod_poly_set_coeff_ui(product, 0, 1);
+        for (i = 0; i < res->num; i++)
+            for (j = 0; j < res->exp[i]; j++)
+                fmpz_mod_poly_mul(product, product, res->poly + i);
+
+        fmpz_mod_poly_scalar_mul_fmpz(product, product,
+                                      &(poly1->coeffs[poly1->length - 1]));
+
+        if (!fmpz_mod_poly_equal(poly1, product))
+        {
+            flint_printf
+                ("Error: product of factors does not equal to the original polynomial\n");
+            flint_printf("poly:\n");
+            fmpz_mod_poly_print(poly1);
+            flint_printf("\n");
+            flint_printf("product:\n");
+            fmpz_mod_poly_print(product);
+            flint_printf("\n");
+            abort();
+        }
+
+        fmpz_clear(modulus);
+        fmpz_mod_poly_clear(product);
+        fmpz_mod_poly_clear(q);
+        fmpz_mod_poly_clear(r);
+        fmpz_mod_poly_clear(poly1);
+        fmpz_mod_poly_clear(poly);
+        fmpz_mod_poly_factor_clear(res);
+    }
+
+    FLINT_TEST_CLEANUP(state);
+    
+    flint_printf("PASS\n");
+    return 0;
+}

external/flint-2.4.3/fmpz_mod_poly_factor/test/t-factor_distinct_deg.c

@@ -0,0 +1,137 @@
+/*=============================================================================
+
+    This file is part of FLINT.
+
+    FLINT is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    FLINT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with FLINT; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+=============================================================================*/
+/******************************************************************************
+
+    Copyright (C) 2007 David Howden
+    Copyright (C) 2007, 2008, 2009, 2010 William Hart
+    Copyright (C) 2008 Richard Howell-Peak
+    Copyright (C) 2011 Fredrik Johansson
+    Copyright (C) 2012 Lina Kulakova
+
+******************************************************************************/
+
+#include <stdlib.h>
+#include "fmpz_mod_poly.h"
+#include "ulong_extras.h"
+
+int
+main(void)
+{
+    int iter;
+    FLINT_TEST_INIT(state);
+    
+
+    flint_printf("factor_distinct_deg....");
+    fflush(stdout);
+
+    for (iter = 0; iter < 200; iter++)
+    {
+        fmpz_mod_poly_t poly1, poly, q, r, product;
+        fmpz_mod_poly_factor_t res;
+        fmpz_t modulus;
+        slong i, length, num;
+        slong *degs;
+
+        fmpz_init(modulus);
+        fmpz_set_ui(modulus, n_randtest_prime(state, 0));
+
+        fmpz_mod_poly_init(poly1, modulus);
+        fmpz_mod_poly_init(poly, modulus);
+        fmpz_mod_poly_init(q, modulus);
+        fmpz_mod_poly_init(r, modulus);
+
+        fmpz_mod_poly_zero(poly1);
+        fmpz_mod_poly_set_coeff_ui(poly1, 0, 1);
+
+        length = n_randint(state, 7) + 2;
+        do
+        {
+            fmpz_mod_poly_randtest(poly, state, length);
+            if (poly->length)
+                fmpz_mod_poly_make_monic(poly, poly);
+        }
+        while ((poly->length < 2) || (!fmpz_mod_poly_is_irreducible(poly)));
+
+        fmpz_mod_poly_mul(poly1, poly1, poly);
+
+        num = n_randint(state, 5) + 1;
+
+        for (i = 1; i < num; i++)
+        {
+            do
+            {
+                length = n_randint(state, 7) + 2;
+                fmpz_mod_poly_randtest(poly, state, length);
+                if (poly->length)
+                {
+                    fmpz_mod_poly_make_monic(poly, poly);
+                    fmpz_mod_poly_divrem(q, r, poly1, poly);
+                }
+            }
+            while ((poly->length < 2) || (!fmpz_mod_poly_is_irreducible(poly))
+                   || (r->length == 0));
+
+            fmpz_mod_poly_mul(poly1, poly1, poly);
+        }
+
+        if (!(degs = flint_malloc((poly1->length - 1) * sizeof(slong))))
+        {
+            flint_printf("Fatal error: not enough memory.");
+            abort();
+        }
+        fmpz_mod_poly_factor_init(res);
+        fmpz_mod_poly_factor_distinct_deg(res, poly1, &degs);
+
+        fmpz_mod_poly_init(product, &poly1->p);
+        fmpz_mod_poly_set_coeff_ui(product, 0, 1);
+        for (i = 0; i < res->num; i++)
+            fmpz_mod_poly_mul(product, product, res->poly + i);
+
+        fmpz_mod_poly_scalar_mul_fmpz(product, product,
+                                      &(poly1->coeffs[poly1->length - 1]));
+
+        if (!fmpz_mod_poly_equal(poly1, product))
+        {
+            flint_printf
+                ("Error: product of factors does not equal to the original polynomial\n");
+            flint_printf("poly:\n");
+            fmpz_mod_poly_print(poly1);
+            flint_printf("\n");
+            flint_printf("product:\n");
+            fmpz_mod_poly_print(product);
+            flint_printf("\n");
+            abort();
+        }
+
+        flint_free(degs);
+        fmpz_clear(modulus);
+        fmpz_mod_poly_clear(product);
+        fmpz_mod_poly_clear(q);
+        fmpz_mod_poly_clear(r);
+        fmpz_mod_poly_clear(poly1);
+        fmpz_mod_poly_clear(poly);
+        fmpz_mod_poly_factor_clear(res);
+    }
+
+    FLINT_TEST_CLEANUP(state);
+    
+    flint_printf("PASS\n");
+    return 0;
+}

external/flint-2.4.3/fmpz_mod_poly_factor/test/t-factor_equal_deg_prob.c

@@ -0,0 +1,108 @@
+/*=============================================================================
+
+    This file is part of FLINT.
+
+    FLINT is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    FLINT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with FLINT; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+=============================================================================*/
+/******************************************************************************
+
+    Copyright (C) 2012 Lina Kulakova
+
+******************************************************************************/
+
+#include <stdlib.h>
+#include "fmpz_mod_poly.h"
+#include "ulong_extras.h"
+
+int
+main(void)
+{
+    int iter;
+    FLINT_TEST_INIT(state);
+    
+
+    flint_printf("factor_equal_deg_prob....");
+    fflush(stdout);
+
+    for (iter = 0; iter < 200; iter++)
+    {
+        fmpz_mod_poly_t poly1, poly2, q, r;
+        fmpz_t modulus;
+        slong length;
+        int i, num;
+
+        fmpz_init_set_ui(modulus, n_randtest_prime(state, 0));
+
+        fmpz_mod_poly_init(q, modulus);
+        fmpz_mod_poly_init(r, modulus);
+        fmpz_mod_poly_init(poly1, modulus);
+        fmpz_mod_poly_init(poly2, modulus);
+
+        length = n_randint(state, 10) + 2;
+        do
+        {
+            fmpz_mod_poly_randtest(poly1, state, length);
+            if (poly1->length)
+                fmpz_mod_poly_make_monic(poly1, poly1);
+        }
+        while ((poly1->length < 2) || (!fmpz_mod_poly_is_irreducible(poly1)));
+
+        num = n_randint(state, 5) + 1;
+
+        for (i = 0; i < num; i++)
+        {
+            do
+            {
+                fmpz_mod_poly_randtest(poly2, state, length);
+                if (poly2->length)
+                    fmpz_mod_poly_make_monic(poly2, poly2);
+            }
+            while ((poly2->length < 2)
+                   || (!fmpz_mod_poly_is_irreducible(poly2)));
+
+            fmpz_mod_poly_mul(poly1, poly1, poly2);
+        }
+
+        while (!fmpz_mod_poly_factor_equal_deg_prob
+               (poly2, state, poly1, length - 1))
+        {
+        };
+        fmpz_mod_poly_divrem(q, r, poly1, poly2);
+        if (!fmpz_mod_poly_is_zero(r))
+        {
+            flint_printf("FAIL:\n");
+            flint_printf("Error: factor does not divide original polynomial\n");
+            flint_printf("factor:\n");
+            fmpz_mod_poly_print(poly2);
+            flint_printf("\n\n");
+            flint_printf("polynomial:\n");
+            fmpz_mod_poly_print(poly1);
+            flint_printf("\n\n");
+            abort();
+        }
+
+        fmpz_clear(modulus);
+        fmpz_mod_poly_clear(q);
+        fmpz_mod_poly_clear(r);
+        fmpz_mod_poly_clear(poly1);
+        fmpz_mod_poly_clear(poly2);
+    }
+
+    FLINT_TEST_CLEANUP(state);
+    
+    flint_printf("PASS\n");
+    return 0;
+}

external/flint-2.4.3/fmpz_mod_poly_factor/test/t-factor_kaltofen_shoup.c

@@ -0,0 +1,142 @@
+/*=============================================================================
+
+    This file is part of FLINT.
+
+    FLINT is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    FLINT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with FLINT; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+=============================================================================*/
+/******************************************************************************
+
+    Copyright (C) 2007 David Howden
+    Copyright (C) 2007, 2008, 2009, 2010 William Hart
+    Copyright (C) 2008 Richard Howell-Peak
+    Copyright (C) 2011 Fredrik Johansson
+    Copyright (C) 2012 Lina Kulakova
+
+******************************************************************************/
+
+#include <stdlib.h>
+#include "fmpz_mod_poly.h"
+#include "ulong_extras.h"
+
+int
+main(void)
+{
+    int iter;
+    FLINT_TEST_INIT(state);
+    
+
+    flint_printf("factor_kaltofen_shoup....");
+    fflush(stdout);
+
+    for (iter = 0; iter < 200; iter++)
+    {
+        fmpz_mod_poly_t poly1, poly, q, r, product;
+        fmpz_mod_poly_factor_t res;
+        fmpz_t modulus;
+        slong i, j, length, num;
+        slong exp[5];
+
+        fmpz_init_set_ui(modulus, n_randtest_prime(state, 0));
+
+        fmpz_mod_poly_init(poly1, modulus);
+        fmpz_mod_poly_init(poly, modulus);
+        fmpz_mod_poly_init(q, modulus);
+        fmpz_mod_poly_init(r, modulus);
+
+        fmpz_mod_poly_zero(poly1);
+        fmpz_mod_poly_set_coeff_ui(poly1, 0, 1);
+
+        length = n_randint(state, 7) + 2;
+        do
+        {
+            fmpz_mod_poly_randtest(poly, state, length);
+            if (poly->length)
+                fmpz_mod_poly_make_monic(poly, poly);
+        }
+        while ((poly->length < 2) || (!fmpz_mod_poly_is_irreducible(poly)));
+
+        exp[0] = n_randint(state, 30) + 1;
+        for (i = 0; i < exp[0]; i++)
+            fmpz_mod_poly_mul(poly1, poly1, poly);
+
+        num = n_randint(state, 5) + 1;
+
+        for (i = 1; i < num; i++)
+        {
+            do
+            {
+                length = n_randint(state, 7) + 2;
+                fmpz_mod_poly_randtest(poly, state, length);
+                if (poly->length)
+                {
+                    fmpz_mod_poly_make_monic(poly, poly);
+                    fmpz_mod_poly_divrem(q, r, poly1, poly);
+                }
+            }
+            while ((poly->length < 2) || (!fmpz_mod_poly_is_irreducible(poly))
+                   || (r->length == 0));
+
+            exp[i] = n_randint(state, 30) + 1;
+            for (j = 0; j < exp[i]; j++)
+                fmpz_mod_poly_mul(poly1, poly1, poly);
+        }
+
+        fmpz_mod_poly_factor_init(res);
+        fmpz_mod_poly_factor_kaltofen_shoup(res, poly1);
+
+        if (res->num != num)
+        {
+            flint_printf("Error: number of factors incorrect: %wd != %wd\n",
+                   res->num, num);
+            abort();
+        }
+
+        fmpz_mod_poly_init(product, &poly1->p);
+        fmpz_mod_poly_set_coeff_ui(product, 0, 1);
+        for (i = 0; i < res->num; i++)
+            for (j = 0; j < res->exp[i]; j++)
+                fmpz_mod_poly_mul(product, product, res->poly + i);
+
+        fmpz_mod_poly_scalar_mul_fmpz(product, product,
+                                      &(poly1->coeffs[poly1->length - 1]));
+
+        if (!fmpz_mod_poly_equal(poly1, product))
+        {
+            flint_printf
+                ("Error: product of factors does not equal to the original polynomial\n");
+            flint_printf("poly:\n");
+            fmpz_mod_poly_print(poly1);
+            flint_printf("\n");
+            flint_printf("product:\n");
+            fmpz_mod_poly_print(product);
+            flint_printf("\n");
+            abort();
+        }
+
+        fmpz_clear(modulus);
+        fmpz_mod_poly_clear(product);
+        fmpz_mod_poly_clear(q);
+        fmpz_mod_poly_clear(r);
+        fmpz_mod_poly_clear(poly1);
+        fmpz_mod_poly_clear(poly);
+        fmpz_mod_poly_factor_clear(res);
+    }
+
+    FLINT_TEST_CLEANUP(state);
+    
+    flint_printf("PASS\n");
+    return 0;
+}

external/flint-2.4.3/fmpz_mod_poly_factor/test/t-factor_squarefree.c

@@ -0,0 +1,144 @@
+/*=============================================================================
+
+    This file is part of FLINT.
+
+    FLINT is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    FLINT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with FLINT; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+=============================================================================*/
+/******************************************************************************
+
+    Copyright (C) 2007 David Howden
+    Copyright (C) 2007, 2008, 2009, 2010 William Hart
+    Copyright (C) 2008 Richard Howell-Peak
+    Copyright (C) 2011 Fredrik Johansson
+    Copyright (C) 2012 Lina Kulakova
+
+******************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <gmp.h>
+#include "flint.h"
+#include "fmpz_vec.h"
+#include "fmpz_mod_poly.h"
+#include "ulong_extras.h"
+
+int
+main(void)
+{
+    int iter;
+    FLINT_TEST_INIT(state);
+    
+
+    flint_printf("factor_squarefree....");
+    fflush(stdout);
+
+    for (iter = 0; iter < 300; iter++)
+    {
+        int result = 1;
+        fmpz_mod_poly_t pol1, poly, quot, rem;
+        fmpz_mod_poly_factor_t res;
+        fmpz_t modulus;
+        slong exp[5], prod1;
+        slong length, i, j, num;
+
+        fmpz_init_set_ui(modulus, n_randtest_prime(state, 0));
+
+        fmpz_mod_poly_init(pol1, modulus);
+        fmpz_mod_poly_init(poly, modulus);
+        fmpz_mod_poly_init(quot, modulus);
+        fmpz_mod_poly_init(rem, modulus);
+
+        fmpz_mod_poly_zero(pol1);
+        fmpz_mod_poly_set_coeff_ui(pol1, 0, 1);
+
+        length = n_randint(state, 7) + 2;
+
+        do
+        {
+            fmpz_mod_poly_randtest(poly, state, length);
+            fmpz_mod_poly_make_monic(poly, poly);
+        }
+        while ((!fmpz_mod_poly_is_irreducible(poly)) || (poly->length < 2));
+        exp[0] = n_randprime(state, 5, 0);
+
+        prod1 = exp[0];
+        for (i = 0; i < exp[0]; i++)
+            fmpz_mod_poly_mul(pol1, pol1, poly);
+
+        num = n_randint(state, 5) + 1;
+        for (i = 1; i < num; i++)
+        {
+            do
+            {
+                length = n_randint(state, 7) + 2;
+                fmpz_mod_poly_randtest(poly, state, length);
+                if (poly->length)
+                {
+                    fmpz_mod_poly_make_monic(poly, poly);
+                    fmpz_mod_poly_divrem(quot, rem, pol1, poly);
+                }
+            }
+            while ((!fmpz_mod_poly_is_irreducible(poly)) ||
+                   (poly->length < 2) || (rem->length == 0));
+
+            do
+                exp[i] = n_randprime(state, 5, 0);
+            while (prod1 % exp[i] == 0);
+
+            prod1 *= exp[i];
+            for (j = 0; j < exp[i]; j++)
+                fmpz_mod_poly_mul(pol1, pol1, poly);
+        }
+
+        fmpz_mod_poly_factor_init(res);
+        fmpz_mod_poly_factor_squarefree(res, pol1);
+
+        result &= (res->num == num);
+        if (result)
+        {
+            ulong prod2 = 1;
+            for (i = 0; i < num; i++)
+                prod2 *= res->exp[i];
+            result &= (prod1 == prod2);
+        }
+
+        if (!result)
+        {
+            flint_printf("Error: exp don't match. Modulus = ");
+            fmpz_print(modulus);
+            flint_printf("\n");
+            for (i = 0; i < res->num; i++)
+                flint_printf("%wd ", res->exp[i]);
+            flint_printf("\n");
+            for (i = 0; i < num; i++)
+                flint_printf("%wd ", exp[i]);
+            flint_printf("\n");
+            abort();
+        }
+
+        fmpz_clear(modulus);
+        fmpz_mod_poly_clear(quot);
+        fmpz_mod_poly_clear(rem);
+        fmpz_mod_poly_clear(pol1);
+        fmpz_mod_poly_clear(poly);
+        fmpz_mod_poly_factor_clear(res);
+    }
+
+    FLINT_TEST_CLEANUP(state);
+    
+    flint_printf("PASS\n");
+    return 0;
+}

external/flint-2.4.3/fmpz_mod_poly_factor/test/t-is_irreducible.c

@@ -0,0 +1,99 @@
+/*=============================================================================
+
+    This file is part of FLINT.
+
+    FLINT is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    FLINT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with FLINT; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+=============================================================================*/
+/******************************************************************************
+
+    Copyright (C) 2011 Fredrik Johansson
+    Copyright (C) 2012 Lina Kulakova
+
+******************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <gmp.h>
+#include "flint.h"
+#include "fmpz_vec.h"
+#include "fmpz_mod_poly.h"
+#include "ulong_extras.h"
+
+int
+main(void)
+{
+    int iter;
+    FLINT_TEST_INIT(state);
+    
+
+    flint_printf("is_irreducible....");
+    fflush(stdout);
+
+    for (iter = 0; iter < 100; iter++)
+    {
+        fmpz_mod_poly_t poly1, poly2;
+        fmpz_t modulus;
+        slong length;
+        int i, num;
+
+        fmpz_init_set_ui(modulus, n_randtest_prime(state, 0));
+
+        fmpz_mod_poly_init(poly1, modulus);
+        fmpz_mod_poly_init(poly2, modulus);
+
+        length = n_randint(state, 10) + 2;
+        do
+        {
+            fmpz_mod_poly_randtest(poly1, state, length);
+            if (!fmpz_mod_poly_is_zero(poly1))
+                fmpz_mod_poly_make_monic(poly1, poly1);
+        }
+        while ((!fmpz_mod_poly_is_irreducible(poly1)) || (poly1->length < 2));
+
+        num = n_randint(state, 5) + 1;
+
+        for (i = 0; i < num; i++)
+        {
+            do
+            {
+                fmpz_mod_poly_randtest(poly2, state, length);
+                if (!fmpz_mod_poly_is_zero(poly1))
+                    fmpz_mod_poly_make_monic(poly2, poly2);
+            }
+            while ((!fmpz_mod_poly_is_irreducible(poly2)) || (poly2->length < 2));
+
+            fmpz_mod_poly_mul(poly1, poly1, poly2);
+        }
+
+        if (fmpz_mod_poly_is_irreducible(poly1))
+        {
+            flint_printf("Error: reducible polynomial declared irreducible!\n");
+            flint_printf("poly:\n");
+            fmpz_mod_poly_print(poly1);
+            flint_printf("\n");
+            abort();
+        }
+
+        fmpz_clear(modulus);
+        fmpz_mod_poly_clear(poly1);
+        fmpz_mod_poly_clear(poly2);
+    }
+
+    FLINT_TEST_CLEANUP(state);
+    
+    flint_printf("PASS\n");
+    return 0;
+}

external/flint-2.4.3/fmpz_mod_poly_factor/test/t-is_irreducible_ddf.c

@@ -0,0 +1,99 @@
+/*=============================================================================
+
+    This file is part of FLINT.
+
+    FLINT is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    FLINT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with FLINT; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+=============================================================================*/
+/******************************************************************************
+
+    Copyright (C) 2011 Fredrik Johansson
+    Copyright (C) 2012 Lina Kulakova
+
+******************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <gmp.h>
+#include "flint.h"
+#include "fmpz_vec.h"
+#include "fmpz_mod_poly.h"
+#include "ulong_extras.h"
+
+int
+main(void)
+{
+    int iter;
+    FLINT_TEST_INIT(state);
+    
+
+    flint_printf("is_irreducible_ddf....");
+    fflush(stdout);
+
+    for (iter = 0; iter < 100; iter++)
+    {
+        fmpz_mod_poly_t poly1, poly2;
+        fmpz_t modulus;
+        slong length;
+        int i, num;
+
+        fmpz_init_set_ui(modulus, n_randtest_prime(state, 0));
+
+        fmpz_mod_poly_init(poly1, modulus);
+        fmpz_mod_poly_init(poly2, modulus);
+
+        length = n_randint(state, 10) + 2;
+        do
+        {
+            fmpz_mod_poly_randtest(poly1, state, length);
+            if (!fmpz_mod_poly_is_zero(poly1))
+                fmpz_mod_poly_make_monic(poly1, poly1);
+        }
+        while ((!fmpz_mod_poly_is_irreducible_ddf(poly1)) || (poly1->length < 2));
+
+        num = n_randint(state, 5) + 1;
+
+        for (i = 0; i < num; i++)
+        {
+            do
+            {
+                fmpz_mod_poly_randtest(poly2, state, length);
+                if (!fmpz_mod_poly_is_zero(poly1))
+                    fmpz_mod_poly_make_monic(poly2, poly2);
+            }
+            while ((!fmpz_mod_poly_is_irreducible_ddf(poly2)) || (poly2->length < 2));
+
+            fmpz_mod_poly_mul(poly1, poly1, poly2);
+        }
+
+        if (fmpz_mod_poly_is_irreducible_ddf(poly1))
+        {
+            flint_printf("Error: reducible polynomial declared irreducible!\n");
+            flint_printf("poly:\n");
+            fmpz_mod_poly_print(poly1);
+            flint_printf("\n");
+            abort();
+        }
+
+        fmpz_clear(modulus);
+        fmpz_mod_poly_clear(poly1);
+        fmpz_mod_poly_clear(poly2);
+    }
+
+    FLINT_TEST_CLEANUP(state);
+    
+    flint_printf("PASS\n");
+    return 0;
+}

external/flint-2.4.3/fmpz_mod_poly_factor/test/t-is_irreducible_rabin.c

@@ -0,0 +1,99 @@
+/*=============================================================================
+
+    This file is part of FLINT.
+
+    FLINT is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    FLINT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with FLINT; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+=============================================================================*/
+/******************************************************************************
+
+    Copyright (C) 2011 Fredrik Johansson
+    Copyright (C) 2012 Lina Kulakova
+
+******************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <gmp.h>
+#include "flint.h"
+#include "fmpz_vec.h"
+#include "fmpz_mod_poly.h"
+#include "ulong_extras.h"
+
+int
+main(void)
+{
+    int iter;
+    FLINT_TEST_INIT(state);
+    
+
+    flint_printf("is_irreducible_rabin....");
+    fflush(stdout);
+
+    for (iter = 0; iter < 100; iter++)
+    {
+        fmpz_mod_poly_t poly1, poly2;
+        fmpz_t modulus;
+        slong length;
+        int i, num;
+
+        fmpz_init_set_ui(modulus, n_randtest_prime(state, 0));
+
+        fmpz_mod_poly_init(poly1, modulus);
+        fmpz_mod_poly_init(poly2, modulus);
+
+        length = n_randint(state, 10) + 2;
+        do
+        {
+            fmpz_mod_poly_randtest(poly1, state, length);
+            if (!fmpz_mod_poly_is_zero(poly1))
+                fmpz_mod_poly_make_monic(poly1, poly1);
+        }
+        while ((!fmpz_mod_poly_is_irreducible_rabin(poly1)) || (poly1->length < 2));
+
+        num = n_randint(state, 5) + 1;
+
+        for (i = 0; i < num; i++)
+        {
+            do
+            {
+                fmpz_mod_poly_randtest(poly2, state, length);
+                if (!fmpz_mod_poly_is_zero(poly1))
+                    fmpz_mod_poly_make_monic(poly2, poly2);
+            }
+            while ((!fmpz_mod_poly_is_irreducible_rabin(poly2)) || (poly2->length < 2));
+
+            fmpz_mod_poly_mul(poly1, poly1, poly2);
+        }
+
+        if (fmpz_mod_poly_is_irreducible_rabin(poly1))
+        {
+            flint_printf("Error: reducible polynomial declared irreducible!\n");
+            flint_printf("poly:\n");
+            fmpz_mod_poly_print(poly1);
+            flint_printf("\n");
+            abort();
+        }
+
+        fmpz_clear(modulus);
+        fmpz_mod_poly_clear(poly1);
+        fmpz_mod_poly_clear(poly2);
+    }
+
+    FLINT_TEST_CLEANUP(state);
+    
+    flint_printf("PASS\n");
+    return 0;
+}

external/flint-2.4.3/fmpz_mod_poly_factor/test/t-is_squarefree.c

@@ -0,0 +1,112 @@
+/*=============================================================================
+
+    This file is part of FLINT.
+
+    FLINT is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    FLINT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with FLINT; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+=============================================================================*/
+/******************************************************************************
+
+    Copyright (C) 2011 Fredrik Johansson
+    Copyright (C) 2012 Lina Kulakova
+
+******************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <gmp.h>
+#include "flint.h"
+#include "fmpz_vec.h"
+#include "fmpz_mod_poly.h"
+#include "ulong_extras.h"
+
+int
+main(void)
+{
+    int iter;
+    FLINT_TEST_INIT(state);
+    
+
+    flint_printf("is_squarefree....");
+    fflush(stdout);
+
+    for (iter = 0; iter < 200 * flint_test_multiplier(); iter++)
+    {
+        fmpz_mod_poly_t poly, Q, R, t;
+        fmpz_t modulus;
+        mp_limb_t mod;
+        slong i, num_factors, exp, max_exp;
+        int v, result;
+
+        mod = n_randtest_prime(state, 0);
+        fmpz_init_set_ui(modulus, mod);
+
+        fmpz_mod_poly_init(poly, modulus);
+        fmpz_mod_poly_init(t, modulus);
+        fmpz_mod_poly_init(Q, modulus);
+        fmpz_mod_poly_init(R, modulus);
+
+        fmpz_mod_poly_set_coeff_ui(poly, 0, n_randint(state, mod));
+        num_factors = n_randint(state, 5);
+
+        max_exp = 0;
+        for (i = 0; i < num_factors; i++)
+        {
+            do {
+                fmpz_mod_poly_randtest(t, state, n_randint(state, 10));
+            } while (!fmpz_mod_poly_is_irreducible(t) ||
+                    (fmpz_mod_poly_length(t) < 2));
+
+            exp = n_randint(state, 4) + 1;
+            if (n_randint(state, 2) == 0)
+                exp = 1;
+
+            fmpz_mod_poly_divrem(Q, R, poly, t);
+            if (!fmpz_mod_poly_is_zero(R))
+            {
+                fmpz_mod_poly_pow(t, t, exp);
+                fmpz_mod_poly_mul(poly, poly, t);
+                max_exp = FLINT_MAX(exp, max_exp);
+            }
+        }
+
+        v = fmpz_mod_poly_is_squarefree(poly);
+
+        if (v == 1)
+            result = (max_exp <= 1 && !fmpz_mod_poly_is_zero(poly));
+        else
+            result = (max_exp > 1 || fmpz_mod_poly_is_zero(poly));
+
+        if (!result)
+        {
+            flint_printf("FAIL: ");
+            fmpz_print(modulus);
+            flint_printf(" %wd, %d\n", max_exp, v);
+            fmpz_mod_poly_print(poly); flint_printf("\n");
+            abort();
+        }
+
+        fmpz_clear(modulus);
+        fmpz_mod_poly_clear(poly);
+        fmpz_mod_poly_clear(t);
+        fmpz_mod_poly_clear(Q);
+        fmpz_mod_poly_clear(R);
+    }
+
+    FLINT_TEST_CLEANUP(state);
+    
+    flint_printf("PASS\n");
+    return 0;
+}