Solverz 0.0.1rc1__tar.gz

solverz-0.0.1rc1/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

solverz-0.0.1rc1/.github/workflows/debug github action.yml

@@ -0,0 +1,19 @@
+
+name: debug github action manually
+
+on:
+  workflow_dispatch:
+    inputs:
+      debug_enabled:
+        type: boolean
+        description: 'Run the build with tmate debugging enabled (https://github.com/marketplace/actions/debugging-with-tmate)'
+        required: false
+        default: false
+jobs:
+  build:
+    runs-on: windows-latest
+    steps:
+      # Enable tmate debugging of manually-triggered workflows if the input option was provided
+      - name: Setup tmate session
+        uses: mxschmitt/action-tmate@v3
+        if: ${{ github.event_name == 'workflow_dispatch' && inputs.debug_enabled }}

solverz-0.0.1rc1/.github/workflows/doc-deploy.yml

@@ -0,0 +1,56 @@
+name: Azure Static Web Apps CI/CD
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    types: [opened, synchronize, reopened, closed]
+    branches:
+      - main
+
+jobs:
+  build_and_deploy_job:
+    if: github.event_name == 'push' || (github.event_name == 'pull_request' && github.event.action != 'closed')
+    runs-on: ubuntu-latest
+    name: Build and Deploy Job
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: true
+          lfs: false
+      - name: Bulid Docs
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.11'
+          cache: 'pip' # caching pip dependencies
+      - run: |
+          pip install -r requirements.txt
+          cd docs
+          pip install -r requirements.txt
+          make html
+      - name: Deploy
+        id: builddeploy
+        uses: Azure/static-web-apps-deploy@v1
+        with:
+          azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN_KIND_MUSHROOM_012AD4400 }}
+          repo_token: ${{ secrets.GITHUB_TOKEN }} # Used for Github integrations (i.e. PR comments)
+          action: "upload"
+          ###### Repository/Build Configurations - These values can be configured to match your app requirements. ######
+          # For more information regarding Static Web App workflow configurations, please visit: https://aka.ms/swaworkflowconfig
+          app_location: "/" # App source code path
+          api_location: "" # Api source code path - optional
+          output_location: "docs/build/html" # Built app content directory - optional
+          ###### End of Repository/Build Configurations ######
+
+  close_pull_request_job:
+    if: github.event_name == 'pull_request' && github.event.action == 'closed'
+    runs-on: ubuntu-latest
+    name: Close Pull Request Job
+    steps:
+      - name: Close Pull Request
+        id: closepullrequest
+        uses: Azure/static-web-apps-deploy@v1
+        with:
+          azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN_KIND_MUSHROOM_012AD4400 }}
+          action: "close"

solverz-0.0.1rc1/.github/workflows/python-package.yml

@@ -0,0 +1,28 @@
+# This workflow will install Python dependencies (if not cached), run tests and lint with a variety of Python versions
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Python package
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ windows-latest ]
+
+    steps:
+    - uses: actions/checkout@v3
+    - uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+        cache: 'pip' # caching pip dependencies
+    - run: |
+        pip install -r requirements.txt
+        cd docs/
+        pip install -r requirements.txt
+        cd ..
+    - run: | # run both independent pytest and doctest
+        pytest -vv

solverz-0.0.1rc1/.gitignore

@@ -0,0 +1,23 @@
+/.idea
+/__pycache__
+/tests/.pytest_cache/
+/.pytest_cache/
+/Solverz/__pycache__
+/tests/__pycache__
+*.docx
+*.mlx
+/study/
+instances/vdp1.mat
+tests/test.ipynb
+tests/jax_test.ipynb
+tests/console.ipynb
+tests/test_julia.jl
+tests/test_sp.ipynb
+*.pyc
+/docs/build/
+Solverz/Lib/
+Solverz/pyvenv.cfg
+Solverz/Scripts
+Solverz/share
+*.nbc
+*.nbi

