20. Handling big, multiline data using the cross-cellset cursor

According to the PI formula devised by J.Marchin:

The n^th term is:

To compute pi to L decimal places, we need to compute the formula to at least the nth term. The value of n is:

The brackets [] in the formula are all Gaussian functions, which are also called rounding functions and which are evaluated as the largest integers that are equal to or less than their actual values.

Use the above formula to compute pi to 10000 decimal places and estimate it takes how long (unit: millisecond) to finish the computation.

Tip:

It is hard to realize the 10000 decimal digits of precision using any type of data. In this case we can use a big integer to handle the computation. To do this we need to prepare a big integer computation script called, say, BigIntegerCalc.splx:

In this script, parameter calc inputs operators +, -, * or /; parameters a and b are sequences of big integers or ordinary integers:

To help understand the script, A3, A7, A11 and A15 record comments, which are explanations and headed by slash / and won’t be taken care of. A1 calls different subprograms to execute the computation. A sequence parameter is used for the invocation by filling its members in the starting cell of the subprogram. During the computation every 10 digits are treated as one “number” and then considered as a new digit value to generate a 10-digit, radix of 10¹⁰ number. The computing process is similar to that for ordinary four arithmetic operations. In order to distinguish jobs of the subprograms, we add comment before each subprogram.

Take the multiplication as an example. The computation starts from the lowest digit “number”. To do this B12 and C12 reverse the order of “number” digits. Variable c is used to record the carry of handling each digit of “number” – compute the product of the current “number” digit and then use integer division to compute the carry while making remainder the radix result. After the loop is finished on a digit, check whether there is a carry and, if there is, add a higher place value to the result.

Specifically, when dealing with big integer computation with the division operation, the divisor must not exceed the radix, and the result should retain only the integer part by discarding the remainder.

Expected results:

SPL code:

Use call() function to invoke the script BigIntegerCalc.splx provided in the Tip part to assist the computation. Between the n^th term and the (n+1) ^th term in the formula, the first part of the latter is 25 times greater than that of the former while there is 239*239 times difference between their second halves. So the divisors in computing the first term should be also adjusted to 25 and 239*239.

C1 defines enough number of “number” digit to store the result – where each “number” is a 10-digit integer – and replaces the real number computation with the computation of a big integer with specified number of digits. B2 and B3 store parameters used by the formula in each round of loop. A4 executes the specified number of loops and after that we can view the result sequence stored by “number” digits. A11 concatenates the final result. Note that if a “number” consists of less than 10 digits, corresponding number of 0s must be added before the existing number.

In handling this task, as repeated calls of *BigIntegerCalc.splx *are needed, we can register the script as a regular function. Change A3’s code to >register(“bigintcalc”,“BigIntegerCalc.splx”), for example, we should also use the registered function when calling the function later. In that case B5’s code will be >B2=bigintcalc(B2,25), and the result is the same after execution. A registered function is valid across all scripts.

22. The simple use of graph plotting
Contents and Exercise Data