mathjson-solver 1.13.0__tar.gz → 1.15.0__tar.gz

mathjson_solver-1.15.0/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: mathjson-solver
+Version: 1.15.0
+Summary: Utilities for MathJSON evaluation
+Home-page: https://github.com/LongenesisLtd/mathjson-solver
+Author: Martins Mednis
+Author-email: mrt@mednis.info
+Project-URL: Bug Tracker, https://github.com/LongenesisLtd/mathjson-solver/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# MathJSON Solver
+
+[![PyPI](https://img.shields.io/pypi/v/mathjson-solver.svg)](https://pypi.org/project/mathjson-solver/)
+[![PyPI Downloads](https://static.pepy.tech/badge/mathjson-solver/month)](https://pepy.tech/projects/mathjson-solver)
+[![Python 3.7+](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/)
+
+A reliable Python library for numerically evaluating mathematical expressions in MathJSON format. Perfect for applications that need to safely execute user-provided formulas, calculate dynamic equations, or process mathematical data.
+
+**What is MathJSON?** MathJSON represents mathematical expressions as JSON arrays, like `["Add", 1, 2, 3]` for 1+2+3. This format is safe, structured, and easy to generate programmatically.
+
+Inspired by [CortexJS Compute Engine](https://cortexjs.io/compute-engine/) though designed as an independent implementation focused on our specific use cases.
+
+## Table of Contents
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Supported Operations](#supported-operations)
+- [Error Handling](#error-handling)
+- [Use Cases](#use-cases)
+- [Testing](#testing)
+- [Community](#community)
+- [Contributing](#contributing)
+
+## Installation
+
+```bash
+pip install mathjson-solver
+```
+
+**Requirements:** Python 3.7+
+
+**Optional:** numpy (only required for `TrapezoidalIntegrate` function)
+
+## Quick Start
+
+```python
+from mathjson_solver import create_solver, MathJSONException
+
+# Define variables and create solver
+parameters = {"x": 2, "y": 3}
+solver = create_solver(parameters)
+
+# Evaluate expressions
+basic_math = solver(["Add", "x", "y", 4])
+print(basic_math)  # 9 (because 2+3+4=9)
+
+# More complex expressions
+result = solver(["Multiply", ["Add", "x", 1], ["Subtract", "y", 1]])
+print(result)  # 6 (because (2+1) * (3-1) = 6)
+
+# Handle errors gracefully
+try:
+    solver(["Divide", 1, 0])
+except MathJSONException as e:
+    print(f"Math error: {e}")
+    # Math error: Problem in Divide. ['Divide', 1, 0]. division by zero
+```
+
+## Supported Operations
+
+The library supports a comprehensive set of mathematical operations:
+
+* **Arithmetic:** Add, Sum, Subtract, Multiply, Divide, Negate, Power, Square, Root, Sqrt, Abs, Round
+* **Trigonometry:** Sin, Cos, Tan, Arcsin, Arccos, Arctan
+* **Logarithms:** Log, Log2, Log10, Exp
+* **Comparison:** Equal, StrictEqual, NotEqual, Greater, GreaterEqual, Less, LessEqual
+* **Logic & Sets:** Any, All, Not, In, NotIn, ContainsAnyOf, ContainsAllOf, ContainsNoneOf
+* **Statistics:** Average, Max, Min, Median, Length
+* **Arrays:** Array creation and manipulation with Map function
+* **Control Flow:** If statements, Switch-Case, Constants definition
+* **Type Conversion:** Int, Float, Str, IsDefined
+* **Date/Time:** Strptime, Strftime, Today, Now, TimeDelta functions
+* **Advanced:** HasMatchingSublist, TrapezoidalIntegrate (requires numpy), Variable references
+* **Constants:** Pi
+
+[View complete documentation with examples →](https://github.com/LongenesisLtd/mathjson-solver/blob/main/docs/README.md)
+
+## Error Handling
+
+MathJSON Solver raises `MathJSONException` for invalid expressions or mathematical errors:
+
+```python
+from mathjson_solver import create_solver, MathJSONException
+
+solver = create_solver({})
+
+# Handle specific math errors
+try:
+    result = solver(["Sqrt", -1])  # Invalid: square root of negative
+except MathJSONException as e:
+    print(f"Cannot evaluate: {e}")
+
+# Handle malformed expressions
+try:
+    result = solver(["UnknownFunction", 1, 2])
+except MathJSONException as e:
+    print(f"Unsupported operation: {e}")
+```
+
+## Use Cases
+
+* **Dynamic Formulas:** Let users create custom calculations in web applications
+* **Scientific Computing:** Evaluate mathematical models with variable parameters
+* **Business Logic:** Process complex pricing rules or scoring algorithms
+* **Data Processing:** Apply mathematical transformations to datasets
+* **Health Applications:** Calculate medical scores, dosages, or risk assessments
+
+## Testing
+
+Install development dependencies and run tests:
+
+```bash
+# Install pytest if not already installed
+pip install pytest
+
+# Run tests from project directory
+pytest
+
+# Run with coverage
+pytest --cov=mathjson_solver
+```
+
+## Community
+
+- **Questions & Discussion:** [GitHub Issues](https://github.com/LongenesisLtd/mathjson-solver/issues)
+- **Bug Reports & Feature Requests:** [GitHub Issues](https://github.com/LongenesisLtd/mathjson-solver/issues)
+- **Documentation:** [Complete Function Reference](https://github.com/LongenesisLtd/mathjson-solver/blob/main/docs/README.md)
+
+## Contributing
+
+We welcome contributions! Please feel free to:
+- Report bugs or request features via [GitHub Issues](https://github.com/LongenesisLtd/mathjson-solver/issues)
+- Submit pull requests with improvements
+
+
+## License
+
+[View license information](https://github.com/LongenesisLtd/mathjson-solver/blob/main/LICENSE)
+
+---
+
+Made with ❤️ by [Longenesis](https://longenesis.com/team)

mathjson_solver-1.15.0/README.md

@@ -0,0 +1,141 @@
+# MathJSON Solver
+
+[![PyPI](https://img.shields.io/pypi/v/mathjson-solver.svg)](https://pypi.org/project/mathjson-solver/)
+[![PyPI Downloads](https://static.pepy.tech/badge/mathjson-solver/month)](https://pepy.tech/projects/mathjson-solver)
+[![Python 3.7+](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/)
+
+A reliable Python library for numerically evaluating mathematical expressions in MathJSON format. Perfect for applications that need to safely execute user-provided formulas, calculate dynamic equations, or process mathematical data.
+
+**What is MathJSON?** MathJSON represents mathematical expressions as JSON arrays, like `["Add", 1, 2, 3]` for 1+2+3. This format is safe, structured, and easy to generate programmatically.
+
+Inspired by [CortexJS Compute Engine](https://cortexjs.io/compute-engine/) though designed as an independent implementation focused on our specific use cases.
+
+## Table of Contents
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Supported Operations](#supported-operations)
+- [Error Handling](#error-handling)
+- [Use Cases](#use-cases)
+- [Testing](#testing)
+- [Community](#community)
+- [Contributing](#contributing)
+
+## Installation
+
+```bash
+pip install mathjson-solver
+```
+
+**Requirements:** Python 3.7+
+
+**Optional:** numpy (only required for `TrapezoidalIntegrate` function)
+
+## Quick Start
+
+```python
+from mathjson_solver import create_solver, MathJSONException
+
+# Define variables and create solver
+parameters = {"x": 2, "y": 3}
+solver = create_solver(parameters)
+
+# Evaluate expressions
+basic_math = solver(["Add", "x", "y", 4])
+print(basic_math)  # 9 (because 2+3+4=9)
+
+# More complex expressions
+result = solver(["Multiply", ["Add", "x", 1], ["Subtract", "y", 1]])
+print(result)  # 6 (because (2+1) * (3-1) = 6)
+
+# Handle errors gracefully
+try:
+    solver(["Divide", 1, 0])
+except MathJSONException as e:
+    print(f"Math error: {e}")
+    # Math error: Problem in Divide. ['Divide', 1, 0]. division by zero
+```
+
+## Supported Operations
+
+The library supports a comprehensive set of mathematical operations:
+
+* **Arithmetic:** Add, Sum, Subtract, Multiply, Divide, Negate, Power, Square, Root, Sqrt, Abs, Round
+* **Trigonometry:** Sin, Cos, Tan, Arcsin, Arccos, Arctan
+* **Logarithms:** Log, Log2, Log10, Exp
+* **Comparison:** Equal, StrictEqual, NotEqual, Greater, GreaterEqual, Less, LessEqual
+* **Logic & Sets:** Any, All, Not, In, NotIn, ContainsAnyOf, ContainsAllOf, ContainsNoneOf
+* **Statistics:** Average, Max, Min, Median, Length
+* **Arrays:** Array creation and manipulation with Map function
+* **Control Flow:** If statements, Switch-Case, Constants definition
+* **Type Conversion:** Int, Float, Str, IsDefined
+* **Date/Time:** Strptime, Strftime, Today, Now, TimeDelta functions
+* **Advanced:** HasMatchingSublist, TrapezoidalIntegrate (requires numpy), Variable references
+* **Constants:** Pi
+
+[View complete documentation with examples →](https://github.com/LongenesisLtd/mathjson-solver/blob/main/docs/README.md)
+
+## Error Handling
+
+MathJSON Solver raises `MathJSONException` for invalid expressions or mathematical errors:
+
+```python
+from mathjson_solver import create_solver, MathJSONException
+
+solver = create_solver({})
+
+# Handle specific math errors
+try:
+    result = solver(["Sqrt", -1])  # Invalid: square root of negative
+except MathJSONException as e:
+    print(f"Cannot evaluate: {e}")
+
+# Handle malformed expressions
+try:
+    result = solver(["UnknownFunction", 1, 2])
+except MathJSONException as e:
+    print(f"Unsupported operation: {e}")
+```
+
+## Use Cases
+
+* **Dynamic Formulas:** Let users create custom calculations in web applications
+* **Scientific Computing:** Evaluate mathematical models with variable parameters
+* **Business Logic:** Process complex pricing rules or scoring algorithms
+* **Data Processing:** Apply mathematical transformations to datasets
+* **Health Applications:** Calculate medical scores, dosages, or risk assessments
+
+## Testing
+
+Install development dependencies and run tests:
+
+```bash
+# Install pytest if not already installed
+pip install pytest
+
+# Run tests from project directory
+pytest
+
+# Run with coverage
+pytest --cov=mathjson_solver
+```
+
+## Community
+
+- **Questions & Discussion:** [GitHub Issues](https://github.com/LongenesisLtd/mathjson-solver/issues)
+- **Bug Reports & Feature Requests:** [GitHub Issues](https://github.com/LongenesisLtd/mathjson-solver/issues)
+- **Documentation:** [Complete Function Reference](https://github.com/LongenesisLtd/mathjson-solver/blob/main/docs/README.md)
+
+## Contributing
+
+We welcome contributions! Please feel free to:
+- Report bugs or request features via [GitHub Issues](https://github.com/LongenesisLtd/mathjson-solver/issues)
+- Submit pull requests with improvements
+
+
+## License
+
+[View license information](https://github.com/LongenesisLtd/mathjson-solver/blob/main/LICENSE)
+
+---
+
+Made with ❤️ by [Longenesis](https://longenesis.com/team)

{mathjson_solver-1.13.0 → mathjson_solver-1.15.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = mathjson-solver
-version = 1.13.0
+version = 1.15.0
 author = Martins Mednis
 author_email = mrt@mednis.info
 description = Utilities for MathJSON evaluation

{mathjson_solver-1.13.0 → mathjson_solver-1.15.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setuptools.setup(
     name="mathjson-solver",
-    version="1.13.0",
+    version="1.15.0",
     author="Martins Mednis",
     author_email="mrt@mednis.info",
     description="Utilities for MathJSON evaluation",

{mathjson_solver-1.13.0 → mathjson_solver-1.15.0}/src/mathjson_solver/__main__.py

@@ -1,5 +1,5 @@
 import numbers
-from typing import Union
+from typing import Union, Any
 from functools import reduce
 import math
 from copy import deepcopy
@@ -8,6 +8,14 @@ import logging
 import traceback
 import datetime
 
+NUMPY_AVAILABLE = False
+try:
+    import numpy as np
+
+    NUMPY_AVAILABLE = True
+except ImportError:
+    pass
+
 NoneType = type(None)
 
 
@@ -46,6 +54,8 @@ def is_numeric(x):
         float(x)
     except ValueError:
         return False
+    except TypeError:
+        return False
     else:
         return True
 
@@ -141,6 +151,16 @@ def comparison_safe_converter(x):
     return x
 
 
+def comparison_safe_converter_for_pairs(
+    v1, v2
+) -> (Union[str, float], Union[str, float]):
+    if is_numeric(v1):
+        v1 = float(v1)
+    if is_numeric(v2):
+        v2 = float(v2)
+    return v1, v2
+
+
 def create_mathjson_solver(solver_parameters):
     def f(s, *args):
         if args:
@@ -160,10 +180,15 @@ def create_mathjson_solver(solver_parameters):
                 tmp = 0
                 for i, x in enumerate(s[1:]):
                     res = f(x, c)
+                    if is_numeric(res):
+                        res = float(res)
                     if i == 0:
                         tmp = res
                     else:
-                        tmp = tmp + res
+                        try:
+                            tmp = tmp + res
+                        except TypeError:
+                            pass
 
                     # if isinstance(res, list):
                     #     l_res.append(sum([xx for xx in res[1:]]))
@@ -180,15 +205,25 @@ def create_mathjson_solver(solver_parameters):
                 #         tmp = tmp + x
                 # return tmp
 
+            # def Sum(s):
+            #     l_res = []
+            #     for x in s[1:]:
+            #         res = f(x, c)
+            #         if isinstance(res, list):
+            #             l_res.append(sum([xx for xx in res[1:]]))
+            #         else:
+            #             l_res.append(res)
+            #     return sum(l_res)
+
             def Sum(s):
-                l_res = []
+                l_res = ["Array"]
                 for x in s[1:]:
                     res = f(x, c)
                     if isinstance(res, list):
-                        l_res.append(sum([xx for xx in res[1:]]))
+                        l_res.append(Add(["Array"] + [xx for xx in res[1:]]))
                     else:
                         l_res.append(res)
-                return sum(l_res)
+                return Add(l_res)
 
             def Max(s):
                 if isinstance(s[1], str):
@@ -222,7 +257,6 @@ def create_mathjson_solver(solver_parameters):
 
             def Length(s):
                 if isinstance(s[1], str):
-
                     return len([x for x in f(s[1], c)][1:])
                 else:
                     return len([x for x in s[1][1:]])
@@ -352,6 +386,24 @@ def create_mathjson_solver(solver_parameters):
                 return not f(s[1])
 
             def Map(s):
+                """
+                ["Map", list, function, more parameters]
+                The `function` must accept at least one parameter. That is for the current loop element.
+                The `more parameters` are for any additional parameters that function might have.
+                """
+                z = f(s[1], c)
+                if isinstance(z, list):
+                    retlist = ["Array"]
+                    for x in z[1:]:
+                        try:
+                            the_function_name = s[2][0]
+                            ss = [the_function_name, x] + s[3:]
+                            retlist.append(f(ss, c))
+                        except MathJSONException:
+                            retlist.append(x)
+                    return retlist
+
+            def StrictMap(s):
                 """
                 ["Map", list, function, more parameters]
                 The `function` must accept at least one parameter. That is for the current loop element.
@@ -366,6 +418,22 @@ def create_mathjson_solver(solver_parameters):
                         retlist.append(f(ss, c))
                     return retlist
 
+            def Filter(s):
+                """
+                ["Filter", list, function, more parameters]
+                The `function` must accept at least one parameter. That is for the current loop element.
+                The `more parameters` are for any additional parameters that function might have.
+                """
+                z = f(s[1], c)
+                if isinstance(z, list):
+                    retlist = ["Array"]
+                    for x in z[1:]:
+                        the_function_name = s[2][0]
+                        ss = [the_function_name, x] + s[3:]
+                        if f(ss, c):
+                            retlist.append(x)
+                    return retlist
+
             def HasMatchingSublist(s):
                 """
                 ["HasMatchingSublist", list, required_match_count, position, contiguous, function, more parameters]
@@ -438,6 +506,108 @@ def create_mathjson_solver(solver_parameters):
                 # Todo: This does not work
                 return s[1] in c.keys()
 
+            def Greater(s):
+                v1, v2 = comparison_safe_converter_for_pairs(f(s[1], c), f(s[2], c))
+                try:
+                    return v1 > v2
+                except TypeError:
+                    return False
+
+            def GreaterEqual(s):
+                v1, v2 = comparison_safe_converter_for_pairs(f(s[1], c), f(s[2], c))
+                try:
+                    return v1 >= v2
+                except TypeError:
+                    return False
+
+            def Less(s):
+                v1, v2 = comparison_safe_converter_for_pairs(f(s[1], c), f(s[2], c))
+                try:
+                    return v1 < v2
+                except TypeError:
+                    return False
+
+            def LessEqual(s):
+                v1, v2 = comparison_safe_converter_for_pairs(f(s[1], c), f(s[2], c))
+                try:
+                    return v1 <= v2
+                except TypeError:
+                    return False
+
+            # sin, cos, tan, arcsin, arccos, arctan
+            def Sin(s):
+                return math.sin(f(s[1], c))
+
+            def Arcsin(s):
+                return math.asin(f(s[1], c))
+
+            def Cos(s):
+                return math.cos(f(s[1], c))
+
+            def Arccos(s):
+                return math.acos(f(s[1], c))
+
+            def Tan(s):
+                return math.tan(f(s[1], c))
+
+            def Arctan(s):
+                return math.atan(f(s[1], c))
+
+            def Pi(s):
+                return math.pi
+
+            def Variable(s):
+                """
+                ["Variable", variable_name]
+                The `variable_name` must be a string.
+                """
+                variable_name = s[1]
+                if variable_name in c:
+                    return f(c[variable_name], c)
+                else:
+                    raise KeyError(f"Variable '{variable_name}' is not defined")
+
+            def Function(s):
+                """
+                ["Function", function_expression, parameters]
+                The `function_name` must be a callable function.
+                The `parameters` are the arguments to be passed to the function.
+                """
+                function_expression = s[1]
+                arguments = s[2:]
+                return 0
+                # return f(function_expression, c) function_name(*parameters)
+
+            def TrapezoidalIntegrate(s):
+                """
+                ["TrapezoidalIntegrate", function_expression, start, end, n, variable]
+                """
+                if not NUMPY_AVAILABLE:
+                    raise ImportError(
+                        "TrapezoidalIntegrate requires 'numpy'. Install with 'pip install numpy'."
+                    )
+                function_expression = s[1]
+                start = f(s[2], c)
+                end = f(s[3], c)
+                n = f(s[4], c)
+                variable = s[5]
+
+                t = np.linspace(start, end, n + 1)
+
+                # Calculate the integral using the trapezoidal rule
+
+                values = []
+                for x in t:
+                    variable_name = variable[1]
+                    variable_value = x
+                    c[variable_name] = variable_value
+                    values.append(f(function_expression, c))
+                h = (end - start) / n
+                # print("values=", values)
+                return h * (0.5 * values[0] + np.sum(values[1:-1]) + 0.5 * values[-1])
+
+                # return total_area
+
             constructs = {
                 "Sum": Sum,
                 "Add": Add,
@@ -461,15 +631,22 @@ def create_mathjson_solver(solver_parameters):
                 "Log": lambda s: math.log(f(s[1], c)),
                 "Log2": lambda s: math.log2(f(s[1], c)),
                 "Log10": lambda s: math.log10(f(s[1], c)),
+                "Ln": lambda s: math.log(f(s[1], c)),
                 # "Equal": lambda s: f"{f(s[1], c)}" == f"{f(s[2], c)}",
                 "Equal": lambda s: comparison_safe_converter(f(s[1], c))
                 == comparison_safe_converter(f(s[2], c)),
                 "StrictEqual": lambda s: f(s[1], c) == f(s[2], c),
-                "Greater": lambda s: f(s[1], c) > f(s[2], c),
-                "GreaterEqual": lambda s: f(s[1], c) >= f(s[2], c),
-                "Less": lambda s: f(s[1], c) < f(s[2], c),
-                "LessEqual": lambda s: f(s[1], c) <= f(s[2], c),
-                "NotEqual": lambda s: f(s[1], c) != f(s[2], c),
+                # "Greater": lambda s: f(s[1], c) > f(s[2], c),
+                "Greater": Greater,
+                # "GreaterEqual": lambda s: f(s[1], c) >= f(s[2], c),
+                "GreaterEqual": GreaterEqual,
+                # "Less": lambda s: f(s[1], c) < f(s[2], c),
+                "Less": Less,
+                # "LessEqual": lambda s: f(s[1], c) <= f(s[2], c),
+                "LessEqual": LessEqual,
+                # "NotEqual": lambda s: f(s[1], c) != f(s[2], c),
+                "NotEqual": lambda s: comparison_safe_converter(f(s[1], c))
+                != comparison_safe_converter(f(s[2], c)),
                 "Abs": lambda s: abs(f(s[1], c)),
                 "Round": lambda s: (
                     round(f(s[1], c), f(s[2], c))
@@ -500,6 +677,8 @@ def create_mathjson_solver(solver_parameters):
                 # "IsDefined": lambda s: s[1] in c,
                 "IsDefined": IsDefined,
                 "Map": Map,
+                "StrictMap": StrictMap,
+                "Filter": Filter,
                 "HasMatchingSublist": HasMatchingSublist,
                 "Strptime": Strptime,
                 "Strftime": Strftime,
@@ -509,6 +688,16 @@ def create_mathjson_solver(solver_parameters):
                 "TimeDeltaHours": TimeDeltaHours,
                 "TimeDeltaMinutes": TimeDeltaMinutes,
                 "TimeDeltaDays": TimeDeltaDays,
+                "Function": Function,
+                "Variable": Variable,
+                "TrapezoidalIntegrate": TrapezoidalIntegrate,
+                "Sin": Sin,
+                "Cos": Cos,
+                "Tan": Tan,
+                "Arcsin": Arcsin,
+                "Arccos": Arccos,
+                "Arctan": Arctan,
+                "Pi": Pi,
             }
             if s[0] in constructs:
                 try:
@@ -563,6 +752,7 @@ def extract_variables(s: Union[list, int, float, str], li: set, ignore_list: set
         "Log",
         "Log2",
         "Log10",
+        "Ln",
         "Equal",
         "Greater",
         "GreaterEqual",
@@ -603,6 +793,16 @@ def extract_variables(s: Union[list, int, float, str], li: set, ignore_list: set
         "TimeDeltaHours",
         "TimeDeltaMinutes",
         "TimeDeltaDays",
+        "Function",
+        "Variable",
+        "TrapezoidalIntegrate",
+        "Sin",
+        "Cos",
+        "Tan",
+        "Arcsin",
+        "Arccos",
+        "Arctan",
+        "Pi",
     ]
     if isinstance(s, str):
         if s in ignore_list: