bibun 0.0.0

data/lib/bibun/step_tracker.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Bibun
+  class DifferentialEquationSystem
+    # A single object of this class tracks positions relative to the step and the independent variable both for
+    # walking forward and logging each step. Separated from the DifferentialStepper to avoid excessive cluttering.
+    class StepTracker
+      # @return [Numeric] Stores the step size defined for the integration, which may change through it for
+      #   adaptive methods.
+      attr_accessor :step_size
+      # @return [Numeric] The timespan set for a full integration.
+      attr_accessor :duration
+      # @return [Numeric] The independent variable interval for logging entries.
+      attr_accessor :logging_interval
+      # @return [Numeric] The number of steps to record a log entry when the logging interval differs from the step
+      #   size.
+      attr_reader :steps_to_log
+
+      # @!group This attributes pertain keeping track of the logging and walking steps.
+      # @return [Numeric] For adaptive methods, stores the future value of the step size since logging still requires
+      # the previous value.
+      attr_accessor :next_step_size
+      # @return [Integer] The ordinal (number) of the current step of the integration.
+      attr_reader :current_step
+      # @return [Numeric] The initial value for the independent variable.
+      attr_reader :starting_point
+      # @return [Numeric] The current position of the independent value during the integration run.
+      attr_reader :current_point
+      # @return [Numeric] The previous position of the independent value during the integration run.
+      attr_reader :previous_point
+      # @return [Numeric] The current or last value of the independent variable in the log.
+      attr_reader :current_logging_point
+      # @return [Numeric] The previous value of the independent variable recorded in the log.
+      attr_reader :previous_logging_point
+      # @return [Integer] The current row number of the log (differs for dense output).
+      attr_reader :current_logging_step
+      # @return [Numeric] For dense output, last logged point from the previous walking step.
+      attr_accessor :last_mark
+      # @return [Boolean] Quick way to established whether dense output has been set or not.
+      attr_reader :dense_output
+      alias dense_output? dense_output
+      # @!endgroup
+
+      # Sets up all values of the tracker for the integration run.
+      def prepare(independent_start, adaptive, single_step:)
+        @current_step = 0
+        @current_logging_step = 0
+        @starting_point = independent_start
+        @current_point = independent_start
+        @current_logging_point = independent_start
+        @last_mark = 0
+
+        if single_step
+          raise ArgumentError, 'Missing step size' if step_size.nil?
+        elsif step_size.nil? || duration.nil?
+          raise ArgumentError, 'Missing duration or step_size'
+        end
+        define_steps_to_log(adaptive)
+        @dense_output = !logging_interval.nil? && adaptive
+      end
+
+      # Sets how many steps are necessary for logging when the method is non adaptive.
+      # @param adaptive [Boolean]
+      def define_steps_to_log(adaptive)
+        return unless steps_to_log.nil? || adaptive
+
+        l = logging_interval.nil? ? 0 : logging_interval
+        @steps_to_log = if l < step_size
+                          1
+                        else
+                          l.fdiv(step_size).to_i
+                        end
+      end
+
+      # Quick calculation of the total number of steps (only known a priori for non adaptive methods).
+      # @return [Integer]
+      def total_steps = (duration / step_size.to_f).to_i
+
+      # Calculates the end of the integration.
+      # @return [Numeric]
+      def ending_point = starting_point + duration
+
+      # For dense output, this is the fraction between the current point and the previous point a which an entry
+      # for logging sits. This is necessary for the polynomial interpolation.
+      # @param point [Integer] The independent variable value at which the theta is calculated.
+      # @return [Float]
+      def theta(point)
+        (point - previous_point) / (current_point - previous_point).to_f
+      end
+
+      # @!group This methods change the value of the walking and logging steps.
+      # Quick method for advancing a step. Made a method expecting future changes which may demand other actions.
+      def walk_forward
+        @current_step += 1
+        @previous_point = current_point
+        @current_point += step_size
+        @step_size = next_step_size unless next_step_size.nil?
+      end
+
+      # Method for the pointer to the current logging step and point to advance.
+      def log_forward(logging_mark)
+        @current_logging_step += 1
+        @current_logging_point = logging_mark
+      end
+
+      # @return [Integer] The number of marks to log for a given step walked.
+      def num_marks
+        ((current_point - last_mark) / logging_interval).to_i
+      end
+
+      # @return [Array<Numeric>] The marks (logging points) where values have to be logged.
+      def marks_to_advance
+        leaps = []
+        if dense_output?
+          (1..num_marks).each { |i| leaps << last_mark + i * logging_interval }
+        elsif (current_step % steps_to_log).zero?
+          leaps << current_point
+        end
+        leaps
+      end
+      # @!endgroup
+
+      # json converter routine for the serializer.
+      def to_json(*_args)
+        { 'step_size' => step_size, 'duration' => duration, 'logging_interval' => logging_interval }.to_json
+      end
+    end
+  end
+end

