bibun 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfdf2da9f4cefc3f0543ab2ea15cd57ff4839df928c5265ab239d071142cf6d3
-  data.tar.gz: 6bd4d352e44a51a4366f0b5c145ac0dd24910439de09dc2d1ef87990c8028bb7
+  metadata.gz: 368fa968d06e81e87ca2b1fd0a86a88cd54384d0e04f9c2761f0471862345107
+  data.tar.gz: f8dea6d3c5ec670677756ade6887bbff52f67dbe04f18ebf9778fe00844478b4
 SHA512:
-  metadata.gz: 6d5c7480c4f0d5ea6b4d0a2d9140f28ef2b8d5158b34bdad797cc63254cc4f1873a40cc9746ffe9c87b3e218674e5bedb98b5886a28efee1b534a0c27ae65a5c
-  data.tar.gz: 4dbc784b29b1ed63e93b305d4c1523a20d2e35beaf9030934531436d397f4f4669f85af4228c3d02b10a7ec0d8446081558cad8515b3ad861e4663e4147874f0
+  metadata.gz: 2fe78590c4d0c1c8cb92788e8c9f07c940e6408e2f12f8625440916000dae8572c1ccea8feac860671ace583b1f2a592dd06a88241147269b9dc5c216fb958c6
+  data.tar.gz: b2879ade4f8c5f7250c6389ab19f99045333b62e39f570836f1721d81c10c326825eb8b97073a008b7c67091ec13d5de3ca8ef1f6fa52e0b264201e7d8381efe

data/CHANGELOG.md

@@ -3,5 +3,7 @@
 All notable changes to this project will be documented in this file.
 
 ## [0.0.0] - 2025-10-04
-
-Initial release.
+Initial release.
+## [0.0.1] - 2025-10-04
+- Changed LaTEX expressions and Mermaid diagrams to embedded images so they display well on the documentation and the online repository.
+- Added git repository link to the homepage attribute.

data/README.md

@@ -2,7 +2,7 @@ Bibun (微分: differential, derivative). This gem implements Runge-Kutta explic
 
 # Quick feature overview
 
-Instant example for a single differential equation with one variable representing a electrical circuit $\frac{dI}{dt}=15-3*I$
+Instant example for a single differential equation with one variable representing a electrical circuit dI / dt = 15 - 3 I
 
 ```ruby
 require 'bibun'
@@ -31,10 +31,8 @@ puts ode.current.value
 ```
 
 Quick example of a differential equation system of two variables, the Lotka Volterra equations with specific parameter values (p and d are the prey and predator variables):
