正木です。

[ruby-math:00461] での Real.atan(x) は x が 1 に近いときには実用にならないので
次のように、積分を使った方法を考えてみました。
Simpson 法で、刻み幅を半分づつにしてできた数列の、収斂を早くしたものを
次のように定義します。ついでに微分の方も書いてあります。

----
class Sequence
  def var(a)
    x=self
    Sequence.new([],x,a){"|n,x,a| (x[n+1]*a-x[n])/(a-1) "}
  end
  def var2(a,b)
    Sequence.new([self],a,b){"|n,a,b| self[n-1].var(a*b**(n-1)) "}
  end

  def delite_nil
    return self if self[0]
    self.Shift.delite_nil
  end

  def var2s(a,b)
    Sequence.new([self.delite_nil],a,b){"|n,a,b| self[n-1].var(a*b**(n-1)).del
ite_nil "}
  end
end

#以上は収斂を早くするためのものです。

class Function
  def derivative
    f=self
    Function.new({},f){"|x,f|  
      s0=Sequence.new([],x,f){\"|n,x,f| d=2**-(n+16);(f[x+d]-f[x-d])/2/d rescu
e nil \"}
      s=s0.var2s(4,4)
      seq=Sequence.new([],s){\" |n,s| s[n][0] \"}
      err=Sequence.new([],seq){\" |n,seq| (seq[n+1]-seq[n]).abs \"}
      RealComplex.new(seq,err*2)
      "}
  end

  def Simpson0(a,b,n=0)
    return 0 if a==b
    f=self
    return (f[a]+4*f[(a+b)/2]+f[b])*(b-a)/6 if n==0
    Simpson0(a,(a+b)/2,n-1)+Simpson0((a+b)/2,b,n-1)
  end

  def SimpsonS(a,b)
    f=self
    Sequence.new([],f,a,b){" |n,f,a,b| f.Simpson0(a,b,n) "}
  end

  def Simpson(*x)
    n=x.size
    return nil if n < 2
    a,b=x[0,2]
    return Simpson(a,b)+Simpson(*x[1..-1]) if n > 2
    return 0 if a==b
    s=SimpsonS(a,b).var2(16,4)
    seq=Sequence.new([],s){" |n,s| s[n][0] "}
    err=Sequence.new([],seq){" |n,seq| (seq[n+1]-seq[n]).abs "}
    RealComplex.new(seq,err*2)
  end
end
----

ただし正則な関数のみを対象にしています。

class Real は名前が不適当なので、 Sequence2 位に名前を変えて
実数を表すときは
Real=Sequence2
実数または複素数(Complex の Cauchy 列)を表すときは
RealComplex=Sequence2
を使うことにしました。

複素積分のときは

Inverse.Simpson(1,Complex(0,1),-1,Complex(0,-1),1) =>Complex(0,2*pi)

のように経路を指定できます。

atan は
Datan=Function.new{"|x| 1/(1+x*x) "}

def Real.atan(x)
  Datan.Simpson(0,x)
end

でも良いのですが少しでも早くするために、それ以前の計算結果を利用する
事にしました。
----
Atan=Function.new({0=>0}){"|x|
  (y=hash.keys.min{|a,b| (a-x).abs<=>(b-x).abs}
  self[y]+Datan.Simpson(y,x)) "}


def Real.atan(x)
  Atan[x]
end
----
順番に計算していくときにはかなり早くなります。

ついでに指数関数と対数関数も書いておきます。
-----
Exp=Function.new({0=>1}){"|x|
  y=hash.keys.min{|a,b| (a-x).abs<=>(b-x).abs}
  z=x-y
  self[z]=(z.abs > 1/2)? self[z/2]**2 :  RealComplex.new(ExpS[z],\"S\")
  self[y]*self[z] "}


Log=Function.new({1=>0}){"|x|
  (y=hash.keys.min{|a,b| (a-x).abs<=>(b-x).abs}
  self[y]+Inverse.Simpson(y,x)) "}
-----

これらの関数は引数が Complex のときは Complex の Cauchy 列を返します。
(上の Log は主値を与えるとは限りません。)


現在議論になっている int/int ですが、割り切れないときは Rational が
当然だと思うので

class Fixnum,Bignum
  def /(y)
    return div(y) if y.kind_of?(Integer) && self%y==0
    x=rdiv(y)
    (x.kind_of?(Rational) && x.denominator==1)? x.numerator : x
  end
end

のようにしています。

5/2 = 2
は数学的にはどう考えても不自然です。
これは、仮に自然数の class があったとして、演算を class 内で閉じさせるために
2-5=3
とするのと同じ程度に無理があります。