[ruby-dev:4823] Re: compare to NaN (Re: Re: call for finite/isnan testers)

けいじゅ＠日本ラショナルソフトウェアです.

休出までして会社に来ているのにと思いつつ....

今日頻繁に登場しておられる方々はみなそうなのかな??

In [ruby-dev :4821 ] the message: "[ruby-dev:4821] Re: compare to NaN
(Re: Re: call for finite/isnan testers) ", on Feb/07 17:59(JST) EGUCHI
Osamu writes:

>えぐち＠エスアンドイー です。

>keiju> 確かにその意見もあるかも知れないですね. 状態であると考えるわけですね.
>
>無限／非数との一致は検査したいと思いますが、
>式の中に無限が登場するのは、いまはあまり良い考えでは
>ないと思っています。

そうですね... ちょっと難しいですよね. それに標準のRubyのモデルとしては
ちょっとって気もします. やるなら, mathn.rbモジュールのように標準とは別
の動作として実装した方が良いかも.

>keiju> >IEEE 準拠と言う見方から、Float::INFINITY でよいように思えてきました。
>keiju> >
>
>具体的には番人に使うケースぐらいしか思い当たらないので、
>それならば、
>
>     →	Float::Max
>	Float::Min
>
>で良いと思います。

そういえば, 番人の例も出ていましたね. 

そういうものも, 標準には添付されていなくて, 上記のようなものが定義され
ている別モジュールでいいんじゃないかしら.

>非数の値を得たい、言う考え自体は私は放棄しました。

色々なパターンの無限があるので, そこが難しいですよね.

>Ruby の Float は名前の通り、計算機の中で扱われる
>浮動小数点数のクラスなので、数学の実数は Real として
>実装する(実装できるようにする)のが良いと思います。

>有理数の全てを仮数／指数の対で表そうとすると、
>この循環小数問題は避けがたいですね。
>
>私は、固定精度を想定したのですが、
>なるほど、可変精度を実装するわけですね、

