Adding nilakantha pi approximation benchmark

benchmarks/float/nilakantha.bril

@@ -0,0 +1,68 @@
+@main {
+  v37: float = const 3;
+  PI: float = id v37;
+  v38: float = const 2;
+  n: float = id v38;
+  v39: float = const 1;
+  sign: float = id v39;
+  v40: float = id PI;
+  v41: float = id n;
+  v42: float = id sign;
+  call @calculatePI v40 v41 v42;
+  v43: int = const 0;
+}
+@calculatePI(PI: float, n: float, sign: float) {
+  v1: float = const 0;
+  i: float = id v1;
+.for.cond.0:
+  v2: float = id i;
+  v3: float = const 1000000;
+  v4: bool = fle v2 v3;
+  br v4 .for.body.0 .for.end.0;
+.for.body.0:
+  v5: float = id n;
+  v6: float = const 1;
+  v7: float = fadd v5 v6;
+  nPlusOne: float = id v7;
+  v8: float = id n;
+  v9: float = const 2;
+  v10: float = fadd v8 v9;
+  nPlusTwo: float = id v10;
+  v11: float = id nPlusOne;
+  v12: float = id nPlusTwo;
+  v13: float = fmul v11 v12;
+  nPlusOne_Times_nPlusTwo: float = id v13;
+  v14: float = id n;
+  v15: float = id nPlusOne_Times_nPlusTwo;
+  v16: float = fmul v14 v15;
+  denom: float = id v16;
+  v17: float = const 4;
+  v18: float = id denom;
+  v19: float = fdiv v17 v18;
+  frac: float = id v19;
+  v20: float = id sign;
+  v21: float = id frac;
+  v22: float = fmul v20 v21;
+  rhs: float = id v22;
+  v23: float = id PI;
+  v24: float = id rhs;
+  v25: float = fadd v23 v24;
+  PI: float = id v25;
+  v26: float = const 0;
+  v27: float = id sign;
+  v28: float = fsub v26 v27;
+  sign: float = id v28;
+  v29: float = id n;
+  v30: float = const 2;
+  v31: float = fadd v29 v30;
+  n: float = id v31;
+  v32: float = id i;
+  v33: float = const 1;
+  v34: float = fadd v32 v33;
+  i: float = id v34;
+  jmp .for.cond.0;
+.for.end.0:
+  v35: float = id PI;
+  print v35;
+  v36: int = const 0;
+}

benchmarks/float/nilakantha.out

@@ -0,0 +1,13 @@
+cfg for main: {'label_0': []}
+
+
+
+
+cfg for calculatePI: {'label_0': ['for.cond.0'], 'for.cond.0': ['for.body.0', 'for.end.0'], 'for.body.0': ['for.cond.0'], 'for.end.0': []}
+
+
+Block label_0 falls through to ['for.cond.0']
+Block for.cond.0 branches to ['for.body.0', 'for.end.0']
+Block for.body.0 jumps to ['for.cond.0']
+
+

benchmarks/float/nilakantha.prof

@@ -0,0 +1,2 @@
+3.14159265358978690
+total_dyn_inst: 45000065

docs/tools/bench.md

@@ -40,6 +40,7 @@ The current benchmarks are:
 * `max-subarray`: solution to the classic Maximum Subarray problem.
 * `mod_inv`: Calculates the [modular inverse][modinv] of `n` under to a prime modulus p.
 * `newton`: Calculate the square root of 99,999 using the [newton method][newton]
+* `nilakantha`: Calculate the value of pi using the [nilakantha infinite series][nilakantha]
 * `norm`: Calculate the [euclidean norm][euclidean] of a vector 
 * `n_root`: Calculate nth root of a float using newton's method.
 * `orders`: Compute the order ord(u) for each u in a cyclic group [<Zn,+>][cgroup] of integers modulo *n* under the group operation + (modulo *n*). Set the second argument *is_lcm* to true if you would like to compute the orders using the lowest common multiple and otherwise the program will use the greatest common divisor.
@@ -100,3 +101,4 @@ Credit for several of these benchmarks goes to Alexa VanHattum and Gregory Yaune
 [qsort]: https://en.wikipedia.org/wiki/Quicksort#Lomuto_partition_scheme
 [modinv]: https://en.wikipedia.org/wiki/Modular_multiplicative_inverse
 [totient]: https://en.wikipedia.org/wiki/Euler's_totient_function
+[nilakantha]: https://en.wikipedia.org/wiki/List_of_formulae_involving_%CF%80