ChebyRuby 0.0.1.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5c0f9d3747a36682aa90b2b738c563d5e744f7b6
+  data.tar.gz: 66f91daacd639572b3ee61bc5cf90664c5d45702
+SHA512:
+  metadata.gz: 35b08a1ba0dee7629ee11c83ca1d461d93d32b31761ee92e4a9b83e9490fa2a6282f873d25a9deb866aed7e3ee5a030aa24a14cad79ed4b66014d46a1e6d782e
+  data.tar.gz: c2cb87ab8481d85bb2f8c085f1d9c6182954188e58eb82d7aa5a2f5572c598a2d9ed943276ed85fa24b682947d53dfcd21e9c84c693e173df6e0a0131c139896

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc 'Run tests'
+task default: :test

data/bin/chebyruby

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'chebyruby'
+puts 'Welcome!'

data/lib/chebyruby.rb

@@ -0,0 +1,8 @@
+class ChebyRuby
+  
+end
+
+require 'chebyruby/romberg_integration'
+require 'chebyruby/simpsons_integration'
+require 'chebyruby/integration'
+require 'chebyruby/univariate_function'

data/lib/chebyruby/differentiation.rb

@@ -0,0 +1,5 @@
+module ChebyRuby::Differentiation
+  def slope(func, a, b)
+    (func.value(b) - func.value(a))/(b-a)
+  end
+end

data/lib/chebyruby/finite_differencing.rb

@@ -0,0 +1,38 @@
+require_relative 'differentiation'
+class ChebyRuby::FiniteDifferencing
+  include Differentiation
+
+  attr_accessor :func
+
+  def initialize(func)
+    @func = func
+  end
+
+  def forward(x, h = 0.1, order = 1)
+    (0..order).map do |i|
+      (-1)**i * FiniteDifferencing::binomial(order, i) *
+      func.value(x + (order - i) * h)
+    end.inject(:+) / (h**order).to_f
+  end
+
+  def backward(x, h = 0.1, order = 1)
+    (0..order).map do |i|
+      (-1)**i * FiniteDifferencing::binomial(order, i) *
+      func.value(x - i * h)
+    end.inject(:+) / (h**order).to_f
+  end
+
+  def central(x, h = 0.1, order = 1)
+    (0..order).map do |i|
+      (-1)**i * FiniteDifferencing::binomial(order, i) *
+      func.value(x + (order/2.0 - i) * h)
+    end.inject(:+) / (h**order).to_f
+  end
+
+  private
+  def FiniteDifferencing.binomial(n, k)
+    (1..k).map do |i|
+      (n + 1 - i)/i.to_f
+    end.inject(:*) || 1
+  end
+end

data/lib/chebyruby/integration.rb

@@ -0,0 +1,23 @@
+module ChebyRuby::Integration
+  def trap_integrate(func, a, b, iterations = 32)
+    h = (b - a)/iterations.to_f
+    mesh = (a..b).step(h).to_a[1...-1]
+    summand = func.value(a) +
+        2 * (mesh.map(&func.func).inject(:+) || 0) + func.value(b)
+    (b - a)/(2.0 * iterations) * summand
+  end
+
+  def accuracy_comparison(a, b, method = 'Trapezoid', cm = 'Trapezoid')
+    case method
+    when 'Trapezoid' then (integrate(a, b) - trap_integrate(func, a, b)).abs
+    when 'Romberg' then (integrate(a, b) - Romberg.sintegrate(func, a, b)).abs
+    when 'Simpsons' then (integrate(a, b) - Simpsons.sintegrate(func, a, b)).abs
+    end
+  end
+
+  class << self
+    def sintegrate(func, a, b)
+      self.new(func).integrate(a, b)
+    end
+  end
+end

data/lib/chebyruby/romberg_integration.rb

@@ -0,0 +1,29 @@
+require_relative 'integration'
+
+class ChebyRuby::RombergIntegration
+  include ChebyRuby::Integration
+
+  attr_accessor :func
+
+  def initialize(func)
+    @func = func
+  end
+
+  def integrate(a, b, iterations = 8)
+    t = Array.new(iterations)
+    iterations.times do |i|
+      t[i] = []
+      t[i][0] = trap_integrate(func, a, b, 2 ** i).to_f
+    end
+    (1...t.length).each do |i|
+      (1..i).each do |k|
+        t[i][k] = ((4 ** k) * t[i][k-1]  - t[i-1][k-1])/(4**k - 1).to_f
+      end
+    end
+    t.last.last
+  end
+
+  def accuracy_comparison(a, b, method = 'Trapezoid')
+    super.accuracy_comparison(a, b, method, 'RombergIntegration')
+  end
+end

