bigdecimal 3.2.3 → 4.1.1

data/sample/nlsolve.rb

@@ -1,40 +1,57 @@
-#!/usr/local/bin/ruby
-# frozen_string_literal: false
-
 #
 # nlsolve.rb
 # An example for solving nonlinear algebraic equation system.
 #
 
 require "bigdecimal"
-require "bigdecimal/newton"
-include Newton
+require_relative "linear"
 
-class Function # :nodoc: all
-  def initialize()
-    @zero = BigDecimal("0.0")
-    @one  = BigDecimal("1.0")
-    @two  = BigDecimal("2.0")
-    @ten  = BigDecimal("10.0")
-    @eps  = BigDecimal("1.0e-16")
-  end
-  def zero;@zero;end
-  def one ;@one ;end
-  def two ;@two ;end
-  def ten ;@ten ;end
-  def eps ;@eps ;end
-  def values(x) # <= defines functions solved
-    f = []
-    f1 = x[0]*x[0] + x[1]*x[1] - @two # f1 = x**2 + y**2 - 2 => 0
-    f2 = x[0] - x[1]                  # f2 = x    - y        => 0
-    f <<= f1
-    f <<= f2
-    f
+# Requires gem matrix
+require "matrix"
+
+# :stopdoc:
+
+def func((x, y)) # defines functions solved
+  [
+    x**2 + y**2 - 2,
+    (x - 1)**2 + (y + 1)**2 - 3
+  ]
+end
+
+def jacobian(x, f, delta, prec)
+  dim = x.size
+  dim.times.map do |i|
+    xplus = Array.new(dim) {|j| x[i] + (j == i ? delta : 0) }
+    xminus = Array.new(dim) {|j| x[i] - (j == i ? delta : 0) }
+    yplus = f.call(xplus)
+    yminus = f.call(xminus)
+    yplus.zip(yminus).map {|p, m| (p - m).div(2 * delta, prec) }
+  end.transpose
+end
+
+def nlsolve(initial_x, prec:, max_iteration: 100, &f)
+  initial_x = initial_x.map {|v| BigDecimal(v) }
+  x = initial_x
+  delta = BigDecimal(0.01)
+  calc_prec = prec + 10
+  max_iteration.times do |iteration|
+    # Newton step
+    jacobian = jacobian(x, f, delta, calc_prec)
+    matrix = Matrix[*jacobian.map {|row| row.map {|v| PrecisionSpecifiedValue.new(v, calc_prec) } }]
+    y = f.call(x)
+    vector = y.map {|v| PrecisionSpecifiedValue.new(v, calc_prec) }
+    dx = matrix.lup.solve(vector).map(&:value)
+    x_prev = x
+    x = x.zip(dx).map {|xi, di| xi.sub(di, prec) }
+    movement = x_prev.zip(x).map {|xn, xi| (xn - xi).abs }.max
+    delta = [movement, delta].min.mult(1, 10)
+    break if movement.zero? || movement.exponent < -prec
   end
+  x
 end
 
-f = BigDecimal.limit(100)
-f = Function.new
-x = [f.zero,f.zero]      # Initial values
-n = nlsolve(f,x)
-p x
+initial_value = [1, 1]
+ans = nlsolve(initial_value, prec: 100) {|x| func(x) }
+diff = func(ans).map {|v| v.mult(1, 10) }
+p(ans:)
+p(diff:)

data/sample/pi.rb

@@ -1,21 +1,16 @@
-#!/usr/local/bin/ruby
-# frozen_string_literal: false
-
 #
 # pi.rb
 #
 # Calculates 3.1415.... (the number of times that a circle's diameter
-# will fit around the circle) using J. Machin's formula.
+# will fit around the circle)
 #
 
 require "bigdecimal"
 require "bigdecimal/math.rb"
 
-include BigMath
-
 if ARGV.size == 1
     print "PI("+ARGV[0]+"):\n"
-    p PI(ARGV[0].to_i)
+    p BigMath.PI(ARGV[0].to_i)
 else
     print "TRY: ruby pi.rb 1000 \n"
 end