01

About

Exercise 3

次のような計算をするメソッドを作って動かす。

• a. 2 つの実数を与え、和を返す (差、商、積も)。気づいたことがあれば述べよ。
• b. 「%」という演算子は剰余 (remainder) を求める演算である。上と同様にやってみよ。
• c. 数値 x を与え、逆数 $1 \over x$ を出力する (分子は「1.0」とした方がいいかもしれない)。
• d. 数値 x を与え、その 8 乗を返す。ついでに 6 乗、7 乗もやるとなおよい。 なお、Ruby のべき乗演算「**」は使わず、なおかつ乗除算が少ないことが望ましい。
• e. 円錐の底面の半径と高さを与え、体積を返す。
• f. 実数 x を与え、x の平方根を出力する。さまざまな値で計算し、精度を検討せよ。11
• g. その他、自分が面白いと思う計算を行うメソッドを作って動かせ。

Exercise 6

その他、コンピュータの実数計算が数学と違っている具体例を示すようなプログラムを好きなように探究してみてください。

Program, execution and description

Exercise 3

コードは以下のようになります。（演習 6 で作成した Sym class を事前に定義する必要があります。）

# a. 2 つの実数を与え、和を返す (差、商、積も)。
def add(x, y) x + y end
def sub(x, y) x - y end
def mul(x, y) x * y end
def div(x, y) x / y end

# b. 剰余 (remainder) を求める演算
def dec(x, y) x % y end

# c. 数値 x を与え、逆数 $1 \over x$ を出力する
def inv(x) 1.0 / x end

# d. 数値 x を与え、その 8 乗を返す
def oct(x) x ** 2 ** 2 ** 2 end

# e. 円錐の底面の半径と高さを与え、体積を返す。
def cone(r, h) r ** 2 * Math::PI * h / 3.0 end

# f. 実数 x を与え、x の平方根
def sqrt(x) x ** 0.5 end

# g その他、自分が面白いと思う計算を行うメソッドを作って動かせ。
x, y = (0..1).map do Sym.new end

# a ~ f 課題の記号計算
a0 = add(x, y)
a1 = sub(x, y)
a2 = mul(x, y)
a3 = div(x, y)
b = dec(x, y)
d = oct(x)
e = cone(x, y)
f = sqrt(x)

puts " i | j | i+j | i-j | i*j | i/j | i%j | i^8 | core | sqrt "
puts ":- |:- | :-- | :-- | :-- | :-- | :-- | :-- | :--- | :---"
(1..5).each do |i|
        (1..5).each do |j|
                x <=> i
                y <=> j
                puts "#{i} | #{j} | #{a0} | #{a1} | #{a2} | #{a3} | #{b} | #{d} | #{e} | #{f}"
        end
end

Exercise 6

Sym は代数計算をするために各演算を override している class です。 数学のように変数から式をつくり、後から数字を代入できるようになります。

仕組みとしてはまず、Sym class の演算子を override をすることで、 演算毎におこりうる処理を lambda 関数として継承させつつ、 @_ で新しく Sym object を生成して return させます。 つぎに Sym object に x <=> 1.0 などで数値を代入したあと to_f が呼ばれたときに、再帰的に全ての処理を実行できます。

class Sym
        def initialize(init = 0.0)
                @v = init
                @_ = ->fun{Sym.new(fun)}
        end
        def to_f() (@v.is_a? Numeric) ? @v: @v[] end
        def to_i() self.to_f.to_i end
        def to_s() self.to_f.to_s end
        def +(_) @_[->{self.to_f + _.to_f}] end
        def -(_) @_[->{self.to_f - _.to_f}] end
        def *(_) @_[->{self.to_f * _.to_f}] end
        def /(_) @_[->{self.to_f / _.to_f}] end
        def %(_) @_[->{self.to_f % _.to_f}] end
        def **(_) @_[->{self.to_f ** _.to_f}] end
        def ==(_) self.to_f == _.to_f end
        def <=>(_) @v = _.to_f end
end

x, y = (0..1).map do Sym.new end
z = (x ** 2 + y ** 2)

x <=> 3
y <=> 4
p "expect #{z} to be 25.0"

x <=> 7
y <=> 24
p "expect #{z} to be 625.0"

About Task

Exercise 3 - g

実行結果は以下のようになります。 （演習 3 - c の逆数についてですが、演算の左側のオペランドが Sym objectではなく 1.0 なので 同様にテストすることが出来ませんでしたが、_1 = Sym(1.0) を用いると同様に実行できます。）

Consideration

a + b - c * d / e のような演算を図にすると以下のようになります。 ab = a + b に対して、 a, b を parent、ab を childとしたとき、 parentでする処理を各演算子 override で child に継承させることで、 最後の childが to_f を実行すると、全ての親の to_fが再帰的に実行させます。

ab    = a + b             # add(a, b)
cd    = c * d             # mul(cd)
cde   = cd / e            # div(cd, e)
      = c * d / e         # div(mul(c, d), e) ∵ cd
abcde = ab - cde          # sub(ab, cde)
      = a + b - c * d / e # sub(add(a, b), div(mul(c, d), e)) ∵ ab, cde