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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
/* mpz_root(root, u, nth) -- Set ROOT to floor(U^(1/nth)).
Return an indication if the result is exact.
Copyright (C) 1999, 2000 Free Software Foundation, Inc.
This file is part of the GNU MP Library.
The GNU MP Library is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or (at your
option) any later version.
The GNU MP Library 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 Lesser General Public
License for more details.
You should have received a copy of the GNU Lesser General Public License
along with the GNU MP Library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
MA 02111-1307, USA. */
/* Naive implementation of nth root extraction. It would probably be a
better idea to use a division-free Newton iteration. It is insane
to use full precision from iteration 1. The mpz_scan1 trick compensates
to some extent. It would be natural to avoid representing the low zero
bits mpz_scan1 is counting, and at the same time call mpn directly. */
#include <stdio.h> /* for NULL */
#include "gmp.h"
#include "gmp-impl.h"
#include "longlong.h"
int
#if __STDC__
mpz_root (mpz_ptr r, mpz_srcptr c, unsigned long int nth)
#else
mpz_root (r, c, nth)
mpz_ptr r;
mpz_srcptr c;
unsigned long int nth;
#endif
{
mpz_t x, t0, t1, t2;
__mpz_struct ccs, *cc = &ccs;
unsigned long int nbits;
int bit;
int exact;
int i;
unsigned long int lowz;
unsigned long int rl;
/* even roots of negatives provoke an exception */
if (mpz_sgn (c) < 0 && (nth & 1) == 0)
SQRT_OF_NEGATIVE;
/* root extraction interpreted as c^(1/nth) means a zeroth root should
provoke a divide by zero, do this even if c==0 */
if (nth == 0)
DIVIDE_BY_ZERO;
if (mpz_sgn (c) == 0)
{
if (r != NULL)
mpz_set_ui (r, 0);
return 1; /* exact result */
}
PTR(cc) = PTR(c);
SIZ(cc) = ABSIZ(c);
nbits = (mpz_sizeinbase (cc, 2) - 1) / nth;
if (nbits == 0)
{
if (r != NULL)
mpz_set_ui (r, 1);
if (mpz_sgn (c) < 0)
{
if (r != NULL)
SIZ(r) = -SIZ(r);
return mpz_cmp_si (c, -1L) == 0;
}
return mpz_cmp_ui (c, 1L) == 0;
}
mpz_init (x);
mpz_init (t0);
mpz_init (t1);
mpz_init (t2);
/* Create a one-bit approximation. */
mpz_set_ui (x, 0);
mpz_setbit (x, nbits);
/* Make the approximation better, one bit at a time. This odd-looking
termination criteria makes large nth get better initial approximation,
which avoids slow convergence for such values. */
bit = nbits - 1;
for (i = 1; (nth >> i) != 0; i++)
{
mpz_setbit (x, bit);
mpz_tdiv_q_2exp (t0, x, bit);
mpz_pow_ui (t1, t0, nth);
mpz_mul_2exp (t1, t1, bit * nth);
if (mpz_cmp (cc, t1) < 0)
mpz_clrbit (x, bit);
bit--; /* check/set next bit */
if (bit < 0)
{
/* We're done. */
mpz_pow_ui (t1, x, nth);
goto done;
}
}
mpz_setbit (x, bit);
mpz_set_ui (t2, 0); mpz_setbit (t2, bit); mpz_add (x, x, t2);
#if DEBUG
/* Check that the starting approximation is >= than the root. */
mpz_pow_ui (t1, x, nth);
if (mpz_cmp (cc, t1) >= 0)
abort ();
#endif
mpz_add_ui (x, x, 1);
/* Main loop */
do
{
lowz = mpz_scan1 (x, 0);
mpz_tdiv_q_2exp (t0, x, lowz);
mpz_pow_ui (t1, t0, nth - 1);
mpz_mul_2exp (t1, t1, lowz * (nth - 1));
mpz_tdiv_q (t2, cc, t1);
mpz_sub (t2, x, t2);
rl = mpz_tdiv_q_ui (t2, t2, nth);
mpz_sub (x, x, t2);
}
while (mpz_sgn (t2) != 0);
/* If we got a non-zero remainder in the last division, we know our root
is too large. */
mpz_sub_ui (x, x, (mp_limb_t) (rl != 0));
/* Adjustment loop. If we spend more care on rounding in the loop above,
we could probably get rid of this, or greatly simplify it. */
{
int bad = 0;
lowz = mpz_scan1 (x, 0);
mpz_tdiv_q_2exp (t0, x, lowz);
mpz_pow_ui (t1, t0, nth);
mpz_mul_2exp (t1, t1, lowz * nth);
while (mpz_cmp (cc, t1) < 0)
{
bad++;
if (bad > 2)
abort (); /* abort if our root is far off */
mpz_sub_ui (x, x, 1);
lowz = mpz_scan1 (x, 0);
mpz_tdiv_q_2exp (t0, x, lowz);
mpz_pow_ui (t1, t0, nth);
mpz_mul_2exp (t1, t1, lowz * nth);
}
}
done:
exact = mpz_cmp (t1, cc) == 0;
if (r != NULL)
{
mpz_set (r, x);
if (mpz_sgn (c) < 0)
SIZ(r) = -SIZ(r);
}
mpz_clear (t2);
mpz_clear (t1);
mpz_clear (t0);
mpz_clear (x);
return exact;
}
|
