flint3-sys 3.5.1

Rust bindings to the FLINT C library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

/*
    Copyright (C) 2018 Fredrik Johansson

    This file is part of FLINT.

    FLINT is free software: you can redistribute it and/or modify it under
    the terms of the GNU Lesser General Public License (LGPL) as published
    by the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.  See <https://www.gnu.org/licenses/>.
*/

#include "test_helpers.h"
#include "arb.h"
#include "arb_mat.h"

#define BLOCK_SIZE 32

static void
fallback(arb_mat_t C, mag_srcptr A, mag_srcptr B, slong ar, slong ac, slong bc)
{
    slong i, j, k, ii, jj, kk;

    for (ii = 0; ii < ar; ii += BLOCK_SIZE)
    {
        for (jj = 0; jj < bc; jj += BLOCK_SIZE)
        {
            for (kk = 0; kk < ac; kk += BLOCK_SIZE)
            {
                for (i = ii; i < FLINT_MIN(ii + BLOCK_SIZE, ar); i++)
                {
                    for (j = jj; j < FLINT_MIN(jj + BLOCK_SIZE, bc); j++)
                    {
                        for (k = kk; k < FLINT_MIN(kk + BLOCK_SIZE, ac); k++)
                        {
                            mag_fast_addmul(arb_radref(arb_mat_entry(C, i, j)),
                                A + i * ac + k, B + j * ac + k);
                        }
                    }
                }
            }
        }
    }
}

TEST_FUNCTION_START(arb_mat_addmul_rad_mag_fast, state)
{
    slong iter;

    for (iter = 0; iter < 10000 * 0.1 * flint_test_multiplier(); iter++)
    {
        arb_mat_t C, D;
        slong m, n, p, density, i, j, off;
        mag_ptr A, B;
        mag_t lo, hi;

        m = n_randint(state, 40);
        n = n_randint(state, 40);
        p = n_randint(state, 40);

        A = _mag_vec_init(m * n);
        B = _mag_vec_init(p * n);
        arb_mat_init(C, m, p);
        arb_mat_init(D, m, p);
        mag_init(lo);
        mag_init(hi);

        density = 1 + n_randint(state, 100);

        off = n_randint(state, 10000);
        for (i = 0; i < m * n; i++)
        {
            if (n_randint(state, 100) < density)
            {
                mag_randtest(A + i, state, 8 + n_randint(state, 10));
                mag_mul_2exp_si(A + i, A + i, off);
            }
        }

        off = n_randint(state, 10000);
        for (i = 0; i < p * n; i++)
        {
            if (n_randint(state, 100) < density)
            {
                mag_randtest(B + i, state, 8 + n_randint(state, 10));
                mag_mul_2exp_si(B + i, B + i, off);
            }
        }

        fallback(C, A, B, m, n, p);
        _arb_mat_addmul_rad_mag_fast(D, A, B, m, n, p);

        for (i = 0; i < m; i++)
        {
            for (j = 0; j < p; j++)
            {
                mag_set_d(lo, 0.9999);
                mag_set_d(hi, 1.0001);
                mag_mul(lo, lo, arb_radref(arb_mat_entry(C, i, j)));
                mag_mul(hi, hi, arb_radref(arb_mat_entry(C, i, j)));

                if (mag_cmp(arb_radref(arb_mat_entry(D, i, j)), lo) < 0 ||
                    mag_cmp(arb_radref(arb_mat_entry(D, i, j)), hi) > 0)
                {
                    flint_printf("FAIL\n");
                    flint_printf("m = %wd, n = %wd, p = %wd\n", m, n, p);
                    flint_printf("i = %wd, j = %wd\n", i, j);
                    mag_printd(arb_radref(arb_mat_entry(C, i, j)), 10);
                    flint_printf("\n");
                    mag_printd(arb_radref(arb_mat_entry(D, i, j)), 10);
                    flint_printf("\n");
                    flint_abort();
                }
            }
        }

        _mag_vec_clear(A, m * n);
        _mag_vec_clear(B, p * n);
        arb_mat_clear(C);
        arb_mat_clear(D);
        mag_clear(lo);
        mag_clear(hi);
    }

    TEST_FUNCTION_END(state);
}