data/lib/bibun/symbol_group.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+module Bibun
+  class DifferentialEquationSystem
+    # This class emcompasses all methods relative to writing and reading parameter and variable values, separated here
+    # to avoid cluttering the outer class. Most of the time the DifferentialEquationSystem class has shortcuts
+    # to access its methods.
+    class SymbolGroup
+      # Hash with all the variables of the DES
+      attr_accessor :variables
+      # Hash with all the parameters of the DES
+      attr_accessor :parameters
+      # Reference to the outer DifferentialEquationSystem object.
+      attr_accessor :system
+
+      def initialize(sys)
+        @variables = {}
+        @parameters = {}
+        @system = sys
+      end
+
+      # Quick way to access the independent variable regardless of the name set to it.
+      # @return [DifferentialSystemVariable]
+      def ind_var = variables.values.find(&:independent?)
+      # Quick accessor to the dependent variables.
+      # @return [Hash{String => DifferentialSystemVariable}]
+      def rate_variables = variables.reject { |_, v| v.independent? }
+      # Quick access to the SubDifferentialEquation objects.
+      # @return [Hash{String => SubDifferentialEquation}]
+      def rate_equations = rate_variables.transform_values(&:rate_equation)
+      # Quick access to the variable values.
+      # @return [Hash{String => Numeric}]
+      def vars_values = variables.transform_values(&:value)
+
+      # This gives a hash with the string symbols of the variables  as the keys rather than the names.
+      # For example: {'t' => 0, 'T' => 25 } instead of { 'time' => 0, 'temperature' => 25 }.
+      # This is useful to provide to the calculators.
+      # @return [Hash{String => Numeric}]
+      def vars_values_hash(with_step_change: false)
+        variables.map { |_, v| [v.symbol, v.value + (with_step_change ? v.step_change : 0)] }.to_h
+      end
+
+      # @return [Hash{String => Array<Numeric>}] Terms with their changes. Useful for debugging.
+      def terms_changes_hash
+        terms_array.map { |t| [t.id, [t.step_change, t.cumulative_change]] }.to_h
+      end
+
+      # Cleans the last addition of the step change for all terms. Necessary for adaptive step size when it is
+      # rejected and recalculated.
+      def undo_term_changes
+        terms_array.each do |t|
+          t.cumulative_change -= t.step_change
+          t.step_change = 0
+        end
+      end
+
+      # This gives a hash with the string symbols of the parameters  as the keys rather than the names.
+      # For example: {'g' => 0, 'ρ' => 25 } instead of { 'gravity' => 9.806, 'density' => 1000 }.
+      # This is useful to provide to the calculators.
+      # @return [Hash{String => Numeric}]
+      def pars_values_hash = parameters.values.map { |p| [p.symbol, p.value] }.to_h
+      # Merge of +vars_values_hash+ and +pars_values_hash+
+      # @return [Hash{String => Numeric}]
+      def syms_values_hash = pars_values_hash.merge(vars_values_hash)
+      # Like {#vars_values_hash} but for the buffer values. Useful for the evaluation of the ks
+      # @return [Hash{String => Numeric}]
+      def vars_buffers_hash = variables.map { |_, v| [v.symbol, v.buffer_value] }.to_h
+      # merge of +vars_buffers_hash+ and +pars_buffer_hash+
+      # @return [Hash{String => Numeric}]
+      def syms_buffers_hash = pars_values_hash.merge(vars_buffers_hash)
+      # Check if the des has any rate additive terms declared.
+      def terms? = rate_variables.any(&:terms?)
+      # Merge the variables and parameters hash.
+      def symbols = variables.merge(parameters)
+      # Check if any variable has tolerances set in for adaptive methods.
+      def tolerances_provided? = rate_variables.any? { |_,v| v.atol.nonzero? || v.rtol.nonzero? }
+      # Returns only the variables with declared tolerances.
+      def vars_with_tols = rate_variables.select { |_, v| v.atol.nonzero? || v.rtol.nonzero? }
+
+      # Returns an array with the rate additive terms to avoid having to traverse variable and equations each time.
+      # @return [Array<DifferentialTerm>]
+      def terms_array
+        rate_variables.values.each_with_object([]) { |v, ar| ar << v.terms.values unless v.terms.empty? }.flatten
+      end
+
+      # Method to assign values to variables and parameters in a single operation.
+      # Also registers those in the log buffer for logging purposes.
+      # @param values_hash [Hash{String => Numeric}] The hash with the variables and parameter names
+      #   and the target values.
+      def assign_values(values_hash)
+        values_hash.each do |k, v|
+          symbols[k].value = v
+          if symbols[k].instance_of?(DifferentialSystemVariable)
+            symbols[k].buffer_value = v
+            system.logger.buffer[k] = v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bibun/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Bibun
+  # Semver constant
+  VERSION = '0.0.0'
+end

