bibun 0.0.0

data/lib/bibun/differential_butcher_table.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Bibun
+  # Class that stores the data relative to the Butcher table used to perform the integration.
+  class DifferentialButcherTable
+    # The Butcher table nodes or c values. At each stage ti = tn + ch.
+    # @return [Array<Numeric>]
+    attr_accessor :nodes
+    # The Butcher node coefficients or a values. At each stage yi = y1ai1 + y2ai2 + y3ai3...y[i-1]ai[i-1]
+    # @return [Array<Numeric>]
+    attr_accessor :matrix_coefficients
+    # The weights by which each k_step value is multiplied before summing them into the final variable change.
+    # They are the Butcher table b values such as k = k1b1 + k2b2...
+    # @return [[Array<Numeric>]]
+    attr_accessor :weights
+    # For embedded methods they are another set of weights which give an estimate of the change for the variable of
+    # lesser order and against which the reference calculation is compared for estimating the error..
+    # They are the Butcher table b* values such as k = k1b*1 + k2b*2...
+    # @return [[Array<Numeric>]]
+    attr_accessor :alternate_weights
+    # @return [Boolean] Indicates whether the butcher table method is adaptive or not.
+    attr_reader :adaptive
+    # @return [Integer] The order of the method.
+    attr_reader :order
+    # @return [Hash{String => Numeric}] Constants for polynomomial interpolation.
+    attr_reader :interpolation_constants
+    # @return [Hash{String => String}] Formulas to calculate coefficients for polynomomial interpolation.
+    attr_reader :interpolation_formulas
+    alias adaptive? adaptive
+
+    # List of methods which can be preloaded. rk4 is the default one for non adaptive and dopr45 for adaptive.
+    DIFFERENTIATION_METHODS = %i[rk4 rk3 midpoint dopr45].freeze
+
+    # Initialization.
+    def initialize
+      @weights, @nodes, @matrix_coefficients = [], [], []
+    end
+
+    # Because a Butcher Table might be provided by the user, evaluates if the arrays are empty to choose whether to
+    # load a default or not.
+    # @return [Boolean]
+    def empty?
+      weights.union(nodes, matrix_coefficients).empty?
+    end
+
+    # @return [Integer] The number of stages for array indexing.
+    def stages
+      weights.size - 1
+    end
+
+    # Loads a preset Butcher Table defined in the inner TOML file.
+    def load_preset(method:)
+      data_path = File.expand_path('../data/butcher_tables.toml', __dir__)
+      rationalize = ->(s) { s.is_a?(String) ? s.to_r : s }
+      rationalize_array = ->(ar) { ar.map! { |val| rationalize.call(val) } }
+      toml = Tomlib.load File.read(data_path)
+      toml = toml[method.to_s]
+      @order = toml['order']
+      @nodes = rationalize_array.call(toml['nodes'])
+      @weights = rationalize_array.call(toml['weights'])
+      @matrix_coefficients = toml['matrix_coefficients']
+      matrix_coefficients.each { |ar| rationalize_array.call(ar) }
+      @adaptive = toml['adaptive']
+      if adaptive?
+        @alternate_weights = rationalize_array.call(toml['alternate_weights'])
+        @interpolation_constants = toml['interpolation']['constants'].transform_values { |v| rationalize.call(v) }
+        @interpolation_formulas = toml['interpolation']['coefficients']
+        interpolation_formulas.store 'final', toml['interpolation']['formula']['final']
+      end
+    end
+  end
+end

