parsimathious 0.1.1__tar.gz

parsimathious-0.1.1/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: parsimathious
+Version: 0.1.1
+Summary: A mathematical expression parser supporting arithmetic, functions, and complex numbers
+Keywords: math,parser,expression,arithmetic,complex numbers
+Author: Simone Sturniolo
+Author-email: Simone Sturniolo <simonesturniolo@gmail.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Dist: parsimonious>=0.11.0
+Requires-Python: >=3.11
+Project-URL: Homepage, https://github.com/stur86/parsimathious
+Project-URL: Repository, https://github.com/stur86/parsimathious
+Project-URL: Issues, https://github.com/stur86/parsimathious/issues
+Description-Content-Type: text/markdown
+
+# parsimathious
+
+[![PyPI](https://img.shields.io/pypi/v/parsimathious)](https://pypi.org/project/parsimathious/)
+[![Python](https://img.shields.io/pypi/pyversions/parsimathious)](https://pypi.org/project/parsimathious/)
+[![Tests](https://github.com/stur86/parsimathious/actions/workflows/test.yml/badge.svg)](https://github.com/stur86/parsimathious/actions/workflows/test.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+`parsimathious` is a simple mathematical expression parser implemented with [`parsimonious`](https://github.com/erikrose/parsimonious). It supports basic arithmetic operations, parentheses, unary functions, constants, and complex numbers.
+
+## Installation
+
+You can install `parsimathious` using pip:
+
+```bash
+pip install parsimathious
+```
+
+## Usage
+
+Import the `ExpressionParser` and create an instance:
+
+```python
+from parsimathious import ExpressionParser
+
+parser = ExpressionParser()
+```
+
+Then you can parse and evaluate expressions:
+
+```python
+result = parser("sin(pi / 2) + 1")
+print(result)  # Output: 2.0
+```
+
+## Supported functions and constants
+
+
+On top of basic arithmetic operations, `parsimathious` supports the following unary functions and constants by default:
+
+| Name     | Python Implementation           | Description                       |
+|----------|--------------------------------|------------------------------------|
+| `sin`    | math.sin                       | Sine                               |
+| `cos`    | math.cos                       | Cosine                             |
+| `tan`    | math.tan                       | Tangent                            |
+| `log`    | math.log                       | Natural logarithm (base e)         |
+| `sqrt`   | math.sqrt                      | Square root                        |
+| `exp`    | math.exp                       | Exponential (e^x)                  |
+| `log10`  | math.log10                     | Logarithm base 10                  |
+| `abs`    | abs                            | Absolute value                     |
+| `floor`  | math.floor                     | Floor (round down)                 |
+| `ceil`   | math.ceil                      | Ceiling (round up)                 |
+| `round`  | round                          | Round to nearest integer           |
+| `sinh`   | math.sinh                      | Hyperbolic sine                    |
+| `cosh`   | math.cosh                      | Hyperbolic cosine                  |
+| `tanh`   | math.tanh                      | Hyperbolic tangent                 |
+| `asin`   | math.asin                      | Arc sine                           |
+| `acos`   | math.acos                      | Arc cosine                         |
+| `atan`   | math.atan                      | Arc tangent                        |
+| `asinh`  | math.asinh                     | Inverse hyperbolic sine            |
+| `acosh`  | math.acosh                     | Inverse hyperbolic cosine          |
+| `atanh`  | math.atanh                     | Inverse hyperbolic tangent         |
+| `sec`    | lambda x: 1 / math.cos(x)      | Secant                             |
+| `csc`    | lambda x: 1 / math.sin(x)      | Cosecant                           |
+| `cot`    | lambda x: 1 / math.tan(x)      | Cotangent                          |
+
+### Constants
+
+| Name | Value                | Description                |
+|------|----------------------|----------------------------|
+| `pi` | math.pi              | The mathematical constant π |
+| `e`  | math.e               | The mathematical constant e |
+| `i`  | 1j                   | The imaginary unit         |
+
+## Custom Unary Functions
+
+It's also possible to support custom unary functions by passing a dictionary of function names to their implementations when creating the `ExpressionParser`:
+
+```python
+import math
+from parsimathious import ExpressionParser, UnaryFunctionMap
+
+custom_functions: UnaryFunctionMap = {
+    "log2": math.log2,  # Logarithm base 2
+    "cube": lambda x: x ** 3,  # Cube function
+}
+
+parser = ExpressionParser(unary_functions=custom_functions)
+result = parser("log2(8) + cube(3)")
+print(result)  # Output: 35.0
+```

parsimathious-0.1.1/README.md

@@ -0,0 +1,90 @@
+# parsimathious
+
+[![PyPI](https://img.shields.io/pypi/v/parsimathious)](https://pypi.org/project/parsimathious/)
+[![Python](https://img.shields.io/pypi/pyversions/parsimathious)](https://pypi.org/project/parsimathious/)
+[![Tests](https://github.com/stur86/parsimathious/actions/workflows/test.yml/badge.svg)](https://github.com/stur86/parsimathious/actions/workflows/test.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+`parsimathious` is a simple mathematical expression parser implemented with [`parsimonious`](https://github.com/erikrose/parsimonious). It supports basic arithmetic operations, parentheses, unary functions, constants, and complex numbers.
+
+## Installation
+
+You can install `parsimathious` using pip:
+
+```bash
+pip install parsimathious
+```
+
+## Usage
+
+Import the `ExpressionParser` and create an instance:
+
+```python
+from parsimathious import ExpressionParser
+
+parser = ExpressionParser()
+```
+
+Then you can parse and evaluate expressions:
+
+```python
+result = parser("sin(pi / 2) + 1")
+print(result)  # Output: 2.0
+```
+
+## Supported functions and constants
+
+
+On top of basic arithmetic operations, `parsimathious` supports the following unary functions and constants by default:
+
+| Name     | Python Implementation           | Description                       |
+|----------|--------------------------------|------------------------------------|
+| `sin`    | math.sin                       | Sine                               |
+| `cos`    | math.cos                       | Cosine                             |
+| `tan`    | math.tan                       | Tangent                            |
+| `log`    | math.log                       | Natural logarithm (base e)         |
+| `sqrt`   | math.sqrt                      | Square root                        |
+| `exp`    | math.exp                       | Exponential (e^x)                  |
+| `log10`  | math.log10                     | Logarithm base 10                  |
+| `abs`    | abs                            | Absolute value                     |
+| `floor`  | math.floor                     | Floor (round down)                 |
+| `ceil`   | math.ceil                      | Ceiling (round up)                 |
+| `round`  | round                          | Round to nearest integer           |
+| `sinh`   | math.sinh                      | Hyperbolic sine                    |
+| `cosh`   | math.cosh                      | Hyperbolic cosine                  |
+| `tanh`   | math.tanh                      | Hyperbolic tangent                 |
+| `asin`   | math.asin                      | Arc sine                           |
+| `acos`   | math.acos                      | Arc cosine                         |
+| `atan`   | math.atan                      | Arc tangent                        |
+| `asinh`  | math.asinh                     | Inverse hyperbolic sine            |
+| `acosh`  | math.acosh                     | Inverse hyperbolic cosine          |
+| `atanh`  | math.atanh                     | Inverse hyperbolic tangent         |
+| `sec`    | lambda x: 1 / math.cos(x)      | Secant                             |
+| `csc`    | lambda x: 1 / math.sin(x)      | Cosecant                           |
+| `cot`    | lambda x: 1 / math.tan(x)      | Cotangent                          |
+
+### Constants
+
+| Name | Value                | Description                |
+|------|----------------------|----------------------------|
+| `pi` | math.pi              | The mathematical constant π |
+| `e`  | math.e               | The mathematical constant e |
+| `i`  | 1j                   | The imaginary unit         |
+
+## Custom Unary Functions
+
+It's also possible to support custom unary functions by passing a dictionary of function names to their implementations when creating the `ExpressionParser`:
+
+```python
+import math
+from parsimathious import ExpressionParser, UnaryFunctionMap
+
+custom_functions: UnaryFunctionMap = {
+    "log2": math.log2,  # Logarithm base 2
+    "cube": lambda x: x ** 3,  # Cube function
+}
+
+parser = ExpressionParser(unary_functions=custom_functions)
+result = parser("log2(8) + cube(3)")
+print(result)  # Output: 35.0
+```

parsimathious-0.1.1/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "parsimathious"
+version = "0.1.1"
+description = "A mathematical expression parser supporting arithmetic, functions, and complex numbers"
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Simone Sturniolo", email = "simonesturniolo@gmail.com" }
+]
+requires-python = ">=3.11"
+keywords = ["math", "parser", "expression", "arithmetic", "complex numbers"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "License :: OSI Approved :: MIT License",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Mathematics"
+]
+dependencies = [
+    "parsimonious>=0.11.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/stur86/parsimathious"
+Repository = "https://github.com/stur86/parsimathious"
+Issues = "https://github.com/stur86/parsimathious/issues"
+
+[build-system]
+requires = ["uv_build>=0.10.8,<0.11.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.3",
+    "taskipy>=1.14.1",
+]
+
+[tool.taskipy.tasks]
+test = "pytest tests"
+build = "uv build"
+publish = "uv publish"

parsimathious-0.1.1/src/parsimathious/__init__.py

@@ -0,0 +1,4 @@
+from .grammar import ExpressionGrammar, UnaryFunctionMap
+from .parser import ExpressionParser
+
+__all__ = ["ExpressionGrammar", "UnaryFunctionMap", "ExpressionParser"]

parsimathious-0.1.1/src/parsimathious/grammar.py

@@ -0,0 +1,90 @@
+import math
+from parsimonious import Grammar, ParseError
+from parsimonious.nodes import Node
+from typing import Dict, Callable
+
+UnaryFunction = Callable[[float], float]
+UnaryFunctionMap = Dict[str, UnaryFunction]
+
+_DEFAULT_UNARY_FUNCTIONS: UnaryFunctionMap = {
+    "sin": math.sin,
+    "cos": math.cos,
+    "tan": math.tan,
+    "log": math.log,
+    "sqrt": math.sqrt,
+    "exp": math.exp,
+    "log10": math.log10,
+    "abs": abs,
+    "floor": math.floor,
+    "ceil": math.ceil,
+    "round": round,
+    "sinh": math.sinh,
+    "cosh": math.cosh,
+    "tanh": math.tanh,
+    "asin": math.asin,
+    "acos": math.acos,
+    "atan": math.atan,
+    "asinh": math.asinh,
+    "acosh": math.acosh,
+    "atanh": math.atanh,
+    "sec": lambda x: 1 / math.cos(x),
+    "csc": lambda x: 1 / math.sin(x),
+    "cot": lambda x: 1 / math.tan(x),
+}
+
+class ExpressionGrammar:
+    _grammar: Grammar
+    
+    def __init__(self, unary_functions: UnaryFunctionMap = _DEFAULT_UNARY_FUNCTIONS):
+        grammar_definition = """
+            expression = sum / unary_number
+            sum = term (add_op term)* 
+            term = factor (mul_op factor)*
+            factor = exp_factor (exp_op exp_factor)*
+            exp_factor = atom
+            unary_number = unary_op number
+            parenthesized_expression = "(" expression ")"
+            add_op = "+" / "-"
+            mul_op = "*" / "/"
+            exp_op = "^"
+            unary_op = "+" / "-"
+            number = ~r"\\d+(\\.\\d+)?"
+            constant = "pi" / "e"
+            imaginary_unit = "i"
+            imaginary_number = number imaginary_unit
+            complex_number = imaginary_number / number / imaginary_unit / constant
+        """
+        if len(unary_functions) > 0:
+            function_keys = list(unary_functions.keys())
+            # Sort them from longest to shortest to ensure correct parsing (e.g., "log10" before "log")
+            function_keys.sort(key=len, reverse=True)
+            function_names = " / ".join(f'"{name}"' for name in function_keys)
+            grammar_definition += f"""atom = function_call / parenthesized_expression / complex_number
+            function_call = function_name parenthesized_expression
+            function_name = {function_names}"""
+        else:
+            grammar_definition += "atom = parenthesized_expression / complex_number"
+
+        self._grammar = Grammar(grammar_definition)
+
+    def __call__(self, expression: str) -> Node:
+        # Strip out all spaces
+        expression = expression.replace(" ", "")
+        try:
+            return self._grammar.parse(expression)
+        except ParseError as e:
+            raise Exception(f"Syntax error at position {e.pos}: {e.text[e.pos:e.pos+20]}") from e
+        except Exception as e:
+            raise Exception(f"Error parsing expression: {e}") from e
+    
+
+if __name__ == "__main__":
+    while True:
+        grammar = ExpressionGrammar()
+        try:
+            expr = input("Enter an expression (or 'exit' to quit): ")
+            if expr.lower() == "exit":
+                break
+            ast = grammar(expr)
+        except Exception as e:
+            print(f"Error: {e}")

parsimathious-0.1.1/src/parsimathious/parser.py

@@ -0,0 +1,102 @@
+import math
+from typing import Any, Sequence
+
+from parsimonious import NodeVisitor
+from parsimonious.nodes import Node
+from .grammar import ExpressionGrammar, UnaryFunctionMap, _DEFAULT_UNARY_FUNCTIONS
+
+
+class ExpressionVisitor(NodeVisitor):
+    def __init__(self, unary_functions: UnaryFunctionMap):
+        super().__init__()
+        self._unary_functions = unary_functions
+        
+    def visit_complex_number(self, node, visited_children):
+        return visited_children[0]
+        
+    def visit_imaginary_number(self, node, visited_children):
+        number_node, _ = visited_children
+        if number_node is None:
+            return complex(0, 1)  # Just "i" means 0 + 1i
+        else:
+            return complex(0, float(number_node))  # e.g., "2i" means 0 + 2i
+        
+    def visit_number(self, node, visited_children):
+        return float(node.text)
+    
+    def visit_imaginary_unit(self, node, visited_children):
+        return 1.0j
+    
+    def visit_constant(self, node, visited_children):
+        constant_map = {
+            "pi": math.pi,
+            "e": math.e,
+        }
+        try:
+            return constant_map[node.text]
+        except KeyError:
+            raise ValueError(f"Unknown constant: {node.text}")
+    
+    def visit_atom(self, node, visited_children):
+        return visited_children[0]
+    
+    def visit_exp_factor(self, node, visited_children):
+        return visited_children[0]
+    
+    def visit_factor(self, node, visited_children):
+        base = visited_children[0]
+        for op, exponent in visited_children[1]:
+            if op.text != "^":
+                raise ValueError(f"Unexpected operator in factor: {op.text}")
+            base = base ** exponent
+        return base
+    
+    def visit_term(self, node, visited_children):
+        result = visited_children[0]
+        for [op], factor in visited_children[1]:
+            if op.text == "*":
+                result *= factor
+            elif op.text == "/":
+                result /= factor
+            else:
+                raise ValueError(f"Unexpected operator in term: {op.text}")
+        return result
+    
+    def visit_sum(self, node, visited_children):
+        result = visited_children[0]
+        for [op], term in visited_children[1]:
+            if op.text == "+":
+                result += term
+            elif op.text == "-":
+                result -= term
+            else:
+                raise ValueError(f"Unexpected operator in expression: {op.text}")
+        return result
+    
+    def visit_parenthesized_expression(self, node, visited_children):
+        _, expr, _ = visited_children
+        return expr[0]
+    
+    def visit_function_name(self, node, visited_children):
+        return node
+    
+    def visit_function_call(self, node, visited_children):
+        function_name_node, arg_node = visited_children
+        function_name = function_name_node.text
+        if function_name not in self._unary_functions:
+            raise ValueError(f"Unknown function: {function_name}")
+        func = self._unary_functions[function_name]
+        arg_value = arg_node  # The argument is the first child of the parenthesized expression
+        return func(arg_value)
+            
+    def generic_visit(self, node: Node, visited_children: Sequence[Any]):
+        return visited_children or node
+    
+class ExpressionParser:
+    def __init__(self, unary_functions: UnaryFunctionMap = _DEFAULT_UNARY_FUNCTIONS):
+        self._grammar = ExpressionGrammar(unary_functions)
+        self._visitor = ExpressionVisitor(unary_functions)
+    
+    def __call__(self, expression: str) -> float | complex:
+        ast = self._grammar(expression)
+        return self._visitor.visit(ast)