固定も可変も実装上あまり変わりませんので(^^;;;

あと, Bigfloat(prec) の用にまず固定精度のBigfloatクラスを生成してその
中では固定精度で計算するというアプローチもありますね. こちらの方が,
Floatなどの既存Floatの考えに馴染むかも知れません.

# coerceの対応が頭いたそうだけど(^^;;;

>この場合は、演算結果の精度のがいくつになるかの規則が問題ですね。
>
>例えば
>  加限算は、絶対値の大きな項の精度になる
>  乗除算は、精度の小さな項の精度になる
>などです。

全部, 精度の小さな項の精度になる

になっています. 加減算でも, 片方の精度を越えた部分に関しては, 計算して
も無意味だと思うのですが?

>四則で既に問題なので、Math 相当の関数全てについて値の精度に
>配慮するのは、かなり厄介ですね。

うーん... 超越関数の精度を自動的に調整するのは難しいですよね. 

sin(val, prec) 見たいにユーザにまかせるのかなって考えていました.

>keiju> # 実装はしても, テストが中途半端なままほっといてんですが(^^;;;
>ありのままな状態で良いので、是非拝見したいです。

あらま(*^^*

大部いじっていないので, もしかしたら本当にデバッグ中かも知れませんので,
動作しないかも知れません.

あと, Bigfloatを

  仮数 * 10 ^ 指数

で表現するか,

  仮数 * 256 ^ 指数

で表現するか, はたまた他にするかが問題だと思いますが, たぶん10を用いて
いたと思います.

# それに当然ですが, rubyで書いてあります.

-- ここから.

require "e2mmap"

def Bigfloat(n, prep = Bigfloat.DEFAULT_PREC)
  Bigfloat.new(n)
end

# dummy definition
class Rational<Numeric;end
class Complex<Numeric;end

class Bigfloat < Numeric

  extend Exception2MessageMapper
  def_e2message(TypeError, "wrong argument type %s (expected %s)")

  # 有効精度. Bigfloat::10進数での桁数
  class << self
    attr :DEFAULT_PREC, TRUE
  end
  @DEFAULT_PREC = 32

  def Bigfloat.count_prec_of_float
    i = 0
    a = 1
    b = 1.0/10.0
    begin
      o = a
      a += b
      b /= 10.0
      i += 1
    end until(a == o)
    i
  end
  FLOAT_PREC = Bigfloat.count_prec_of_float

  # expが有効なのは整数の時だけ.
  def initialize(num, prec = Bigfloat.DEFAULT_PREC, exp = 0)
    @prec = prec

    case num
    when Integer
      @exp = exp
      @prov = num
      while (d, m = @prov.divmod(10); m == 0)
	@exp += 1
	@prov = d
      end
    when Rational
      Bigfloat.new(num.numerator, prec) / Bigfloat.new(num.denominator, prec)
    when Float
      prov, exp2 = Math.frexp(num)
      exp10 = 0
      while Integer(prov) != prov
	exp10 -= 1
	prov *= 10
      end
      if exp2 < 0
	while (n = prov/2; Integer(n) == n or exp2 == 0)
	  prov = n
	  exp2 -= 1
	end
	while exp2 != 0
	  prov *= 5
	  exp10 -= 1
	  exp2 -= 1
	end
      else
	while exp2 != 0
	  prov *= 2
	  exp2 += 1
	end
      end

    when String
      # [+|-]99999.?99999[e[+|-]99999]
      num =~ /([-+]?[0-9]*)\.?([0-9]*)(e([+-]?[0-9]+))?$/
      int = $1
      dec = $2
      @prov = Integer(int + dec)
      if $4
	@exp = Integer($4) - dec.size
      else
	@exp = -dec.size
      end
      while (d, m = @prov.divmod(10); m == 0)
	@exp += 1
	@prov = d
      end
    when Bigfloat
      @exp, @prov = num.instance_eval("[@exp, @prov]")
    else
      Bigfloat.fail(TypeError, 
		    num.type,
		    "Inetger or Float or String or Bigfloat or Rational")
    end
  end

  attr :exp
  attr :prov
  attr :prec

  def +(other)
    case other
    when Bigfloat
      #break
    when Integer, Rational
      self + Bigfloat(other)
    when Float
      Float(self) + other
    when Complex
      Complex(self) + other
    else
      x, y = other.coerce(self)
      x + y
    end

    n_prec = [@prec, other.prec].min

    s_p = @prov
    o_p = other.prov

    n_exp = [@exp, other.exp].min
    if @exp < other.exp
      o_p *= 10 ** (other.exp - @exp)
    elsif @exp > other.exp
      s_p *= 10 ** (@exp - other.exp)
    end

    n_p = s_p + o_p
    Bigfloat.new(n_p, n_prec, n_exp)
  end

  def -(other)
    case other
    when Bigfloat
      #break
    when Integer, Rational
      self - Bigfloat(other)
    when Float
      Float(self) - other
    when Complex
      Complex(self) - other
    else
      x, y = other.coerce(self)
      x - y
    end

    n_prec = [@prec, other.prec].min

    s_p = @prov
    o_p = other.prov

    n_exp = [@exp, other.exp].min
    if @exp < other.exp
      o_p *= 10 ** (other.exp - @exp)
    elsif @exp > other.exp
      s_p *= 10 ** (@exp - other.exp)
    end

    n_p = s_p - o_p
    Bigfloat.new(n_p, n_prec, n_exp)
  end

  def *(other)
    case other
    when Bigfloat
      #break
    when Integer, Rational
      self * Bigfloat(other)
    when Float
      Float(self) * other
    when Complex
      Complex(self) * other
    else
      x, y = other.coerce(self)
      x - y
    end

    n_prec = [@prec, other.prec].min

    s_p = @prov
    o_p = other.prov

    n_exp = @exp + other.exp
    n_p = s_p * o_p
    Bigfloat.new(n_p, n_prec, n_exp)
  end

  def /(other)
    case other
    when Bigfloat
      #break
    when Integer, Rational
      self / Bigfloat(other)
    when Float
      Float(self) / other
    when Complex
      Complex(self) / other
    else
      x, y = other.coerce(self)
      x / y
    end

    n_prec = [@prec, other.prec].min

    s_p = @prov
    o_p = other.prov

    s_exp = @exp
    s_len = Integer(Math.log(s_p) + 1)
    o_len = Integer(Math.log(o_p) + 1)
    if s_len < n_prec + o_len
      s_p *= 10 ** (n_prec + o_len - s_len)
      s_exp -= n_prec + o_len - s_len
    end

    n_exp = s_exp - other.exp
    n_p = s_p / o_p

    Bigfloat.new(n_p, n_prec, n_exp)
  end

  def coerce(other)
    case other
    when Integer, Rational
      return Bigfloat(other, self.prec), self
    when Float
      return other, self.to_f
    when Complex
      return other, Complex(self)
    else
      super
    end
  end

  def to_f
    @prov * 10**@exp
  end

  def to_s
    s = @prov.to_s
    if @exp >= 0
      s.concat "0" * @exp
      s.concat ".0"
    else
      if s.size + @exp >= 0
	s[s.size + @exp, 0] = "."
      else
	s.sub!(/(-?)([0-9]*)/){
	  $1+"0." + "0" * -(@exp + s.size) + $2
	}
      end
    end
    s
  end
end
  


__
................................石塚 圭樹＠日本ラショナルソフトェア...
----------------------------------->> e-mail: [e-mail] <<---