API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 12th, 2018
87
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 16.42 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.     Copyright (C) 2018 Association des collaborateurs de D.H.J Polymath
  3.  
  4.     This is free software: you can redistribute it and/or modify it under
  5.     the terms of the GNU Lesser General Public License (LGPL) as published
  6.     by the Free Software Foundation; either version 2.1 of the License, or
  7.     (at your option) any later version.  See <http://www.gnu.org/licenses/>.
  8. */
  9.  
  10. #include "acb_poly.h"
  11.  
  12.  
  13. typedef acb_poly_struct *acb_poly_ptr;
  14. typedef const acb_poly_struct *acb_poly_srcptr;
  15.  
  16. void
  17. acb_poly_re_inplace(acb_poly_t p)
  18. {
  19.     slong i;
  20.     for (i = 0; i < acb_poly_length(p); i++)
  21.     {
  22.         acb_ptr z = acb_poly_get_coeff_ptr(p, i);
  23.         arb_zero(acb_imagref(z));
  24.     }
  25. }
  26.  
  27. void
  28. acb_poly_re(acb_poly_t p, const acb_poly_t q)
  29. {
  30.     if (p != q)
  31.         acb_poly_set(p, q);
  32.  
  33.     acb_poly_re_inplace(p);
  34. }
  35.  
  36. void
  37. acb_poly_im_inplace(acb_poly_t p)
  38. {
  39.     slong i;
  40.     for (i = 0; i < acb_poly_length(p); i++)
  41.     {
  42.         acb_ptr z = acb_poly_get_coeff_ptr(p, i);
  43.         arb_set(acb_realref(z), acb_imagref(z));
  44.         arb_zero(acb_imagref(z));
  45.     }
  46. }
  47.  
  48. void
  49. acb_poly_im(acb_poly_t p, const acb_poly_t q)
  50. {
  51.     if (p != q)
  52.         acb_poly_set(p, q);
  53.  
  54.     acb_poly_im_inplace(p);
  55. }
  56.  
  57. void
  58. acb_poly_abs_series(acb_poly_t res,
  59.         const acb_poly_t p, slong n, slong prec)
  60. {
  61.     acb_poly_t a, b;
  62.  
  63.     acb_poly_init(a);
  64.     acb_poly_init(b);
  65.  
  66.     acb_poly_re(a, p);
  67.     acb_poly_mullow(a, a, a, n, prec);
  68.  
  69.     acb_poly_im(b, p);
  70.     acb_poly_mullow(b, b, b, n, prec);
  71.  
  72.     acb_poly_add_series(res, a, b, n, prec);
  73.  
  74.     acb_poly_sqrt_series(res, res, n, prec);
  75.     acb_poly_re_inplace(res);
  76.  
  77.     acb_poly_clear(a);
  78.     acb_poly_clear(b);
  79. }
  80.  
  81.  
  82.  
  83.  
  84.  
  85.  
  86.  
  87. void
  88. _acb_poly_xNpoly_series(acb_poly_t res,
  89.         const acb_poly_t N, const acb_poly_t t, slong n, slong prec)
  90. {
  91.     acb_poly_t p, q;
  92.     acb_t pi;
  93.  
  94.     acb_init(pi);
  95.     acb_const_pi(pi, prec);
  96.  
  97.     acb_poly_init(p);
  98.     acb_poly_mullow(p, N, N, n, prec);
  99.     acb_poly_scalar_mul(p, p, pi, prec);
  100.     acb_poly_scalar_mul_2exp_si(p, p, 2);
  101.  
  102.     acb_poly_init(q);
  103.     acb_poly_scalar_mul(q, t, pi, prec);
  104.     acb_poly_scalar_mul_2exp_si(q, q, -2);
  105.  
  106.     acb_poly_sub_series(res, p, q, n, prec);
  107.  
  108.     acb_clear(pi);
  109.     acb_poly_clear(p);
  110.     acb_poly_clear(q);
  111. }
  112.  
  113. static void
  114. _acb_poly_delta1_series(acb_poly_t res,
  115.         const acb_poly_t xN, const acb_poly_t y, slong n, slong prec)
  116. {
  117.     acb_t pi;
  118.     acb_poly_t num, den;
  119.  
  120.     acb_init(pi);
  121.     acb_const_pi(pi, prec);
  122.  
  123.     acb_poly_init(num);
  124.     acb_poly_scalar_mul(num, y, pi, prec);
  125.     acb_poly_scalar_mul_2exp_si(num, num, -1);
  126.  
  127.     acb_poly_init(den);
  128.     acb_poly_scalar_mul_2exp_si(den, y, 1);
  129.     acb_poly_add_si(den, den, 14, prec);
  130.     acb_poly_scalar_div(den, den, pi, prec);
  131.     acb_poly_neg(den, den);
  132.     acb_poly_add_si(den, den, -6, prec);
  133.     acb_poly_add_series(den, den, xN, n, prec);
  134.  
  135.     acb_poly_div_series(res, num, den, n, prec);
  136.  
  137.     acb_clear(pi);
  138.     acb_poly_clear(num);
  139.     acb_poly_clear(den);
  140. }
  141.  
  142. static void
  143. _acb_poly_delta2_series(acb_poly_t res,
  144.         const acb_poly_t xN, const acb_poly_t xNp1,
  145.         const acb_poly_t y, slong n, slong prec)
  146. {
  147.     acb_poly_t da, db;
  148.     acb_t pi, onei;
  149.  
  150.     acb_init(pi);
  151.     acb_const_pi(pi, prec);
  152.  
  153.     acb_init(onei);
  154.     acb_onei(onei);
  155.  
  156.     acb_poly_init(da);
  157.     acb_poly_add_si(da, y, 7, prec);
  158.     acb_poly_mullow(da, da, y, n, prec);
  159.     acb_poly_scalar_mul_2exp_si(da, da, 1);
  160.     acb_poly_div_series(da, da, xN, n, prec);
  161.     acb_poly_div_series(da, da, xN, n, prec);
  162.  
  163.     acb_poly_init(db);
  164.     acb_poly_scalar_mul(db, xNp1, onei, prec);
  165.     acb_poly_add_series(db, db, y, n, prec);
  166.     acb_poly_add_si(db, db, 1, prec);
  167.     acb_poly_abs_series(db, db, n, prec);
  168.     acb_poly_scalar_div(db, db, pi, prec);
  169.     acb_poly_scalar_mul_2exp_si(db, db, -2);
  170.     acb_poly_log_series(db, db, n, prec);
  171.  
  172.     acb_poly_mullow(res, da, db, n, prec);
  173.  
  174.     acb_clear(pi);
  175.     acb_clear(onei);
  176.     acb_poly_clear(da);
  177.     acb_poly_clear(db);
  178. }
  179.  
  180. void
  181. _acb_poly_delta_series(acb_poly_t res,
  182.         const acb_poly_t xN, const acb_poly_t xNp1,
  183.         const acb_poly_t y, slong n, slong prec)
  184. {
  185.     acb_poly_t d1, d2;
  186.  
  187.     acb_poly_init(d1);
  188.     acb_poly_init(d2);
  189.  
  190.     _acb_poly_delta1_series(d1, xN, y, n, prec);
  191.     _acb_poly_delta2_series(d2, xN, xNp1, y, n, prec);
  192.     acb_poly_add_series(res, d1, d2, n, prec);
  193.  
  194.     acb_poly_clear(d1);
  195.     acb_poly_clear(d2);
  196. }
  197.  
  198.  
  199.  
  200.  
  201.  
  202.  
  203.  
  204.  
  205.  
  206. static void
  207. _acb_poly_bt_series(acb_poly_t res,
  208.         const acb_t logk, const acb_poly_t t, slong n, slong prec)
  209. {
  210.     acb_poly_scalar_mul(res, t, logk, prec);
  211.     acb_poly_scalar_mul(res, res, logk, prec);
  212.     acb_poly_scalar_mul_2exp_si(res, res, -2);
  213.     acb_poly_exp_series(res, res, n, prec);
  214. }
  215.  
  216. static void
  217. _acb_poly_at_series(acb_poly_t res,
  218.         const acb_t logk, const acb_poly_t t, const acb_poly_t y,
  219.         slong n, slong prec)
  220. {
  221.     acb_poly_t p;
  222.  
  223.     acb_poly_init(p);
  224.     acb_poly_scalar_mul(p, t, logk, prec);
  225.     acb_poly_scalar_mul_2exp_si(p, p, -2);
  226.     acb_poly_add_series(p, p, y, n, prec);
  227.  
  228.     acb_poly_scalar_mul(res, p, logk, prec);
  229.     acb_poly_exp_series(res, res, n, prec);
  230.  
  231.     acb_poly_clear(p);
  232. }
  233.  
  234. static void
  235. _acb_poly_afac_series(acb_poly_t res,
  236.         const acb_poly_t logNpoly, const acb_poly_t delta, const acb_poly_t xN,
  237.         const acb_poly_t t, const acb_poly_t y, slong n, slong prec)
  238. {
  239.     acb_poly_t p, q;
  240.  
  241.     acb_poly_init(p);
  242.     acb_poly_add_si(p, xN, -6, prec);
  243.     acb_poly_scalar_mul_2exp_si(p, p, 1);
  244.  
  245.     acb_poly_init(q);
  246.     acb_poly_div_series(q, t, p, n, prec);
  247.     acb_poly_add_si(q, q, -1, prec);
  248.     acb_poly_mullow(q, q, y, n, prec);
  249.     acb_poly_mullow(q, q, logNpoly, n, prec);
  250.  
  251.     acb_poly_add_series(res, delta, q, n, prec);
  252.     acb_poly_exp_series(res, res, n, prec);
  253.  
  254.     acb_poly_clear(p);
  255.     acb_poly_clear(q);
  256. }
  257.  
  258. static void
  259. _acb_poly_sb_series(acb_poly_t res,
  260.         const acb_poly_t logNpoly, const acb_poly_t t, const acb_poly_t y,
  261.         slong n, slong prec)
  262. {
  263.     acb_poly_t p;
  264.  
  265.     acb_poly_init(p);
  266.     acb_poly_mullow(p, t, logNpoly, n, prec);
  267.     acb_poly_add_series(p, p, y, n, prec);
  268.  
  269.     acb_poly_add_si(res, p, 1, prec);
  270.     acb_poly_scalar_mul_2exp_si(res, res, -1);
  271.  
  272.     acb_poly_clear(p);
  273. }
  274.  
  275.  
  276. static void
  277. _first_n_primes(ulong *primes, ulong n)
  278. {
  279.     ulong p = 2;
  280.     ulong k = 0;
  281.     while (k < n)
  282.     {
  283.         primes[k++] = p;
  284.         p = n_nextprime(p, 1);
  285.     }
  286. }
  287.  
  288. static void
  289. _acb_poly_abbeff_largex_e2_tbound(acb_poly_t res,
  290.         const acb_poly_t t, const acb_poly_t y, const acb_poly_t Npoly,
  291.         acb_poly_srcptr at, acb_poly_srcptr bt, acb_poly_srcptr moll,
  292.         slong nprimes, const ulong *primes, const slong *d,
  293.         slong D, slong N, slong n, slong prec)
  294. {
  295.     slong divs;
  296.     acb_t logk, logN;
  297.     acb_poly_t ksummand_a, ndsum_a, absndsum_a, ndsummand_a;
  298.     acb_poly_t ksummand_b, ndsum_b, absndsum_b, ndsummand_b;
  299.     acb_poly_t lbbound, labound;
  300.     acb_poly_t afac, sb, delta, xN, xNp1, kterm;
  301.     acb_poly_t Np1poly, logNpoly;
  302.     slong i, j, k, nd;
  303.  
  304.     divs = 1 << nprimes;
  305.  
  306.     acb_init(logN);
  307.     acb_init(logk);
  308.  
  309.     acb_poly_init(ksummand_a);
  310.     acb_poly_init(ndsum_a);
  311.     acb_poly_init(absndsum_a);
  312.     acb_poly_init(ndsummand_a);
  313.  
  314.     acb_poly_init(ksummand_b);
  315.     acb_poly_init(ndsum_b);
  316.     acb_poly_init(absndsum_b);
  317.     acb_poly_init(ndsummand_b);
  318.  
  319.     acb_poly_init(lbbound);
  320.     acb_poly_init(labound);
  321.     acb_poly_init(afac);
  322.     acb_poly_init(sb);
  323.     acb_poly_init(delta);
  324.     acb_poly_init(xN);
  325.     acb_poly_init(xNp1);
  326.     acb_poly_init(kterm);
  327.  
  328.     acb_poly_init(Np1poly);
  329.     acb_poly_init(logNpoly);
  330.  
  331.     acb_set_si(logN, N);
  332.     acb_log(logN, logN, prec);
  333.  
  334.     acb_poly_log_series(logNpoly, Npoly, n, prec);
  335.     acb_poly_add_si(Np1poly, Npoly, 1, prec);
  336.     _acb_poly_sb_series(sb, logNpoly, t, y, n, prec);
  337.     _acb_poly_xNpoly_series(xN, Npoly, t, n, prec);
  338.     _acb_poly_xNpoly_series(xNp1, Np1poly, t, n, prec);
  339.     _acb_poly_delta_series(delta, xN, xNp1, y, n, prec);
  340.     _acb_poly_afac_series(afac, logNpoly, delta, xN, t, y, n, prec);
  341.  
  342.     acb_poly_zero(lbbound);
  343.     acb_poly_zero(labound);
  344.     for (k = 2; k <= D*N; k++)
  345.     {
  346.         acb_poly_zero(ndsum_a);
  347.         acb_poly_zero(ndsum_b);
  348.         for (nd = 1; nd <= divs; nd++)
  349.         {
  350.             if ((k % d[nd] == 0) && (k <= d[nd]*N))
  351.             {
  352.                 j = k / d[nd];
  353.  
  354.                 acb_poly_mullow(ndsummand_b, moll + nd, bt + j, n, prec);
  355.                 acb_poly_add_series(ndsum_b, ndsum_b, ndsummand_b, n, prec);
  356.  
  357.                 acb_poly_mullow(ndsummand_a, moll + nd, at + j, n, prec);
  358.                 acb_poly_mullow(ndsummand_a, ndsummand_a, afac, n, prec);
  359.                 acb_poly_add_series(ndsum_a, ndsum_a, ndsummand_a, n, prec);
  360.             }
  361.         }
  362.         if (!acb_poly_is_zero(ndsum_b) || !acb_poly_is_zero(ndsum_a))
  363.         {
  364.             acb_set_si(logk, k);
  365.             acb_log(logk, logk, prec);
  366.             acb_poly_scalar_mul(kterm, sb, logk, prec);
  367.             acb_poly_neg(kterm, kterm);
  368.             acb_poly_exp_series(kterm, kterm, n, prec);
  369.         }
  370.         if (!acb_poly_is_zero(ndsum_b))
  371.         {
  372.             acb_poly_abs_series(absndsum_b, ndsum_b, n, prec);
  373.             acb_poly_mullow(ksummand_b, kterm, absndsum_b, n, prec);
  374.             acb_poly_add_series(lbbound, lbbound, ksummand_b, n, prec);
  375.         }
  376.         if (!acb_poly_is_zero(ndsum_a))
  377.         {
  378.             acb_poly_abs_series(absndsum_a, ndsum_a, n, prec);
  379.             acb_poly_mullow(ksummand_a, kterm, absndsum_a, n, prec);
  380.             acb_poly_add_series(labound, labound, ksummand_a, n, prec);
  381.         }
  382.     }
  383.  
  384.     acb_poly_mullow(res, afac, at + 1, n, prec);
  385.     acb_poly_neg(res, res);
  386.     acb_poly_sub_series(res, res, lbbound, n, prec);
  387.     acb_poly_sub_series(res, res, labound, n, prec);
  388.     acb_poly_add_si(res, res, 1, prec);
  389.  
  390. finish:
  391.  
  392.     acb_clear(logN);
  393.     acb_clear(logk);
  394.  
  395.     acb_poly_clear(ksummand_a);
  396.     acb_poly_clear(ndsum_a);
  397.     acb_poly_clear(absndsum_a);
  398.     acb_poly_clear(ndsummand_a);
  399.  
  400.     acb_poly_clear(ksummand_b);
  401.     acb_poly_clear(ndsum_b);
  402.     acb_poly_clear(absndsum_b);
  403.     acb_poly_clear(ndsummand_b);
  404.  
  405.     acb_poly_clear(lbbound);
  406.     acb_poly_clear(labound);
  407.     acb_poly_clear(afac);
  408.     acb_poly_clear(sb);
  409.     acb_poly_clear(delta);
  410.     acb_poly_clear(xN);
  411.     acb_poly_clear(xNp1);
  412.     acb_poly_clear(kterm);
  413.  
  414.     acb_poly_clear(Np1poly);
  415.     acb_poly_clear(logNpoly);
  416. }
  417.  
  418. slong run(const acb_t t, const acb_t y,
  419.         slong Na, slong Nb, slong Nstep,
  420.         slong nprimes, slong n, slong digits, slong prec)
  421. {
  422.     slong D, N, Nmax;
  423.     acb_poly_ptr bt, at;
  424.     slong i, j, k;
  425.     slong high_prec;
  426.     acb_t logk, coeff;
  427.     acb_poly_t tpoly, ypoly, rpoly, rdpoly, Npoly;
  428.     acb_poly_ptr moll;
  429.     slong divs;
  430.     ulong *primes;
  431.     slong *d;
  432.     slong completed_steps = 0;
  433.  
  434.     high_prec = digits * 3.32192809488736 + 10;
  435.     Nmax = Nb;
  436.  
  437.     acb_init(logk);
  438.     acb_init(coeff);
  439.     acb_poly_init(tpoly);
  440.     acb_poly_init(ypoly);
  441.     acb_poly_init(rpoly);
  442.     acb_poly_init(rdpoly);
  443.     acb_poly_init(Npoly);
  444.  
  445.     acb_poly_set_acb(tpoly, t);
  446.     acb_poly_set_acb(ypoly, y);
  447.  
  448.     divs = 1 << nprimes;
  449.     primes = flint_malloc(nprimes * sizeof(*primes));
  450.     _first_n_primes(primes, nprimes);
  451.  
  452.     D = 1;
  453.     for (i = 0; i < nprimes; i++)
  454.     {
  455.         D *= primes[i];
  456.     }
  457.  
  458.     bt = flint_malloc((Nmax * D + 1) * sizeof(*bt));
  459.     at = flint_malloc((Nmax * D + 1) * sizeof(*at));
  460.  
  461.     for (k = 1; k <= Nmax * D; k++)
  462.     {
  463.         acb_set_si(logk, k);
  464.         acb_log(logk, logk, prec);
  465.  
  466.         acb_poly_init(bt + k);
  467.         acb_poly_init(at + k);
  468.  
  469.         _acb_poly_bt_series(bt + k, logk, tpoly, n, prec);
  470.         _acb_poly_at_series(at + k, logk, tpoly, ypoly, n, prec);
  471.     }
  472.  
  473.     d = flint_malloc((divs + 1) * sizeof(*d));
  474.     moll = flint_malloc((divs + 1) * sizeof(*moll));
  475.     for (i = 0; i < divs; i++)
  476.     {
  477.         acb_poly_init(moll + i + 1);
  478.         acb_poly_one(moll + i + 1);
  479.         d[i + 1] = 1;
  480.         for (j = 0; j < nprimes; j++)
  481.         {
  482.             if (i & (1 << j))
  483.             {
  484.                 d[i + 1] *= primes[j];
  485.                 acb_poly_mullow(
  486.                         moll + i + 1, moll + i + 1, bt + primes[j], n, prec);
  487.                 acb_poly_neg(moll + i + 1, moll + i + 1);
  488.             }
  489.         }
  490.     }
  491.  
  492.     for (N = Na; N <= Nb; N += Nstep)
  493.     {
  494.         acb_poly_one(Npoly);
  495.         acb_poly_shift_left(Npoly, Npoly, 1);
  496.         acb_poly_add_si(Npoly, Npoly, N, prec);
  497.  
  498.         _acb_poly_abbeff_largex_e2_tbound(rpoly, tpoly, ypoly, Npoly,
  499.                 at, bt, moll, nprimes, primes, d,
  500.                 D, N, n, prec);
  501.  
  502.         acb_poly_set(rdpoly, rpoly);
  503.         for (i = 0; i < n + 1; i++)
  504.         {
  505.             acb_poly_get_coeff_acb(coeff, rdpoly, 0);
  506.             if (acb_rel_accuracy_bits(coeff) < high_prec)
  507.             {
  508.                 goto finish;
  509.             }
  510.             acb_poly_derivative(rdpoly, rdpoly, prec);
  511.         }
  512.  
  513.         flint_printf("%ld", N);
  514.         acb_poly_set(rdpoly, rpoly);
  515.         for (i = 0; i < n; i++)
  516.         {
  517.             acb_poly_get_coeff_acb(coeff, rdpoly, 0);
  518.             flint_printf("\t");
  519.             arf_printd(arb_midref(acb_realref(coeff)), digits);
  520.             acb_poly_derivative(rdpoly, rdpoly, prec);
  521.         }
  522.         flint_printf("\n");
  523.  
  524.         completed_steps++;
  525.     }
  526.  
  527. finish:
  528.  
  529.     acb_clear(logk);
  530.     acb_clear(coeff);
  531.     acb_poly_clear(tpoly);
  532.     acb_poly_clear(ypoly);
  533.     acb_poly_clear(rpoly);
  534.     acb_poly_clear(rdpoly);
  535.     acb_poly_clear(Npoly);
  536.  
  537.     for (k = 1; k <= Nmax * D; k++)
  538.     {
  539.         acb_poly_clear(bt + k);
  540.         acb_poly_clear(at + k);
  541.     }
  542.     flint_free(bt);
  543.     flint_free(at);
  544.  
  545.     for (i = 0; i < divs; i++)
  546.     {
  547.         acb_poly_clear(moll + i + 1);
  548.     }
  549.     flint_free(d);
  550.     flint_free(moll);
  551.     flint_free(primes);
  552.  
  553.     return completed_steps;
  554. }
  555.  
  556.  
  557. int main(int argc, char *argv[])
  558. {
  559.     const char *t_str, *y_str;
  560.     const char *Na_str, *Nb_str, *Nstep_str;
  561.     const char *m_str, *n_str, *d_str;
  562.     acb_t t, y;
  563.     slong Na, Nb, Nstep;
  564.     slong m, n, d, nderivs;
  565.     slong total_steps, completed_steps;
  566.     slong prec;
  567.     int result = EXIT_SUCCESS;
  568.     int usage_error = 0;
  569.  
  570.     acb_init(t);
  571.     acb_init(y);
  572.  
  573.     if (argc != 9)
  574.     {
  575.         usage_error = 1;
  576.         result = EXIT_FAILURE;
  577.         goto finish;
  578.     }
  579.  
  580.     t_str = argv[1];
  581.     y_str = argv[2];
  582.     Na_str = argv[3];
  583.     Nb_str = argv[4];
  584.     Nstep_str = argv[5];
  585.     m_str = argv[6];
  586.     n_str = argv[7];
  587.     d_str = argv[8];
  588.  
  589.     Na = atol(Na_str);
  590.     Nb = atol(Nb_str);
  591.     Nstep = atol(Nstep_str);
  592.     m = atol(m_str);
  593.     nderivs = atol(n_str);
  594.     d = atol(d_str);
  595.  
  596.     n = nderivs + 1;
  597.  
  598.     if (Na < 1 || Nb < 1 || Nstep < 1 || Na > Nb ||
  599.         m < 0 || m > 20 || n < 0 || d < 1)
  600.     {
  601.         usage_error = 1;
  602.         result = EXIT_FAILURE;
  603.         goto finish;
  604.     }
  605.  
  606.     prec = 16;
  607.     total_steps = 1 + (Nb - Na) / Nstep;
  608.     completed_steps = 0;
  609.     while (completed_steps < total_steps)
  610.     {
  611.         acb_zero(t);
  612.         acb_zero(y);
  613.         arb_set_str(acb_realref(t), t_str, prec);
  614.         arb_set_str(acb_realref(y), y_str, prec);
  615.         completed_steps += run(
  616.                 t, y, Na + Nstep * completed_steps, Nb, Nstep, m, n, d, prec);
  617.         prec *= 2;
  618.     }
  619.  
  620. finish:
  621.  
  622.     if (usage_error && result == EXIT_FAILURE)
  623.     {
  624.         flint_printf("Usage:\n");
  625.         flint_printf("%s t y Na Nb Nstep m n d\n\n", argv[0]);
  626.         flint_printf(
  627.     "This script computes a lower bound of abs(Aeff + Beff)/abs(Beff0)\n"
  628.     "for N between 'Na' and 'Nb' with steps of size 'Nstep'.\n"
  629.     "It uses an Euler mollification that includes m primes,\n"
  630.     "so that for example m=0 corresponds to no mollification\n"
  631.     "and m=3 corresponds to an Euler mollification that uses\n"
  632.     "the first three primes {2, 3, 5}.\n"
  633.     "Each row of output consists of N followed by the bound\n"
  634.     "and n derivatives with respect to N, so that for example\n"
  635.     "n=2 would print rows consisting of N, the bound,\n"
  636.     "the first derivative of the bound with respect to N,\n"
  637.     "and the second derivative of the bound with respect to N.\n"
  638.     "All output has d significant decimal digits of accuracy.\n");
  639.     }
  640.  
  641.     acb_clear(t);
  642.     acb_clear(y);
  643.  
  644.     flint_cleanup();
  645.     return result;
  646. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!