Riemann Zeta Function

zeta.c

#include <stdio.h>
#include <math.h>

double lim(double (*f)(double), double p)
{
    double a(int n)
    {
        if (isinf(p)) {
            return pow(2, n);
        }
        else if (p == 0) {
            return 1 / pow(2, n);
        }
        return n;
    }
    double L;
    double x;
    int n;
    for (n = 1;; n++) {
        x = a(n);
        L = f(a(n + 1));
        if (fabs(f(x) - L) == 0) {
            return L;
        }
    }
}

double sum(double (*f)(double), int m, double n)
{
    if (isfinite(n)) {
        if (m > n) {
            return 0;
        }
        return f(n) + sum(f, m, n - 1);
    }
    else {
        double g(double n)
        {
            return sum(f, m, n);
        }
        return lim(g, INFINITY);
    }
}

int factorial(int n)
{
    if (n == 0) {
        return 1;
    }
    return n * factorial(n - 1);
}

double exp(double x)
{
    double f(double n)
    {
        return pow(x, n) / factorial(n);
    }
    return sum(f, 0, INFINITY);
}

double D(double (*f)(double), double a)
{
    double g(double h)
    {
        return (f(a + h) - f(a)) / h;
    }
    return lim(g, 0);
}

double zeta(double s)
{
    double f(double n)
    {
        return pow(n, -s);
    }
    return sum(f, 1, INFINITY);
}

int main(void)
{
    printf("%g\n", zeta(0));
    return 0;
}

zeta.js

function lim(f, p) {
  var e = Number.MIN_VALUE;
  var a;
  switch (p) {
    case 0:
      a = function(n) {
        return 1 / Math.pow(2, n);
      };
    case Infinity:
      a = function(n) {
        return Math.pow(2, n);
      };
  }
  for (var n = 1;; n++) {
    var L = f(a(n + 1));
    var x = a(n);
    if (Math.abs(f(x) - L) < e) {
      return L;
    }
  }
}

function D(f) {
  return function(a) {
    return lim(function(h) { return (f(a + h) - f(a)) / h }, 0);
  };
}

function sum(f, m, n) {
  if (isFinite(n)) {
    if (m > n) {
      return 0;
    }
    return f(n) + sum(f, m, n - 1);
  }
  else {
    return lim(function(n) { return sum(f, m, n) }, Infinity);
  }
}

function product(f, m, n) {
  if (isFinite(n)) {
    if (m > n) {
      return 1;
    }
    return f(n) * product(f, m, n - 1);
  }
  else {
    return lim(function(n) { return product(f, m, n) }, Infinity);
  }
}

function factorial(n) {
  if (n == 0) {
    return 1;
  }
  return n * factorial(n - 1);
}

PI = 1 / (2 * Math.sqrt(2) / 9801 * sum(function(k) {
  return factorial(4 * k) * (1103 + 26390 * k) /
         (Math.pow(factorial(k), 4) * Math.pow(396, 4 * k));
}, 0, Infinity));

function exp(x) {
  return sum(function(n) { return Math.pow(x, n) / factorial(n) }, 0, Infinity);
}

function B(n) {
  return (n == 0 ? 1 : 0) - sum(function(k) {
    return C(n, k) * B(k) / (n - k + 1);
  }, 0, n - 1);
}

function C(n, k) {
  if (k == 0) {
    return 1;
  }
  if (n == 0) {
    return 0;
  }
  return C(n - 1, k - 1) + C(n - 1, k);
}

function zeta(s) {
  return sum(function(n) { return Math.pow(n, -s) }, 1, Infinity);
}