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

{mathjson_solver-1.15.0/src/mathjson_solver.egg-info → mathjson_solver-1.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathjson-solver
-Version: 1.15.0
+Version: 1.16.0
 Summary: Utilities for MathJSON evaluation
 Home-page: https://github.com/LongenesisLtd/mathjson-solver
 Author: Martins Mednis

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

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

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

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

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

@@ -19,6 +19,107 @@ except ImportError:
 NoneType = type(None)
 
 
+# def find_interpolation_bounds(
+#     l: list, target: int | float
+# ) -> Union[Union[int, float], tuple[Union[int, float], Union[int, float]]]:
+#     for i, x in enumerate(l):
+#         if i == 0:
+#             continue
+#         if l[i - 1] <= target and target <= l[i]:
+#             if target == l[i - 1] or target == l[i]:
+#                 return target
+#             else:
+#                 return l[i - 1], l[i]
+#     else:
+#         raise ValueError("Target value is outside interpolation range.")
+
+
+def _MultiplyByScalar(l: list[numbers.Real], a: numbers.Real) -> list[numbers.Real]:
+    return [x * a for x in l]
+
+
+def _MultiplyByArray(
+    l1: list[numbers.Real], l2: list[numbers.Real]
+) -> list[numbers.Real]:
+    return [a * b for a, b in zip(l1, l2)]
+
+
+def _AddScalar(l: list[numbers.Real], a: numbers.Real) -> list[numbers.Real]:
+    return [x + a for x in l]
+
+
+def _SubtractScalar(l: list[numbers.Real], a: numbers.Real) -> list[numbers.Real]:
+    return [x - a for x in l]
+
+
+def _AddArray(l1: list[numbers.Real], l2: list[numbers.Real]) -> list[numbers.Real]:
+    return [a + b for a, b in zip(l1, l2)]
+
+
+def _SubtractArray(
+    l1: list[numbers.Real], l2: list[numbers.Real]
+) -> list[numbers.Real]:
+    return [a - b for a, b in zip(l1, l2)]
+
+
+def _CumulativeProduct(l: list) -> list:
+    res = []
+    for i, x in enumerate(l):
+        if i == 0:
+            res.append(x)
+        else:
+            res.append(reduce(lambda a, b: a * b, l[: i + 1]))
+    return res
+
+
+def find_interpolation_bounds_indexes(
+    l: list, target: int | float
+) -> Union[Union[int, float], tuple[Union[int, float], Union[int, float]]]:
+    for i, x in enumerate(l):
+        if i == 0:
+            continue
+        if l[i - 1] <= target and target <= l[i]:
+            if target == l[i - 1]:
+                return i - 1
+            elif target == l[i]:
+                return i
+            else:
+                return i - 1, i
+    else:
+        raise ValueError("Target value is outside interpolation range.")
+
+
+def find_interpolation_bounds_2indexes(
+    l: list, target: int | float
+) -> Union[Union[int, float], tuple[Union[int, float], Union[int, float]]]:
+    for i, x in enumerate(l):
+        if i == len(l) - 1:
+            return i - 1, i
+        if l[i] <= target and target < l[i + 1]:
+            return i, i + 1
+    else:
+        raise ValueError("Target value is outside interpolation range.")
+
+
+def linear_interpolate(x_array, y_array, target_x):
+    # Find the interval where target_x falls
+    # Handle edge cases (target_x outside range)
+    # Apply: y = y1 + (y2 - y1) * (target_x - x1) / (x2 - x1)
+
+    # first check if both arrays are the same length
+    if len(x_array) != len(y_array) or len(x_array) < 2:
+        raise ValueError(
+            "Both arrays need to be the same length and with at least 2 elements."
+        )
+    bounds_indexes = find_interpolation_bounds_indexes(x_array, target_x)
+    if isinstance(bounds_indexes, tuple):
+        x1, x2 = x_array[bounds_indexes[0]], x_array[bounds_indexes[1]]
+        y1, y2 = y_array[bounds_indexes[0]], y_array[bounds_indexes[1]]
+        return y1 + (y2 - y1) * (target_x - x1) / (x2 - x1)
+    else:
+        return y_array[bounds_indexes]
+
+
 class MathJSONException(Exception):
     """Exception for MathJSON processing issues"""
 
@@ -578,6 +679,204 @@ def create_mathjson_solver(solver_parameters):
                 return 0
                 # return f(function_expression, c) function_name(*parameters)
 
+            def MultiplyByScalar(s):
+                """
+                ["MultiplyByScalar", array, scalar]
+                The `array` must be an array of numeric values.
+                The `scalar` is the number to multiply each element by.
+                """
+                array = f(s[1], c)
+                scalar = f(s[2], c)
+                if not (isinstance(array, list) and array[0] == "Array"):
+                    raise ValueError("Parameter 1 must be an array.")
+                array = [f(x, c) for x in array[1:]]
+                return ["Array"] + _MultiplyByScalar(array, scalar)
+
+            def MultiplyByArray(s):
+                """
+                ["MultiplyByArray", array1, array2]
+                The `array1` and `array2` must be arrays of the same length.
+                """
+                array1 = f(s[1], c)
+                array2 = f(s[2], c)
+                if not (isinstance(array1, list) and array1[0] == "Array"):
+                    raise ValueError("Parameter 1 must be an array.")
+                if not (isinstance(array2, list) and array2[0] == "Array"):
+                    raise ValueError("Parameter 2 must be an array.")
+                array1 = [f(x, c) for x in array1[1:]]
+                array2 = [f(x, c) for x in array2[1:]]
+                if len(array1) != len(array2):
+                    raise ValueError("Both arrays must be of the same length.")
+                return ["Array"] + _MultiplyByArray(array1, array2)
+
+            def AddScalar(s):
+                """
+                ["AddScalar", array, scalar]
+                The `array` must be an array of numeric values.
+                The `scalar` is the number to add to each element.
+                """
+                array = f(s[1], c)
+                scalar = f(s[2], c)
+                if not (isinstance(array, list) and array[0] == "Array"):
+                    raise ValueError("Parameter 1 must be an array.")
+                array = [f(x, c) for x in array[1:]]
+                return ["Array"] + _AddScalar(array, scalar)
+
+            def SubtractScalar(s):
+                """
+                ["SubtractScalar", array, scalar]
+                The `array` must be an array of numeric values.
+                The `scalar` is the number to subtract from each element.
+                """
+                array = f(s[1], c)
+                scalar = f(s[2], c)
+                if not (isinstance(array, list) and array[0] == "Array"):
+                    raise ValueError("Parameter 1 must be an array.")
+                array = [f(x, c) for x in array[1:]]
+                return ["Array"] + _SubtractScalar(array, scalar)
+
+            def AddArray(s):
+                """
+                ["AddArray", array1, array2]
+                The `array1` and `array2` must be arrays of the same length.
+                """
+                array1 = f(s[1], c)
+                array2 = f(s[2], c)
+                if not (isinstance(array1, list) and array1[0] == "Array"):
+                    raise ValueError("Parameter 1 must be an array.")
+                if not (isinstance(array2, list) and array2[0] == "Array"):
+                    raise ValueError("Parameter 2 must be an array.")
+                array1 = [f(x, c) for x in array1[1:]]
+                array2 = [f(x, c) for x in array2[1:]]
+                if len(array1) != len(array2):
+                    raise ValueError("Both arrays must be of the same length.")
+                return ["Array"] + _AddArray(array1, array2)
+
+            def SubtractArray(s):
+                """
+                ["SubtractArray", array1, array2]
+                The `array1` and `array2` must be arrays of the same length.
+                """
+                array1 = f(s[1], c)
+                array2 = f(s[2], c)
+                if not (isinstance(array1, list) and array1[0] == "Array"):
+                    raise ValueError("Parameter 1 must be an array.")
+                if not (isinstance(array2, list) and array2[0] == "Array"):
+                    raise ValueError("Parameter 2 must be an array.")
+                array1 = [f(x, c) for x in array1[1:]]
+                array2 = [f(x, c) for x in array2[1:]]
+                if len(array1) != len(array2):
+                    raise ValueError("Both arrays must be of the same length.")
+                return ["Array"] + _SubtractArray(array1, array2)
+
+            def GenerateRange(s):
+                """
+                ["GenerateRange", end]
+                or
+                ["GenerateRange", start, end, step]
+                The `start`, `end`, and `step` are numeric values.
+                """
+                if len(s) == 2:
+                    end = f(s[1], c)
+                    start = 0
+                    step = 1
+                elif len(s) == 4:
+                    start = f(s[1], c)
+                    end = f(s[2], c)
+                    step = f(s[3], c)
+                else:
+                    raise ValueError(
+                        "GenerateRange requires either 1 or 3 parameters (end or start, end, step)."
+                    )
+                if step == 0:
+                    raise ValueError("Step cannot be zero.")
+                if (start < end and step < 0) or (start > end and step > 0):
+                    raise ValueError("Step direction is incorrect for the given range.")
+                result = ["Array"]
+                if start < end:
+                    current = start
+                    while current < end:
+                        result.append(current)
+                        current += step
+                else:
+                    current = start
+                    while current > end:
+                        result.append(current)
+                        current += step
+                return result
+
+            def AtIndex(s):
+                """
+                ["AtIndex", array, index]
+                The `array` must be an array of values.
+                The `index` is the index of the element to retrieve.
+                """
+                array = f(s[1], c)
+                index = f(s[2], c)
+                if not (isinstance(array, list) and array[0] == "Array"):
+                    raise ValueError("Parameter 1 must be an array.")
+                # array = [f(x, c) for x in array[1:]]
+                # return array[index]
+                array = [x for x in array[1:]]
+                return f(array[index], c)
+
+            def Slice(s):
+                """
+                ["Slice", array, start, end]
+                The `array` must be an array of values.
+                The `start` and `end` are the slice indices.
+                """
+                array = f(s[1], c)
+                start = f(s[2], c)
+                end = f(s[3], c)
+                if not (isinstance(array, list) and array[0] == "Array"):
+                    raise ValueError("Parameter 1 must be an array.")
+                array = [f(x, c) for x in array[1:]]
+                return ["Array"] + array[start:end]
+
+            def CumulativeProduct(s):
+                """
+                ["CumulativeProduct", array]
+                The `array` must be an array of numeric values.
+                """
+                array = f(s[1], c)
+                if not (isinstance(array, list) and array[0] == "Array"):
+                    raise ValueError("Parameter 1 must be an array.")
+                array = [f(x, c) for x in array[1:]]
+                return ["Array"] + _CumulativeProduct(array)
+                # return _CumulativeProduct(array)
+
+            def Interp(s):
+                """
+                ["Interp", x_array, y_array, target_x]
+                The `x_array` and `y_array` must be arrays of the same length.
+                The `target_x` is the x value to interpolate for.
+                """
+                x_array = f(s[1], c)
+                y_array = f(s[2], c)
+                target_x = f(s[3], c)
+                if not (isinstance(x_array, list) and x_array[0] == "Array"):
+                    raise ValueError("Parameter 1 must be an array.")
+                if not (isinstance(y_array, list) and y_array[0] == "Array"):
+                    raise ValueError("Parameter 2 must be an array.")
+                x_array = [f(x, c) for x in x_array[1:]]
+                y_array = [f(y, c) for y in y_array[1:]]
+                return linear_interpolate(x_array, y_array, target_x)
+
+            def FindIntervalIndex(s):
+                """
+                ["FindIntervalIndex", array, target_value]
+                The `array` must be an array of numeric values.
+                The `target_value` is the value to find the interval index for.
+                """
+                array = f(s[1], c)
+                target_value = f(s[2], c)
+                if not (isinstance(array, list) and array[0] == "Array"):
+                    raise ValueError("Parameter 1 must be an array.")
+                array = [f(x, c) for x in array[1:]]
+                zz = find_interpolation_bounds_2indexes(array, target_value)
+                return zz[0]
+
             def TrapezoidalIntegrate(s):
                 """
                 ["TrapezoidalIntegrate", function_expression, start, end, n, variable]
@@ -690,6 +989,18 @@ def create_mathjson_solver(solver_parameters):
                 "TimeDeltaDays": TimeDeltaDays,
                 "Function": Function,
                 "Variable": Variable,
+                "MultiplyByScalar": MultiplyByScalar,
+                "MultiplyByArray": MultiplyByArray,
+                "AddScalar": AddScalar,
+                "SubtractScalar": SubtractScalar,
+                "AddArray": AddArray,
+                "SubtractArray": SubtractArray,
+                "GenerateRange": GenerateRange,
+                "AtIndex": AtIndex,
+                "Slice": Slice,
+                "CumulativeProduct": CumulativeProduct,
+                "Interp": Interp,
+                "FindIntervalIndex": FindIntervalIndex,
                 "TrapezoidalIntegrate": TrapezoidalIntegrate,
                 "Sin": Sin,
                 "Cos": Cos,
@@ -699,6 +1010,9 @@ def create_mathjson_solver(solver_parameters):
                 "Arctan": Arctan,
                 "Pi": Pi,
             }
+            if not s:
+                # Empty equation given - []
+                return None
             if s[0] in constructs:
                 try:
                     return constructs[s[0]](s)
@@ -795,6 +1109,19 @@ def extract_variables(s: Union[list, int, float, str], li: set, ignore_list: set
         "TimeDeltaDays",
         "Function",
         "Variable",
+        "MultiplyByScalar",
+        "MultiplyByArray",
+        "AddScalar",
+        "SubtractScalar",
+        "AddArray",
+        "SubtractArray",
+        "GenerateRange",
+        "AtIndex",
+        "Slice",
+        "CumulativeProduct",
+        "Interp",
+        "FindIntervalIndex",
+        "TrapezoidalIntegrate",
         "TrapezoidalIntegrate",
         "Sin",
         "Cos",

{mathjson_solver-1.15.0 → mathjson_solver-1.16.0/src/mathjson_solver.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathjson-solver
-Version: 1.15.0
+Version: 1.16.0
 Summary: Utilities for MathJSON evaluation
 Home-page: https://github.com/LongenesisLtd/mathjson-solver
 Author: Martins Mednis

mathjson_solver-1.16.0/src/mathjson_solver.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+LICENSE
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+src/mathjson_solver/__init__.py
+src/mathjson_solver/__main__.py
+src/mathjson_solver.egg-info/PKG-INFO
+src/mathjson_solver.egg-info/SOURCES.txt
+src/mathjson_solver.egg-info/dependency_links.txt
+src/mathjson_solver.egg-info/top_level.txt
+tests/test_CumulativeProduct.py
+tests/test_Slice.py
+tests/test_TrapezoidalIntegratel.py
+tests/test_atindex.py
+tests/test_equal.py
+tests/test_exceptions.py
+tests/test_extract_variables.py
+tests/test_findinterval.py
+tests/test_gail_model.py
+tests/test_interpolate.py
+tests/test_range.py
+tests/test_scalars.py
+tests/test_sets.py
+tests/test_simple_cases.py
+tests/test_with_pytest.py

mathjson_solver-1.16.0/tests/test_CumulativeProduct.py

@@ -0,0 +1,18 @@
+import sys
+import os
+import pytest
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "../src/"))
+
+from mathjson_solver import create_solver
+
+
+def test_CumulativeProduct1():
+    parameters = {"test_array": ["Array", 2, 3, 4, 5]}
+
+    expression = ["CumulativeProduct", "test_array"]
+
+    expected_result = ["Array", 2, 6, 24, 120]
+    solver = create_solver(parameters)
+    # assert solver(expression) == expected_result
+    assert solver(expression) == expected_result

mathjson_solver-1.16.0/tests/test_Slice.py

@@ -0,0 +1,37 @@
+import sys
+import os
+import pytest
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "../src/"))
+
+from mathjson_solver import create_solver
+
+
+@pytest.mark.parametrize(
+    "parameters, expression, expected_result",
+    [
+        (
+            {"test_array": ["Array", 10, 20, 30, 40, 50, 60]},
+            ["Slice", "test_array", 2, 4],
+            ["Array", 30, 40],
+        ),
+        (
+            {"test_array": ["Array", 10, 20, 30, 40, 50, 60]},
+            ["Slice", "test_array", 2, 5],
+            ["Array", 30, 40, 50],
+        ),
+        (
+            {"test_array": ["Array", 10, 20, 30, 40, 50, 60]},
+            ["Length", ["Slice", "test_array", 2, 5]],
+            3,
+        ),
+        (
+            {"test_array": ["Array", 10, 20, 30, 40, 50, 60]},
+            ["Sum", ["Slice", "test_array", 2, 5]],
+            120,
+        ),
+    ],
+)
+def test_slice1(parameters, expression, expected_result):
+    solver = create_solver(parameters)
+    assert solver(expression) == expected_result