-$$
-\frac{dp}{dt}=0.08p-0.001pd \\
-\frac{dd}{dt}=-0.02d+0.00001pd
-$$
+
+![](https://dl.dropboxusercontent.com/scl/fi/wf89aeu1q7s0t6gh7cmez/lotka_volterra.png?rlkey=3crlrsswmmmhepab71861ewa9&st=5b7fsdlj&dl=0)
 
 
 ```RUby
@@ -91,16 +89,7 @@ predator_data = lv.logs['predator']
 
 With the same basics, a more complex system: an salt tank receiving two inlets, one outlet and variable water volume, proportional loss rate. The concentration is calculated and tracked from the salt mass and volume variables and each flow contribution is tracked separatedly:
 
-```mermaid
----
-title: Interface
----
-flowchart LR
-  tan[Container Tank] -- fo --> out[Outlet]
-  bri[Brine inlet cs] -- fb --> tan
-  spw[Springwater inlet] -- fw --> tan
-  tan -- lV --> los[Loss rate]
-```
+![](https://dl.dropboxusercontent.com/scl/fi/hl6i98ycweiwfno23chga/brine_tank.png?rlkey=5ecegbv8mn6g93duqs3xbonnn&st=57rk4owp&dl=0)
 
 ```Ruby
 tank = Bibun::DifferentialEquationSystem.new
@@ -153,28 +142,15 @@ The gem uses the `json`, `tomlib` and `csv` libraries for importing and exportin
 
 `Formatador` is used to display a progress bar while doing the integration and for outputting a DES summary.
 
+## License
+
+This gem has a MIT style license except it forbids its use for AI training purposes (see license file, based on https://github.com/non-ai-licenses/non-ai-licenses).
+
 # General Interface and usage
 
 The outer `DifferentialEquationSystem` class exposes enough general methods to be able to perform straightforward integration runs, but for a completely control over the integration process it is better to understand and access the inner objects that compose it. Below is the basic interface to a differential equation system object:
 
-```mermaid
----
-title: Interface
----
-flowchart LR
-  sys[System] --shortcut--> vars[variables]
-  sys --> syms[syms]
-  syms --> vars
-  syms --> pars
-  sys --shortcut--> pars[parameters]
-  vars --> eq[rate_equations]
-  vars --shortcut--> rt[terms]
-  eq --> rt
-  sys --> st[stepper]
-  st --> bc[butcher_table]
-  sys --> log[logger]
-  sys --> tr[tracker]
-```
+![](https://dl.dropboxusercontent.com/scl/fi/h9ssqhvo8v06qo1kqukyv/bibun_interface.png?rlkey=se11fn4a7qxj00f52fz1936cc&st=zkskxt9s&dl=0)
 
 For easier access there are shortcut methods such as System -> Variables or Variable -> Terms even if the strict relationship lies between adjacent classes.
 
@@ -183,11 +159,10 @@ For easier access there are shortcut methods such as System -> Variables or Vari
 The Lotka-Volterra equations will be used as the working example for the documentation.
 
 The Lotka-Volterra equations model the change across time in the populations of a prey and a predator species:
-$$
-\frac{dp}{dt}=kp-apd \\
-\frac{dd}{dt}=-rd+bpd
-$$
-$p$ and $d$ are the variables for the prey and predator populations and $k$, $a$, $r$ and $b$ are constant parameters or coefficients.
+
+![](https://dl.dropboxusercontent.com/scl/fi/c0jil0apjimwmah20lpvi/Lotka-Volterra-with-parameters.png?rlkey=bq460iw7f6nfdlwimmo8j61c4&st=yszk2x5h&dl=0)
+
+p and d are the variables for the prey and predator populations and k, a, r and b are constant parameters or coefficients.
 
 This differential equation system is nonlinear and cyclical, with prey and predator population oscillating around their own maximum and minimum and with a phase shift between them.
 
@@ -290,7 +265,7 @@ lv.add_variable 'predator', 'd', rate_equation: '0.02 * d - 0.00001 * p * d '
 lv.predator.rate_equation.rate_function = '-0.02 * d + 0.00001 * p * d'
 ```
 
-The expression of the rate function must be provided with the form $dx_i/dt = f(X)$ and using the symbols previously assigned to the variables and parameters.
+The expression of the rate function must be provided with the form dxi/dt = f(X) and using the symbols previously assigned to the variables and parameters.
 
 ## Adding rate additive terms
 
@@ -343,7 +318,7 @@ lv.integrate starting_values: { 'prey_growth' => 0.08, 'prey_consumption' => 0.0
 
 ## Constant step, non adaptive
 
-The method `integrate` is the main method to perform the integration, that is, starts a run where the variable values at each step are calculated numerically using a numerical method. The `starting_values:` parameter allows a last chance to introduce initial values; `step_size:` is used to input the desired step size ($h$) and the `duration:` parameter determines the lenght of the run.  For a non adaptive method, the total number of steps performed will be total_steps =  duration / step_size since the step size is held constant.
+The method `integrate` is the main method to perform the integration, that is, starts a run where the variable values at each step are calculated numerically using a numerical method. The `starting_values:` parameter allows a last chance to introduce initial values; `step_size:` is used to input the desired step size (h) and the `duration:` parameter determines the lenght of the run.  For a non adaptive method, the total number of steps performed will be total_steps =  duration / step_size since the step size is held constant.
 
 ```Ruby
 lv.integrate starting_values: { 'time' => 0, 'prey' => 1000, 'predator' => 50 }, step_size: 1, duration: 100
@@ -501,7 +476,7 @@ Checking some rows of the generated file:
 |  38  |   82.7   |      -1.67       |         3.57         | 2137.5 |    170.72     |     -178.41      |        25.86        |
 |  39  |   84.6   |      -1.71       |         3.63         | 2129.8 |    169.94     |     -181.66      |        25.19        |
 
-The sums of the terms for each variable equal the value of the variable for the next step. Here at time 37 we can verify that the value for time 38 for the predator population is $80.8 - 1.63 + 3.5  = 82.67$, showing the separate contributions due to predation and decay.
+The sums of the terms for each variable equal the value of the variable for the next step. Here at time 37 we can verify that the value for time 38 for the predator population is 80.8 - 1.63 + 3.5  = 82.67, showing the separate contributions due to predation and decay.
 
 *NOTE: when the logging interval is not equal to the step size, the term logs account for it in order to always represent the total change between two logging rows, so their logged values will differ if the logging interval change.*
 
@@ -541,15 +516,13 @@ lv.set_global_tolerance 0.1, 0.01 # atol of 0.1 and rtol of 0.01
 ```
 
 The stepper evaluates the error at each iteration and increases the initial step size given if it the overall error is smaller than the aggregate `err` index or decreases the error and repeats the iteration if the error surpasses the aggregate. Because criteria for calculating the error and changing the step size is not set in stone, `Bibun` uses the following formulas[^1] :
-$$
-err = \sqrt{\frac{1}{N}\sum{(\frac{\Delta}{scale})^2}} \\
-\Delta = x_{5^{th}order}-x_{4^{th}order} \\
-scale = atol+rtol\times max(x_n,x_{n+1})
-$$
+
+![](https://dl.dropboxusercontent.com/scl/fi/ok6thj37csqlne420uh5j/error_estimation.png?rlkey=rmbnhsstj4vpwx7nx2lwuolpb&st=p97jczdr&dl=0)
+
 Where N is the number of variables with nonzero tolerance. Step size is decreased and the step performed again if err < 1 and step size is increased otherwise. The size adjustment is done according to:
-$$
-h_{next}=h \times clamp(0.9(\frac{1}{err})^{1/5},1/5, 10)
-$$
+
+![](https://dl.dropboxusercontent.com/scl/fi/6c65qcc907hsc7ydwehw8/step_size_readjustment.png?rlkey=ur0m44eu3vgtfugvghbvmlq75&st=du4uz8o8&dl=0)
+
 The 0.9 safety factor is a reccomendation by J.C. Butcher[^2] while the 1/5..10 range is a recommendation by W. H. Press.
 
 ### Using dense output

data/lib/bibun/version.rb

@@ -2,5 +2,5 @@
 
 module Bibun
   # Semver constant
-  VERSION = '0.0.0'
+  VERSION = '0.0.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bibun
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Javier Oswaldo Hernández Batis
@@ -209,7 +209,7 @@ description: "This gem allows to do simulation runs of systems of ordinary diffe
   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"
+  printing runs to csv files,\nwhich engineers may find convenient.\n"
 email: johernandezbatis@startmail.com
 executables: []
 extensions: []
@@ -231,7 +231,7 @@ files:
 - lib/bibun/symbol_group.rb
 - lib/bibun/version.rb
 - lib/data/butcher_tables.toml
-homepage: https://rubygems.org/gems/bibun_hoteishiki
+homepage: https://git.sr.ht/~skyfish/bibun
 licenses:
 - Nonstandard
 metadata: {}
@@ -251,5 +251,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.7.2
 specification_version: 4
-summary: A gem to run simulation of differential equation systems via numerical methods.
+summary: A gem to run simulations of differential equation systems via numerical methods.
 test_files: []