DouKaku?

module Main (main) where

import Data.List
import System.Environment
import System.IO
import CReal

default (CReal)

f :: CReal -> (Int, CReal)
f n = (ceiling n, exp $ pi * sqrt n)

g :: CReal -> Bool
g n = 0.0001 > h n

h :: CReal -> CReal
h n = if 0.5 > n' - n then n' - n else 1 - (n' - n)
  where n' = fromInteger $ ceiling n

main :: IO ()
main = do { args <- getArgs
          ; case args of
              []  -> loop 100 0
              n:_ -> loop (read n) 0
          }
loop n m 
 | n == m = return ()
 | True   = mapM_ (k . f) [(m*100)+1 .. (m+1)*100] >> loop n (m+1)

k :: (Int,CReal) -> IO ()
k n@(i,r) = if g r then hPutStrLn stdout (show n) >> hFlush stdout
	    else putStr (show i ++ "\r") >> hFlush stdout

function doukaku60(){ // 精度的に 58 が限界。
  with(Math) for(var r = [], f, n = 1; n < 200; n++)
    if(abs((f = exp(PI * sqrt(n))) - round(f)) < 1e-4) r.push([n, f]);
  return r;
}
// ↓ Apfloat を用いて書き換え //

function doukaku60_(){
  var F = Packages.org.apfloat.Apfloat;
  var M = Packages.org.apfloat.ApfloatMath;
  for(var r = [], p = 25, h = new F(0.5, p), f, n = 1; n < 200; n++){
    f = M.exp(M.pi(p).multiply(M.sqrt(new F(n, p))));
    if(M.abs(f.subtract(f.add(h).floor())).floatValue() < 1e-4) r.push([n, f.toString(true)]);
  }
  return r;
}
print(doukaku60_().join('\n'))

--- a.orig	Sat Sep 15 15:12:33 2007
+++ a.py	Sat Sep 15 15:12:50 2007
@@ -16,7 +16,7 @@
     for n in xrange(1, 200):
         x = decimal_exp(pi * Decimal(n).sqrt()) # result
         i = x.quantize(Decimal("1.0"), rounding=ROUND_HALF_UP) # nearest integer
-        if (x - i).quantize(Decimal("0.00001"), rounding=ROUND_DOWN) == 0:
+        if (x - i).quantize(Decimal("0.0001"), rounding=ROUND_DOWN) == 0:
             print n, x
 
 if __name__ == '__main__':

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <gmp.h>

mpf_t curr, next, bunsi, bunbo;

void mpf_exp(mpf_t x)
{
    unsigned int k;

    mpf_set_ui(curr, 1.0);
    mpf_set_ui(bunsi, 1.0);
    mpf_set_ui(bunbo, 1.0);

    for (k = 1; ;k++) {
        mpf_mul(bunsi, bunsi, x);
        mpf_mul_ui(bunbo, bunbo, k);
        mpf_div(next, bunsi, bunbo);
        mpf_add(next, next, curr);
        if (mpf_cmp(curr, next) == 0) {
            mpf_set(x, curr);
            return;
        }
        mpf_set(curr, next);
    }
}

int main(int argc, char *argv[])
{
    char buf[128], tmp[8];
    double d;
    int i;
    mpf_t x, pi;

    mpf_set_default_prec(128);

    mpf_init(curr);
    mpf_init(next);
    mpf_init(bunsi);
    mpf_init(bunbo);
    mpf_init(x);
    mpf_init(pi);

    mpf_set_str(pi, "3.1415926535897932384626433832795029", 10);

    for (i = 1; i < 200; i++) {
        mpf_set_ui(x, i);
        mpf_sqrt(x, x);
        mpf_mul(x, x, pi);
        mpf_exp(x);

        gmp_sprintf(buf, "%.*Ff", 6, x);
        d = atof(strncpy(tmp, strchr(buf, '.'), 7));
        if ((d < 0.0001) || ((1 - d) < 0.0001))
            printf("%d %s\n", i, buf);
    }

    mpf_clear(curr);
    mpf_clear(next);
    mpf_clear(bunsi);
    mpf_clear(bunbo);
    mpf_clear(x);
    mpf_clear(pi);

    return 0;
}

from decimal import *
import itertools

def divmod(x, y): # workaround for python2.5 decimal mod bug.
    div = x // y
    mod = x - div * y
    return div, mod

def decimal_exp(x):
    div, mod = divmod(x, Decimal("2.3025850929940456840179914546844"))
    curr, bunsi, bunbo = Decimal("1.0"), Decimal("1.0"), 1
    for k in itertools.count(1):
        bunsi *= mod
        bunbo *= k
        next = curr + bunsi / bunbo
        if curr == next:
            return (10 ** div) * curr
        curr = next

def main():
    pi = Decimal("3.141592653589793238462643383279")
    for n in xrange(1, 200):
        x = decimal_exp(pi * Decimal(n).sqrt()) # result
        i = x.quantize(Decimal("1.0"), rounding=ROUND_HALF_UP) # nearest integer
        if (x - i).quantize(Decimal("0.0001"), rounding=ROUND_DOWN) == 0:
            print n, x

if __name__ == '__main__':
    try:
        import psyco
    except ImportError:
        pass
    else:
        psyco.full()
    main()

import java.math.BigDecimal;
import java.math.MathContext;

public class Sample {
    private static final double EPS = 0.000001;
    private static final double EPS2 = 1e-25;
    private static final BigDecimal TWO = new BigDecimal(2);
    private static final BigDecimal PI = new BigDecimal
        ("3.141592653589793238462643383279");
    private static final BigDecimal LN10 = new BigDecimal
        ("2.3025850929940456840179914546844");
    public static BigDecimal exp(BigDecimal x) {
        BigDecimal[] dr = x.divideAndRemainder(LN10);
        int n = dr[0].intValue();
        x = dr[1];
        int i = 1;
        BigDecimal b = new BigDecimal(i++);
        BigDecimal c = x.scaleByPowerOfTen(n);;
        BigDecimal a = new BigDecimal(1.0).scaleByPowerOfTen(n);
        BigDecimal d;
        while ((d = c.divide(b, MathContext.DECIMAL128)).doubleValue() > EPS) {
            a = a.add(d);
            b = b.multiply(new BigDecimal(i++));
            c = c.multiply(x);
        }
        return a;
    }

    public static BigDecimal sqrt(BigDecimal a) {
        BigDecimal x = new BigDecimal(Math.sqrt(a.doubleValue()));
        BigDecimal delta;
        do {
            delta = (x.multiply(x).subtract(a)).divide(TWO.multiply(x), 
                                                       MathContext.DECIMAL128);
            x = x.subtract(delta);
        } while (delta.abs().doubleValue() > EPS2);
        return x;
    }

    public static void main(String[] args) {
        for (int i = 1; i < 200; i++) {
            BigDecimal er = exp(PI.multiply(sqrt(new BigDecimal(i))));
            BigDecimal rer = new BigDecimal(er.toBigInteger());
            double a = er.subtract(rer).doubleValue();
            if (a < 0.0001 || a > 0.9999) {
                System.out.printf("%d: %f%n", i, er);
            }
        }
    }
}