Chapter 7

Section 7.5, "Estimating the main term"

./Hv N v flag

bounds
sum_{1<=s<=Y: (s,v)=1} h_v(Y/s)/s    and
sum_{1<=s<=Y: (s,v)=1} (h_v(Y/s)-(zeta(2) sigma(v)/phi(v)))/s

for all 2<=Y<=N.

Here v=1 or v=2, as usual.
If flag=1 (default value: 0),
the program outputs values of the sums for many 1<=Y<=N.

Examples:
./Hv 1000000 1 
Output:
For 2<=Y<=1000000, v=1,
	sum_{1<=s<=Y: (s,v)=1} h_v(Y/s)/s <= -0.0495 + 1.43398402/Y
and sum_{1<=s<=Y: (s,v)=1} (h_v(Y/s)-(zeta(2) sigma(v)/phi(v)))/s is at most
	  - (zeta(2) sigma(v)/v) log y - 0.998982 (1 - y^(-3/2))
	  
./Hv 1500000 2 
Output:
For 2<=Y<=1500000, v=2,
     sum_{1<=s<=Y: (s,v)=1} h_v(Y/s)/s <= 1.31742 + 3.143498953/Y
and sum_{1<=s<=Y: (s,v)=1} (h_v(Y/s)-(zeta(2) sigma(v)/phi(v)))/s is at most
      - (zeta(2) sigma(v)/v) log y - 1.817075 (1 - y^(-4/3))

Section 7.7, "Remainder terms"

./zetashortinteg

computes the integrals

1/(2 pi i) int |P_{19}(s+1/2) P_{19}(s+1)| |zeta(s+1/2) zeta(s+1)/s^2| ds
   on a straight path from -8i - 1/4 to -8i - 1/4

1/(2 pi i) int |P_{11}(s+1/2) P_{11}(s+1)| |zeta(s+1/2) zeta(s+1/4)/s^2| ds
   on straight paths from -200i to -0.005 and then to 200i

The output also describes the command-line options.

The output reads:

Compute integrals using subdivision and Gauss-Legendre quadrature.
Usage: quadrature [-prec p] [-tol eps] [-twice]

-prec p    - precision in bits (default p = 333)
-tol eps   - approximate absolute error goal (default 2^-p)
-twice     - run twice (to see overhead of computing nodes)


Computing I = 1/(2 pi i) int |P_{19}(s+1/2) P_{19}(s+1)| |zeta(s+1/2) zeta(s+1)/s^2| ds
	(straight path from -8i - 1/4 to -8i - 1/4)
cpu/wall(s): 1.082 1.082
I = [1.062703031892010378576890606769076043668358020046322816102350032299515897077273077624311145400744 +/- 6.00e-97]

Computing I = 1/(2 pi i) int |P_{11}(s+1/2) P_{11}(s+1)| |zeta(s+1/2) zeta(s+1/4)/s^2| ds
	(straight paths from -200i to -0.005 to 200i)
cpu/wall(s): 7.17 7.171
I = [0.685046394902281984659578323592463337890433665540571159101615349752037769796658341961383398117849 +/- 4.12e-97]

----------------------------------------------------------------

./zetalonginteg m c1 c2 sigma k0 k1

computes
I = 1/(2 pi i) int |P_m(s+c1) P_m(s+c2)| |zeta(s+c1) zeta(s+c2)/s^2| ds

on a path consisting of the vertical segment from sigma - k1 i to sigma - k0 i
                                         and from sigma + k0 i to sigma + k0 i

(Of course, that is just twice the integral on the first segment.)

Here m, k0 and k1 are non-negative integers, and c1, c2 and sigma are real.

Here P_m(s) = \prod_{p\leq m} (1-p^{-s})

Default values:
m=19, c1=1.0, c2=0.5, sigma=-0.25, k0=8, k1=40000

--------------------------
We need to run:

./zetalonginteg 11 0.25 0.5 0.0 200 40000
./zetalonginteg 19 1.0  0.5 -0.25 8 40000

The output is long - it is meant to keep track of the computation's progress.
(It is an overnight computation.) The result is given by the last line.
In the two cases above, the last line is:

[0.0092693764454452320933 +/- 1.92e-6]
[0.073690118617378175259 +/- 3.43e-7]

respectively.