data/lib/bibun.rb

@@ -0,0 +1,22 @@
+require 'keisan'
+require 'formatador'
+require 'csv'
+require 'json'
+require 'tomlib'
+
+require_relative 'bibun/version'
+require_relative 'bibun/differential_equation_system'
+require_relative 'bibun/differential_system_symbol'
+require_relative 'bibun/differential_system_variable'
+require_relative 'bibun/differential_system_parameter'
+require_relative 'bibun/differential_stepper'
+require_relative 'bibun/differential_butcher_table'
+require_relative 'bibun/differential_equation_logger'
+require_relative 'bibun/step_tracker'
+require_relative 'bibun/symbol_group'
+require_relative 'bibun/log_entry'
+
+# Standard container for the whole library which consists of a single module.
+module Bibun
+
+end

data/lib/data/butcher_tables.toml

@@ -0,0 +1,44 @@
+[midpoint]
+type = 'Runge-Kuta'
+adaptive = false
+order = 2
+stages = 2
+nodes = [0, '1/2']
+weights = [0, 1]
+matrix_coefficients = [['1/2']]
+[rk4]
+type = 'Runge-Kutta'
+adaptive = false
+order = 4
+stages = 4
+nodes = [0, '1/2', '1/2', 1]
+weights = ['1/6', '1/3', '1/3', '1/6']
+matrix_coefficients = [['1/2'], [0, '1/2'], [0, 0, 1]]
+[dopr45]
+type = 'Runge-Kutta'
+adaptive = true
+order = 5
+stages = 7
+nodes = [0, '1/5', '3/10', '4/5', '8/9', 1, 1]
+weights = ['35/384', 0, '500/1113', '125/192', '-2187/6784', '11/84', 0]
+alternate_weights = ['5179/57600', 0, '7571/16695', '393/640', '-92097/339200', '187/2100', '1/40']
+matrix_coefficients = [['1/5'], ['3/40', '9/40'], ['44/45', '-56/15', '32/9'],
+                ['19372/6561', '-25360/2187', '64448/6561', '-212/729'],
+                ['9017/3168', '-355/33', '46732/5247', '49/176', '-5103/18656'],
+                ['35/384', 0, '500/1113', '125/192', '-2187/6784', '11/84']]
+[dopr45.interpolation.constants]
+d1 = '-12715105075/11282082432'
+d2 = 0
+d3 = '87487479700/32700410799'
+d4 = '-10690763975/1880347072'
+d5 = '701980252875/199316789632'
+d6 = '-1453857185/822651844'
+d7 = '69997945/29380423'
+[dopr45.interpolation.coefficients]
+r1 = 'y0'
+r2 = 'y1 - y0'
+r3 = 'k1 - (y1 - y0)'
+r4 = '2 * (y1 - y0) - k1 - k7'
+r5 = 'd1 * k1 + d2 * k2 + d3 * k3 + d4 * k4 + d5 * k5 + d6 * k6 + d7 * k7'
+[dopr45.interpolation.formula]
+final = 'r1 + theta * (r2 + (1 - theta) * (r3 + theta * (r4 + (1 - theta) * r5)))'

metadata

