[ruby-dev:5408] Re: Bigfloat [compare to NaN]

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

In [ruby-dev :5397 ] the message: "[ruby-dev:5397] Re: Bigfloat
[compare to NaN] ", on Feb/20 19:28(JST) GOTO Kentaro writes:

>ごとけんです

>>>ちなみに現行では Integer.induced_from() は Integer() と同じく
>>>変換にしてますが，これと必ずインスタンスを生成するのとくらべると，
>>>どっちがよいですか??
>>ん? いっている意味がよく分かりません. もうちょっと詳しくお願いします
>>(__;;;
>
>つまり，Integer.induced_from(a).id == Integer(a).id
>がなりたつかどうかです．現行では，Integer.induced_from(a)
>は a.kind_of?(Integer) のとき a をそのまま返し，
>そうでなければ新しくインスタンスを生成して返します．
>これは Integer() の挙動を採用しているためです．
>
>例:
>
>  a = 1000000000000000000000000000
>  p a.id == Integer(a).id #=> true
>  p a.id == Integer.induced_from(a).id #=> true
>
>これと，必ずインスタンスを生成するのとくらべると，
>どっちがよいですか??

これは.

>>ちょっとだけ言わしてもらえば, 数関係クラスのインスタンスにはnewはふさ
>>わしくないって気がしています. 数っていうものは(仮想的に)既に存在してい
>>てそれを使えるように引っ張ってくるというイメージです.

ということからも, インスタンスを生成しなくて良いと思っています.

>なるほど．それなら，Bigfloat がデフォルトの精度を持たないとして
>Bigfloat.new をユーザーから隠蔽できるような仕組みが必要かも
>知れませんね．

そこまでこだわることもないと今は思っていますが, 今は実現不可能ではない
ですね. 

できれば, 全ての数値関連クラスではnewがない方が良いかと思います.

>>>::class は文法的に無理でしょう．::CLASS かな．
>下の案に基本的に賛成してもらえたので，後学のために
>お聞きしたいのですが，どうやるんですか??

なにも. ふつうです.

class Foo
  def Foo.class
    p 1
  end
end

Foo.class

これは, ちょっと前のバージョンからできるようになっています. 

>>>    Bigfloat
>>>    Bigfloat() # 精度が不定のクラス Bigfloat !< Precision
>>
>>ここと.
>>
>>>    Bigfloat(prec) # クラス．
>>>    Bigfloat[num]
>>>    Bigfloat()[num]  # 精度が不定というエラーにすべきか?
>>
>>ここ.
>>デフォルト精度があっても良いかも知れませんね. 大体の人は1つの精度で使
>>うと思うし.
>>
>># 精度不定のクラスが意味があるなら別ですが.
>
>たぶん，インターフェイスの実装は前に僕が Anumber として
>示したデレーゲーションに既存のクラス生成を抑止したような
>ものになると思いますので， x.kind_of?(Bigfloat) を
>チェックするために不定も意味があると思います．

実装に関しては, まだ早いかと思わないでもないですが.

1. 個々のインスタンスが精度を持っているが無駄じゃないか?
2. この場合デレゲーションをしなくても良いのではないか?

という感じがあります. 数値関係のインスタンスは量が多くなる傾向があるこ
とと, 精度をそんなに変えて使うかな? って思いがあります. ということで, 
クラスに精度の情報を持たせた方がいいかな? って思っています.

あまり考えずにサブクラスを作るのは私は反対しているのですが, ここでは, 
デレゲーションを使わないで済むなら使わなくても. って気分があります.

ということで私の実装案をこのメイルの末尾につけます.

ごとけんさんの案とそんなに違いないんですが.

1. Bigfloatはデフォルトの精度を持っている
2. Bigfloat(prec)はBigfloatのサブクラスとする.
   Bigfloat(prec).nameすると変な文字が出るのも可哀想なので定数に設定し
   ています. # Bigfloat.to_s, nameを再定義した方がかっこういいかな...
3. 精度の情報はクラスのインスタンス変数に持たせている

具体的に実装してあるのは, 以下のメソッドですが実際に動作します(実質的
に+だけですけど). coerceも精度の高い方にちゃんと合わせます(^^;;

class Bigfloat < Numeric
  def Bigfloat.class(prec)
  def Bigfloat.PREC
  def prec
  def Bigfloat.[](*param)
  def +(other)
  def coerce(other)
end
def Bigfloat(prep)

デフォルトの精度を持っては駄目となるとちょっと変わってきますが, 実装で
きないこともないでしょう.

あと, デフォルトの精度を持つとしてもユーザが指定できた方がいいかなと思
いますので, その時もちょっと実装が変わるかなと...

# 見ていただくと理解していただけると信じているのですが, ごとけんさんの
# よりもエレガントかと(^^;;;

そうそう, えぐちさんバグを見つけました. initializeのなかのRationalの対
応部分です. 

# 大元になった私のbigfloatがバグっていたせいですが(^^;;;

>>私はこの案に基本的に賛成です. 

>>1つあるとしたら, パラメータ付きはみな -zationをつけるとなっていると, 
>>区別がつきやすくていいなと思うぐらいですが.
>>
>>  Bigfloat                    デフォルト精度のBigfloat
>>  Bigfloatization(perc)       精度付きのBigfloat
>>  Matrixization(klass, n, m)  パラメトライズドMatrix
>
>Matrixization という言葉がいいのかどうかは英語人の
>数学者じゃないので分かりませんが，有理化や複素化が
>整域や単位的環に対して自然に定義できるのにくらべ
># 複素化は初耳でしたが単位的環なら出来るみたいですね．
>行列というのはは線形作用素の表現ですから行列化と
>聞くとなんか違うもの(例えばリー環の表現とか)を想起します．

うーん. そうですか...

>>あと, グローバルなインターフェイスの変更(追加)も含んでいるので, 松本氏
>>の意見なんかも聞きたいなと思ったりして.
>同感です．そんな分けで長く引用してみました．

実際にテストしていると

  Bigfloat(100)[10] 

結構書きづらいなと. やはりデフォルトの精度はあった方が良いなぁって気が
しました. あと, 

  Bigfloat(100)

は, この場合クラスを返すんですが, 他の場合と比べると, 数値を返すような
気にさせてしまいますね...

やはり

>>  Bigfloat                    デフォルト精度のBigfloat
>>  Bigfloatization(perc)       精度付きのBigfloat

ってなっていた方が良いかなあ... って気もします.

ここから. Bigfloat(prec)案
--
#
# bigfloat.rb:
#
require "e2mmap"

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

def inf?(n)
  n == n * 1.1
end
def nan?(n)
  n != n
end

class Bigfloat < Numeric
  extend Exception2MessageMapper
  def_e2message(TypeError, "wrong argument type %s (expected %s)")

  BASE = 10 # XXX base of @exp
  @PREC = 32 # XXX default prec

  CLASSES = {}
  CLASSES[@PREC] = self

  def Bigfloat.class(prec)
    raise "err!!" if !prec.kind_of?(Integer) or prec <= 0
    return CLASSES[prec] if CLASSES[prec]
    CLASSES[prec] = klass = Class.new(Bigfloat)
    const_set("P_#{prec}", klass)
    klass.instance_eval{@PREC = prec}
    klass
  end

  def Bigfloat.PREC
    @PREC
  end

  def prec
    type.PREC
  end

  def Bigfloat.[](*param)
    self.new(*param)
  end

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

  attr :sign # plus(and zero):+1, minus:-1, +Inf:+Inf, -Inf:-Inf, NaN:NaN
  attr :prov # PREC'digits prov.
  attr :exp  # base BASE of exp.

  def normalize!
    if @prov == 0 then
      @sign, @prov, @exp = +1, 0, 0
      return
    end
    @sign, @prov = +1, @sign * @prov
    @sign, @prov = -@sign, -@prov if @prov < 0
    while @prov < BASE ** prec
      @prov *= BASE
      @exp -= 1
    end
    while @prov >= BASE ** (prec + 1)
      @prov /= BASE
      @exp += 1
    end
  end

  def initialize(num, exp = 0)
    @sign, @prov, @exp = +1, 0, 0
    case num
    when Integer
      @sign, @prov, @exp = +1, num, exp
    when Rational
      num = type.new(num.numerator) / type.new(num.denominator)
      @sign, @prov, @exp = num.instance_eval("[@sign, @prov, @exp ]")
    when Float
      if inf?(num) or nan?(num) then
	@sign, @prov, @exp = num, 0, 0
	return
      end
      @sign = +1;
      @sign, num = -1, -num if num < 0
      exp10 = Integer(Math.log10(num))
      @exp = exp10 - FLOAT_PREC
      @prov = Integer(num / (BASE ** @exp))
    when String
      case num 
      when /^\s*([+]?Inf)$/ 
	@sign = +1.0 / 0.0
	return
      when /^\s*(-Inf)$/ 
	@sign = -1.0 / 0.0
	return
      when /^\s*NaN$/ 
	@sign = 1.0 % 0.0
	return
      when /^\s*([-+]?[0-9]*)\.?([0-9]*)([eE]([+-]?[0-9]+))?$/
	@prov = $1.to_i * (10 ** $2.size) 
	@sign, @prov = -1, -@prov if @prov < 0 
	@prov += $2.to_i
	@exp = -$2.size
	@exp += $4.to_i if $4
      end
    when Bigfloat
       @sign, @prov, @exp = num.instance_eval("[@sign, @prov, @exp ]")
    else
      Bigfloat.fail(TypeError, 
		    num.type,
		    "Inetger, Float, String, Bigfloat or Rational")
    end

    normalize!
  end

  def inspect
    "Bigfloat(#{to_a})"
  end

  def to_s
    return @sign.inspect if inf?(@sign) or nan?(@sign)
    s = ""
    s += "-" if @sign < 0
    n, d = @prov.divmod(10 ** prec)
    s += n.inspect
    s += "."
    s += format("%0*d", prec, d.inspect)
#    return s if @prov == 0 or (@exp + prec) == 0 
    s += "E"
    s += (@exp + prec).inspect
  end

  def abs
    sign, prov, exp = instance_eval("[@sign, @prov, @exp]")
    type.new(sign, prov, exp)
  end

  def to_i
    Integer(@sign * @prov * 10 ** @exp)
  end

  def to_f
    @sign * @prov * 10.0 ** @exp
  end

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

    left  = @sign * @prov
    right = other.sign * other.prov
    if @exp > other.exp then
      left *= BASE ** (@exp - other.exp)
      exp = other.exp
    else
      right *= BASE ** (other.exp - @exp)
      exp = @exp
    end
    type.new(left + right, exp)
  end

  def coerce(other)
    case other
    when Bigfloat
      if prec > other.prec
	return type[other], self
      else
	return other, other.type[self]
      end
    when Integer, Rational, Float
      return type(other), self
    when Complex
      return other, Complex(self)
    else
      super
    end
  end
end

def Bigfloat(prep)
  Bigfloat.class(prep)
end

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