data/lib/chebyruby/simpsons_integration.rb

@@ -0,0 +1,25 @@
+require_relative 'integration'
+
+class ChebyRuby::SimpsonsIntegration
+  include ChebyRuby::Integration
+
+  attr_accessor :func
+
+  def initialize(func)
+    @func = func
+  end
+
+  def integrate(a, b, iterations = 32)
+    h = (b - a) / iterations.to_f
+    mesh = (a..b).step(h).to_a[1...-1]
+    even = mesh.each_with_index.select{|i, j| j.odd?}.map(&:first)
+    odd = mesh.each_with_index.select{|i, j| j.even?}.map(&:first)
+    summand = func.value(a) + func.value(b) +
+        2 * even.map(&func.func).inject(:+) + 4 * odd.map(&func.func).inject(:+)
+    (h / 3.0) * summand
+  end
+
+  def accuracy_comparison(a, b, method = 'Trapezoid')
+    super.accuracy_comparison(a, b, method, 'RombergIntegration')
+  end
+end

data/lib/chebyruby/univariate_function.rb

@@ -0,0 +1,21 @@
+# This is the class for a univariate function.
+#
+# @attr func [Lambda] the univariate function.
+class ChebyRuby::UnivariateFunction
+  attr_accessor :func
+
+  # The constructor for the class UnivariateFunction.
+  #
+  # @param [Lambda] func which represents the function.
+  def initialize(&func)
+    @func = func
+  end
+
+  # This gets the value of the function at a specified value.
+  #
+  # @param [Numeric] x the value at which the function is evaluated.
+  # @return the value of the function at x.
+  def value(x)
+    func.call(x.to_f)
+  end
+end

data/test/test_function.rb

@@ -0,0 +1,35 @@
+require 'minitest/autorun'
+require 'chebyruby'
+
+class TestFunction < Minitest::Test
+  def setup
+    @sin = ChebyRuby::UnivariateFunction.new {|x| Math.sin(x)}
+    @exp = ChebyRuby::UnivariateFunction.new {|x| Math.exp(x)}
+    @pol = ChebyRuby::UnivariateFunction.new {|x| x**2 + 2*x + 1}
+  end
+
+  def test_functions_return_floats
+    assert_kind_of Float, @sin.value(rand)
+    assert_kind_of Float, @exp.value(rand)
+    assert_kind_of Float, @pol.value(rand)
+  end
+
+  def test_functions_return_floats_with_integer_parameters
+    assert_kind_of Float, @sin.value(1)
+    assert_kind_of Float, @exp.value(0)
+    assert_kind_of Float, @pol.value(0)
+  end
+
+  def test_functions_return_expected_values
+    assert_in_delta 0, @sin.value(0), 1e-8
+    assert_in_delta 0, @sin.value(Math::PI), 1e-8
+    assert_in_delta 1, @exp.value(0), 1e-8
+    assert_in_delta Math::E, @exp.value(1), 1e-8
+    z = rand
+    assert_in_delta (Math::E ** z), @exp.value(z), 1e-8
+    assert_in_delta 1, @pol.value(0), 1e-8
+    assert_in_delta 4, @pol.value(1), 1e-8
+    f = -> (x) {x**2 + 2*x + 1}
+    assert_in_delta f.call(z), @pol.value(z), 1e-8
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: ChebyRuby
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre
+platform: ruby
+authors:
+- Eli Sadoff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-15 00:00:00.000000000 Z
+dependencies: []
+description: A gem for numerical analysis and scientific computing.
+email: snood1205@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- bin/chebyruby
+- lib/chebyruby.rb
+- lib/chebyruby/differentiation.rb
+- lib/chebyruby/finite_differencing.rb
+- lib/chebyruby/integration.rb
+- lib/chebyruby/romberg_integration.rb
+- lib/chebyruby/simpsons_integration.rb
+- lib/chebyruby/univariate_function.rb
+- test/test_function.rb
+homepage: https://github.com/snood1205/chebyruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A gem for numerical analysis and scientific computing.This is a pre-release
+  so beware.
+test_files:
+- test/test_function.rb