data/lib/bibun/differential_equation_logger.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Bibun
+  class DifferentialEquationSystem
+    # Class to handle the logging of values calculated through the simulation of differential equations.
+    # This class is not meant to be used or instantiated independently, the DES instance already creates one when
+    # initialized. Should be always accesed through the DifferentialEquationSystem#logger getter.
+    class DifferentialEquationLogger
+      # @return [Hash{String => LogEntry}] Each of the entries or columns to register in the log.
+      attr_accessor :entries
+      # @return [SymbolGroup] Accessor to the SymbolGroup of the DES
+      attr_reader :syms
+      attr_accessor :buffer, :has_expressions, :system, :tracker
+      attr_reader :logging_interval
+
+      def initialize(system, tracker, syms)
+        @entries         = {}
+        @logs            = {}
+        @order           = []
+        @buffer          = {}
+        @has_expressions = false
+        @system          = system
+        @syms            = syms
+        @tracker         = tracker
+      end
+
+      # Direct access in a hash style to the entries' arrays of values.
+      # @return [Hash{String => Array<Numeric>}]
+      def logs = entries.transform_values(&:values)
+
+      # Adds an arbitrary number of variables to the logger.
+      def add_variables(vars_decimals)
+        vars_decimals.each { |k, v| entries.store k, VariableLogEntry.new(self, v, k) }
+      end
+
+      # Method to add an specific additive term pertaining an specific variable.
+      def add_rate_term(variable_name, term_name, decimals)
+        entries.store "#{variable_name}:#{term_name}", TermLogEntry.new(self, decimals, variable_name, term_name)
+      end
+
+      # The equivalent of a database ROW_NUMBER, for those cases where time is not an integer.
+      def add_step_state
+        entries.store 'step', StepLogEntry.new(self, 0)
+      end
+
+      # Way to add custom expressions whose calculation is desired to be tracked and logged.
+      def add_expression(name, formula, decimals)
+        entries.store name, ExpressionLogEntry.new(self, decimals, name, formula)
+        @has_expressions = true
+      end
+
+      # Adds a single variable to the logger along its additive terms. All terms are added by default, but this
+      # behaviour can be overriden by passing a list including only the target terms.
+      def add_variable_with_terms(variable, decimals, *only)
+        add_variables({ variable => decimals })
+        stream_array = only.empty? ? syms.variables[variable].terms.keys : only
+        stream_array.each { |s| add_rate_term(variable, s, decimals) }
+      end
+
+      # To avoid having to write a decimal specification for each variable, this methods allows to add several variables
+      # simultaneously while only passing a single decimal specification for all of them.
+      def add_same_decimals_to_variables(decimals, *variable_group)
+        variable_group.each { |v| add_variables({ v => decimals }) }
+      end
+
+      # Quickest way to set a logger. All is needed is to provide the decimals once. The with_streams: keyword argument
+      # allows to have all terms from all variables logged.
+      def add_all(decimals, with_terms: false)
+        if with_terms
+          add_variables({ syms.ind_var.name => decimals })
+          syms.rate_variables.each_key do |k|
+            add_variable_with_terms(k, decimals)
+          end
+        else
+          add_variables(syms.variables.transform_values { |_| decimals })
+        end
+      end
+
+      # Quick method to check if there is any rate additive term to log.
+      def log_terms? = entries.values.any? { |le| le.instance_of?(TermLogEntry) }
+
+      # Quick way to access the terms.
+      # @return [Array<TermLogEntry>] The array with the log entries.
+      def term_entries = entries.values.select { |et| et.instance_of?(TermLogEntry) }
+
+      # Preparation routine. Logs the initial values of the variables.
+      def prepare
+        start_logs
+        log_start
+      end
+
+      # Caches the parameters for expression calculations
+      def start_logs
+        @parameters = syms.pars_values_hash if @has_expressions
+      end
+
+      # Registering the log interval. Method is placed here because it is intuitive since it pertains the logging.
+      def logging_interval=(independent_variable_interval)
+        tracker.logging_interval = independent_variable_interval
+      end
+
+      # Adds the first row to the log comprised of the starting values and expressions calculated from them.
+      def log_start
+        entries.values.reject {|v| v.instance_of?(TermLogEntry) }.each do |ls|
+          ls.buffer_hash = syms.syms_values_hash
+          if ls.instance_of?(VariableLogEntry)
+            ls.register_value
+          else
+            ls.register # Step and Expressions
+          end
+        end
+      end
+
+      # Core method that adds a row to the logs and gets called once per each step walked.
+      # The marks are the logging points by the walking step which are 'marked' to be recorded.
+      def log_forward
+        marks = tracker.marks_to_advance
+        marks.each_index do |i|
+          tracker.log_forward marks[i]
+          prepare_expression_buffers(marks, i) if @has_expressions
+          entries.each_value { |e| e.register(marks, i) }
+        end
+        if tracker.dense_output?
+          term_entries.each do |et|
+            already_covered = marks.empty? ? 0 : et.term_obj.last_interpol
+            et.term_obj.lagging_change += et.term_obj.step_change - already_covered
+          end
+        end
+        tracker.last_mark = tracker.current_logging_point
+      end
+
+      # Right now I have no way to get the variables from a Keisan AST so if there is an expression then I calculate
+      # the values of all variables and put them in the buffer for the correct expression evaluation.
+      # TODO: Find a way to extract the variables of the AST to limit only to the ones necessary.
+      def prepare_expression_buffers(marks, index)
+        syms.rate_variables.each_value do |v|
+          v.buffer_value = system.stepper.variable_log_value(v, marks, index)
+        end
+        hash = syms.syms_buffers_hash
+        entries.values.select { |le| le.instance_of?(ExpressionLogEntry) }
+               .each { |le| le.buffer_hash = hash }
+      end
+
+      # Once simulation is over, records all loggable elements to a csv file in the order they were added.
+      def save_to_file(file_name)
+        CSV.open(file_name, 'w', headers: true) do |csv|
+          csv << entries.keys
+          (0..tracker.current_logging_step).each do |row|
+            csv << entries.map { |_, v| v[row] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bibun/differential_equation_system.rb

@@ -0,0 +1,367 @@
+# frozen_string_literal: true
+
+module Bibun
+  # TODO
+  #   Add more functionality to put the time steps in actual time units
+  #   Add capability to detect and stop the simulation when a variable becomes stationary.
+  #   Use Ractors in the Stepper to optimize
+
+  # Class to integrate systems of ordinary differential equations by numerical methods.
+  # Used mostly to integrate runs using Runge-Kutta or Dormand-Prince methods.
+  # From here on DES => Differential Equation System.
+  # @author Javier Oswaldo Hernández Batis
+  class DifferentialEquationSystem
+    # Holds the SymbolGroup object which contains the variables and parameters of the DES.
+    attr_accessor :syms
+    # Holds the stepper object which executes the integration steps.
+    attr_accessor :stepper
+    # Holds the logger objects which is in charge of logging the variable and other values taken at each step.
+    attr_accessor :logger
+    # Holds the step tracker object which keeps track of the independent variable and step positions through the
+    # integration
+    attr_accessor :tracker
+    # Global boolean which can display useful data for debugging.
+    attr_accessor :debug_mode
+    alias debug_mode? debug_mode
+
+    # Adds the four inner objects for reference and manipulation and time as the default independent variable.
+    def initialize
+      @tracker = StepTracker.new
+      @syms = SymbolGroup.new(self)
+      @logger  = DifferentialEquationLogger.new(self, @tracker, @syms)
+      @stepper = DifferentialStepper.new(self, @tracker, @syms)
+
+      @debug_mode = false
+      add_independent 'time', 't', 'Time'
+    end
+
+    # Basic method to add a dependent variable to the DES.
+    # @param name [String] Name to use for accessing the variable in the variables hash and through the generated
+    #   accessor method. Use caveats for method naming (no dashes or spaces, etc). If only one ordered argument is
+    #   passed, the symbol will get the same value as the variable name and no accessor method will be left.
+    # @param symbol [String] String used in formulas for Keisan. Recommended to be short as in 't' for time.
+    # @param title [String] Longer name which could be used for presentation and printing which unlike name has no
+    #   restrictions.
+    # @param unit [String] The units of the variable, for printing and reporting.
+    # @param type [Symbol] A custom type that can be added for variable grouping; for example :concentration for
+    #   substance concentrations in reactor systems.
+    # @param rate_function [String] The string that contains the mathematical formula for the derivative of the variable.
+    #   Will be used by Keisan. Use regular Ruby syntax. For example if the differential equation is
+    #   dq / dt = 2 t**2 - 3 * q, introduce '2 t**2 - 3 * q'
+    # @param atol [Float] The absolute tolerance for error to be used in adaptive method. At least one dependant variable
+    #   must have a nonzero value for either absolute or relative tolerance.
+    # @param rtol [Float] The relative tolerance for error to be used in adaptive method.
+    # @param accessor [Boolean] Controls if an accessor method is created for the variable using its name argument.
+    # @return [DifferentialSystemVariable] The variable created.
+    # @example Add a Volume variable to represent a basin volume
+    #   add_variable 'volume', 'V', 'Basin Volume', 'm3', rate_function: 'F - eV'
+    def add_variable(name, symbol = nil, title = nil, unit = nil, type: nil, rate_function: nil, atol: 0, rtol: 0,
+                     accessor: true)
+
+      symbol_provided = !symbol.nil?
+      symbol = name unless symbol_provided
+      var = DifferentialSystemVariable.new(name: name, symbol: symbol, title: title,unit: unit, type:, rate_function:,
+                                           atol:, rtol:)
+      variables.store name.downcase, var
+      return unless accessor && symbol_provided
+
+      instance_variable_set "@#{name.downcase}", var
+      define_singleton_method name.downcase do
+        instance_variable_get "@#{name.downcase}"
+      end
+      var
+    end
+
+    # Method to edit the independent variable, which is created automatically.
+    # @param var_name [String] Name to use for accessing the variable in the variables hash and through the generated
+    #   accessor method. Use caveats for method naming (no dashes or spaces, etc). If only one ordered argument is
+    #   passed, the symbol will get the same value as the variable name and no accessor method will be left.
+    # @param symbol [String] String used in formulas for Keisan. Recommended to be short as in 't' for time.
+    # @param title [String] Longer name which could be used for presentation and printing which unlike name has no
+    #   restrictions.
+    # @param unit [String] The units of the variable, for printing and reporting.
+    # @param accessor [Boolean] If false, removes the accesor method.
+    # @example Changing to the usual x for x and y differential equations.
+    #   edit_independent_variable 'x'
+    def edit_independent_variable(var_name, symbol = nil, title = nil, unit = nil, accessor: true)
+      symbol_provided = !symbol.nil?
+      ind = syms.ind_var
+      old_key = variables.key(ind)
+      symbol = var_name unless symbol_provided
+      ind.name, ind.symbol, ind.title, ind.unit = var_name, symbol, title, unit
+      variables[var_name] = variables.delete old_key
+      singleton_class.undef_method(old_key)
+      return unless accessor && symbol_provided
+
+      instance_variable_set "@#{var_name.downcase}", ind
+      define_singleton_method var_name.downcase do
+        instance_variable_get "@#{var_name.downcase}"
+      end
+    end
+
+    # Basic method to add a dependent variable to the DES.
+    # @param name [String] Name to use for accessing the variable in the variables hash and through the generated
+    #   accessor method. Use caveats for method naming (no dashes or spaces, etc). If only one ordered argument is
+    #   passed, the symbol will get the same value as the variable name and no accessor method will be left.
+    # @param symbol [String] String used in formulas for Keisan. Recommended to be short as in 't' for time.
+    # @param title [String] Longer name which could be used for presentation and printing which unlike name has no
+    #   restrictions.
+    # @param unit [String] The units of the variable, for printing and reporting.
+    # @param value [Numeric] Allows to set the value of the parameter.
+    # @param accessor [Boolean] Controls if an accessor method is created for the variable using its name argument.
+    # @return [DifferentialSystemParameter] The parameter created.
+    # @example Add a rate coefficient ára,eter-
+    #   add_parameter 'rate_coefficient', 'r', 'Rate Coefficient', 'h-1', value: 0.52
+    def add_parameter(name, symbol = nil, title = nil, unit = nil, value: nil, accessor: true)
+      symbol_provided = !symbol.nil?
+      symbol = name unless symbol_provided
+      par = DifferentialSystemParameter.new name: name, symbol: symbol, title: title,
+                                            unit: unit, value: value
+      parameters.store name.downcase, par
+      return unless accessor && symbol_provided
+
+      instance_variable_set("@#{name.downcase}", par)
+      define_singleton_method name.downcase do
+        instance_variable_get "@#{name.downcase}"
+      end
+      par
+    end
+
+    # Shortcut method which adds multiple variable in quick form (name identical to symbol, no accessor) along their
+    # rate variable.
+    # @param vars_hash [Hash{String => String}] The hash with the variable names as keys and rate function as values.
+    # @example
+    #   add_variables({'y' => '3 * t - 2', 'z' => '2 * y - t'})
+    def add_variables(vars_hash)
+      vars_hash.each { |k, v| add_variable k, rate_function: v }
+    end
+
+    # Similar to add_variables, add multiple parameters in quick style (name identical to symbol, no accessor) along
+    # their values.
+    # @param pars_hash [Hash{String => Numeric}] The hash with the parameters names and values.
+    # @example
+    #   add_parameters({ a => 3.5, b => 3/5r })
+    def add_parameters(pars_hash)
+      pars_hash.each { |k, v| add_parameter k, value: v }
+    end
+
+    # Shortcut writer method to edit the step_size attribute of the tracker object.
+    # @param step_size [Numeric] the width of the step_size.
+    def step_size=(step_size)
+      tracker.step_size = step_size
+    end
+
+    # Shortcut writer method to edit the duration attribute of the step_tracker object.
+    # @param duration [Numeric] the total duration or timespan of the integration.
+    def duration=(duration)
+      tracker.duration = duration
+    end
+
+    # Shortcut method to add uniform tolerances to all dependent variable. Not recommended if variables are of
+    # different units or priority. See {#add_variable}
+    def set_global_tolerance(atol = 0, rtol = 0)
+      rate_variables.each { |v| v.atol = atol; v.rtol = rtol }
+    end
+
+    # Way to assign values for both parameters and variables for the start of the run. Shortcut to the method of the
+    # syms oject.
+    # @param values_hash [Hash{String => Numeric}] Hash with the variable and parameter names and their intended values.
+    # @example
+    #   des.assign_values({ 'time' => 0, 'pressure' => 0.5, 'temperature' => 273.15 })
+    def assign_values(values_hash)
+      syms.assign_values(values_hash)
+    end
+
+    # Shortcut method to the logger method +add_variables+.
+    def add_variables_to_log(vars_decimals)
+      logger.add_variables(vars_decimals)
+    end
+
+    # Shortcut method to +Logger#add_all+ log all variables and optionally their rate terms.
+    def log_all(decimals, with_terms: false)
+      logger.add_all(decimals, with_terms:)
+    end
+
+    # Shortcut method to access the variables of the _syms_ object.
+    # @return [Hash{String => DifferentialSystemVariable}] The hash with the variables.
+    # @example
+    #   puts des.variables['time'].value
+    def variables = syms.variables
+    # Shortcut method to acess the parameters of the _syms_ object.
+    # @return [Hash{String => DifferentialSystemParameter}]
+    def parameters = syms.parameters
+    # Checks if the prepare_integration method has already been called. Because the _current_step_ attribute is only set
+    # until the method is called, if it is not nil it means the DES is already set. See {#prepare_integration}
+    def ready? = !tracker.current_step.nil?
+    # Checks if the adpative method is in use.
+    def adaptive? = stepper.butcher_table.adaptive?
+    # Shortcut to get the logs
+    def logs = logger.logs
+
+    # The main exposed method to perform the numerical integration through a whole range (duration or timespan).
+    # @param starting_values[Hash{String => Numeric}] Provides a last chance to introduce all values to the variables
+    #   and parameters. See {#assign_values}. The independent variable is set to zero if not provided. Every other
+    #   variable or parameter with nil value will raise an error.
+    # @param step_size[Numeric] Allows to pass the step_size to be used (for adaptive methods, on the first one at
+    #   least). The step size can be set beforehand.
+    # @param duration[Numeric] Allows to pass the duration or timespan of the integration.
+    # @param method[Symbol] Specifies a preset method. Currently :rk4, :midpoint and :dopr45 (adpative) are available.
+    #   It will default to :4rk and :dopr45 for non adaptive and adaptive unless a custom butcher table has been
+    #   previously set in the _stepper.butcher_table_ object.
+    # @param adaptive[Boolean] Chooses if an adpative step size or non adaptive is going to be used.
+    # @param display_progress[Boolean] Controls whether a progress bar is displayed in CLI or not.
+    def integrate(starting_values: nil, step_size: nil, duration: nil, method: nil, adaptive: false,
+                  display_progress: true)
+      prepare_integration(starting_values:, step_size:, duration:, method:, adaptive:) unless ready?
+      progress_bar = Formatador::ProgressBar.new(tracker.total_steps, color: 'light_green') if display_progress
+      while syms.ind_var.value < tracker.ending_point
+        unitary_step
+        progress_bar.increment if display_progress
+      end
+      self
+    end
+
+    # Performs only a single step of the integration. Might generate several logging points when using dense output.
+    # see {#integrate} for parameters.
+    def single_step(starting_values: nil, step_size: nil, duration: nil, method: nil, adaptive: false)
+      prepare_integration(starting_values:, step_size:, duration:, method:, adaptive:, single_step: true) unless ready?
+      unitary_step
+      self
+    end
+
+    # Converts to JSON object
+    # @return [json] The json object.
+    def to_json(*_args)
+      { 'variables' => syms.rate_variables.values,
+        'parameters' => syms.parameters.values,
+        'logging' => logger.entries.values,
+        'values' => syms.variables.transform_values(&:value),
+        'simulation_options' => tracker }.to_json
+    end
+
+    # Converts to TOML object. So far there is no satisfactory way to handle null data. Tomlib converts nil to "" so
+    # loading it back with _from_toml_ may cause error.
+    def to_toml
+      Tomlib.dump(JSON.parse(to_json))
+    end
+
+    # Parses a JSON and loads all its data into the DES object. Useful to store integration metadata and load it later.
+    # @return [DifferentialEquationSystem] The DES object itself.
+    def from_json(data)
+      from_serial(JSON.parse(data))
+    end
+
+    # Parses a JSON and loads all its data into the DES object. Useful to store integration metadata and load it later.
+    # @return [DifferentialEquationSystem] The DES object itself.
+    def from_toml(data)
+      from_serial(Tomlib.load(data))
+    end
+
+    # Prints to stdout a summary of the DES.
+    def formatador_print
+      f = Formatador.new
+      f.display_line 'Variables'
+      vars = variables.values.reduce([]) do |ar, v|
+        ar.push({ symbol: v.symbol, name: v.name, unit: v.unit })
+      end
+      f.display_compact_table vars, %i[symbol name unit]
+      f.display_line 'Parameters'
+      params = parameters.values.reduce([]) do |ar, v|
+        ar.push({ symbol: v.symbol, name: v.name, unit: v.unit, value: v.value })
+      end
+      f.display_compact_table params, %i[symbol name value unit]
+      f.display_line 'Equations'
+      eqs = []
+      syms.rate_equations.each do |n, e|
+        if e.terms.empty?
+          eqs.push({ equation: n, formula: e.rate_function })
+        else
+          e.terms.each { |sk, sv| eqs.push({ variable: n, term: sk, formula: sv.rate_function }) }
+        end
+      end
+      f.display_compact_table eqs, %i[variable term formula]
+    end
+
+    private
+
+    # This is the core internal method that represents the traversing of one step.
+    def unitary_step
+      walk_step
+      append_log
+      change_variables
+    end
+
+    # Adds the independent variable. Kept private to avoid external libraries being able to add independent variables.
+    def add_independent(name, symbol = nil, title = nil)
+      symbol = name if symbol.nil?
+      variables.store name.downcase,
+                      instance_variable_set("@#{name.downcase}",
+                                            DifferentialSystemVariable.new(name: name, symbol: symbol, title: title,
+                                                                           independent: true))
+      define_singleton_method name.downcase do
+        instance_variable_get "@#{name.downcase}"
+      end
+    end
+
+    # Routine shared by #from_json and #from_toml
+    def from_serial(poro)
+      poro['variables'].each do |v|
+        add_variable v['name'], v['symbol'], v['title'], v['unit'], rate_function: v['rate_function']
+        var = variables[v['name']]
+        if v['rate_function']
+          var.rate_equation.rate_function = v['rate_function']
+        else
+          v['terms'].each { |h| var.rate_equation.add_rate_term(h['name'], h['rate_function']) }
+        end
+      end
+      poro['parameters'].each do |p|
+        add_parameter p['name'], p['symbol'], p['title'], p['unit'], value: p['value']
+      end
+      poro['logging'].each do |l|
+        case l['type']
+        when 'variable'
+          logger.add_variables({ l['variable'] => l['decimals'] })
+        when 'term'
+          logger.add_rate_term l['variable'], l['term'], l['decimals']
+        when 'step'
+          logger.add_step_state
+        when 'expression'
+          logger.add_expression l['name'], l['formula'], l['decimals']
+        end
+      end
+      assign_values poro['values']
+      tracker.step_size        = poro['simulation_options']['step_size']
+      tracker.duration         = poro['simulation_options']['duration']
+      tracker.logging_interval = poro['simulation_options']['logging_interval']
+      self
+    end
+
+    # Major method to set up all instance variable and objects before starting to perform steps. Single step is
+    # included to discriminate whether a duration is necessary or not.
+    def prepare_integration(starting_values: nil, step_size: nil, duration: nil, method: nil, adaptive: false,
+                            single_step: false)
+      assign_values({ syms.ind_var.name => 0 }) if syms.ind_var.value.nil?
+      assign_values starting_values unless starting_values.nil?
+      tracker.step_size = step_size unless step_size.nil?
+      tracker.duration  = duration unless duration.nil?
+      method ||= (adaptive ? :dopr45 : :rk4)
+      stepper.prepare(method:)
+      tracker.prepare(syms.ind_var.value, stepper.butcher_table.adaptive?, single_step: single_step)
+      logger.prepare
+    end
+
+    # Method which calls the major core method which performs a single step.
+    def walk_step
+      stepper.walk_step tracker.step_size
+      tracker.walk_forward
+    end
+
+    def change_variables
+      variables.each_value { |v| v.value += v.step_change; v.buffer_value = v.value }
+    end
+
+    def append_log
+      logger.log_forward
+    end
+  end
+end