@@ -0,0 +1,255 @@
+--- !ruby/object:Gem::Specification
+name: bibun
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Javier Oswaldo Hernández Batis
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIEojCCAwqgAwIBAgIBATANBgkqhkiG9w0BAQsFADBLMRkwFwYDVQQDDBBqb2hl
+  cm5hbmRlemJhdGlzMRkwFwYKCZImiZPyLGQBGRYJc3RhcnRtYWlsMRMwEQYKCZIm
+  iZPyLGQBGRYDY29tMB4XDTI1MTAwNDIwMjgwMVoXDTI2MTAwNDIwMjgwMVowSzEZ
+  MBcGA1UEAwwQam9oZXJuYW5kZXpiYXRpczEZMBcGCgmSJomT8ixkARkWCXN0YXJ0
+  bWFpbDETMBEGCgmSJomT8ixkARkWA2NvbTCCAaIwDQYJKoZIhvcNAQEBBQADggGP
+  ADCCAYoCggGBALeKx5HEeuWn5qCjxPzjDhdm+PVZZqoVBsr0zOpgLXQ1fFbcchAo
+  TN6N5EBBpspNPTGseSoLVkbkYgkLj8xsoGIHnqooM3NsCEl10XKBH7WrHpkqGenV
+  7FU5cBhsOzyK9vHcYn6avgrivg918LBw6/jKTCpzci5g1raBn6n8ngrwVY2jOsqW
+  J78vwAA6VKPGpR555UmvO4lg8GrS03ktyvDdL99PlhHgzfaLDXYh4tUoy5izwM1t
+  JqpbiRimocklRs4jlTcZveBl4Pd/XGzNXSVmFqCmFz5lugFB+DFkyyt8ruhJ1Dtm
+  HZSKIy+Xmi17XcNAw+DeJeXMRGh/ddl5uAHWRxjX5tcpX7m/54QL1Hyi9uR/IQvR
+  L8oCHRq6l43vK8LCAoMV/LbCfzVOXHUhjtOCQnGkJJ5/27hz8MIxKhw+Sann/0jo
+  +KWrGFblBFp1lim477FuBbruP5SPReKjkXQ9dkU08O6woyYA0IjzWeSnXO49CpMm
+  3fywTmAXgKLbjQIDAQABo4GQMIGNMAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0G
+  A1UdDgQWBBS2ZcS8Y0Z1s0+eOUjd6hq8LSP6UzApBgNVHREEIjAggR5qb2hlcm5h
+  bmRlemJhdGlzQHN0YXJ0bWFpbC5jb20wKQYDVR0SBCIwIIEeam9oZXJuYW5kZXpi
+  YXRpc0BzdGFydG1haWwuY29tMA0GCSqGSIb3DQEBCwUAA4IBgQBvJpZUyWWtaeVw
+  A/UrnPCwjwM9H9W9aNUurWV8P+RJo74Th5Mpp7ZxAT2McIUveRDJNe8aZC7+D7li
+  NAOcGIABK8vj//iqh7WuiYIrPcCnzvwumZNtxDnnhaMjpk3DTdjJMwyOUcos7hMi
+  GNHX0DpWElZ1Lrkt8HaJpRefhmmDmQBrwGD3s6cztE5ynX6uKGVt1acBZNp3lrej
+  9QNc1iKB6K2DfuVzwxPU6da7HC5E/nQKh1/cIAOf/fgYiJ1f3Qq1jlR9jptPdKOu
+  k8yqdQxomOFGpEsrtiFw7NlChWENONF20k15vyGyuTVVBBFDvKuZiEqsGemm6o1j
+  yDbiN5LLe5fm2a15tXbu6fhj7ITmqwteZUIIhgF8JWs1jJyonWOlaSiAkeHpsAE/
+  Ns9BT67XevfsONA6aGf9YTMfyCdzqW8kkhlVQt24qZBz8Ebblv7dLUxJscWIl4tW
+  Ek0z5JjyW9vxbdAQ1KtrTm5X+tpdfERGuyRe+q2o0BlsccV/5xc=
+  -----END CERTIFICATE-----
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: formatador
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: keisan
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: tomlib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.80'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.80'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: ruby-prof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: super_diff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: "This gem allows to do simulation runs of systems of ordinary differential
+  equations of one independent variable \nusing numerical Runge-Kutta methods for
+  approximation. Contains some features like calculation of separate additive\nterms
+  of the differential equations, calculation of custom expressions and logging and
+  printing runs to a csv files,\nwhich engineers may find it convenient.\n"
+email: johernandezbatis@startmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/bibun.rb
+- lib/bibun/differential_butcher_table.rb
+- lib/bibun/differential_equation_logger.rb
+- lib/bibun/differential_equation_system.rb
+- lib/bibun/differential_stepper.rb
+- lib/bibun/differential_system_parameter.rb
+- lib/bibun/differential_system_symbol.rb
+- lib/bibun/differential_system_variable.rb
+- lib/bibun/log_entry.rb
+- lib/bibun/step_tracker.rb
+- lib/bibun/symbol_group.rb
+- lib/bibun/version.rb
+- lib/data/butcher_tables.toml
+homepage: https://rubygems.org/gems/bibun_hoteishiki
+licenses:
+- Nonstandard
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: A gem to run simulation of differential equation systems via numerical methods.
+test_files: []