solverz-0.0.1rc1/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.3
+Name: Solverz
+Version: 0.0.1rc1
+Summary: A simulation modelling language
+Project-URL: Homepage, https://github.com/smallbunnies/Solverz
+Project-URL: Issues, https://github.com/smallbunnies/Solverz/issues
+Author-email: Ruizhi Yu <rz.yu@foxmail.com>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Requires-Dist: dill>=0.3.7
+Requires-Dist: matplotlib>=3.5.2
+Requires-Dist: networkx>=3.1
+Requires-Dist: numba==0.58.1
+Requires-Dist: numpy>=1.26.3
+Requires-Dist: openpyxl>=3.0.10
+Requires-Dist: pandas>=1.4.2
+Requires-Dist: pytest>=7.2.2
+Requires-Dist: scipy>=1.12.0
+Requires-Dist: sympy>=1.11.1
+Requires-Dist: tqdm>=4.64.1
+Description-Content-Type: text/markdown
+
+# Overview
+Solverz is an open-source python-based simulation modelling language that provides symbolic interfaces for you to model your equations and can then generate functions or numba-jitted python modules for numerical solutions. 
+
+Solverz supports three types of abstract equation types, that are
+
+- Algebraic Equations (AEs) $0=F(y,p)$
+- Finite Difference Algebraic Equations (FDAEs) $0=F(y,p,y_0)$
+- Differential Algebraic Equations (DAEs) $M\dot{y}=F(t,y,p)$
+
+where $p$ is the parameter set of your models, $y_0$ is the previous time node value of $y$.
+
+For example, we want to know how long it takes for an apple to fall from a tree to the ground. We have the DAE 
+
+$$
+\begin{aligned}
+&v'=-9.8\\
+&h'=v
+\end{aligned}
+$$ 
+
+with $v(0)=20$ and $h(0)=0$, we can just type the codes
+```python
+import matplotlib.pyplot as plt
+import numpy as np
+from Solverz import Model, Var, Ode, Opt, made_numerical, Rodas
+
+# Declare a simulation model
+m = Model()
+# Declare variables and equations
+m.h = Var('h', 0)
+m.v = Var('v', 20)
+m.f1 = Ode('f1', f=m.v, diff_var=m.h)
+m.f2 = Ode('f2', f=-9.8, diff_var=m.v)
+# Create the symbolic equation instance and the variable combination 
+bball, y0 = m.create_instance()
+# Transform symbolic equations to python numerical functions.
+nbball = made_numerical(bball, y0, sparse=True)
+
+# Define events, that is,  if the apple hits the ground then the simulation will cease.
+def events(t, y):
+    value = np.array([y[0]]) 
+    isterminal = np.array([1]) 
+    direction = np.array([-1]) 
+    return value, isterminal, direction
+
+# Solve the DAE
+sol = Rodas(nbball,
+            np.linspace(0, 30, 100), 
+            y0, 
+            Opt(event=events))
+
+# Visualize
+plt.plot(sol.T, sol.Y['h'][:, 0])
+plt.xlabel('Time/s')
+plt.ylabel('h/m')
+plt.show()
+```
+Then we have
+
+![image.png](res.png)
+
+The model is solved with the stiffly accurate Rosenbrock type method, but you can also write your own solvers by the generated numerical interfaces since, for example, the Newton-Raphson solver implememtation for AEs is as simple as below.
+```python
+@ae_io_parser
+def nr_method(eqn: nAE,
+              y: np.ndarray,
+              opt: Opt = None):
+    if opt is None:
+        opt = Opt(ite_tol=1e-8)
+
+    tol = opt.ite_tol
+    p = eqn.p
+    df = eqn.F(y, p)
+    ite = 0
+    # main loop
+    while max(abs(df)) > tol:
+        ite = ite + 1
+        y = y - solve(eqn.J(y, p), df)
+        df = eqn.F(y, p)
+        if ite >= 100:
+            print(f"Cannot converge within 100 iterations. Deviation: {max(abs(df))}!")
+            break
+
+    return aesol(y, ite)
+```
+The implementation of the NR solver just resembles the formulae you read in any numerical analysis book. This is because the numerical AE object `eqn` provides the $F(t,y,p)$ interface and its Jacobian $J(t,y,p)$, which is derived by symbolic differentiation. 
+
+Sometimes you have very complex models and you dont want to re-derive them everytime. With Solverz, you can just use
+```python
+from Solverz import module_printer
+
+pyprinter = module_printer(bball,
+                           y0,
+                           'bounceball',
+                           jit=True)
+pyprinter.render()
+```
+to generate an independent python module of your simulation models. You can import them to your .py file by
+
+```python
+from bounceball import mdl as nbball, y as y0
+```
+
+# Installation
+
+# Useful Resources
+
+- [Solverz Documentation](https://docs.solverz.org)
+- [Solverz Cookbook](https://cookbook.solverz.org)
+
+ 

solverz-0.0.1rc1/README.md

@@ -0,0 +1,111 @@
+# Overview
+Solverz is an open-source python-based simulation modelling language that provides symbolic interfaces for you to model your equations and can then generate functions or numba-jitted python modules for numerical solutions. 
+
+Solverz supports three types of abstract equation types, that are
+
+- Algebraic Equations (AEs) $0=F(y,p)$
+- Finite Difference Algebraic Equations (FDAEs) $0=F(y,p,y_0)$
+- Differential Algebraic Equations (DAEs) $M\dot{y}=F(t,y,p)$
+
+where $p$ is the parameter set of your models, $y_0$ is the previous time node value of $y$.
+
+For example, we want to know how long it takes for an apple to fall from a tree to the ground. We have the DAE 
+
+$$
+\begin{aligned}
+&v'=-9.8\\
+&h'=v
+\end{aligned}
+$$ 
+
+with $v(0)=20$ and $h(0)=0$, we can just type the codes
+```python
+import matplotlib.pyplot as plt
+import numpy as np
+from Solverz import Model, Var, Ode, Opt, made_numerical, Rodas
+
+# Declare a simulation model
+m = Model()
+# Declare variables and equations
+m.h = Var('h', 0)
+m.v = Var('v', 20)
+m.f1 = Ode('f1', f=m.v, diff_var=m.h)
+m.f2 = Ode('f2', f=-9.8, diff_var=m.v)
+# Create the symbolic equation instance and the variable combination 
+bball, y0 = m.create_instance()
+# Transform symbolic equations to python numerical functions.
+nbball = made_numerical(bball, y0, sparse=True)
+
+# Define events, that is,  if the apple hits the ground then the simulation will cease.
+def events(t, y):
+    value = np.array([y[0]]) 
+    isterminal = np.array([1]) 
+    direction = np.array([-1]) 
+    return value, isterminal, direction
+
+# Solve the DAE
+sol = Rodas(nbball,
+            np.linspace(0, 30, 100), 
+            y0, 
+            Opt(event=events))
+
+# Visualize
+plt.plot(sol.T, sol.Y['h'][:, 0])
+plt.xlabel('Time/s')
+plt.ylabel('h/m')
+plt.show()
+```
+Then we have
+
+![image.png](res.png)
+
+The model is solved with the stiffly accurate Rosenbrock type method, but you can also write your own solvers by the generated numerical interfaces since, for example, the Newton-Raphson solver implememtation for AEs is as simple as below.
+```python
+@ae_io_parser
+def nr_method(eqn: nAE,
+              y: np.ndarray,
+              opt: Opt = None):
+    if opt is None:
+        opt = Opt(ite_tol=1e-8)
+
+    tol = opt.ite_tol
+    p = eqn.p
+    df = eqn.F(y, p)
+    ite = 0
+    # main loop
+    while max(abs(df)) > tol:
+        ite = ite + 1
+        y = y - solve(eqn.J(y, p), df)
+        df = eqn.F(y, p)
+        if ite >= 100:
+            print(f"Cannot converge within 100 iterations. Deviation: {max(abs(df))}!")
+            break
+
+    return aesol(y, ite)
+```
+The implementation of the NR solver just resembles the formulae you read in any numerical analysis book. This is because the numerical AE object `eqn` provides the $F(t,y,p)$ interface and its Jacobian $J(t,y,p)$, which is derived by symbolic differentiation. 
+
+Sometimes you have very complex models and you dont want to re-derive them everytime. With Solverz, you can just use
+```python
+from Solverz import module_printer
+
+pyprinter = module_printer(bball,
+                           y0,
+                           'bounceball',
+                           jit=True)
+pyprinter.render()
+```
+to generate an independent python module of your simulation models. You can import them to your .py file by
+
+```python
+from bounceball import mdl as nbball, y as y0
+```
+
+# Installation
+
+# Useful Resources
+
+- [Solverz Documentation](https://docs.solverz.org)
+- [Solverz Cookbook](https://cookbook.solverz.org)
+
+ 

solverz-0.0.1rc1/Solverz/__init__.py

@@ -0,0 +1,15 @@
+from Solverz.equation.eqn import Eqn, Ode, HyperbolicPde
+from Solverz.equation.equations import AE, FDAE, DAE
+from Solverz.equation.param import Param, IdxParam, TimeSeriesParam
+from Solverz.sym_algebra.symbols import idx, Para, iVar, iAliasVar
+from Solverz.sym_algebra.functions import Sign, Abs, transpose, exp, Diag, Mat_Mul, sin, cos, Min, AntiWindUp, Saturation
+from Solverz.num_api.custom_function import minmod_flag, minmod
+from Solverz.variable.variables import Vars, TimeVars, as_Vars
+from Solverz.solvers import *
+from Solverz.code_printer.make_pyfunc import made_numerical
+from Solverz.code_printer.py_printer import render_modules
+from Solverz.code_printer.make_module import module_printer
+from Solverz.utilities.io import save, load, save_result
+from Solverz.utilities.profile import count_time
+from Solverz.variable.ssymbol import Var, AliasVar
+from Solverz.model.basic import Model

solverz-0.0.1rc1/Solverz/code_printer/make_module.py

@@ -0,0 +1,34 @@
+from typing import List
+
+from Solverz.code_printer.py_printer import render_modules as py_module_renderer
+from Solverz.equation.equations import AE, FDAE, DAE
+from Solverz.variable.variables import Vars
+
+
+class module_printer:
+    def __init__(self,
+                 mdl: AE | FDAE | DAE,
+                 variables: Vars | List[Vars],
+                 name: str,
+                 lang='python',
+                 directory=None,
+                 jit=False):
+        self.name = name
+        self.lang = lang
+        self.mdl = mdl
+        if isinstance(variables, Vars):
+            self.variables = [variables]
+        else:
+            self.variables = variables
+        self.directory = directory
+        self.jit = jit
+
+    def render(self):
+        if self.lang == 'python':
+            py_module_renderer(self.mdl,
+                               *self.variables,
+                               name=self.name,
+                               directory=self.directory,
+                               numba=self.jit)
+        else:
+            raise NotImplemented(f"{self.lang} module renderer not implemented!")

solverz-0.0.1rc1/Solverz/code_printer/make_pyfunc.py

@@ -0,0 +1,5 @@
+import numpy as np
+
+from Solverz.code_printer.py_printer import made_numerical
+
+