Implement exp, log, power and ** in ruby

[tompng]

Writing in Ruby is easier than C.
This will bring both maintainability and performance (because implementing faster algorithm is easy).
Eliminates problem like #340 in the long run. (already fixed)
Use case of BigMath.log BigMath.exp are high-precision calculation (if not, using Float is enough).
Cost of multiplications/divisions are dominant. There is not much need to implement it in C.

Fixes #83, #345, #352
Fixes power, log and exp part of #340 (already fixed)

Benchmark

Makes BigMath.log(10, prec) which is the bottleneck of BigDecimal#** faster

scenario	BigMath.log(10, 1000)	BigMath.log(10, 30)
Master	0.644637s	0.000409s
This pull request	0.044400s	0.000072s
With #343	0.007985s	0.000071s
With #323	0.004952s	0.000061s

Makes BigMath.exp(large_x) faster (#82)

scenario	BigMath.exp(10000, 100)	BigMath.exp(100000, 100)
Master	0.011882s	0.366918s
This pull request	0.000192s	0.000211s

[tompng]

This part is tested as a spec in test_bigdecimal.rb
assert_positive_infinite(BigDecimal(3) ** (2**100))

[tompng]

y**10 makes relative error 10 times larger. (y*(1+e))**10 = y**10 * (1+10*e+...)
In the last step of this method cnt.times{y = y**10}, error will be 10**cnt times larger.
Calculation of exp(x) needs cnt more digits.

[tompng]

This is what the original log implementation in C was doing.
Converts x: 0.1..10 → (x-1)/(x+1): -0.818..0.818 to make Taylor series converge. (but converge of 0.818**n was very slow. This is the slowness reason of log(10))

[tompng]

To minimize the computation cost, we need to minimize this:

sqrt_cost * sqrt_steps + mult_cost * taylor_steps

Taylor steps can be approximated as:

taylor_steps = const1 * prec / (-log10(|x-1| / 2**sqrt_steps))

Assuming sqrt_cost and mult_cost are ideally the same order, (note that currently it is not)
We need to minimize something like this:

sqrt_steps + const1 * prec / (log10(|x-1|) + log10(2) * sqrt_step)

sqrt_steps that minimizes the cost should be

sqrt_steps = const2 * sqrt(prec) + log10(|x-1|) / log10(2)
           ≒ const2 * sqrt(prec) + 3 * x_minus_one_exponent