1use crate::deps::*;
4use crate::flint::*;
5use crate::fmpq_types::*;
6use crate::fmpz_types::*;
7use crate::gr::*;
8use crate::gr_types::*;
9
10
11pub type gr_poly_roots_op = ::std::option::Option<
12 unsafe extern "C" fn(
13 arg1: *mut gr_vec_struct,
14 arg2: *mut gr_vec_struct,
15 arg3: *const gr_poly_struct,
16 arg4: libc::c_int,
17 arg5: gr_ctx_ptr,
18 ) -> libc::c_int,
19>;
20pub type gr_poly_roots_op_other = ::std::option::Option<
21 unsafe extern "C" fn(
22 arg1: *mut gr_vec_struct,
23 arg2: *mut gr_vec_struct,
24 arg3: *const gr_poly_struct,
25 arg4: gr_ctx_ptr,
26 arg5: libc::c_int,
27 arg6: gr_ctx_ptr,
28 ) -> libc::c_int,
29>;
30pub type _gr_method_compose_mod_op = ::std::option::Option<
31 unsafe extern "C" fn(
32 arg1: gr_ptr,
33 arg2: gr_srcptr,
34 arg3: slong,
35 arg4: gr_srcptr,
36 arg5: gr_srcptr,
37 arg6: slong,
38 arg7: *mut gr_ctx_struct,
39 ) -> libc::c_int,
40>;
41pub type _gr_method_compose_mod_preinv_op = ::std::option::Option<
42 unsafe extern "C" fn(
43 arg1: gr_ptr,
44 arg2: gr_srcptr,
45 arg3: slong,
46 arg4: gr_srcptr,
47 arg5: gr_srcptr,
48 arg6: slong,
49 arg7: gr_srcptr,
50 arg8: slong,
51 arg9: *mut gr_ctx_struct,
52 ) -> libc::c_int,
53>;
54extern "C" {
55 pub fn gr_poly_init(poly: *mut gr_poly_struct, ctx: *mut gr_ctx_struct);
56 pub fn gr_poly_init2(poly: *mut gr_poly_struct, len: slong, ctx: *mut gr_ctx_struct);
57 pub fn gr_poly_clear(poly: *mut gr_poly_struct, ctx: *mut gr_ctx_struct);
58 #[link_name = "gr_poly_coeff_ptr__extern"]
59 pub fn gr_poly_coeff_ptr(
60 poly: *mut gr_poly_struct,
61 i: slong,
62 ctx: *mut gr_ctx_struct,
63 ) -> gr_ptr;
64 #[link_name = "gr_poly_entry_ptr__extern"]
65 pub fn gr_poly_entry_ptr(
66 poly: *mut gr_poly_struct,
67 i: slong,
68 ctx: *mut gr_ctx_struct,
69 ) -> gr_ptr;
70 #[link_name = "gr_poly_coeff_srcptr__extern"]
71 pub fn gr_poly_coeff_srcptr(
72 poly: *const gr_poly_struct,
73 i: slong,
74 ctx: *mut gr_ctx_struct,
75 ) -> gr_srcptr;
76 #[link_name = "gr_poly_entry_srcptr__extern"]
77 pub fn gr_poly_entry_srcptr(
78 poly: *const gr_poly_struct,
79 i: slong,
80 ctx: *mut gr_ctx_struct,
81 ) -> gr_srcptr;
82 #[link_name = "gr_poly_length__extern"]
83 pub fn gr_poly_length(poly: *const gr_poly_struct, UNUSED_ctx: *mut gr_ctx_struct) -> slong;
84 #[link_name = "gr_poly_swap__extern"]
85 pub fn gr_poly_swap(
86 poly1: *mut gr_poly_struct,
87 poly2: *mut gr_poly_struct,
88 UNUSED_ctx: *mut gr_ctx_struct,
89 );
90 pub fn gr_poly_fit_length(poly: *mut gr_poly_struct, len: slong, ctx: *mut gr_ctx_struct);
91 pub fn _gr_poly_set_length(poly: *mut gr_poly_struct, len: slong, ctx: *mut gr_ctx_struct);
92 pub fn _gr_poly_normalise(poly: *mut gr_poly_struct, ctx: *mut gr_ctx_struct);
93 pub fn gr_poly_set(
94 res: *mut gr_poly_struct,
95 src: *const gr_poly_struct,
96 ctx: *mut gr_ctx_struct,
97 ) -> libc::c_int;
98 pub fn _gr_poly_reverse(
99 res: gr_ptr,
100 poly: gr_srcptr,
101 len: slong,
102 n: slong,
103 ctx: *mut gr_ctx_struct,
104 ) -> libc::c_int;
105 pub fn gr_poly_reverse(
106 res: *mut gr_poly_struct,
107 poly: *const gr_poly_struct,
108 n: slong,
109 ctx: *mut gr_ctx_struct,
110 ) -> libc::c_int;
111 pub fn gr_poly_truncate(
112 poly: *mut gr_poly_struct,
113 src: *const gr_poly_struct,
114 newlen: slong,
115 ctx: *mut gr_ctx_struct,
116 ) -> libc::c_int;
117 #[link_name = "gr_poly_zero__extern"]
118 pub fn gr_poly_zero(poly: *mut gr_poly_struct, ctx: *mut gr_ctx_struct) -> libc::c_int;
119 pub fn gr_poly_one(poly: *mut gr_poly_struct, ctx: *mut gr_ctx_struct) -> libc::c_int;
120 pub fn gr_poly_neg_one(poly: *mut gr_poly_struct, ctx: *mut gr_ctx_struct) -> libc::c_int;
121 pub fn gr_poly_gen(poly: *mut gr_poly_struct, ctx: *mut gr_ctx_struct) -> libc::c_int;
122 pub fn _gr_poly_write(
123 out: *mut gr_stream_struct,
124 poly: gr_srcptr,
125 len: slong,
126 x: *const libc::c_char,
127 ctx: *mut gr_ctx_struct,
128 ) -> libc::c_int;
129 pub fn gr_poly_write(
130 out: *mut gr_stream_struct,
131 poly: *const gr_poly_struct,
132 x: *const libc::c_char,
133 ctx: *mut gr_ctx_struct,
134 ) -> libc::c_int;
135 pub fn _gr_poly_get_str(
136 res: *mut *mut libc::c_char,
137 f: gr_srcptr,
138 len: slong,
139 x: *const libc::c_char,
140 ctx: *mut gr_ctx_struct,
141 ) -> libc::c_int;
142 pub fn gr_poly_get_str(
143 res: *mut *mut libc::c_char,
144 poly: *const gr_poly_struct,
145 x: *const libc::c_char,
146 ctx: *mut gr_ctx_struct,
147 ) -> libc::c_int;
148 pub fn _gr_poly_set_str(
149 res: gr_ptr,
150 s: *const libc::c_char,
151 x: *const libc::c_char,
152 len: slong,
153 ctx: *mut gr_ctx_struct,
154 ) -> libc::c_int;
155 pub fn gr_poly_set_str(
156 res: *mut gr_poly_struct,
157 s: *const libc::c_char,
158 x: *const libc::c_char,
159 ctx: *mut gr_ctx_struct,
160 ) -> libc::c_int;
161 pub fn gr_poly_print(poly: *const gr_poly_struct, ctx: *mut gr_ctx_struct) -> libc::c_int;
162 pub fn gr_poly_randtest(
163 poly: *mut gr_poly_struct,
164 state: *mut flint_rand_struct,
165 len: slong,
166 ctx: *mut gr_ctx_struct,
167 ) -> libc::c_int;
168 pub fn _gr_poly_equal(
169 poly1: gr_srcptr,
170 len1: slong,
171 poly2: gr_srcptr,
172 len2: slong,
173 ctx: *mut gr_ctx_struct,
174 ) -> truth_t;
175 pub fn gr_poly_equal(
176 poly1: *const gr_poly_struct,
177 poly2: *const gr_poly_struct,
178 ctx: *mut gr_ctx_struct,
179 ) -> truth_t;
180 pub fn gr_poly_is_zero(poly: *const gr_poly_struct, ctx: *mut gr_ctx_struct) -> truth_t;
181 pub fn gr_poly_is_one(poly: *const gr_poly_struct, ctx: *mut gr_ctx_struct) -> truth_t;
182 pub fn gr_poly_is_gen(poly: *const gr_poly_struct, ctx: *mut gr_ctx_struct) -> truth_t;
183 pub fn gr_poly_is_scalar(poly: *const gr_poly_struct, ctx: *mut gr_ctx_struct) -> truth_t;
184 pub fn gr_poly_set_scalar(
185 poly: *mut gr_poly_struct,
186 x: gr_srcptr,
187 ctx: *mut gr_ctx_struct,
188 ) -> libc::c_int;
189 pub fn gr_poly_set_si(
190 poly: *mut gr_poly_struct,
191 x: slong,
192 ctx: *mut gr_ctx_struct,
193 ) -> libc::c_int;
194 pub fn gr_poly_set_ui(
195 poly: *mut gr_poly_struct,
196 x: ulong,
197 ctx: *mut gr_ctx_struct,
198 ) -> libc::c_int;
199 pub fn gr_poly_set_fmpz(
200 poly: *mut gr_poly_struct,
201 x: *const fmpz,
202 ctx: *mut gr_ctx_struct,
203 ) -> libc::c_int;
204 pub fn gr_poly_set_fmpq(
205 poly: *mut gr_poly_struct,
206 x: *const fmpq,
207 ctx: *mut gr_ctx_struct,
208 ) -> libc::c_int;
209 pub fn gr_poly_set_fmpz_poly(
210 res: *mut gr_poly_struct,
211 src: *const fmpz_poly_struct,
212 ctx: *mut gr_ctx_struct,
213 ) -> libc::c_int;
214 pub fn gr_poly_set_fmpq_poly(
215 res: *mut gr_poly_struct,
216 src: *const fmpq_poly_struct,
217 ctx: *mut gr_ctx_struct,
218 ) -> libc::c_int;
219 pub fn gr_poly_set_gr_poly_other(
220 res: *mut gr_poly_struct,
221 x: *const gr_poly_struct,
222 x_ctx: *mut gr_ctx_struct,
223 ctx: *mut gr_ctx_struct,
224 ) -> libc::c_int;
225 pub fn gr_poly_set_coeff_scalar(
226 poly: *mut gr_poly_struct,
227 n: slong,
228 x: gr_srcptr,
229 ctx: *mut gr_ctx_struct,
230 ) -> libc::c_int;
231 pub fn gr_poly_set_coeff_si(
232 poly: *mut gr_poly_struct,
233 n: slong,
234 x: slong,
235 ctx: *mut gr_ctx_struct,
236 ) -> libc::c_int;
237 pub fn gr_poly_set_coeff_ui(
238 poly: *mut gr_poly_struct,
239 n: slong,
240 x: ulong,
241 ctx: *mut gr_ctx_struct,
242 ) -> libc::c_int;
243 pub fn gr_poly_set_coeff_fmpz(
244 poly: *mut gr_poly_struct,
245 n: slong,
246 x: *const fmpz,
247 ctx: *mut gr_ctx_struct,
248 ) -> libc::c_int;
249 pub fn gr_poly_set_coeff_fmpq(
250 poly: *mut gr_poly_struct,
251 n: slong,
252 x: *const fmpq,
253 ctx: *mut gr_ctx_struct,
254 ) -> libc::c_int;
255 pub fn gr_poly_get_coeff_scalar(
256 res: gr_ptr,
257 poly: *const gr_poly_struct,
258 n: slong,
259 ctx: *mut gr_ctx_struct,
260 ) -> libc::c_int;
261 pub fn gr_poly_neg(
262 res: *mut gr_poly_struct,
263 src: *const gr_poly_struct,
264 ctx: *mut gr_ctx_struct,
265 ) -> libc::c_int;
266 pub fn _gr_poly_add(
267 res: gr_ptr,
268 poly1: gr_srcptr,
269 len1: slong,
270 poly2: gr_srcptr,
271 len2: slong,
272 ctx: *mut gr_ctx_struct,
273 ) -> libc::c_int;
274 pub fn gr_poly_add(
275 res: *mut gr_poly_struct,
276 poly1: *const gr_poly_struct,
277 poly2: *const gr_poly_struct,
278 ctx: *mut gr_ctx_struct,
279 ) -> libc::c_int;
280 pub fn _gr_poly_sub(
281 res: gr_ptr,
282 poly1: gr_srcptr,
283 len1: slong,
284 poly2: gr_srcptr,
285 len2: slong,
286 ctx: *mut gr_ctx_struct,
287 ) -> libc::c_int;
288 pub fn gr_poly_sub(
289 res: *mut gr_poly_struct,
290 poly1: *const gr_poly_struct,
291 poly2: *const gr_poly_struct,
292 ctx: *mut gr_ctx_struct,
293 ) -> libc::c_int;
294 pub fn _gr_poly_mul(
295 res: gr_ptr,
296 poly1: gr_srcptr,
297 len1: slong,
298 poly2: gr_srcptr,
299 len2: slong,
300 ctx: *mut gr_ctx_struct,
301 ) -> libc::c_int;
302 pub fn gr_poly_mul(
303 res: *mut gr_poly_struct,
304 poly1: *const gr_poly_struct,
305 poly2: *const gr_poly_struct,
306 ctx: *mut gr_ctx_struct,
307 ) -> libc::c_int;
308 #[link_name = "_gr_poly_mullow__extern"]
309 pub fn _gr_poly_mullow(
310 res: gr_ptr,
311 poly1: gr_srcptr,
312 len1: slong,
313 poly2: gr_srcptr,
314 len2: slong,
315 len: slong,
316 ctx: *mut gr_ctx_struct,
317 ) -> libc::c_int;
318 pub fn _gr_poly_mullow_generic(
319 res: gr_ptr,
320 poly1: gr_srcptr,
321 len1: slong,
322 poly2: gr_srcptr,
323 len2: slong,
324 n: slong,
325 ctx: *mut gr_ctx_struct,
326 ) -> libc::c_int;
327 pub fn gr_poly_mullow(
328 res: *mut gr_poly_struct,
329 poly1: *const gr_poly_struct,
330 poly2: *const gr_poly_struct,
331 n: slong,
332 ctx: *mut gr_ctx_struct,
333 ) -> libc::c_int;
334 pub fn _gr_poly_mulmid_complex_reorder(
335 res: gr_ptr,
336 poly1: gr_srcptr,
337 len1: slong,
338 poly2: gr_srcptr,
339 len2: slong,
340 nlo: slong,
341 nhi: slong,
342 karatsuba: libc::c_int,
343 ctx: *mut gr_ctx_struct,
344 real_ctx: *mut gr_ctx_struct,
345 ) -> libc::c_int;
346 pub fn gr_poly_mulmid_complex_reorder(
347 res: *mut gr_poly_struct,
348 poly1: *const gr_poly_struct,
349 poly2: *const gr_poly_struct,
350 nlo: slong,
351 nhi: slong,
352 karatsuba: libc::c_int,
353 ctx: *mut gr_ctx_struct,
354 real_ctx: *mut gr_ctx_struct,
355 ) -> libc::c_int;
356 pub fn _gr_poly_mullow_complex_reorder(
357 res: gr_ptr,
358 poly1: gr_srcptr,
359 len1: slong,
360 poly2: gr_srcptr,
361 len2: slong,
362 n: slong,
363 karatsuba: libc::c_int,
364 ctx: *mut gr_ctx_struct,
365 real_ctx: *mut gr_ctx_struct,
366 ) -> libc::c_int;
367 pub fn gr_poly_mullow_complex_reorder(
368 res: *mut gr_poly_struct,
369 poly1: *const gr_poly_struct,
370 poly2: *const gr_poly_struct,
371 n: slong,
372 karatsuba: libc::c_int,
373 ctx: *mut gr_ctx_struct,
374 real_ctx: *mut gr_ctx_struct,
375 ) -> libc::c_int;
376 pub fn _gr_poly_mullow_bivariate_KS(
377 res: gr_ptr,
378 poly1: gr_srcptr,
379 len1: slong,
380 poly2: gr_srcptr,
381 len2: slong,
382 n: slong,
383 ctx: *mut gr_ctx_struct,
384 ) -> libc::c_int;
385 pub fn gr_poly_mullow_bivariate_KS(
386 res: *mut gr_poly_struct,
387 poly1: *const gr_poly_struct,
388 poly2: *const gr_poly_struct,
389 n: slong,
390 ctx: *mut gr_ctx_struct,
391 ) -> libc::c_int;
392 pub fn _gr_poly_mullow_toom_serial(
393 res: gr_ptr,
394 poly1: gr_srcptr,
395 len1: slong,
396 poly2: gr_srcptr,
397 len2: slong,
398 trunc: slong,
399 num_points: slong,
400 splitting_degree: slong,
401 ctx: *mut gr_ctx_struct,
402 ) -> libc::c_int;
403 pub fn gr_poly_mullow_toom_serial(
404 res: *mut gr_poly_struct,
405 poly1: *const gr_poly_struct,
406 poly2: *const gr_poly_struct,
407 n: slong,
408 num_points: slong,
409 splitting_degree: slong,
410 ctx: *mut gr_ctx_struct,
411 ) -> libc::c_int;
412 #[link_name = "_gr_poly_mulmid__extern"]
413 pub fn _gr_poly_mulmid(
414 res: gr_ptr,
415 poly1: gr_srcptr,
416 len1: slong,
417 poly2: gr_srcptr,
418 len2: slong,
419 nlo: slong,
420 nhi: slong,
421 ctx: *mut gr_ctx_struct,
422 ) -> libc::c_int;
423 pub fn _gr_poly_mulmid_generic(
424 res: gr_ptr,
425 poly1: gr_srcptr,
426 len1: slong,
427 poly2: gr_srcptr,
428 len2: slong,
429 nlo: slong,
430 nhi: slong,
431 ctx: *mut gr_ctx_struct,
432 ) -> libc::c_int;
433 pub fn gr_poly_mulmid(
434 res: *mut gr_poly_struct,
435 poly1: *const gr_poly_struct,
436 poly2: *const gr_poly_struct,
437 nlo: slong,
438 nhi: slong,
439 ctx: *mut gr_ctx_struct,
440 ) -> libc::c_int;
441 pub fn _gr_poly_mulmid_classical(
442 res: gr_ptr,
443 poly1: gr_srcptr,
444 len1: slong,
445 poly2: gr_srcptr,
446 len2: slong,
447 nlo: slong,
448 nhi: slong,
449 ctx: *mut gr_ctx_struct,
450 ) -> libc::c_int;
451 pub fn gr_poly_mulmid_classical(
452 res: *mut gr_poly_struct,
453 poly1: *const gr_poly_struct,
454 poly2: *const gr_poly_struct,
455 nlo: slong,
456 nhi: slong,
457 ctx: *mut gr_ctx_struct,
458 ) -> libc::c_int;
459 pub fn _gr_poly_mulmid_bivariate_KS(
460 res: gr_ptr,
461 poly1: gr_srcptr,
462 len1: slong,
463 poly2: gr_srcptr,
464 len2: slong,
465 nlo: slong,
466 nhi: slong,
467 ctx: *mut gr_ctx_struct,
468 ) -> libc::c_int;
469 pub fn gr_poly_mulmid_bivariate_KS(
470 res: *mut gr_poly_struct,
471 poly1: *const gr_poly_struct,
472 poly2: *const gr_poly_struct,
473 nlo: slong,
474 nhi: slong,
475 ctx: *mut gr_ctx_struct,
476 ) -> libc::c_int;
477 #[link_name = "_gr_poly_mullow_classical__extern"]
478 pub fn _gr_poly_mullow_classical(
479 res: gr_ptr,
480 poly1: gr_srcptr,
481 len1: slong,
482 poly2: gr_srcptr,
483 len2: slong,
484 n: slong,
485 ctx: *mut gr_ctx_struct,
486 ) -> libc::c_int;
487 pub fn gr_poly_mullow_classical(
488 res: *mut gr_poly_struct,
489 poly1: *const gr_poly_struct,
490 poly2: *const gr_poly_struct,
491 n: slong,
492 ctx: *mut gr_ctx_struct,
493 ) -> libc::c_int;
494 pub fn _gr_poly_mul_karatsuba(
495 res: gr_ptr,
496 poly1: gr_srcptr,
497 len1: slong,
498 poly2: gr_srcptr,
499 len2: slong,
500 ctx: *mut gr_ctx_struct,
501 ) -> libc::c_int;
502 pub fn gr_poly_mul_karatsuba(
503 res: *mut gr_poly_struct,
504 poly1: *const gr_poly_struct,
505 poly2: *const gr_poly_struct,
506 ctx: *mut gr_ctx_struct,
507 ) -> libc::c_int;
508 pub fn _gr_poly_mul_toom33(
509 res: gr_ptr,
510 poly1: gr_srcptr,
511 len1: slong,
512 poly2: gr_srcptr,
513 len2: slong,
514 ctx: *mut gr_ctx_struct,
515 ) -> libc::c_int;
516 pub fn gr_poly_mul_toom33(
517 res: *mut gr_poly_struct,
518 poly1: *const gr_poly_struct,
519 poly2: *const gr_poly_struct,
520 ctx: *mut gr_ctx_struct,
521 ) -> libc::c_int;
522 pub fn gr_poly_add_scalar(
523 res: *mut gr_poly_struct,
524 poly: *const gr_poly_struct,
525 c: gr_srcptr,
526 ctx: *mut gr_ctx_struct,
527 ) -> libc::c_int;
528 pub fn gr_poly_add_ui(
529 res: *mut gr_poly_struct,
530 poly: *const gr_poly_struct,
531 c: ulong,
532 ctx: *mut gr_ctx_struct,
533 ) -> libc::c_int;
534 pub fn gr_poly_add_si(
535 res: *mut gr_poly_struct,
536 poly: *const gr_poly_struct,
537 c: slong,
538 ctx: *mut gr_ctx_struct,
539 ) -> libc::c_int;
540 pub fn gr_poly_add_fmpz(
541 res: *mut gr_poly_struct,
542 poly: *const gr_poly_struct,
543 c: *const fmpz,
544 ctx: *mut gr_ctx_struct,
545 ) -> libc::c_int;
546 pub fn gr_poly_add_fmpq(
547 res: *mut gr_poly_struct,
548 poly: *const gr_poly_struct,
549 c: *const fmpq,
550 ctx: *mut gr_ctx_struct,
551 ) -> libc::c_int;
552 pub fn gr_poly_sub_scalar(
553 res: *mut gr_poly_struct,
554 poly: *const gr_poly_struct,
555 c: gr_srcptr,
556 ctx: *mut gr_ctx_struct,
557 ) -> libc::c_int;
558 pub fn gr_poly_sub_ui(
559 res: *mut gr_poly_struct,
560 poly: *const gr_poly_struct,
561 c: ulong,
562 ctx: *mut gr_ctx_struct,
563 ) -> libc::c_int;
564 pub fn gr_poly_sub_si(
565 res: *mut gr_poly_struct,
566 poly: *const gr_poly_struct,
567 c: slong,
568 ctx: *mut gr_ctx_struct,
569 ) -> libc::c_int;
570 pub fn gr_poly_sub_fmpz(
571 res: *mut gr_poly_struct,
572 poly: *const gr_poly_struct,
573 c: *const fmpz,
574 ctx: *mut gr_ctx_struct,
575 ) -> libc::c_int;
576 pub fn gr_poly_sub_fmpq(
577 res: *mut gr_poly_struct,
578 poly: *const gr_poly_struct,
579 c: *const fmpq,
580 ctx: *mut gr_ctx_struct,
581 ) -> libc::c_int;
582 pub fn gr_poly_mul_scalar(
583 res: *mut gr_poly_struct,
584 poly: *const gr_poly_struct,
585 c: gr_srcptr,
586 ctx: *mut gr_ctx_struct,
587 ) -> libc::c_int;
588 pub fn gr_poly_scalar_mul(
589 res: *mut gr_poly_struct,
590 c: gr_srcptr,
591 poly: *const gr_poly_struct,
592 ctx: *mut gr_ctx_struct,
593 ) -> libc::c_int;
594 pub fn gr_poly_mul_ui(
595 res: *mut gr_poly_struct,
596 poly: *const gr_poly_struct,
597 c: ulong,
598 ctx: *mut gr_ctx_struct,
599 ) -> libc::c_int;
600 pub fn gr_poly_mul_si(
601 res: *mut gr_poly_struct,
602 poly: *const gr_poly_struct,
603 c: slong,
604 ctx: *mut gr_ctx_struct,
605 ) -> libc::c_int;
606 pub fn gr_poly_mul_fmpz(
607 res: *mut gr_poly_struct,
608 poly: *const gr_poly_struct,
609 c: *const fmpz,
610 ctx: *mut gr_ctx_struct,
611 ) -> libc::c_int;
612 pub fn gr_poly_mul_fmpq(
613 res: *mut gr_poly_struct,
614 poly: *const gr_poly_struct,
615 c: *const fmpq,
616 ctx: *mut gr_ctx_struct,
617 ) -> libc::c_int;
618 pub fn gr_poly_addmul_scalar(
619 res: *mut gr_poly_struct,
620 poly: *const gr_poly_struct,
621 c: gr_srcptr,
622 ctx: *mut gr_ctx_struct,
623 ) -> libc::c_int;
624 pub fn gr_poly_submul_scalar(
625 res: *mut gr_poly_struct,
626 poly: *const gr_poly_struct,
627 c: gr_srcptr,
628 ctx: *mut gr_ctx_struct,
629 ) -> libc::c_int;
630 pub fn _gr_poly_pow_series_ui_binexp(
631 res: gr_ptr,
632 f: gr_srcptr,
633 flen: slong,
634 exp: ulong,
635 len: slong,
636 ctx: *mut gr_ctx_struct,
637 ) -> libc::c_int;
638 pub fn gr_poly_pow_series_ui_binexp(
639 res: *mut gr_poly_struct,
640 poly: *const gr_poly_struct,
641 exp: ulong,
642 len: slong,
643 ctx: *mut gr_ctx_struct,
644 ) -> libc::c_int;
645 pub fn _gr_poly_pow_series_ui(
646 res: gr_ptr,
647 f: gr_srcptr,
648 flen: slong,
649 exp: ulong,
650 len: slong,
651 ctx: *mut gr_ctx_struct,
652 ) -> libc::c_int;
653 pub fn gr_poly_pow_series_ui(
654 res: *mut gr_poly_struct,
655 poly: *const gr_poly_struct,
656 exp: ulong,
657 len: slong,
658 ctx: *mut gr_ctx_struct,
659 ) -> libc::c_int;
660 pub fn _gr_poly_pow_ui_binexp(
661 res: gr_ptr,
662 f: gr_srcptr,
663 flen: slong,
664 exp: ulong,
665 ctx: *mut gr_ctx_struct,
666 ) -> libc::c_int;
667 pub fn gr_poly_pow_ui_binexp(
668 res: *mut gr_poly_struct,
669 poly: *const gr_poly_struct,
670 exp: ulong,
671 ctx: *mut gr_ctx_struct,
672 ) -> libc::c_int;
673 pub fn _gr_poly_pow_ui(
674 res: gr_ptr,
675 f: gr_srcptr,
676 flen: slong,
677 exp: ulong,
678 ctx: *mut gr_ctx_struct,
679 ) -> libc::c_int;
680 pub fn gr_poly_pow_ui(
681 res: *mut gr_poly_struct,
682 poly: *const gr_poly_struct,
683 exp: ulong,
684 ctx: *mut gr_ctx_struct,
685 ) -> libc::c_int;
686 pub fn gr_poly_pow_fmpz(
687 res: *mut gr_poly_struct,
688 poly: *const gr_poly_struct,
689 exp: *const fmpz,
690 ctx: *mut gr_ctx_struct,
691 ) -> libc::c_int;
692 pub fn _gr_poly_pow_series_fmpq_recurrence(
693 h: gr_ptr,
694 f: gr_srcptr,
695 flen: slong,
696 exp: *const fmpq,
697 len: slong,
698 precomp: libc::c_int,
699 ctx: *mut gr_ctx_struct,
700 ) -> libc::c_int;
701 pub fn gr_poly_pow_series_fmpq_recurrence(
702 res: *mut gr_poly_struct,
703 poly: *const gr_poly_struct,
704 exp: *const fmpq,
705 len: slong,
706 ctx: *mut gr_ctx_struct,
707 ) -> libc::c_int;
708 pub fn _gr_poly_shift_left(
709 res: gr_ptr,
710 poly: gr_srcptr,
711 len: slong,
712 n: slong,
713 ctx: *mut gr_ctx_struct,
714 ) -> libc::c_int;
715 pub fn gr_poly_shift_left(
716 res: *mut gr_poly_struct,
717 poly: *const gr_poly_struct,
718 n: slong,
719 ctx: *mut gr_ctx_struct,
720 ) -> libc::c_int;
721 pub fn _gr_poly_shift_right(
722 res: gr_ptr,
723 poly: gr_srcptr,
724 len: slong,
725 n: slong,
726 ctx: *mut gr_ctx_struct,
727 ) -> libc::c_int;
728 pub fn gr_poly_shift_right(
729 res: *mut gr_poly_struct,
730 poly: *const gr_poly_struct,
731 n: slong,
732 ctx: *mut gr_ctx_struct,
733 ) -> libc::c_int;
734 pub fn gr_poly_div_scalar(
735 res: *mut gr_poly_struct,
736 poly: *const gr_poly_struct,
737 c: gr_srcptr,
738 ctx: *mut gr_ctx_struct,
739 ) -> libc::c_int;
740 pub fn gr_poly_inv(
741 res: *mut gr_poly_struct,
742 poly: *const gr_poly_struct,
743 ctx: *mut gr_ctx_struct,
744 ) -> libc::c_int;
745 pub fn _gr_poly_divrem_basecase_preinv1(
746 Q: gr_ptr,
747 R: gr_ptr,
748 A: gr_srcptr,
749 lenA: slong,
750 B: gr_srcptr,
751 lenB: slong,
752 invB: gr_srcptr,
753 ctx: *mut gr_ctx_struct,
754 ) -> libc::c_int;
755 pub fn _gr_poly_divrem_basecase_noinv(
756 Q: gr_ptr,
757 R: gr_ptr,
758 A: gr_srcptr,
759 lenA: slong,
760 B: gr_srcptr,
761 lenB: slong,
762 ctx: *mut gr_ctx_struct,
763 ) -> libc::c_int;
764 pub fn _gr_poly_divrem_basecase(
765 Q: gr_ptr,
766 R: gr_ptr,
767 A: gr_srcptr,
768 lenA: slong,
769 B: gr_srcptr,
770 lenB: slong,
771 ctx: *mut gr_ctx_struct,
772 ) -> libc::c_int;
773 pub fn gr_poly_divrem_basecase(
774 Q: *mut gr_poly_struct,
775 R: *mut gr_poly_struct,
776 A: *const gr_poly_struct,
777 B: *const gr_poly_struct,
778 ctx: *mut gr_ctx_struct,
779 ) -> libc::c_int;
780 pub fn _gr_poly_divrem_divconquer_preinv1(
781 Q: gr_ptr,
782 R: gr_ptr,
783 A: gr_srcptr,
784 lenA: slong,
785 B: gr_srcptr,
786 lenB: slong,
787 invB: gr_srcptr,
788 cutoff: slong,
789 ctx: *mut gr_ctx_struct,
790 ) -> libc::c_int;
791 pub fn _gr_poly_divrem_divconquer_noinv(
792 Q: gr_ptr,
793 R: gr_ptr,
794 A: gr_srcptr,
795 lenA: slong,
796 B: gr_srcptr,
797 lenB: slong,
798 cutoff: slong,
799 ctx: *mut gr_ctx_struct,
800 ) -> libc::c_int;
801 pub fn _gr_poly_divrem_divconquer(
802 Q: gr_ptr,
803 R: gr_ptr,
804 A: gr_srcptr,
805 lenA: slong,
806 B: gr_srcptr,
807 lenB: slong,
808 cutoff: slong,
809 ctx: *mut gr_ctx_struct,
810 ) -> libc::c_int;
811 pub fn gr_poly_divrem_divconquer(
812 Q: *mut gr_poly_struct,
813 R: *mut gr_poly_struct,
814 A: *const gr_poly_struct,
815 B: *const gr_poly_struct,
816 cutoff: slong,
817 ctx: *mut gr_ctx_struct,
818 ) -> libc::c_int;
819 pub fn _gr_poly_divrem_newton(
820 Q: gr_ptr,
821 R: gr_ptr,
822 A: gr_srcptr,
823 lenA: slong,
824 B: gr_srcptr,
825 lenB: slong,
826 ctx: *mut gr_ctx_struct,
827 ) -> libc::c_int;
828 pub fn gr_poly_divrem_newton(
829 Q: *mut gr_poly_struct,
830 R: *mut gr_poly_struct,
831 A: *const gr_poly_struct,
832 B: *const gr_poly_struct,
833 ctx: *mut gr_ctx_struct,
834 ) -> libc::c_int;
835 #[link_name = "_gr_poly_divrem__extern"]
836 pub fn _gr_poly_divrem(
837 Q: gr_ptr,
838 R: gr_ptr,
839 A: gr_srcptr,
840 lenA: slong,
841 B: gr_srcptr,
842 lenB: slong,
843 ctx: *mut gr_ctx_struct,
844 ) -> libc::c_int;
845 pub fn _gr_poly_divrem_generic(
846 Q: gr_ptr,
847 R: gr_ptr,
848 A: gr_srcptr,
849 lenA: slong,
850 B: gr_srcptr,
851 lenB: slong,
852 ctx: *mut gr_ctx_struct,
853 ) -> libc::c_int;
854 pub fn gr_poly_divrem(
855 Q: *mut gr_poly_struct,
856 R: *mut gr_poly_struct,
857 A: *const gr_poly_struct,
858 B: *const gr_poly_struct,
859 ctx: *mut gr_ctx_struct,
860 ) -> libc::c_int;
861 pub fn _gr_poly_div_divconquer_preinv1(
862 Q: gr_ptr,
863 A: gr_srcptr,
864 lenA: slong,
865 B: gr_srcptr,
866 lenB: slong,
867 invB: gr_srcptr,
868 cutoff: slong,
869 ctx: *mut gr_ctx_struct,
870 ) -> libc::c_int;
871 pub fn _gr_poly_div_divconquer_noinv(
872 Q: gr_ptr,
873 A: gr_srcptr,
874 lenA: slong,
875 B: gr_srcptr,
876 lenB: slong,
877 cutoff: slong,
878 ctx: *mut gr_ctx_struct,
879 ) -> libc::c_int;
880 pub fn _gr_poly_div_divconquer(
881 Q: gr_ptr,
882 A: gr_srcptr,
883 lenA: slong,
884 B: gr_srcptr,
885 lenB: slong,
886 cutoff: slong,
887 ctx: *mut gr_ctx_struct,
888 ) -> libc::c_int;
889 pub fn gr_poly_div_divconquer(
890 Q: *mut gr_poly_struct,
891 A: *const gr_poly_struct,
892 B: *const gr_poly_struct,
893 cutoff: slong,
894 ctx: *mut gr_ctx_struct,
895 ) -> libc::c_int;
896 pub fn _gr_poly_div_basecase_preinv1(
897 Q: gr_ptr,
898 A: gr_srcptr,
899 lenA: slong,
900 B: gr_srcptr,
901 lenB: slong,
902 invB: gr_srcptr,
903 ctx: *mut gr_ctx_struct,
904 ) -> libc::c_int;
905 pub fn _gr_poly_div_basecase_noinv(
906 Q: gr_ptr,
907 A: gr_srcptr,
908 lenA: slong,
909 B: gr_srcptr,
910 lenB: slong,
911 ctx: *mut gr_ctx_struct,
912 ) -> libc::c_int;
913 pub fn _gr_poly_div_basecase(
914 Q: gr_ptr,
915 A: gr_srcptr,
916 lenA: slong,
917 B: gr_srcptr,
918 lenB: slong,
919 ctx: *mut gr_ctx_struct,
920 ) -> libc::c_int;
921 pub fn gr_poly_div_basecase(
922 Q: *mut gr_poly_struct,
923 A: *const gr_poly_struct,
924 B: *const gr_poly_struct,
925 ctx: *mut gr_ctx_struct,
926 ) -> libc::c_int;
927 pub fn _gr_poly_div_newton(
928 Q: gr_ptr,
929 A: gr_srcptr,
930 lenA: slong,
931 B: gr_srcptr,
932 lenB: slong,
933 ctx: *mut gr_ctx_struct,
934 ) -> libc::c_int;
935 pub fn gr_poly_div_newton(
936 Q: *mut gr_poly_struct,
937 A: *const gr_poly_struct,
938 B: *const gr_poly_struct,
939 ctx: *mut gr_ctx_struct,
940 ) -> libc::c_int;
941 #[link_name = "_gr_poly_div__extern"]
942 pub fn _gr_poly_div(
943 Q: gr_ptr,
944 A: gr_srcptr,
945 lenA: slong,
946 B: gr_srcptr,
947 lenB: slong,
948 ctx: *mut gr_ctx_struct,
949 ) -> libc::c_int;
950 pub fn _gr_poly_div_generic(
951 Q: gr_ptr,
952 A: gr_srcptr,
953 lenA: slong,
954 B: gr_srcptr,
955 lenB: slong,
956 ctx: *mut gr_ctx_struct,
957 ) -> libc::c_int;
958 pub fn gr_poly_div(
959 Q: *mut gr_poly_struct,
960 A: *const gr_poly_struct,
961 B: *const gr_poly_struct,
962 ctx: *mut gr_ctx_struct,
963 ) -> libc::c_int;
964 pub fn _gr_poly_rem(
965 R: gr_ptr,
966 A: gr_srcptr,
967 lenA: slong,
968 B: gr_srcptr,
969 lenB: slong,
970 ctx: *mut gr_ctx_struct,
971 ) -> libc::c_int;
972 pub fn gr_poly_rem(
973 R: *mut gr_poly_struct,
974 A: *const gr_poly_struct,
975 B: *const gr_poly_struct,
976 ctx: *mut gr_ctx_struct,
977 ) -> libc::c_int;
978 pub fn _gr_poly_div_newton_n_preinv(
979 Q: gr_ptr,
980 A: gr_srcptr,
981 lenA: slong,
982 UNUSED_B: gr_srcptr,
983 lenB: slong,
984 Binv: gr_srcptr,
985 lenBinv: slong,
986 ctx: *mut gr_ctx_struct,
987 ) -> libc::c_int;
988 pub fn gr_poly_div_newton_n_preinv(
989 Q: *mut gr_poly_struct,
990 A: *const gr_poly_struct,
991 B: *const gr_poly_struct,
992 Binv: *const gr_poly_struct,
993 ctx: *mut gr_ctx_struct,
994 ) -> libc::c_int;
995 pub fn _gr_poly_divrem_newton_n_preinv(
996 Q: gr_ptr,
997 R: gr_ptr,
998 A: gr_srcptr,
999 lenA: slong,
1000 B: gr_srcptr,
1001 lenB: slong,
1002 Binv: gr_srcptr,
1003 lenBinv: slong,
1004 ctx: *mut gr_ctx_struct,
1005 ) -> libc::c_int;
1006 pub fn gr_poly_divrem_newton_n_preinv(
1007 Q: *mut gr_poly_struct,
1008 R: *mut gr_poly_struct,
1009 A: *const gr_poly_struct,
1010 B: *const gr_poly_struct,
1011 Binv: *const gr_poly_struct,
1012 ctx: *mut gr_ctx_struct,
1013 ) -> libc::c_int;
1014 pub fn _gr_poly_inv_series_newton(
1015 Qinv: gr_ptr,
1016 Q: gr_srcptr,
1017 Qlen: slong,
1018 len: slong,
1019 cutoff: slong,
1020 ctx: *mut gr_ctx_struct,
1021 ) -> libc::c_int;
1022 pub fn gr_poly_inv_series_newton(
1023 Qinv: *mut gr_poly_struct,
1024 Q: *const gr_poly_struct,
1025 len: slong,
1026 cutoff: slong,
1027 ctx: *mut gr_ctx_struct,
1028 ) -> libc::c_int;
1029 pub fn _gr_poly_inv_series_basecase_preinv1(
1030 res: gr_ptr,
1031 A: gr_srcptr,
1032 Alen: slong,
1033 Ainv: gr_srcptr,
1034 len: slong,
1035 ctx: *mut gr_ctx_struct,
1036 ) -> libc::c_int;
1037 pub fn _gr_poly_inv_series_basecase_generic(
1038 Qinv: gr_ptr,
1039 Q: gr_srcptr,
1040 Qlen: slong,
1041 len: slong,
1042 ctx: *mut gr_ctx_struct,
1043 ) -> libc::c_int;
1044 pub fn gr_poly_inv_series_basecase(
1045 Qinv: *mut gr_poly_struct,
1046 Q: *const gr_poly_struct,
1047 len: slong,
1048 ctx: *mut gr_ctx_struct,
1049 ) -> libc::c_int;
1050 #[link_name = "_gr_poly_inv_series_basecase__extern"]
1051 pub fn _gr_poly_inv_series_basecase(
1052 res: gr_ptr,
1053 f: gr_srcptr,
1054 flen: slong,
1055 len: slong,
1056 ctx: *mut gr_ctx_struct,
1057 ) -> libc::c_int;
1058 #[link_name = "_gr_poly_inv_series__extern"]
1059 pub fn _gr_poly_inv_series(
1060 res: gr_ptr,
1061 f: gr_srcptr,
1062 flen: slong,
1063 len: slong,
1064 ctx: *mut gr_ctx_struct,
1065 ) -> libc::c_int;
1066 pub fn _gr_poly_inv_series_generic(
1067 Qinv: gr_ptr,
1068 Q: gr_srcptr,
1069 Qlen: slong,
1070 len: slong,
1071 ctx: *mut gr_ctx_struct,
1072 ) -> libc::c_int;
1073 pub fn gr_poly_inv_series(
1074 Qinv: *mut gr_poly_struct,
1075 Q: *const gr_poly_struct,
1076 len: slong,
1077 ctx: *mut gr_ctx_struct,
1078 ) -> libc::c_int;
1079 pub fn _gr_poly_div_series_newton(
1080 res: gr_ptr,
1081 A: gr_srcptr,
1082 Alen: slong,
1083 B: gr_srcptr,
1084 Blen: slong,
1085 len: slong,
1086 cutoff: slong,
1087 ctx: *mut gr_ctx_struct,
1088 ) -> libc::c_int;
1089 pub fn gr_poly_div_series_newton(
1090 Q: *mut gr_poly_struct,
1091 A: *const gr_poly_struct,
1092 B: *const gr_poly_struct,
1093 len: slong,
1094 cutoff: slong,
1095 ctx: *mut gr_ctx_struct,
1096 ) -> libc::c_int;
1097 pub fn _gr_poly_div_series_divconquer(
1098 res: gr_ptr,
1099 A: gr_srcptr,
1100 Alen: slong,
1101 B: gr_srcptr,
1102 Blen: slong,
1103 len: slong,
1104 cutoff: slong,
1105 ctx: *mut gr_ctx_struct,
1106 ) -> libc::c_int;
1107 pub fn gr_poly_div_series_divconquer(
1108 Q: *mut gr_poly_struct,
1109 A: *const gr_poly_struct,
1110 B: *const gr_poly_struct,
1111 len: slong,
1112 cutoff: slong,
1113 ctx: *mut gr_ctx_struct,
1114 ) -> libc::c_int;
1115 pub fn _gr_poly_div_series_basecase_generic(
1116 Q: gr_ptr,
1117 A: gr_srcptr,
1118 Alen: slong,
1119 B: gr_srcptr,
1120 Blen: slong,
1121 len: slong,
1122 ctx: *mut gr_ctx_struct,
1123 ) -> libc::c_int;
1124 pub fn gr_poly_div_series_basecase(
1125 Q: *mut gr_poly_struct,
1126 A: *const gr_poly_struct,
1127 B: *const gr_poly_struct,
1128 len: slong,
1129 ctx: *mut gr_ctx_struct,
1130 ) -> libc::c_int;
1131 pub fn _gr_poly_div_series_basecase_preinv1(
1132 Q: gr_ptr,
1133 A: gr_srcptr,
1134 Alen: slong,
1135 B: gr_srcptr,
1136 Blen: slong,
1137 Binv: gr_srcptr,
1138 len: slong,
1139 ctx: *mut gr_ctx_struct,
1140 ) -> libc::c_int;
1141 pub fn _gr_poly_div_series_basecase_noinv(
1142 Q: gr_ptr,
1143 A: gr_srcptr,
1144 Alen: slong,
1145 B: gr_srcptr,
1146 Blen: slong,
1147 len: slong,
1148 ctx: *mut gr_ctx_struct,
1149 ) -> libc::c_int;
1150 pub fn _gr_poly_div_series_invmul(
1151 Q: gr_ptr,
1152 A: gr_srcptr,
1153 Alen: slong,
1154 B: gr_srcptr,
1155 Blen: slong,
1156 len: slong,
1157 ctx: *mut gr_ctx_struct,
1158 ) -> libc::c_int;
1159 pub fn gr_poly_div_series_invmul(
1160 Q: *mut gr_poly_struct,
1161 A: *const gr_poly_struct,
1162 B: *const gr_poly_struct,
1163 len: slong,
1164 ctx: *mut gr_ctx_struct,
1165 ) -> libc::c_int;
1166 #[link_name = "_gr_poly_div_series_basecase__extern"]
1167 pub fn _gr_poly_div_series_basecase(
1168 res: gr_ptr,
1169 f: gr_srcptr,
1170 flen: slong,
1171 g: gr_srcptr,
1172 glen: slong,
1173 len: slong,
1174 ctx: *mut gr_ctx_struct,
1175 ) -> libc::c_int;
1176 #[link_name = "_gr_poly_div_series__extern"]
1177 pub fn _gr_poly_div_series(
1178 res: gr_ptr,
1179 f: gr_srcptr,
1180 flen: slong,
1181 g: gr_srcptr,
1182 glen: slong,
1183 len: slong,
1184 ctx: *mut gr_ctx_struct,
1185 ) -> libc::c_int;
1186 pub fn _gr_poly_div_series_generic(
1187 Q: gr_ptr,
1188 A: gr_srcptr,
1189 Alen: slong,
1190 B: gr_srcptr,
1191 Blen: slong,
1192 len: slong,
1193 ctx: *mut gr_ctx_struct,
1194 ) -> libc::c_int;
1195 pub fn gr_poly_div_series(
1196 Q: *mut gr_poly_struct,
1197 A: *const gr_poly_struct,
1198 B: *const gr_poly_struct,
1199 len: slong,
1200 ctx: *mut gr_ctx_struct,
1201 ) -> libc::c_int;
1202 pub fn _gr_poly_divexact_basecase_bidirectional(
1203 Q: gr_ptr,
1204 A: gr_srcptr,
1205 Alen: slong,
1206 B: gr_srcptr,
1207 Blen: slong,
1208 ctx: *mut gr_ctx_struct,
1209 ) -> libc::c_int;
1210 pub fn gr_poly_divexact_basecase_bidirectional(
1211 Q: *mut gr_poly_struct,
1212 A: *const gr_poly_struct,
1213 B: *const gr_poly_struct,
1214 ctx: *mut gr_ctx_struct,
1215 ) -> libc::c_int;
1216 pub fn _gr_poly_divexact_bidirectional(
1217 Q: gr_ptr,
1218 A: gr_srcptr,
1219 Alen: slong,
1220 B: gr_srcptr,
1221 Blen: slong,
1222 ctx: *mut gr_ctx_struct,
1223 ) -> libc::c_int;
1224 pub fn gr_poly_divexact_bidirectional(
1225 Q: *mut gr_poly_struct,
1226 A: *const gr_poly_struct,
1227 B: *const gr_poly_struct,
1228 ctx: *mut gr_ctx_struct,
1229 ) -> libc::c_int;
1230 pub fn _gr_poly_divexact_basecase_noinv(
1231 Q: gr_ptr,
1232 A: gr_srcptr,
1233 Alen: slong,
1234 B: gr_srcptr,
1235 Blen: slong,
1236 ctx: *mut gr_ctx_struct,
1237 ) -> libc::c_int;
1238 pub fn _gr_poly_divexact_basecase(
1239 Q: gr_ptr,
1240 A: gr_srcptr,
1241 Alen: slong,
1242 B: gr_srcptr,
1243 Blen: slong,
1244 ctx: *mut gr_ctx_struct,
1245 ) -> libc::c_int;
1246 pub fn gr_poly_divexact_basecase(
1247 Q: *mut gr_poly_struct,
1248 A: *const gr_poly_struct,
1249 B: *const gr_poly_struct,
1250 ctx: *mut gr_ctx_struct,
1251 ) -> libc::c_int;
1252 #[link_name = "_gr_poly_divexact__extern"]
1253 pub fn _gr_poly_divexact(
1254 Q: gr_ptr,
1255 A: gr_srcptr,
1256 lenA: slong,
1257 B: gr_srcptr,
1258 lenB: slong,
1259 ctx: *mut gr_ctx_struct,
1260 ) -> libc::c_int;
1261 pub fn _gr_poly_divexact_generic(
1262 Q: gr_ptr,
1263 A: gr_srcptr,
1264 lenA: slong,
1265 B: gr_srcptr,
1266 lenB: slong,
1267 ctx: *mut gr_ctx_struct,
1268 ) -> libc::c_int;
1269 pub fn gr_poly_divexact(
1270 Q: *mut gr_poly_struct,
1271 A: *const gr_poly_struct,
1272 B: *const gr_poly_struct,
1273 ctx: *mut gr_ctx_struct,
1274 ) -> libc::c_int;
1275 pub fn _gr_poly_divexact_series_basecase_noinv(
1276 Q: gr_ptr,
1277 A: gr_srcptr,
1278 Alen: slong,
1279 B: gr_srcptr,
1280 Blen: slong,
1281 len: slong,
1282 ctx: *mut gr_ctx_struct,
1283 ) -> libc::c_int;
1284 pub fn _gr_poly_divexact_series_basecase(
1285 Q: gr_ptr,
1286 A: gr_srcptr,
1287 Alen: slong,
1288 B: gr_srcptr,
1289 Blen: slong,
1290 len: slong,
1291 ctx: *mut gr_ctx_struct,
1292 ) -> libc::c_int;
1293 pub fn gr_poly_divexact_series_basecase(
1294 Q: *mut gr_poly_struct,
1295 A: *const gr_poly_struct,
1296 B: *const gr_poly_struct,
1297 len: slong,
1298 ctx: *mut gr_ctx_struct,
1299 ) -> libc::c_int;
1300 pub fn _gr_poly_sqrt_series_newton(
1301 res: gr_ptr,
1302 f: gr_srcptr,
1303 flen: slong,
1304 len: slong,
1305 cutoff: slong,
1306 ctx: *mut gr_ctx_struct,
1307 ) -> libc::c_int;
1308 pub fn gr_poly_sqrt_series_newton(
1309 res: *mut gr_poly_struct,
1310 f: *const gr_poly_struct,
1311 len: slong,
1312 cutoff: slong,
1313 ctx: *mut gr_ctx_struct,
1314 ) -> libc::c_int;
1315 pub fn _gr_poly_sqrt_series_basecase(
1316 res: gr_ptr,
1317 f: gr_srcptr,
1318 flen: slong,
1319 len: slong,
1320 ctx: *mut gr_ctx_struct,
1321 ) -> libc::c_int;
1322 pub fn gr_poly_sqrt_series_basecase(
1323 res: *mut gr_poly_struct,
1324 f: *const gr_poly_struct,
1325 len: slong,
1326 ctx: *mut gr_ctx_struct,
1327 ) -> libc::c_int;
1328 pub fn _gr_poly_sqrt_series_miller(
1329 res: gr_ptr,
1330 f: gr_srcptr,
1331 flen: slong,
1332 len: slong,
1333 ctx: *mut gr_ctx_struct,
1334 ) -> libc::c_int;
1335 pub fn gr_poly_sqrt_series_miller(
1336 res: *mut gr_poly_struct,
1337 f: *const gr_poly_struct,
1338 len: slong,
1339 ctx: *mut gr_ctx_struct,
1340 ) -> libc::c_int;
1341 #[link_name = "_gr_poly_sqrt_series__extern"]
1342 pub fn _gr_poly_sqrt_series(
1343 res: gr_ptr,
1344 f: gr_srcptr,
1345 flen: slong,
1346 len: slong,
1347 ctx: *mut gr_ctx_struct,
1348 ) -> libc::c_int;
1349 pub fn _gr_poly_sqrt_series_generic(
1350 res: gr_ptr,
1351 f: gr_srcptr,
1352 flen: slong,
1353 len: slong,
1354 ctx: *mut gr_ctx_struct,
1355 ) -> libc::c_int;
1356 pub fn gr_poly_sqrt_series(
1357 res: *mut gr_poly_struct,
1358 f: *const gr_poly_struct,
1359 len: slong,
1360 ctx: *mut gr_ctx_struct,
1361 ) -> libc::c_int;
1362 pub fn _gr_poly_rsqrt_series_newton(
1363 res: gr_ptr,
1364 f: gr_srcptr,
1365 flen: slong,
1366 len: slong,
1367 cutoff: slong,
1368 ctx: *mut gr_ctx_struct,
1369 ) -> libc::c_int;
1370 pub fn gr_poly_rsqrt_series_newton(
1371 res: *mut gr_poly_struct,
1372 f: *const gr_poly_struct,
1373 len: slong,
1374 cutoff: slong,
1375 ctx: *mut gr_ctx_struct,
1376 ) -> libc::c_int;
1377 pub fn _gr_poly_rsqrt_series_basecase(
1378 res: gr_ptr,
1379 f: gr_srcptr,
1380 flen: slong,
1381 len: slong,
1382 ctx: *mut gr_ctx_struct,
1383 ) -> libc::c_int;
1384 pub fn gr_poly_rsqrt_series_basecase(
1385 res: *mut gr_poly_struct,
1386 f: *const gr_poly_struct,
1387 len: slong,
1388 ctx: *mut gr_ctx_struct,
1389 ) -> libc::c_int;
1390 pub fn _gr_poly_rsqrt_series_miller(
1391 res: gr_ptr,
1392 f: gr_srcptr,
1393 flen: slong,
1394 len: slong,
1395 ctx: *mut gr_ctx_struct,
1396 ) -> libc::c_int;
1397 pub fn gr_poly_rsqrt_series_miller(
1398 res: *mut gr_poly_struct,
1399 f: *const gr_poly_struct,
1400 len: slong,
1401 ctx: *mut gr_ctx_struct,
1402 ) -> libc::c_int;
1403 #[link_name = "_gr_poly_rsqrt_series__extern"]
1404 pub fn _gr_poly_rsqrt_series(
1405 res: gr_ptr,
1406 f: gr_srcptr,
1407 flen: slong,
1408 len: slong,
1409 ctx: *mut gr_ctx_struct,
1410 ) -> libc::c_int;
1411 pub fn _gr_poly_rsqrt_series_generic(
1412 res: gr_ptr,
1413 f: gr_srcptr,
1414 flen: slong,
1415 len: slong,
1416 ctx: *mut gr_ctx_struct,
1417 ) -> libc::c_int;
1418 pub fn gr_poly_rsqrt_series(
1419 res: *mut gr_poly_struct,
1420 f: *const gr_poly_struct,
1421 len: slong,
1422 ctx: *mut gr_ctx_struct,
1423 ) -> libc::c_int;
1424 pub fn _gr_poly_evaluate_rectangular(
1425 res: gr_ptr,
1426 poly: gr_srcptr,
1427 len: slong,
1428 x: gr_srcptr,
1429 ctx: *mut gr_ctx_struct,
1430 ) -> libc::c_int;
1431 pub fn gr_poly_evaluate_rectangular(
1432 res: gr_ptr,
1433 poly: *const gr_poly_struct,
1434 x: gr_srcptr,
1435 ctx: *mut gr_ctx_struct,
1436 ) -> libc::c_int;
1437 pub fn _gr_poly_evaluate_modular(
1438 res: gr_ptr,
1439 poly: gr_srcptr,
1440 len: slong,
1441 x: gr_srcptr,
1442 ctx: *mut gr_ctx_struct,
1443 ) -> libc::c_int;
1444 pub fn gr_poly_evaluate_modular(
1445 res: gr_ptr,
1446 poly: *const gr_poly_struct,
1447 x: gr_srcptr,
1448 ctx: *mut gr_ctx_struct,
1449 ) -> libc::c_int;
1450 pub fn _gr_poly_evaluate_horner(
1451 res: gr_ptr,
1452 poly: gr_srcptr,
1453 len: slong,
1454 x: gr_srcptr,
1455 ctx: *mut gr_ctx_struct,
1456 ) -> libc::c_int;
1457 pub fn gr_poly_evaluate_horner(
1458 res: gr_ptr,
1459 poly: *const gr_poly_struct,
1460 x: gr_srcptr,
1461 ctx: *mut gr_ctx_struct,
1462 ) -> libc::c_int;
1463 pub fn _gr_poly_evaluate(
1464 res: gr_ptr,
1465 poly: gr_srcptr,
1466 len: slong,
1467 x: gr_srcptr,
1468 ctx: *mut gr_ctx_struct,
1469 ) -> libc::c_int;
1470 pub fn gr_poly_evaluate(
1471 res: gr_ptr,
1472 poly: *const gr_poly_struct,
1473 x: gr_srcptr,
1474 ctx: *mut gr_ctx_struct,
1475 ) -> libc::c_int;
1476 pub fn _gr_poly_evaluate_other_horner(
1477 res: gr_ptr,
1478 f: gr_srcptr,
1479 len: slong,
1480 x: gr_srcptr,
1481 x_ctx: *mut gr_ctx_struct,
1482 ctx: *mut gr_ctx_struct,
1483 ) -> libc::c_int;
1484 pub fn gr_poly_evaluate_other_horner(
1485 res: gr_ptr,
1486 f: *const gr_poly_struct,
1487 a: gr_srcptr,
1488 a_ctx: *mut gr_ctx_struct,
1489 ctx: *mut gr_ctx_struct,
1490 ) -> libc::c_int;
1491 pub fn _gr_poly_evaluate_other_rectangular(
1492 res: gr_ptr,
1493 f: gr_srcptr,
1494 len: slong,
1495 x: gr_srcptr,
1496 x_ctx: *mut gr_ctx_struct,
1497 ctx: *mut gr_ctx_struct,
1498 ) -> libc::c_int;
1499 pub fn gr_poly_evaluate_other_rectangular(
1500 res: gr_ptr,
1501 f: *const gr_poly_struct,
1502 a: gr_srcptr,
1503 a_ctx: *mut gr_ctx_struct,
1504 ctx: *mut gr_ctx_struct,
1505 ) -> libc::c_int;
1506 pub fn _gr_poly_evaluate_other(
1507 res: gr_ptr,
1508 f: gr_srcptr,
1509 len: slong,
1510 x: gr_srcptr,
1511 x_ctx: *mut gr_ctx_struct,
1512 ctx: *mut gr_ctx_struct,
1513 ) -> libc::c_int;
1514 pub fn gr_poly_evaluate_other(
1515 res: gr_ptr,
1516 f: *const gr_poly_struct,
1517 a: gr_srcptr,
1518 a_ctx: *mut gr_ctx_struct,
1519 ctx: *mut gr_ctx_struct,
1520 ) -> libc::c_int;
1521 pub fn _gr_poly_taylor_shift_horner(
1522 res: gr_ptr,
1523 poly: gr_srcptr,
1524 len: slong,
1525 c: gr_srcptr,
1526 ctx: *mut gr_ctx_struct,
1527 ) -> libc::c_int;
1528 pub fn gr_poly_taylor_shift_horner(
1529 res: *mut gr_poly_struct,
1530 f: *const gr_poly_struct,
1531 c: gr_srcptr,
1532 ctx: *mut gr_ctx_struct,
1533 ) -> libc::c_int;
1534 pub fn _gr_poly_taylor_shift_divconquer(
1535 res: gr_ptr,
1536 poly: gr_srcptr,
1537 len: slong,
1538 c: gr_srcptr,
1539 ctx: *mut gr_ctx_struct,
1540 ) -> libc::c_int;
1541 pub fn gr_poly_taylor_shift_divconquer(
1542 res: *mut gr_poly_struct,
1543 f: *const gr_poly_struct,
1544 c: gr_srcptr,
1545 ctx: *mut gr_ctx_struct,
1546 ) -> libc::c_int;
1547 pub fn _gr_poly_taylor_shift_convolution(
1548 res: gr_ptr,
1549 poly: gr_srcptr,
1550 len: slong,
1551 c: gr_srcptr,
1552 ctx: *mut gr_ctx_struct,
1553 ) -> libc::c_int;
1554 pub fn gr_poly_taylor_shift_convolution(
1555 res: *mut gr_poly_struct,
1556 f: *const gr_poly_struct,
1557 c: gr_srcptr,
1558 ctx: *mut gr_ctx_struct,
1559 ) -> libc::c_int;
1560 pub fn _gr_poly_taylor_shift_generic(
1561 res: gr_ptr,
1562 poly: gr_srcptr,
1563 len: slong,
1564 c: gr_srcptr,
1565 ctx: *mut gr_ctx_struct,
1566 ) -> libc::c_int;
1567 #[link_name = "_gr_poly_taylor_shift__extern"]
1568 pub fn _gr_poly_taylor_shift(
1569 res: gr_ptr,
1570 f: gr_srcptr,
1571 len: slong,
1572 c: gr_srcptr,
1573 ctx: *mut gr_ctx_struct,
1574 ) -> libc::c_int;
1575 pub fn gr_poly_taylor_shift(
1576 res: *mut gr_poly_struct,
1577 f: *const gr_poly_struct,
1578 c: gr_srcptr,
1579 ctx: *mut gr_ctx_struct,
1580 ) -> libc::c_int;
1581 pub fn _gr_poly_compose_horner(
1582 res: gr_ptr,
1583 poly1: gr_srcptr,
1584 len1: slong,
1585 poly2: gr_srcptr,
1586 len2: slong,
1587 ctx: *mut gr_ctx_struct,
1588 ) -> libc::c_int;
1589 pub fn gr_poly_compose_horner(
1590 res: *mut gr_poly_struct,
1591 poly1: *const gr_poly_struct,
1592 poly2: *const gr_poly_struct,
1593 ctx: *mut gr_ctx_struct,
1594 ) -> libc::c_int;
1595 pub fn _gr_poly_compose_divconquer(
1596 res: gr_ptr,
1597 poly1: gr_srcptr,
1598 len1: slong,
1599 poly2: gr_srcptr,
1600 len2: slong,
1601 ctx: *mut gr_ctx_struct,
1602 ) -> libc::c_int;
1603 pub fn gr_poly_compose_divconquer(
1604 res: *mut gr_poly_struct,
1605 poly1: *const gr_poly_struct,
1606 poly2: *const gr_poly_struct,
1607 ctx: *mut gr_ctx_struct,
1608 ) -> libc::c_int;
1609 pub fn _gr_poly_compose(
1610 res: gr_ptr,
1611 poly1: gr_srcptr,
1612 len1: slong,
1613 poly2: gr_srcptr,
1614 len2: slong,
1615 ctx: *mut gr_ctx_struct,
1616 ) -> libc::c_int;
1617 pub fn gr_poly_compose(
1618 res: *mut gr_poly_struct,
1619 poly1: *const gr_poly_struct,
1620 poly2: *const gr_poly_struct,
1621 ctx: *mut gr_ctx_struct,
1622 ) -> libc::c_int;
1623 pub fn _gr_poly_compose_series_horner(
1624 res: gr_ptr,
1625 poly1: gr_srcptr,
1626 len1: slong,
1627 poly2: gr_srcptr,
1628 len2: slong,
1629 n: slong,
1630 ctx: *mut gr_ctx_struct,
1631 ) -> libc::c_int;
1632 pub fn gr_poly_compose_series_horner(
1633 res: *mut gr_poly_struct,
1634 poly1: *const gr_poly_struct,
1635 poly2: *const gr_poly_struct,
1636 n: slong,
1637 ctx: *mut gr_ctx_struct,
1638 ) -> libc::c_int;
1639 pub fn _gr_poly_compose_series_brent_kung(
1640 res: gr_ptr,
1641 poly1: gr_srcptr,
1642 len1: slong,
1643 poly2: gr_srcptr,
1644 len2: slong,
1645 n: slong,
1646 ctx: *mut gr_ctx_struct,
1647 ) -> libc::c_int;
1648 pub fn gr_poly_compose_series_brent_kung(
1649 res: *mut gr_poly_struct,
1650 poly1: *const gr_poly_struct,
1651 poly2: *const gr_poly_struct,
1652 n: slong,
1653 ctx: *mut gr_ctx_struct,
1654 ) -> libc::c_int;
1655 pub fn _gr_poly_compose_series_divconquer(
1656 res: gr_ptr,
1657 poly1: gr_srcptr,
1658 len1: slong,
1659 poly2: gr_srcptr,
1660 len2: slong,
1661 n: slong,
1662 ctx: *mut gr_ctx_struct,
1663 ) -> libc::c_int;
1664 pub fn gr_poly_compose_series_divconquer(
1665 res: *mut gr_poly_struct,
1666 poly1: *const gr_poly_struct,
1667 poly2: *const gr_poly_struct,
1668 n: slong,
1669 ctx: *mut gr_ctx_struct,
1670 ) -> libc::c_int;
1671 pub fn _gr_poly_compose_series(
1672 res: gr_ptr,
1673 poly1: gr_srcptr,
1674 len1: slong,
1675 poly2: gr_srcptr,
1676 len2: slong,
1677 n: slong,
1678 ctx: *mut gr_ctx_struct,
1679 ) -> libc::c_int;
1680 pub fn gr_poly_compose_series(
1681 res: *mut gr_poly_struct,
1682 poly1: *const gr_poly_struct,
1683 poly2: *const gr_poly_struct,
1684 n: slong,
1685 ctx: *mut gr_ctx_struct,
1686 ) -> libc::c_int;
1687 pub fn _gr_poly_revert_series_lagrange(
1688 res: gr_ptr,
1689 f: gr_srcptr,
1690 flen: slong,
1691 n: slong,
1692 ctx: *mut gr_ctx_struct,
1693 ) -> libc::c_int;
1694 pub fn gr_poly_revert_series_lagrange(
1695 res: *mut gr_poly_struct,
1696 f: *const gr_poly_struct,
1697 n: slong,
1698 ctx: *mut gr_ctx_struct,
1699 ) -> libc::c_int;
1700 pub fn _gr_poly_revert_series_lagrange_fast(
1701 res: gr_ptr,
1702 f: gr_srcptr,
1703 flen: slong,
1704 n: slong,
1705 ctx: *mut gr_ctx_struct,
1706 ) -> libc::c_int;
1707 pub fn gr_poly_revert_series_lagrange_fast(
1708 res: *mut gr_poly_struct,
1709 f: *const gr_poly_struct,
1710 n: slong,
1711 ctx: *mut gr_ctx_struct,
1712 ) -> libc::c_int;
1713 pub fn _gr_poly_revert_series_newton(
1714 res: gr_ptr,
1715 f: gr_srcptr,
1716 flen: slong,
1717 n: slong,
1718 ctx: *mut gr_ctx_struct,
1719 ) -> libc::c_int;
1720 pub fn gr_poly_revert_series_newton(
1721 res: *mut gr_poly_struct,
1722 f: *const gr_poly_struct,
1723 n: slong,
1724 ctx: *mut gr_ctx_struct,
1725 ) -> libc::c_int;
1726 pub fn _gr_poly_revert_series(
1727 res: gr_ptr,
1728 f: gr_srcptr,
1729 flen: slong,
1730 n: slong,
1731 ctx: *mut gr_ctx_struct,
1732 ) -> libc::c_int;
1733 pub fn gr_poly_revert_series(
1734 res: *mut gr_poly_struct,
1735 f: *const gr_poly_struct,
1736 n: slong,
1737 ctx: *mut gr_ctx_struct,
1738 ) -> libc::c_int;
1739 pub fn _gr_poly_derivative(
1740 res: gr_ptr,
1741 poly: gr_srcptr,
1742 len: slong,
1743 ctx: *mut gr_ctx_struct,
1744 ) -> libc::c_int;
1745 pub fn gr_poly_derivative(
1746 res: *mut gr_poly_struct,
1747 poly: *const gr_poly_struct,
1748 ctx: *mut gr_ctx_struct,
1749 ) -> libc::c_int;
1750 pub fn _gr_poly_nth_derivative(
1751 res: gr_ptr,
1752 poly: gr_srcptr,
1753 n: ulong,
1754 len: slong,
1755 ctx: *mut gr_ctx_struct,
1756 ) -> libc::c_int;
1757 pub fn gr_poly_nth_derivative(
1758 res: *mut gr_poly_struct,
1759 poly: *const gr_poly_struct,
1760 n: ulong,
1761 ctx: *mut gr_ctx_struct,
1762 ) -> libc::c_int;
1763 pub fn _gr_poly_integral(
1764 res: gr_ptr,
1765 poly: gr_srcptr,
1766 len: slong,
1767 ctx: *mut gr_ctx_struct,
1768 ) -> libc::c_int;
1769 pub fn gr_poly_integral(
1770 res: *mut gr_poly_struct,
1771 poly: *const gr_poly_struct,
1772 ctx: *mut gr_ctx_struct,
1773 ) -> libc::c_int;
1774 pub fn _gr_poly_make_monic(
1775 res: gr_ptr,
1776 poly: gr_srcptr,
1777 len: slong,
1778 ctx: *mut gr_ctx_struct,
1779 ) -> libc::c_int;
1780 pub fn gr_poly_make_monic(
1781 res: *mut gr_poly_struct,
1782 src: *const gr_poly_struct,
1783 ctx: *mut gr_ctx_struct,
1784 ) -> libc::c_int;
1785 pub fn _gr_poly_is_monic(poly: gr_srcptr, len: slong, ctx: *mut gr_ctx_struct) -> truth_t;
1786 pub fn gr_poly_is_monic(res: *const gr_poly_struct, ctx: *mut gr_ctx_struct) -> truth_t;
1787 pub fn _gr_poly_canonical_associate(
1788 res: gr_ptr,
1789 u: gr_ptr,
1790 poly: gr_srcptr,
1791 len: slong,
1792 ctx: *mut gr_ctx_struct,
1793 ) -> libc::c_int;
1794 pub fn gr_poly_canonical_associate(
1795 res: *mut gr_poly_struct,
1796 u: *mut gr_poly_struct,
1797 poly: *const gr_poly_struct,
1798 ctx: *mut gr_ctx_struct,
1799 ) -> libc::c_int;
1800 pub fn _gr_poly_hgcd(
1801 r: gr_ptr,
1802 sgn: *mut slong,
1803 M: *mut gr_ptr,
1804 lenM: *mut slong,
1805 A: gr_ptr,
1806 lenA: *mut slong,
1807 B: gr_ptr,
1808 lenB: *mut slong,
1809 a: gr_srcptr,
1810 lena: slong,
1811 b: gr_srcptr,
1812 lenb: slong,
1813 cutoff: slong,
1814 ctx: *mut gr_ctx_struct,
1815 ) -> libc::c_int;
1816 pub fn _gr_poly_gcd_hgcd(
1817 G: gr_ptr,
1818 _lenG: *mut slong,
1819 A: gr_srcptr,
1820 lenA: slong,
1821 B: gr_srcptr,
1822 lenB: slong,
1823 inner_cutoff: slong,
1824 cutoff: slong,
1825 ctx: *mut gr_ctx_struct,
1826 ) -> libc::c_int;
1827 pub fn gr_poly_gcd_hgcd(
1828 G: *mut gr_poly_struct,
1829 A: *const gr_poly_struct,
1830 B: *const gr_poly_struct,
1831 inner_cutoff: slong,
1832 cutoff: slong,
1833 ctx: *mut gr_ctx_struct,
1834 ) -> libc::c_int;
1835 pub fn _gr_poly_gcd_euclidean(
1836 G: gr_ptr,
1837 lenG: *mut slong,
1838 A: gr_srcptr,
1839 lenA: slong,
1840 B: gr_srcptr,
1841 lenB: slong,
1842 ctx: *mut gr_ctx_struct,
1843 ) -> libc::c_int;
1844 pub fn gr_poly_gcd_euclidean(
1845 G: *mut gr_poly_struct,
1846 A: *const gr_poly_struct,
1847 B: *const gr_poly_struct,
1848 ctx: *mut gr_ctx_struct,
1849 ) -> libc::c_int;
1850 pub fn _gr_poly_gcd_subresultant(
1851 G: gr_ptr,
1852 lenG: *mut slong,
1853 poly1: gr_srcptr,
1854 len1: slong,
1855 poly2: gr_srcptr,
1856 len2: slong,
1857 ctx: *mut gr_ctx_struct,
1858 ) -> libc::c_int;
1859 pub fn gr_poly_gcd_subresultant(
1860 G: *mut gr_poly_struct,
1861 poly1: *const gr_poly_struct,
1862 poly2: *const gr_poly_struct,
1863 ctx: *mut gr_ctx_struct,
1864 ) -> libc::c_int;
1865 pub fn _gr_poly_gcd_generic(
1866 G: gr_ptr,
1867 lenG: *mut slong,
1868 A: gr_srcptr,
1869 lenA: slong,
1870 B: gr_srcptr,
1871 lenB: slong,
1872 ctx: *mut gr_ctx_struct,
1873 ) -> libc::c_int;
1874 #[link_name = "_gr_poly_gcd__extern"]
1875 pub fn _gr_poly_gcd(
1876 G: gr_ptr,
1877 lenG: *mut slong,
1878 A: gr_srcptr,
1879 lenA: slong,
1880 B: gr_srcptr,
1881 lenB: slong,
1882 ctx: *mut gr_ctx_struct,
1883 ) -> libc::c_int;
1884 pub fn gr_poly_gcd(
1885 G: *mut gr_poly_struct,
1886 A: *const gr_poly_struct,
1887 B: *const gr_poly_struct,
1888 ctx: *mut gr_ctx_struct,
1889 ) -> libc::c_int;
1890 pub fn gr_poly_gcd_wrapper(
1891 gcd_impl: gr_method_poly_gcd_op,
1892 canonicalise_unit: libc::c_int,
1893 G: *mut gr_poly_struct,
1894 A: *const gr_poly_struct,
1895 B: *const gr_poly_struct,
1896 ctx: *mut gr_ctx_struct,
1897 ) -> libc::c_int;
1898 pub fn _gr_poly_xgcd_euclidean(
1899 lenG: *mut slong,
1900 G: gr_ptr,
1901 S: gr_ptr,
1902 T: gr_ptr,
1903 A: gr_srcptr,
1904 lenA: slong,
1905 B: gr_srcptr,
1906 lenB: slong,
1907 ctx: *mut gr_ctx_struct,
1908 ) -> libc::c_int;
1909 pub fn gr_poly_xgcd_euclidean(
1910 G: *mut gr_poly_struct,
1911 S: *mut gr_poly_struct,
1912 T: *mut gr_poly_struct,
1913 A: *const gr_poly_struct,
1914 B: *const gr_poly_struct,
1915 ctx: *mut gr_ctx_struct,
1916 ) -> libc::c_int;
1917 pub fn _gr_poly_xgcd_hgcd(
1918 Glen: *mut slong,
1919 G: gr_ptr,
1920 S: gr_ptr,
1921 T: gr_ptr,
1922 A: gr_srcptr,
1923 lenA: slong,
1924 B: gr_srcptr,
1925 lenB: slong,
1926 hgcd_cutoff: slong,
1927 cutoff: slong,
1928 ctx: *mut gr_ctx_struct,
1929 ) -> libc::c_int;
1930 pub fn gr_poly_xgcd_hgcd(
1931 G: *mut gr_poly_struct,
1932 S: *mut gr_poly_struct,
1933 T: *mut gr_poly_struct,
1934 A: *const gr_poly_struct,
1935 B: *const gr_poly_struct,
1936 hgcd_cutoff: slong,
1937 cutoff: slong,
1938 ctx: *mut gr_ctx_struct,
1939 ) -> libc::c_int;
1940 #[link_name = "_gr_poly_xgcd__extern"]
1941 pub fn _gr_poly_xgcd(
1942 Glen: *mut slong,
1943 G: gr_ptr,
1944 S: gr_ptr,
1945 T: gr_ptr,
1946 A: gr_srcptr,
1947 lenA: slong,
1948 B: gr_srcptr,
1949 lenB: slong,
1950 ctx: *mut gr_ctx_struct,
1951 ) -> libc::c_int;
1952 pub fn _gr_poly_xgcd_generic(
1953 Glen: *mut slong,
1954 G: gr_ptr,
1955 S: gr_ptr,
1956 T: gr_ptr,
1957 A: gr_srcptr,
1958 lenA: slong,
1959 B: gr_srcptr,
1960 lenB: slong,
1961 ctx: *mut gr_ctx_struct,
1962 ) -> libc::c_int;
1963 pub fn gr_poly_xgcd_wrapper(
1964 _xgcd_op: gr_method_poly_xgcd_op,
1965 G: *mut gr_poly_struct,
1966 S: *mut gr_poly_struct,
1967 T: *mut gr_poly_struct,
1968 A: *const gr_poly_struct,
1969 B: *const gr_poly_struct,
1970 ctx: *mut gr_ctx_struct,
1971 ) -> libc::c_int;
1972 pub fn gr_poly_xgcd(
1973 G: *mut gr_poly_struct,
1974 S: *mut gr_poly_struct,
1975 T: *mut gr_poly_struct,
1976 A: *const gr_poly_struct,
1977 B: *const gr_poly_struct,
1978 ctx: *mut gr_ctx_struct,
1979 ) -> libc::c_int;
1980 pub fn _gr_poly_resultant_euclidean(
1981 res: gr_ptr,
1982 poly1: gr_srcptr,
1983 len1: slong,
1984 poly2: gr_srcptr,
1985 len2: slong,
1986 ctx: *mut gr_ctx_struct,
1987 ) -> libc::c_int;
1988 pub fn gr_poly_resultant_euclidean(
1989 r: gr_ptr,
1990 f: *const gr_poly_struct,
1991 g: *const gr_poly_struct,
1992 ctx: *mut gr_ctx_struct,
1993 ) -> libc::c_int;
1994 pub fn _gr_poly_resultant_hgcd(
1995 res: gr_ptr,
1996 A: gr_srcptr,
1997 lenA: slong,
1998 B: gr_srcptr,
1999 lenB: slong,
2000 inner_cutoff: slong,
2001 cutoff: slong,
2002 ctx: *mut gr_ctx_struct,
2003 ) -> libc::c_int;
2004 pub fn gr_poly_resultant_hgcd(
2005 r: gr_ptr,
2006 f: *const gr_poly_struct,
2007 g: *const gr_poly_struct,
2008 inner_cutoff: slong,
2009 cutoff: slong,
2010 ctx: *mut gr_ctx_struct,
2011 ) -> libc::c_int;
2012 pub fn _gr_poly_resultant_sylvester(
2013 res: gr_ptr,
2014 poly1: gr_srcptr,
2015 len1: slong,
2016 poly2: gr_srcptr,
2017 len2: slong,
2018 ctx: *mut gr_ctx_struct,
2019 ) -> libc::c_int;
2020 pub fn gr_poly_resultant_sylvester(
2021 r: gr_ptr,
2022 f: *const gr_poly_struct,
2023 g: *const gr_poly_struct,
2024 ctx: *mut gr_ctx_struct,
2025 ) -> libc::c_int;
2026 pub fn _gr_poly_resultant_small(
2027 res: gr_ptr,
2028 poly1: gr_srcptr,
2029 len1: slong,
2030 poly2: gr_srcptr,
2031 len2: slong,
2032 ctx: *mut gr_ctx_struct,
2033 ) -> libc::c_int;
2034 pub fn gr_poly_resultant_small(
2035 r: gr_ptr,
2036 f: *const gr_poly_struct,
2037 g: *const gr_poly_struct,
2038 ctx: *mut gr_ctx_struct,
2039 ) -> libc::c_int;
2040 pub fn _gr_poly_resultant(
2041 res: gr_ptr,
2042 poly1: gr_srcptr,
2043 len1: slong,
2044 poly2: gr_srcptr,
2045 len2: slong,
2046 ctx: *mut gr_ctx_struct,
2047 ) -> libc::c_int;
2048 pub fn gr_poly_resultant(
2049 r: gr_ptr,
2050 f: *const gr_poly_struct,
2051 g: *const gr_poly_struct,
2052 ctx: *mut gr_ctx_struct,
2053 ) -> libc::c_int;
2054 pub fn _gr_poly_newton_basis_evaluate(
2055 res: gr_ptr,
2056 basis: gr_srcptr,
2057 poly: gr_srcptr,
2058 len: slong,
2059 x: gr_srcptr,
2060 ctx: *mut gr_ctx_struct,
2061 ) -> libc::c_int;
2062 pub fn gr_poly_newton_basis_evaluate(
2063 res: gr_ptr,
2064 basis: *const gr_vec_struct,
2065 poly: *const gr_poly_struct,
2066 x: gr_srcptr,
2067 ctx: *mut gr_ctx_struct,
2068 ) -> libc::c_int;
2069 pub fn _gr_poly_newton_basis_interpolate_exact(
2070 res: gr_ptr,
2071 basis: gr_srcptr,
2072 ys: gr_srcptr,
2073 len: slong,
2074 ctx: *mut gr_ctx_struct,
2075 ) -> libc::c_int;
2076 pub fn gr_poly_newton_basis_interpolate_exact(
2077 res: *mut gr_poly_struct,
2078 basis: *const gr_vec_struct,
2079 ys: *const gr_vec_struct,
2080 ctx: *mut gr_ctx_struct,
2081 ) -> libc::c_int;
2082 pub fn _gr_poly_newton_basis_interpolate(
2083 res: gr_ptr,
2084 basis: gr_srcptr,
2085 ys: gr_srcptr,
2086 len: slong,
2087 ctx: *mut gr_ctx_struct,
2088 ) -> libc::c_int;
2089 pub fn gr_poly_newton_basis_interpolate(
2090 res: *mut gr_poly_struct,
2091 basis: *const gr_vec_struct,
2092 ys: *const gr_vec_struct,
2093 ctx: *mut gr_ctx_struct,
2094 ) -> libc::c_int;
2095 pub fn _gr_poly_newton_basis_to_monomial(
2096 res: gr_ptr,
2097 basis: gr_srcptr,
2098 poly: gr_srcptr,
2099 len: slong,
2100 ctx: *mut gr_ctx_struct,
2101 ) -> libc::c_int;
2102 pub fn gr_poly_newton_basis_to_monomial(
2103 res: *mut gr_poly_struct,
2104 basis: *const gr_vec_struct,
2105 poly: *const gr_poly_struct,
2106 ctx: *mut gr_ctx_struct,
2107 ) -> libc::c_int;
2108 pub fn _gr_poly_newton_basis_from_monomial(
2109 res: gr_ptr,
2110 basis: gr_srcptr,
2111 poly: gr_srcptr,
2112 len: slong,
2113 ctx: *mut gr_ctx_struct,
2114 ) -> libc::c_int;
2115 pub fn gr_poly_newton_basis_from_monomial(
2116 res: *mut gr_poly_struct,
2117 basis: *const gr_vec_struct,
2118 poly: *const gr_poly_struct,
2119 ctx: *mut gr_ctx_struct,
2120 ) -> libc::c_int;
2121 pub fn _gr_poly_tree_alloc(len: slong, ctx: *mut gr_ctx_struct) -> *mut gr_ptr;
2122 pub fn _gr_poly_tree_free(tree: *mut gr_ptr, len: slong, ctx: *mut gr_ctx_struct);
2123 pub fn _gr_poly_tree_build(
2124 tree: *mut gr_ptr,
2125 roots: gr_srcptr,
2126 len: slong,
2127 ctx: *mut gr_ctx_struct,
2128 ) -> libc::c_int;
2129 pub fn _gr_poly_product_roots(
2130 poly: gr_ptr,
2131 xs: gr_srcptr,
2132 n: slong,
2133 ctx: *mut gr_ctx_struct,
2134 ) -> libc::c_int;
2135 pub fn gr_poly_product_roots(
2136 poly: *mut gr_poly_struct,
2137 xs: *const gr_vec_struct,
2138 ctx: *mut gr_ctx_struct,
2139 ) -> libc::c_int;
2140 pub fn _gr_poly_evaluate_vec_fast_precomp(
2141 vs: gr_ptr,
2142 poly: gr_srcptr,
2143 plen: slong,
2144 tree: *const gr_ptr,
2145 len: slong,
2146 ctx: *mut gr_ctx_struct,
2147 ) -> libc::c_int;
2148 pub fn _gr_poly_evaluate_vec_fast(
2149 ys: gr_ptr,
2150 poly: gr_srcptr,
2151 plen: slong,
2152 xs: gr_srcptr,
2153 n: slong,
2154 ctx: *mut gr_ctx_struct,
2155 ) -> libc::c_int;
2156 pub fn gr_poly_evaluate_vec_fast(
2157 ys: *mut gr_vec_struct,
2158 poly: *const gr_poly_struct,
2159 xs: *const gr_vec_struct,
2160 ctx: *mut gr_ctx_struct,
2161 ) -> libc::c_int;
2162 pub fn _gr_poly_evaluate_vec_iter(
2163 ys: gr_ptr,
2164 poly: gr_srcptr,
2165 plen: slong,
2166 xs: gr_srcptr,
2167 n: slong,
2168 ctx: *mut gr_ctx_struct,
2169 ) -> libc::c_int;
2170 pub fn gr_poly_evaluate_vec_iter(
2171 ys: *mut gr_vec_struct,
2172 poly: *const gr_poly_struct,
2173 xs: *const gr_vec_struct,
2174 ctx: *mut gr_ctx_struct,
2175 ) -> libc::c_int;
2176 pub fn _gr_poly_interpolate_exact_newton(
2177 res: gr_ptr,
2178 xs: gr_srcptr,
2179 ys: gr_srcptr,
2180 len: slong,
2181 ctx: *mut gr_ctx_struct,
2182 ) -> libc::c_int;
2183 pub fn gr_poly_interpolate_exact_newton(
2184 poly: *mut gr_poly_struct,
2185 xs: *const gr_vec_struct,
2186 ys: *const gr_vec_struct,
2187 ctx: *mut gr_ctx_struct,
2188 ) -> libc::c_int;
2189 pub fn _gr_poly_interpolate_newton(
2190 res: gr_ptr,
2191 xs: gr_srcptr,
2192 ys: gr_srcptr,
2193 len: slong,
2194 ctx: *mut gr_ctx_struct,
2195 ) -> libc::c_int;
2196 pub fn gr_poly_interpolate_newton(
2197 poly: *mut gr_poly_struct,
2198 xs: *const gr_vec_struct,
2199 ys: *const gr_vec_struct,
2200 ctx: *mut gr_ctx_struct,
2201 ) -> libc::c_int;
2202 pub fn _gr_poly_interpolation_weights(
2203 w: gr_ptr,
2204 tree: *const gr_ptr,
2205 len: slong,
2206 ctx: *mut gr_ctx_struct,
2207 ) -> libc::c_int;
2208 pub fn _gr_poly_interpolate_fast_precomp(
2209 poly: gr_ptr,
2210 ys: gr_srcptr,
2211 tree: *const gr_ptr,
2212 weights: gr_srcptr,
2213 len: slong,
2214 ctx: *mut gr_ctx_struct,
2215 ) -> libc::c_int;
2216 pub fn _gr_poly_interpolate_fast(
2217 res: gr_ptr,
2218 xs: gr_srcptr,
2219 ys: gr_srcptr,
2220 len: slong,
2221 ctx: *mut gr_ctx_struct,
2222 ) -> libc::c_int;
2223 pub fn gr_poly_interpolate_fast(
2224 poly: *mut gr_poly_struct,
2225 xs: *const gr_vec_struct,
2226 ys: *const gr_vec_struct,
2227 ctx: *mut gr_ctx_struct,
2228 ) -> libc::c_int;
2229 pub fn _gr_poly_interpolate_exact(
2230 res: gr_ptr,
2231 xs: gr_srcptr,
2232 ys: gr_srcptr,
2233 len: slong,
2234 ctx: *mut gr_ctx_struct,
2235 ) -> libc::c_int;
2236 pub fn gr_poly_interpolate_exact(
2237 poly: *mut gr_poly_struct,
2238 xs: *const gr_vec_struct,
2239 ys: *const gr_vec_struct,
2240 ctx: *mut gr_ctx_struct,
2241 ) -> libc::c_int;
2242 pub fn _gr_poly_interpolate(
2243 res: gr_ptr,
2244 xs: gr_srcptr,
2245 ys: gr_srcptr,
2246 len: slong,
2247 ctx: *mut gr_ctx_struct,
2248 ) -> libc::c_int;
2249 pub fn gr_poly_interpolate(
2250 poly: *mut gr_poly_struct,
2251 xs: *const gr_vec_struct,
2252 ys: *const gr_vec_struct,
2253 ctx: *mut gr_ctx_struct,
2254 ) -> libc::c_int;
2255 pub fn gr_poly_factor_squarefree(
2256 c: gr_ptr,
2257 fac: *mut gr_vec_struct,
2258 exp: *mut gr_vec_struct,
2259 F: *const gr_poly_struct,
2260 ctx: *mut gr_ctx_struct,
2261 ) -> libc::c_int;
2262 pub fn gr_poly_squarefree_part(
2263 res: *mut gr_poly_struct,
2264 poly: *const gr_poly_struct,
2265 ctx: *mut gr_ctx_struct,
2266 ) -> libc::c_int;
2267 pub fn gr_poly_leading_taylor_shift(
2268 shift: gr_ptr,
2269 p: *const gr_poly_struct,
2270 q: *const gr_poly_struct,
2271 ctx: *mut gr_ctx_struct,
2272 ) -> libc::c_int;
2273 pub fn gr_poly_shift_equivalent(
2274 shift: *mut fmpz,
2275 p: *const gr_poly_struct,
2276 q: *const gr_poly_struct,
2277 ctx: *mut gr_ctx_struct,
2278 ) -> truth_t;
2279 pub fn gr_poly_dispersion_resultant(
2280 disp: *mut fmpz,
2281 disp_set: *mut gr_vec_struct,
2282 f: *const gr_poly_struct,
2283 g: *const gr_poly_struct,
2284 ctx: *mut gr_ctx_struct,
2285 ) -> libc::c_int;
2286 pub fn gr_poly_dispersion_from_factors(
2287 disp: *mut fmpz,
2288 disp_set: *mut gr_vec_struct,
2289 ffac: *const gr_vec_struct,
2290 gfac: *const gr_vec_struct,
2291 ctx: *mut gr_ctx_struct,
2292 ) -> libc::c_int;
2293 pub fn gr_poly_dispersion_factor(
2294 disp: *mut fmpz,
2295 disp_set: *mut gr_vec_struct,
2296 f: *const gr_poly_struct,
2297 g: *const gr_poly_struct,
2298 ctx: *mut gr_ctx_struct,
2299 ) -> libc::c_int;
2300 pub fn gr_poly_dispersion(
2301 disp: *mut fmpz,
2302 disp_set: *mut gr_vec_struct,
2303 f: *const gr_poly_struct,
2304 g: *const gr_poly_struct,
2305 ctx: *mut gr_ctx_struct,
2306 ) -> libc::c_int;
2307 pub fn _gr_poly_shiftless_decomposition_from_factors(
2308 slfac: *mut gr_vec_struct,
2309 slshifts: *mut gr_vec_struct,
2310 slmult: *mut gr_vec_struct,
2311 fac: *const gr_vec_struct,
2312 mult: *const gr_vec_struct,
2313 ctx: *mut gr_ctx_struct,
2314 ) -> libc::c_int;
2315 pub fn gr_poly_shiftless_decomposition_from_factors(
2316 slfac: *mut gr_vec_struct,
2317 slshifts: *mut gr_vec_struct,
2318 slmult: *mut gr_vec_struct,
2319 fac: *const gr_vec_struct,
2320 mult: *const gr_vec_struct,
2321 ctx: *mut gr_ctx_struct,
2322 ) -> libc::c_int;
2323 pub fn gr_poly_shiftless_decomposition_factor(
2324 c: gr_ptr,
2325 slfac: *mut gr_vec_struct,
2326 slshifts: *mut gr_vec_struct,
2327 slmult: *mut gr_vec_struct,
2328 pol: *const gr_poly_struct,
2329 ctx: *mut gr_ctx_struct,
2330 ) -> libc::c_int;
2331 pub fn gr_poly_shiftless_decomposition(
2332 c: gr_ptr,
2333 slfac: *mut gr_vec_struct,
2334 slshifts: *mut gr_vec_struct,
2335 slmult: *mut gr_vec_struct,
2336 pol: *const gr_poly_struct,
2337 ctx: *mut gr_ctx_struct,
2338 ) -> libc::c_int;
2339 pub fn _gr_poly_refine_roots_aberth(
2340 w: gr_ptr,
2341 f: gr_srcptr,
2342 f_prime: gr_srcptr,
2343 deg: slong,
2344 z: gr_srcptr,
2345 progressive: libc::c_int,
2346 ctx: *mut gr_ctx_struct,
2347 ) -> libc::c_int;
2348 pub fn _gr_poly_refine_roots_wdk(
2349 w: gr_ptr,
2350 f: gr_srcptr,
2351 deg: slong,
2352 z: gr_srcptr,
2353 progressive: libc::c_int,
2354 ctx: *mut gr_ctx_struct,
2355 ) -> libc::c_int;
2356 #[link_name = "gr_poly_roots__extern"]
2357 pub fn gr_poly_roots(
2358 roots: *mut gr_vec_struct,
2359 mult: *mut gr_vec_struct,
2360 poly: *const gr_poly_struct,
2361 flags: libc::c_int,
2362 ctx: *mut gr_ctx_struct,
2363 ) -> libc::c_int;
2364 #[link_name = "gr_poly_roots_other__extern"]
2365 pub fn gr_poly_roots_other(
2366 roots: *mut gr_vec_struct,
2367 mult: *mut gr_vec_struct,
2368 poly: *const gr_poly_struct,
2369 poly_ctx: *mut gr_ctx_struct,
2370 flags: libc::c_int,
2371 ctx: *mut gr_ctx_struct,
2372 ) -> libc::c_int;
2373 pub fn _gr_poly_asin_series(
2374 res: gr_ptr,
2375 f: gr_srcptr,
2376 flen: slong,
2377 len: slong,
2378 ctx: *mut gr_ctx_struct,
2379 ) -> libc::c_int;
2380 pub fn gr_poly_asin_series(
2381 res: *mut gr_poly_struct,
2382 f: *const gr_poly_struct,
2383 len: slong,
2384 ctx: *mut gr_ctx_struct,
2385 ) -> libc::c_int;
2386 pub fn _gr_poly_asinh_series(
2387 res: gr_ptr,
2388 f: gr_srcptr,
2389 flen: slong,
2390 len: slong,
2391 ctx: *mut gr_ctx_struct,
2392 ) -> libc::c_int;
2393 pub fn gr_poly_asinh_series(
2394 res: *mut gr_poly_struct,
2395 f: *const gr_poly_struct,
2396 len: slong,
2397 ctx: *mut gr_ctx_struct,
2398 ) -> libc::c_int;
2399 pub fn _gr_poly_acos_series(
2400 res: gr_ptr,
2401 f: gr_srcptr,
2402 flen: slong,
2403 len: slong,
2404 ctx: *mut gr_ctx_struct,
2405 ) -> libc::c_int;
2406 pub fn gr_poly_acos_series(
2407 res: *mut gr_poly_struct,
2408 f: *const gr_poly_struct,
2409 len: slong,
2410 ctx: *mut gr_ctx_struct,
2411 ) -> libc::c_int;
2412 pub fn _gr_poly_acosh_series(
2413 res: gr_ptr,
2414 f: gr_srcptr,
2415 flen: slong,
2416 len: slong,
2417 ctx: *mut gr_ctx_struct,
2418 ) -> libc::c_int;
2419 pub fn gr_poly_acosh_series(
2420 res: *mut gr_poly_struct,
2421 f: *const gr_poly_struct,
2422 len: slong,
2423 ctx: *mut gr_ctx_struct,
2424 ) -> libc::c_int;
2425 pub fn _gr_poly_atan_series(
2426 res: gr_ptr,
2427 f: gr_srcptr,
2428 flen: slong,
2429 len: slong,
2430 ctx: *mut gr_ctx_struct,
2431 ) -> libc::c_int;
2432 pub fn gr_poly_atan_series(
2433 res: *mut gr_poly_struct,
2434 f: *const gr_poly_struct,
2435 len: slong,
2436 ctx: *mut gr_ctx_struct,
2437 ) -> libc::c_int;
2438 pub fn _gr_poly_atanh_series(
2439 res: gr_ptr,
2440 f: gr_srcptr,
2441 flen: slong,
2442 len: slong,
2443 ctx: *mut gr_ctx_struct,
2444 ) -> libc::c_int;
2445 pub fn gr_poly_atanh_series(
2446 res: *mut gr_poly_struct,
2447 f: *const gr_poly_struct,
2448 len: slong,
2449 ctx: *mut gr_ctx_struct,
2450 ) -> libc::c_int;
2451 pub fn _gr_poly_log_series(
2452 res: gr_ptr,
2453 f: gr_srcptr,
2454 flen: slong,
2455 len: slong,
2456 ctx: *mut gr_ctx_struct,
2457 ) -> libc::c_int;
2458 pub fn gr_poly_log_series(
2459 res: *mut gr_poly_struct,
2460 f: *const gr_poly_struct,
2461 len: slong,
2462 ctx: *mut gr_ctx_struct,
2463 ) -> libc::c_int;
2464 pub fn _gr_poly_log1p_series(
2465 res: gr_ptr,
2466 f: gr_srcptr,
2467 flen: slong,
2468 len: slong,
2469 ctx: *mut gr_ctx_struct,
2470 ) -> libc::c_int;
2471 pub fn gr_poly_log1p_series(
2472 res: *mut gr_poly_struct,
2473 f: *const gr_poly_struct,
2474 len: slong,
2475 ctx: *mut gr_ctx_struct,
2476 ) -> libc::c_int;
2477 pub fn _gr_poly_exp_series_basecase(
2478 f: gr_ptr,
2479 h: gr_srcptr,
2480 hlen: slong,
2481 n: slong,
2482 ctx: *mut gr_ctx_struct,
2483 ) -> libc::c_int;
2484 pub fn gr_poly_exp_series_basecase(
2485 f: *mut gr_poly_struct,
2486 h: *const gr_poly_struct,
2487 n: slong,
2488 ctx: *mut gr_ctx_struct,
2489 ) -> libc::c_int;
2490 pub fn _gr_poly_exp_series_basecase_mul(
2491 f: gr_ptr,
2492 h: gr_srcptr,
2493 hlen: slong,
2494 n: slong,
2495 ctx: *mut gr_ctx_struct,
2496 ) -> libc::c_int;
2497 pub fn gr_poly_exp_series_basecase_mul(
2498 f: *mut gr_poly_struct,
2499 h: *const gr_poly_struct,
2500 n: slong,
2501 ctx: *mut gr_ctx_struct,
2502 ) -> libc::c_int;
2503 pub fn _gr_poly_exp_series_newton(
2504 f: gr_ptr,
2505 g: gr_ptr,
2506 h: gr_srcptr,
2507 hlen: slong,
2508 n: slong,
2509 cutoff: slong,
2510 ctx: *mut gr_ctx_struct,
2511 ) -> libc::c_int;
2512 pub fn gr_poly_exp_series_newton(
2513 f: *mut gr_poly_struct,
2514 h: *const gr_poly_struct,
2515 n: slong,
2516 cutoff: slong,
2517 ctx: *mut gr_ctx_struct,
2518 ) -> libc::c_int;
2519 #[link_name = "_gr_poly_exp_series__extern"]
2520 pub fn _gr_poly_exp_series(
2521 res: gr_ptr,
2522 f: gr_srcptr,
2523 flen: slong,
2524 len: slong,
2525 ctx: *mut gr_ctx_struct,
2526 ) -> libc::c_int;
2527 pub fn _gr_poly_exp_series_generic(
2528 f: gr_ptr,
2529 h: gr_srcptr,
2530 hlen: slong,
2531 n: slong,
2532 ctx: *mut gr_ctx_struct,
2533 ) -> libc::c_int;
2534 pub fn gr_poly_exp_series(
2535 f: *mut gr_poly_struct,
2536 h: *const gr_poly_struct,
2537 n: slong,
2538 ctx: *mut gr_ctx_struct,
2539 ) -> libc::c_int;
2540 pub fn _gr_poly_sin_cos_series_basecase(
2541 s: gr_ptr,
2542 c: gr_ptr,
2543 h: gr_srcptr,
2544 hlen: slong,
2545 n: slong,
2546 times_pi: libc::c_int,
2547 ctx: *mut gr_ctx_struct,
2548 ) -> libc::c_int;
2549 pub fn gr_poly_sin_cos_series_basecase(
2550 s: *mut gr_poly_struct,
2551 c: *mut gr_poly_struct,
2552 h: *const gr_poly_struct,
2553 n: slong,
2554 times_pi: libc::c_int,
2555 ctx: *mut gr_ctx_struct,
2556 ) -> libc::c_int;
2557 pub fn _gr_poly_sin_cos_series_tangent(
2558 s: gr_ptr,
2559 c: gr_ptr,
2560 h: gr_srcptr,
2561 hlen: slong,
2562 n: slong,
2563 times_pi: libc::c_int,
2564 ctx: *mut gr_ctx_struct,
2565 ) -> libc::c_int;
2566 pub fn gr_poly_sin_cos_series_tangent(
2567 s: *mut gr_poly_struct,
2568 c: *mut gr_poly_struct,
2569 h: *const gr_poly_struct,
2570 n: slong,
2571 times_pi: libc::c_int,
2572 ctx: *mut gr_ctx_struct,
2573 ) -> libc::c_int;
2574 pub fn _gr_poly_tan_series_basecase(
2575 f: gr_ptr,
2576 h: gr_srcptr,
2577 hlen: slong,
2578 n: slong,
2579 ctx: *mut gr_ctx_struct,
2580 ) -> libc::c_int;
2581 pub fn gr_poly_tan_series_basecase(
2582 f: *mut gr_poly_struct,
2583 h: *const gr_poly_struct,
2584 n: slong,
2585 ctx: *mut gr_ctx_struct,
2586 ) -> libc::c_int;
2587 pub fn _gr_poly_tan_series_newton(
2588 f: gr_ptr,
2589 h: gr_srcptr,
2590 hlen: slong,
2591 n: slong,
2592 cutoff: slong,
2593 ctx: *mut gr_ctx_struct,
2594 ) -> libc::c_int;
2595 pub fn gr_poly_tan_series_newton(
2596 f: *mut gr_poly_struct,
2597 h: *const gr_poly_struct,
2598 n: slong,
2599 cutoff: slong,
2600 ctx: *mut gr_ctx_struct,
2601 ) -> libc::c_int;
2602 pub fn _gr_poly_tan_series(
2603 f: gr_ptr,
2604 h: gr_srcptr,
2605 hlen: slong,
2606 n: slong,
2607 ctx: *mut gr_ctx_struct,
2608 ) -> libc::c_int;
2609 pub fn gr_poly_tan_series(
2610 f: *mut gr_poly_struct,
2611 h: *const gr_poly_struct,
2612 n: slong,
2613 ctx: *mut gr_ctx_struct,
2614 ) -> libc::c_int;
2615 pub fn _gr_poly_mulmod(
2616 res: gr_ptr,
2617 poly1: gr_srcptr,
2618 len1: slong,
2619 poly2: gr_srcptr,
2620 len2: slong,
2621 f: gr_srcptr,
2622 lenf: slong,
2623 ctx: *mut gr_ctx_struct,
2624 ) -> libc::c_int;
2625 pub fn gr_poly_mulmod(
2626 res: *mut gr_poly_struct,
2627 poly1: *const gr_poly_struct,
2628 poly2: *const gr_poly_struct,
2629 f: *const gr_poly_struct,
2630 ctx: *mut gr_ctx_struct,
2631 ) -> libc::c_int;
2632 pub fn _gr_poly_mulmod_preinv(
2633 res: gr_ptr,
2634 poly1: gr_srcptr,
2635 len1: slong,
2636 poly2: gr_srcptr,
2637 len2: slong,
2638 f: gr_srcptr,
2639 lenf: slong,
2640 finv: gr_srcptr,
2641 lenfinv: slong,
2642 ctx: *mut gr_ctx_struct,
2643 ) -> libc::c_int;
2644 pub fn gr_poly_mulmod_preinv(
2645 res: *mut gr_poly_struct,
2646 poly1: *const gr_poly_struct,
2647 poly2: *const gr_poly_struct,
2648 f: *const gr_poly_struct,
2649 finv: *const gr_poly_struct,
2650 ctx: *mut gr_ctx_struct,
2651 ) -> libc::c_int;
2652 pub fn _gr_poly_powmod_fmpz_binexp(
2653 res: gr_ptr,
2654 poly: gr_srcptr,
2655 e: *const fmpz,
2656 f: gr_srcptr,
2657 lenf: slong,
2658 ctx: *mut gr_ctx_struct,
2659 ) -> libc::c_int;
2660 pub fn gr_poly_powmod_fmpz_binexp(
2661 res: *mut gr_poly_struct,
2662 poly: *const gr_poly_struct,
2663 e: *const fmpz,
2664 f: *const gr_poly_struct,
2665 ctx: *mut gr_ctx_struct,
2666 ) -> libc::c_int;
2667 pub fn _gr_poly_powmod_fmpz_binexp_preinv(
2668 res: gr_ptr,
2669 poly: gr_srcptr,
2670 e: *const fmpz,
2671 f: gr_srcptr,
2672 lenf: slong,
2673 finv: gr_srcptr,
2674 lenfinv: slong,
2675 ctx: *mut gr_ctx_struct,
2676 ) -> libc::c_int;
2677 pub fn gr_poly_powmod_fmpz_binexp_preinv(
2678 res: *mut gr_poly_struct,
2679 poly: *const gr_poly_struct,
2680 e: *const fmpz,
2681 f: *const gr_poly_struct,
2682 finv: *const gr_poly_struct,
2683 ctx: *mut gr_ctx_struct,
2684 ) -> libc::c_int;
2685 pub fn _gr_poly_powmod_x_fmpz_preinv(
2686 res: gr_ptr,
2687 e: *const fmpz,
2688 f: gr_srcptr,
2689 lenf: slong,
2690 finv: gr_srcptr,
2691 lenfinv: slong,
2692 ctx: *mut gr_ctx_struct,
2693 ) -> libc::c_int;
2694 pub fn gr_poly_powmod_x_fmpz_preinv(
2695 res: *mut gr_poly_struct,
2696 e: *const fmpz,
2697 f: *const gr_poly_struct,
2698 finv: *const gr_poly_struct,
2699 ctx: *mut gr_ctx_struct,
2700 ) -> libc::c_int;
2701 pub fn _gr_poly_powmod_ui_binexp(
2702 res: gr_ptr,
2703 poly: gr_srcptr,
2704 e: ulong,
2705 f: gr_srcptr,
2706 lenf: slong,
2707 ctx: *mut gr_ctx_struct,
2708 ) -> libc::c_int;
2709 pub fn gr_poly_powmod_ui_binexp(
2710 res: *mut gr_poly_struct,
2711 poly: *const gr_poly_struct,
2712 e: ulong,
2713 f: *const gr_poly_struct,
2714 ctx: *mut gr_ctx_struct,
2715 ) -> libc::c_int;
2716 pub fn _gr_poly_powmod_ui_binexp_preinv(
2717 res: gr_ptr,
2718 poly: gr_srcptr,
2719 e: ulong,
2720 f: gr_srcptr,
2721 lenf: slong,
2722 finv: gr_srcptr,
2723 lenfinv: slong,
2724 ctx: *mut gr_ctx_struct,
2725 ) -> libc::c_int;
2726 pub fn gr_poly_powmod_ui_binexp_preinv(
2727 res: *mut gr_poly_struct,
2728 poly: *const gr_poly_struct,
2729 e: ulong,
2730 f: *const gr_poly_struct,
2731 finv: *const gr_poly_struct,
2732 ctx: *mut gr_ctx_struct,
2733 ) -> libc::c_int;
2734 pub fn _gr_poly_powmod_fmpz_sliding_preinv(
2735 res: gr_ptr,
2736 poly: gr_srcptr,
2737 e: *const fmpz,
2738 k: ulong,
2739 f: gr_srcptr,
2740 lenf: slong,
2741 finv: gr_srcptr,
2742 lenfinv: slong,
2743 ctx: *mut gr_ctx_struct,
2744 ) -> libc::c_int;
2745 pub fn gr_poly_powmod_fmpz_sliding_preinv(
2746 res: *mut gr_poly_struct,
2747 poly: *const gr_poly_struct,
2748 e: *const fmpz,
2749 k: ulong,
2750 f: *const gr_poly_struct,
2751 finv: *const gr_poly_struct,
2752 ctx: *mut gr_ctx_struct,
2753 ) -> libc::c_int;
2754 pub fn gr_poly_compose_mod_wrapper(
2755 _compose_mod: _gr_method_compose_mod_op,
2756 res: *mut gr_poly_struct,
2757 poly1: *const gr_poly_struct,
2758 poly2: *const gr_poly_struct,
2759 poly3: *const gr_poly_struct,
2760 ctx: *mut gr_ctx_struct,
2761 ) -> libc::c_int;
2762 pub fn gr_poly_compose_mod_preinv_wrapper(
2763 _compose_mod: _gr_method_compose_mod_preinv_op,
2764 res: *mut gr_poly_struct,
2765 poly1: *const gr_poly_struct,
2766 poly2: *const gr_poly_struct,
2767 poly3: *const gr_poly_struct,
2768 poly3inv: *const gr_poly_struct,
2769 ctx: *mut gr_ctx_struct,
2770 ) -> libc::c_int;
2771 pub fn _gr_poly_compose_mod_horner(
2772 res: gr_ptr,
2773 poly1: gr_srcptr,
2774 len1: slong,
2775 poly2: gr_srcptr,
2776 poly3: gr_srcptr,
2777 len3: slong,
2778 ctx: *mut gr_ctx_struct,
2779 ) -> libc::c_int;
2780 pub fn gr_poly_compose_mod_horner(
2781 res: *mut gr_poly_struct,
2782 poly1: *const gr_poly_struct,
2783 poly2: *const gr_poly_struct,
2784 poly3: *const gr_poly_struct,
2785 ctx: *mut gr_ctx_struct,
2786 ) -> libc::c_int;
2787 pub fn _gr_poly_compose_mod_brent_kung(
2788 res: gr_ptr,
2789 poly1: gr_srcptr,
2790 len1: slong,
2791 poly2: gr_srcptr,
2792 poly3: gr_srcptr,
2793 len3: slong,
2794 ctx: *mut gr_ctx_struct,
2795 ) -> libc::c_int;
2796 pub fn gr_poly_compose_mod_brent_kung(
2797 res: *mut gr_poly_struct,
2798 poly1: *const gr_poly_struct,
2799 poly2: *const gr_poly_struct,
2800 poly3: *const gr_poly_struct,
2801 ctx: *mut gr_ctx_struct,
2802 ) -> libc::c_int;
2803 pub fn _gr_poly_compose_mod(
2804 res: gr_ptr,
2805 poly1: gr_srcptr,
2806 len1: slong,
2807 poly2: gr_srcptr,
2808 poly3: gr_srcptr,
2809 len3: slong,
2810 ctx: *mut gr_ctx_struct,
2811 ) -> libc::c_int;
2812 pub fn gr_poly_compose_mod(
2813 res: *mut gr_poly_struct,
2814 poly1: *const gr_poly_struct,
2815 poly2: *const gr_poly_struct,
2816 poly3: *const gr_poly_struct,
2817 ctx: *mut gr_ctx_struct,
2818 ) -> libc::c_int;
2819 pub fn _gr_poly_compose_mod_horner_preinv(
2820 res: gr_ptr,
2821 poly1: gr_srcptr,
2822 len1: slong,
2823 poly2: gr_srcptr,
2824 poly3: gr_srcptr,
2825 len3: slong,
2826 poly3inv: gr_srcptr,
2827 inv3len: slong,
2828 ctx: *mut gr_ctx_struct,
2829 ) -> libc::c_int;
2830 pub fn gr_poly_compose_mod_horner_preinv(
2831 res: *mut gr_poly_struct,
2832 poly1: *const gr_poly_struct,
2833 poly2: *const gr_poly_struct,
2834 poly3: *const gr_poly_struct,
2835 poly3inv: *const gr_poly_struct,
2836 ctx: *mut gr_ctx_struct,
2837 ) -> libc::c_int;
2838 pub fn _gr_poly_compose_mod_brent_kung_preinv(
2839 res: gr_ptr,
2840 poly1: gr_srcptr,
2841 len1: slong,
2842 poly2: gr_srcptr,
2843 poly3: gr_srcptr,
2844 len3: slong,
2845 poly3inv: gr_srcptr,
2846 inv3len: slong,
2847 ctx: *mut gr_ctx_struct,
2848 ) -> libc::c_int;
2849 pub fn gr_poly_compose_mod_brent_kung_preinv(
2850 res: *mut gr_poly_struct,
2851 poly1: *const gr_poly_struct,
2852 poly2: *const gr_poly_struct,
2853 poly3: *const gr_poly_struct,
2854 poly3inv: *const gr_poly_struct,
2855 ctx: *mut gr_ctx_struct,
2856 ) -> libc::c_int;
2857 pub fn _gr_poly_compose_mod_preinv(
2858 res: gr_ptr,
2859 poly1: gr_srcptr,
2860 len1: slong,
2861 poly2: gr_srcptr,
2862 poly3: gr_srcptr,
2863 len3: slong,
2864 poly3inv: gr_srcptr,
2865 inv3len: slong,
2866 ctx: *mut gr_ctx_struct,
2867 ) -> libc::c_int;
2868 pub fn gr_poly_compose_mod_preinv(
2869 res: *mut gr_poly_struct,
2870 poly1: *const gr_poly_struct,
2871 poly2: *const gr_poly_struct,
2872 poly3: *const gr_poly_struct,
2873 poly3inv: *const gr_poly_struct,
2874 ctx: *mut gr_ctx_struct,
2875 ) -> libc::c_int;
2876 pub fn _gr_poly_reduce_matrix_mod_poly(
2877 A: *mut gr_mat_struct,
2878 B: *const gr_mat_struct,
2879 f: *const gr_poly_struct,
2880 ctx: *mut gr_ctx_struct,
2881 ) -> libc::c_int;
2882 pub fn _gr_poly_precompute_matrix(
2883 A: *mut gr_mat_struct,
2884 poly1: gr_srcptr,
2885 poly2: gr_srcptr,
2886 len2: slong,
2887 poly2inv: gr_srcptr,
2888 len2inv: slong,
2889 ctx: *mut gr_ctx_struct,
2890 ) -> libc::c_int;
2891 pub fn gr_poly_precompute_matrix(
2892 A: *mut gr_mat_struct,
2893 poly1: *const gr_poly_struct,
2894 poly2: *const gr_poly_struct,
2895 poly2inv: *const gr_poly_struct,
2896 ctx: *mut gr_ctx_struct,
2897 ) -> libc::c_int;
2898 pub fn _gr_poly_compose_mod_brent_kung_precomp_preinv(
2899 res: gr_ptr,
2900 poly1: gr_srcptr,
2901 len1: slong,
2902 A: *const gr_mat_struct,
2903 poly3: gr_srcptr,
2904 len3: slong,
2905 poly3inv: gr_srcptr,
2906 len3inv: slong,
2907 ctx: *mut gr_ctx_struct,
2908 ) -> libc::c_int;
2909 pub fn gr_poly_compose_mod_brent_kung_precomp_preinv(
2910 res: *mut gr_poly_struct,
2911 poly1: *const gr_poly_struct,
2912 A: *const gr_mat_struct,
2913 poly3: *const gr_poly_struct,
2914 poly3inv: *const gr_poly_struct,
2915 ctx: *mut gr_ctx_struct,
2916 ) -> libc::c_int;
2917 pub fn _gr_poly_test_mullow(
2918 mullow_impl: gr_method_poly_binary_trunc_op,
2919 mullow_ref: gr_method_poly_binary_trunc_op,
2920 state: *mut flint_rand_struct,
2921 iters: slong,
2922 maxn: slong,
2923 ctx: *mut gr_ctx_struct,
2924 );
2925 pub fn _gr_poly_test_mulmid(
2926 mulmid_impl: gr_method_poly_binary_trunc2_op,
2927 mulmid_ref: gr_method_poly_binary_trunc2_op,
2928 state: *mut flint_rand_struct,
2929 iters: slong,
2930 maxn: slong,
2931 ctx: *mut gr_ctx_struct,
2932 );
2933 pub fn _gr_poly_test_approx_mulmid_pos_entrywise_accurate(
2934 mulmid_impl: gr_method_poly_binary_trunc2_op,
2935 mulmid_ref: gr_method_poly_binary_trunc2_op,
2936 rel_tol: gr_srcptr,
2937 state: *mut flint_rand_struct,
2938 iters: slong,
2939 maxn: slong,
2940 ctx: *mut gr_ctx_struct,
2941 );
2942 pub fn _gr_poly_test_divrem(
2943 divrem_impl: gr_method_poly_binary_binary_op,
2944 state: *mut flint_rand_struct,
2945 iters: slong,
2946 maxn: slong,
2947 ctx: *mut gr_ctx_struct,
2948 );
2949 pub fn _gr_poly_test_div(
2950 div_impl: gr_method_poly_binary_op,
2951 state: *mut flint_rand_struct,
2952 iters: slong,
2953 maxn: slong,
2954 ctx: *mut gr_ctx_struct,
2955 );
2956 pub fn _gr_poly_test_inv_series(
2957 inv_series_impl: gr_method_poly_unary_trunc_op,
2958 state: *mut flint_rand_struct,
2959 iters: slong,
2960 maxn: slong,
2961 ctx: *mut gr_ctx_struct,
2962 );
2963 pub fn _gr_poly_test_div_series(
2964 div_series_impl: gr_method_poly_binary_trunc_op,
2965 state: *mut flint_rand_struct,
2966 iters: slong,
2967 maxn: slong,
2968 ctx: *mut gr_ctx_struct,
2969 );
2970 pub fn _gr_poly_test_gcd_field(
2971 gcd_impl: gr_method_poly_gcd_op,
2972 state: *mut flint_rand_struct,
2973 iters: slong,
2974 maxn: slong,
2975 ctx: *mut gr_ctx_struct,
2976 );
2977 pub fn _gr_poly_test_gcd_ufd(
2978 gcd_impl: gr_method_poly_gcd_op,
2979 state: *mut flint_rand_struct,
2980 iters: slong,
2981 maxn: slong,
2982 ctx: *mut gr_ctx_struct,
2983 );
2984 pub fn _gr_poly_test_xgcd(
2985 xgcd_impl: gr_method_poly_xgcd_op,
2986 state: *mut flint_rand_struct,
2987 iters: slong,
2988 maxn: slong,
2989 ctx: *mut gr_ctx_struct,
2990 );
2991}