added statscounter code

3 files changed, 183 insertions, 0 deletions

diff --git a/vendor/bundle/ruby/3.4.0/gems/bigdecimal-4.1.2/sample/linear.rb b/vendor/bundle/ruby/3.4.0/gems/bigdecimal-4.1.2/sample/linear.rb
new file mode 100644
index 0000000..0cfac03
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/bigdecimal-4.1.2/sample/linear.rb
@@ -0,0 +1,110 @@
+#
+# linear.rb
+#
+# Solves linear equation system(A*x = b) by LU decomposition method.
+#  where  A is a coefficient matrix,x is an answer vector,b is a constant vector.
+#
+# USAGE:
+#   ruby linear.rb [input file solved]
+#
+
+# :stopdoc:
+require "bigdecimal"
+
+# Requires gem matrix
+require "matrix"
+
+class PrecisionSpecifiedValue
+  # NOTE:
+  #   Change following PREC if needed.
+
+  attr_reader :value
+  def initialize(value, prec)
+    @value = BigDecimal(value)
+    @prec = prec
+  end
+
+  def unwrap(value)
+    PrecisionSpecifiedValue === value ? value.value : value
+  end
+
+  def coerce(other)
+    [self.class.new(unwrap(other), @prec), self]
+  end
+
+  def abs
+    self.class.new(@value.abs, @prec)
+  end
+
+  def >(other)
+    @value > unwrap(other)
+  end
+
+  def <(other)
+    @value < unwrap(other)
+  end
+
+  def -(other)
+    self.class.new(@value.sub(unwrap(other), @prec), @prec)
+  end
+
+  def +(other)
+    self.class.new(@value.add(unwrap(other), @prec), @prec)
+  end
+
+  def *(other)
+    self.class.new(@value.mult(unwrap(other), @prec), @prec)
+  end
+
+  def quo(other)
+    self.class.new(@value.div(unwrap(other), @prec), @prec)
+  end
+end
+
+return if __FILE__ != $0
+
+def rd_order(na)
+  printf("Number of equations ?") if(na <= 0)
+  ARGF.gets().to_i
+end
+
+na = ARGV.size
+
+while (n=rd_order(na))>0
+  a = []
+  b = []
+  if na <= 0
+     # Read data from console.
+     printf("\nEnter coefficient matrix element A[i,j]\n")
+     for i in 0...n do
+       a << n.times.map do |j|
+         printf("A[%d,%d]? ",i,j); s = ARGF.gets
+         BigDecimal(s)
+       end
+       printf("Contatant vector element b[%d] ? ",i)
+       b << BigDecimal(ARGF.gets)
+     end
+  else
+    # Read data from specified file.
+    printf("Coefficient matrix and constant vector.\n")
+    for i in 0...n do
+      s = ARGF.gets
+      printf("%d) %s",i,s)
+      s = s.split
+      a << n.times.map {|j| BigDecimal(s[j]) }
+      b << BigDecimal(s[n])
+    end
+  end
+
+  prec = 100
+  matrix = Matrix[*a.map {|row| row.map {|v| PrecisionSpecifiedValue.new(v, prec) } }]
+  vector = b.map {|v| PrecisionSpecifiedValue.new(v, prec) }
+  x = matrix.lup.solve(vector).map(&:value)
+
+  printf("Answer(x[i] & (A*x-b)[i]) follows\n")
+  for i in 0...n do
+     printf("x[%d]=%s ",i,x[i].to_s)
+     diff = a[i].zip(x).sum {|aij, xj| aij*xj }.sub(b[i], 10)
+     printf(" & %s\n", diff.to_s)
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/bigdecimal-4.1.2/sample/nlsolve.rb b/vendor/bundle/ruby/3.4.0/gems/bigdecimal-4.1.2/sample/nlsolve.rb
new file mode 100644
index 0000000..7953653
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/bigdecimal-4.1.2/sample/nlsolve.rb
@@ -0,0 +1,57 @@
+#
+# nlsolve.rb
+# An example for solving nonlinear algebraic equation system.
+#
+
+require "bigdecimal"
+require_relative "linear"
+
+# 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
+
+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:)
diff --git a/vendor/bundle/ruby/3.4.0/gems/bigdecimal-4.1.2/sample/pi.rb b/vendor/bundle/ruby/3.4.0/gems/bigdecimal-4.1.2/sample/pi.rb
new file mode 100644
index 0000000..4b17ed0
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/bigdecimal-4.1.2/sample/pi.rb
@@ -0,0 +1,16 @@
+#
+# pi.rb
+#
+# Calculates 3.1415.... (the number of times that a circle's diameter
+# will fit around the circle)
+#
+
+require "bigdecimal"
+require "bigdecimal/math.rb"
+
+if ARGV.size == 1
+    print "PI("+ARGV[0]+"):\n"
+    p BigMath.PI(ARGV[0].to_i)
+else
+    print "TRY: ruby pi.rb 1000 \n"
+end