physure 0.2.0__tar.gz → 0.2.1__tar.gz

{physure-0.2.0 → physure-0.2.1}/Cargo.lock

@@ -1044,7 +1044,7 @@ checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
 [[package]]
 name = "physure"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "approx 0.5.1",
  "arrow",
@@ -1063,7 +1063,7 @@ dependencies = [
 
 [[package]]
 name = "physure-python"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "arrow",
  "chrono",

{physure-0.2.0 → physure-0.2.1}/Cargo.toml

@@ -9,7 +9,7 @@ resolver = "2"
 members  = ["physure-core", "physure-python"]
 
 [workspace.package]
-version     = "0.2.0"
+version     = "0.2.1"
 edition     = "2021"
 license     = "MIT"
 repository  = "https://github.com/Alexisrx96/physure"

{physure-0.2.0 → physure-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: physure
-Version: 0.2.0
+Version: 0.2.1
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -80,17 +80,21 @@ Project-URL: Documentation, https://physure.readthedocs.io/
 Project-URL: Homepage, https://github.com/Alexisrx96/physure
 Project-URL: Source, https://github.com/Alexisrx96/physure
 
-# physure 🔬
-
 <div align="center">
 
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/Alexisrx96/physure/main/assets/logo-horizontal-dark.svg">
+  <img src="https://raw.githubusercontent.com/Alexisrx96/physure/main/assets/logo-horizontal-light.svg" alt="physure" width="440">
+</picture>
+
 <h3><b>Unit-aware, dimension-correct computing for Python — powered by a Rust core</b></h3>
 <p><i>Units, dimensions, and correlated uncertainty tracked through every calculation, with zero overhead under <code>torch.compile</code> / <code>jax.jit</code>.</i></p>
 
-[![PyPI](https://img.shields.io/pypi/v/physure)](https://pypi.org/project/physure/)
-[![Python 3.11–3.14](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue)](https://pypi.org/project/physure/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/Alexisrx96/physure/blob/main/LICENSE)
-[![Rust core](https://img.shields.io/badge/core-Rust%20%F0%9F%A6%80-orange)](https://github.com/Alexisrx96/physure/tree/main/physure-core/)
+[![PyPI](https://img.shields.io/pypi/v/physure?color=F59E0B&labelColor=18181A)](https://pypi.org/project/physure/)
+[![crates.io](https://img.shields.io/crates/v/physure?color=F59E0B&labelColor=18181A)](https://crates.io/crates/physure)
+[![CI](https://img.shields.io/github/actions/workflow/status/Alexisrx96/physure/tests.yml?branch=main&labelColor=18181A)](https://github.com/Alexisrx96/physure/actions/workflows/tests.yml)
+[![Python 3.11–3.14](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-F59E0B?labelColor=18181A)](https://pypi.org/project/physure/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-F59E0B?labelColor=18181A)](https://github.com/Alexisrx96/physure/blob/main/LICENSE)
 
 </div>
 

{physure-0.2.0 → physure-0.2.1}/README.md

@@ -1,14 +1,18 @@
-# physure 🔬
-
 <div align="center">
 
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/Alexisrx96/physure/main/assets/logo-horizontal-dark.svg">
+  <img src="https://raw.githubusercontent.com/Alexisrx96/physure/main/assets/logo-horizontal-light.svg" alt="physure" width="440">
+</picture>
+
 <h3><b>Unit-aware, dimension-correct computing for Python — powered by a Rust core</b></h3>
 <p><i>Units, dimensions, and correlated uncertainty tracked through every calculation, with zero overhead under <code>torch.compile</code> / <code>jax.jit</code>.</i></p>
 
-[![PyPI](https://img.shields.io/pypi/v/physure)](https://pypi.org/project/physure/)
-[![Python 3.11–3.14](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue)](https://pypi.org/project/physure/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/Alexisrx96/physure/blob/main/LICENSE)
-[![Rust core](https://img.shields.io/badge/core-Rust%20%F0%9F%A6%80-orange)](https://github.com/Alexisrx96/physure/tree/main/physure-core/)
+[![PyPI](https://img.shields.io/pypi/v/physure?color=F59E0B&labelColor=18181A)](https://pypi.org/project/physure/)
+[![crates.io](https://img.shields.io/crates/v/physure?color=F59E0B&labelColor=18181A)](https://crates.io/crates/physure)
+[![CI](https://img.shields.io/github/actions/workflow/status/Alexisrx96/physure/tests.yml?branch=main&labelColor=18181A)](https://github.com/Alexisrx96/physure/actions/workflows/tests.yml)
+[![Python 3.11–3.14](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-F59E0B?labelColor=18181A)](https://pypi.org/project/physure/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-F59E0B?labelColor=18181A)](https://github.com/Alexisrx96/physure/blob/main/LICENSE)
 
 </div>
 

{physure-0.2.0 → physure-0.2.1}/physure/__init__.py

@@ -26,7 +26,7 @@ from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
 # ── Version ───────────────────────────────────────────────────────────────────
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 
 # ── Rust-first: hard import of native core ────────────────────────────────────
 # Unlike physure, physure has NO pure-Python fallback.
@@ -143,6 +143,26 @@ _PLOT_ATTRS = {
     "plot_pairplot",
     "plot_covariance",
 }
+_HELPER_ATTRS = {
+    "approx_eq",
+    "linspace",
+    "sqrt",
+    "sin",
+    "cos",
+    "tan",
+    "asin",
+    "acos",
+    "atan",
+    "atan2",
+    "sinh",
+    "cosh",
+    "tanh",
+    "exp",
+    "log",
+    "log10",
+    "pi",
+    "e",
+}
 
 
 def _load_io(name: str) -> Any:
@@ -151,6 +171,12 @@ def _load_io(name: str) -> Any:
     return save_state if name == "save_state" else load_state
 
 
+def _load_helpers(name: str) -> Any:
+    import physure.ext.helpers as helpers
+
+    return getattr(helpers, name)
+
+
 def _load_q(name: str) -> Any:
     from physure.application.factories import QuantityFactory
 
@@ -283,6 +309,8 @@ for _attr in ("equivalencies", "spectral", "thermodynamic"):
     _ATTR_LOADERS[_attr] = _load_equivalencies
 for _attr in _PLOT_ATTRS:
     _ATTR_LOADERS[_attr] = _load_plotting
+for _attr in _HELPER_ATTRS:
+    _ATTR_LOADERS[_attr] = _load_helpers
 del _attr
 
 
@@ -332,15 +360,28 @@ __all__ = [
     "Uncertainty",
     "UnitNotFoundError",
     "UnknownUnitError",
+    "acos",
+    "approx_eq",
+    "asin",
+    "atan",
+    "atan2",
+    "cos",
+    "cosh",
     "create_default_system",
     "create_system",
     "default_system",
+    "e",
     "equivalencies",
+    "exp",
     "get_active_system",
     "get_current_system",
     "get_unit",
     "jit",
+    "linspace",
     "load_state",
+    "log",
+    "log10",
+    "pi",
     "plot",
     "plot_covariance",
     "plot_interactive",
@@ -348,8 +389,13 @@ __all__ = [
     "plot_parallel_coordinates",
     "plot_slices",
     "save_state",
+    "sin",
+    "sinh",
+    "sqrt",
     "spectral",
     "system_context",
+    "tan",
+    "tanh",
     "thermodynamic",
     "uncertainty_mode",
     "units",

{physure-0.2.0 → physure-0.2.1}/physure/domain/measurement/_arithmetic_mixin.py

@@ -1144,10 +1144,24 @@ class ArithmeticMixin:
         self._record_op(op, other, res)
         return res
 
+    def _reject_bare_number_add_sub(self, other: Quantity | Numeric) -> None:
+        """A bare number carries no unit: '5 m + 2' must raise, never.
+
+        silently assume the 2 is metres. Only a dimensionless quantity
+        may absorb bare numbers additively.
+        """
+        if isinstance(other, _q()) or self.dimension.is_dimensionless:
+            return
+        if isinstance(other, (int, float, complex)) or self._backend.is_array(
+            other
+        ):
+            raise IncompatibleUnitsError(self.unit, CompoundUnit({}))
+
     def _add_sub_impl(
         self, other: Quantity | Numeric, is_add: bool
     ) -> Quantity:
         op = "add" if is_add else "sub"
+        self._reject_bare_number_add_sub(other)
         rust_res = self._check_and_handle_rust_propagation(other, op)
         if rust_res is not None:
             return rust_res
@@ -1186,6 +1200,7 @@ class ArithmeticMixin:
 
     def __rsub__(self, other: Quantity | Numeric) -> Quantity:
         """Right subtraction."""
+        self._reject_bare_number_add_sub(other)
         rust_res = self._check_and_handle_rust_propagation(other, "rsub")
         if rust_res is not None:
             return rust_res

{physure-0.2.0 → physure-0.2.1}/physure/domain/symbolic/native.py

@@ -140,8 +140,8 @@ def _add_like_unit(nodes: tuple[Node, ...]) -> CompoundUnit | None:
     return result
 
 
-def _infer_unit_none(node: Node) -> CompoundUnit | None:
-    return None
+def _infer_unit_number(node: Number) -> CompoundUnit | None:
+    return CompoundUnit({})
 
 
 def _infer_unit_quantity(node: Quantity) -> CompoundUnit | None:
@@ -198,9 +198,13 @@ def _infer_unit_transcendental(
     return None
 
 
+def _infer_unit_symbol(node: Symbol) -> CompoundUnit | None:
+    return None
+
+
 _INFER_UNIT_DISPATCH: dict[type, Callable[[Any], CompoundUnit | None]] = {
-    Number: _infer_unit_none,
-    Symbol: _infer_unit_none,
+    Number: _infer_unit_number,
+    Symbol: _infer_unit_symbol,
     Quantity: _infer_unit_quantity,
     Add: _infer_unit_add,
     Sub: _infer_unit_sub,

{physure-0.2.0 → physure-0.2.1}/physure/ext/grammar.py

@@ -73,7 +73,7 @@ _NUMBER_PAT = r"\d+\.?\d*(?:[eE]\s*[+-]?\s*\d+)?|\.\d+(?:[eE]\s*[+-]?\s*\d+)?"
 _IDENT_PAT = r"[^\W\d]\w*"
 _SUP_PAT = r"[⁻⁰¹²³⁴⁵⁶⁷⁸⁹]+"
 _SQRT_PAT = r"√"
-_OP_PAT = r"\+/-|±|<=|>=|!=|==|=>|->|\*\s*\*|\*\*|[-+*/^()=?<>×÷,:|]"  # noqa: RUF001
+_OP_PAT = r"\+/-|±|<=|>=|!=|==|=>|->|≈|\*\s*\*|\*\*|[-+*/^()=?<>×÷,:|]"  # noqa: RUF001
 
 _OP_ALIASES = {"×": "*", "÷": "/"}  # noqa: RUF001
 _TOKEN_RE = re.compile(
@@ -158,6 +158,25 @@ def _top_level_index(tokens: list[Token], op: str) -> int:
     return -1
 
 
+def _approx_eq(
+    a: Any, b: Any, rel_tol: float = 0.1, abs_tol: float = 1e-5
+) -> bool:
+    a_mag = getattr(a, "magnitude", a)
+    b_mag = getattr(b, "magnitude", b)
+    if hasattr(a, "to") and hasattr(b, "unit"):
+        try:
+            b_converted = b.to(a.unit)
+            b_mag = b_converted.magnitude
+        except Exception:
+            return False
+    try:
+        return math.isclose(
+            float(a_mag), float(b_mag), rel_tol=rel_tol, abs_tol=abs_tol
+        )
+    except Exception:
+        return False
+
+
 _COMPARISONS: dict[str, Callable[[Any, Any], bool]] = {
     "<": operator.lt,
     ">": operator.gt,
@@ -165,6 +184,7 @@ _COMPARISONS: dict[str, Callable[[Any, Any], bool]] = {
     ">=": operator.ge,
     "==": operator.eq,
     "!=": operator.ne,
+    "≈": _approx_eq,
 }
 
 
@@ -511,9 +531,160 @@ _FUNCTIONS: dict[str, tuple[int, float, Callable[..., GrammarValue]]] = {
     "exp": (1, 1, lambda x: _transcendental(x, "exp")),
     "log": (1, 1, lambda x: _transcendental(x, "log")),
     "ln": (1, 1, lambda x: _transcendental(x, "log")),
+    "linspace": (2, 3, lambda *a: _linspace_fn(*a)),
+    "plot": (1, 3, lambda *a: _plot_fn(*a)),
 }
 
 
+def _linspace_fn(
+    start: GrammarValue, stop: GrammarValue, num: GrammarValue = 50
+) -> Any:
+    import numpy as np
+
+    from physure.domain.measurement.quantity import Quantity
+
+    start_mag = getattr(start, "magnitude", start)
+    stop_mag = getattr(stop, "magnitude", stop)
+    unit = getattr(start, "unit", getattr(stop, "unit", None))
+    system = getattr(start, "system", getattr(stop, "system", None))
+
+    arr = np.linspace(float(start_mag), float(stop_mag), int(num))
+    if unit is not None:
+        return Quantity.from_input(arr, unit, system)
+    return arr
+
+
+def _format_unit_str(unit_raw: str) -> str:
+    u = str(unit_raw).strip()
+    if u in ("1", "", "None"):
+        return ""
+    aliases = {
+        "kg·m/s²": "N",
+        "kg*m/s^2": "N",
+        "kg·m³/(A·s³)": "N/C",
+        "A·s": "C",
+    }
+    return aliases.get(u, u)
+
+
+def _draw_ascii_plot(
+    x: Any, y: Any, title: str = "Plot", x_unit: str = "", y_unit: str = ""
+) -> str:
+    import numpy as np
+
+    x_arr = np.asarray(x, dtype=float)
+    y_arr = np.asarray(y, dtype=float)
+    if len(x_arr) == 0 or len(y_arr) == 0:
+        return f"📊 {title}: [No data points]"
+
+    width = 46
+    height = 8
+
+    x_grid = np.linspace(x_arr.min(), x_arr.max(), width)
+    y_grid = np.interp(x_grid, x_arr, y_arr)
+
+    y_min, y_max = y_grid.min(), y_grid.max()
+    y_span = (y_max - y_min) if (y_max != y_min) else 1.0
+
+    fmt_x = _format_unit_str(x_unit)
+    fmt_y = _format_unit_str(y_unit)
+
+    lines = []
+    lines.append(f"  📊 {title}")
+    lines.append(f"  {y_max:.3e} {fmt_y}".strip().rjust(18) + " ┐")
+
+    for r in range(height - 1, -1, -1):
+        y_level = y_min + (r / (height - 1)) * y_span
+        row_chars = []
+        for c in range(width):
+            val = y_grid[c]
+            diff = abs(val - y_level) / y_span
+            if diff < (1.0 / (2 * height)):
+                row_chars.append("█")
+            elif val > y_level:
+                row_chars.append("░")
+            else:
+                row_chars.append(" ")
+        lines.append("                   │ " + "".join(row_chars))
+
+    lines.append(
+        f"  {y_min:.3e} {fmt_y}".strip().rjust(18) + " └" + "─" * width
+    )
+    x_min_str = f"{x_arr.min():.3e} {fmt_x}".strip()
+    x_max_str = f"{x_arr.max():.3e} {fmt_x}".strip()
+    pad_len = max(1, width - len(x_min_str) - len(x_max_str) + 12)
+    lines.append(
+        "                     " + x_min_str + " " * pad_len + x_max_str
+    )
+
+    return "\n".join(lines)
+
+
+def _plot_fn(*args: Any, **kwargs: Any) -> Any:
+    import base64
+    import io
+
+    import matplotlib
+
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    import numpy as np
+
+    x_val = args[0] if len(args) >= 2 else None
+    y_val = args[1] if len(args) >= 2 else args[0]
+
+    y_mag = getattr(y_val, "magnitude", y_val)
+    y_unit = _format_unit_str(getattr(y_val, "unit", ""))
+    y_arr = np.asarray(y_mag, dtype=float)
+
+    if x_val is not None:
+        x_mag = getattr(x_val, "magnitude", x_val)
+        x_unit = _format_unit_str(getattr(x_val, "unit", ""))
+        x_arr = np.asarray(x_mag, dtype=float)
+    else:
+        x_arr = np.arange(len(y_arr))
+        x_unit = ""
+
+    title = str(kwargs.get("title", "Physure Live Plot"))
+    ascii_plot = _draw_ascii_plot(
+        x_arr, y_arr, title=title, x_unit=x_unit, y_unit=y_unit
+    )
+
+    fig, ax = plt.subplots(figsize=(6.5, 3.8))
+    ax.plot(x_arr, y_arr, color="#4ec9b0", linewidth=2.5)
+    ax.fill_between(x_arr, y_arr, color="#4ec9b0", alpha=0.12)
+
+    x_label_str = f"x ({x_unit})" if x_unit else "x"
+    y_label_str = f"y ({y_unit})" if y_unit else "y"
+
+    ax.set_xlabel(x_label_str, color="#cccccc", fontsize=9.5)
+    ax.set_ylabel(y_label_str, color="#cccccc", fontsize=9.5)
+
+    ax.set_title(
+        title, color="#569cd6", fontsize=11, fontweight="bold", pad=12
+    )
+    ax.grid(True, linestyle=":", alpha=0.35, color="#666666")
+    ax.tick_params(colors="#cccccc", labelsize=8.5)
+
+    for spine in ax.spines.values():
+        spine.set_color("#444444")
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+
+    fig.patch.set_facecolor("#1e1e1e")
+    ax.set_facecolor("#252526")
+    fig.tight_layout()
+
+    buf = io.BytesIO()
+    fig.savefig(buf, format="png", bbox_inches="tight", dpi=140)
+    buf.seek(0)
+    b64 = base64.b64encode(buf.read()).decode("utf-8")
+    plt.close(fig)
+
+    b64_tag = f"[PLOT_IMAGE:data:image/png;base64,{b64}]"
+    return f"{ascii_plot}\n{b64_tag}"
+
+
 def _format_sig_figs(val: GrammarValue, sig_figs: int) -> GrammarValue:
     """Formats a scalar or Quantity magnitude to sig_figs significant figures."""
     mag = getattr(val, "magnitude", val)
@@ -584,7 +755,7 @@ class GrammarInterpreter:
                 text = text[1:]
             if text.endswith("\n"):
                 text = text[:-1]
-            results.append(text)
+            results.append(self._interpolate_text(text))
             current_line += match.group(0).count("\n")
             pos = match.end()
 
@@ -592,6 +763,21 @@ class GrammarInterpreter:
         results.extend(self._run_segment(tail, start_line_num=current_line))
         return results
 
+    def _interpolate_text(self, text: str) -> str:
+        def replacer(m: re.Match[str]) -> str:
+            expr = m.group(1).strip()
+            try:
+                res_list = self._run_segment(expr)
+                if res_list:
+                    val = res_list[-1]
+                    if val is not None:
+                        return str(val)
+            except Exception as e:
+                return f"{{ERR: {e}}}"
+            return m.group(0)
+
+        return re.sub(r"\{([^}]+)\}", replacer, text)
+
     def _run_segment(
         self, segment: str, start_line_num: int = 1
     ) -> list[GrammarValue | None]:

physure-0.2.1/physure/ext/helpers.py

@@ -0,0 +1,146 @@
+"""Helper functions for exported Physure DSL scripts."""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+from physure.application.factories import QuantityFactory
+
+Q_ = QuantityFactory()
+
+pi = math.pi
+e = math.e
+
+
+def _to_float(val: Any) -> float:
+    return float(getattr(val, "magnitude", val))
+
+
+def approx_eq(
+    a: Any, b: Any, rel_tol: float = 0.1, abs_tol: float = 1e-5
+) -> bool:
+    """Check approximate equality between numbers or Quantities."""
+    if hasattr(a, "approx_eq") and hasattr(b, "_core") and hasattr(a, "_core"):
+        try:
+            return bool(a._core.approx_eq(b._core, rel_tol, abs_tol))
+        except Exception:
+            pass
+    a_mag = getattr(a, "magnitude", a)
+    b_mag = getattr(b, "magnitude", b)
+    if hasattr(a, "to") and hasattr(b, "unit"):
+        try:
+            b_mag = b.to(a.unit).magnitude
+        except Exception:
+            return False
+    try:
+        return math.isclose(
+            float(a_mag), float(b_mag), rel_tol=rel_tol, abs_tol=abs_tol
+        )
+    except Exception:
+        return False
+
+
+def linspace(start: Any, stop: Any, num: int = 50) -> Any:
+    """Generate linearly spaced numbers or Quantities."""
+    import numpy as np
+
+    start_val = getattr(start, "magnitude", start)
+    stop_val = getattr(stop, "magnitude", stop)
+    unit = getattr(start, "unit", getattr(stop, "unit", None))
+    arr = np.linspace(float(start_val), float(stop_val), int(num))
+    if unit:
+        return Q_(arr, str(unit))
+    return arr
+
+
+def plot(*args: Any) -> None:
+    """Plot physical quantities using matplotlib."""
+    try:
+        import matplotlib.pyplot as plt
+
+        _fig, ax = plt.subplots()
+        if len(args) >= 2:
+            x, y = args[0], args[1]
+            x_val = getattr(x, "magnitude", x)
+            y_val = getattr(y, "magnitude", y)
+            ax.plot(x_val, y_val)
+        elif len(args) == 1:
+            y = args[0]
+            y_val = getattr(y, "magnitude", y)
+            ax.plot(y_val)
+        plt.show()
+    except Exception as err:
+        print(f"Plot error: {err}")
+
+
+def sqrt(x: Any) -> Any:
+    """Square root supporting Quantities and numbers."""
+    if hasattr(x, "unit") or hasattr(x, "magnitude"):
+        return x**0.5
+    return math.sqrt(float(x))
+
+
+def sin(x: Any) -> float:
+    """Sine of scalar value."""
+    return math.sin(_to_float(x))
+
+
+def cos(x: Any) -> float:
+    """Cosine of scalar value."""
+    return math.cos(_to_float(x))
+
+
+def tan(x: Any) -> float:
+    """Tangent of scalar value."""
+    return math.tan(_to_float(x))
+
+
+def asin(x: Any) -> float:
+    """Arcsine of scalar value."""
+    return math.asin(_to_float(x))
+
+
+def acos(x: Any) -> float:
+    """Arccosine of scalar value."""
+    return math.acos(_to_float(x))
+
+
+def atan(x: Any) -> float:
+    """Arctangent of scalar value."""
+    return math.atan(_to_float(x))
+
+
+def atan2(y: Any, x: Any) -> float:
+    """Two-argument arctangent of scalar values."""
+    return math.atan2(_to_float(y), _to_float(x))
+
+
+def sinh(x: Any) -> float:
+    """Hyperbolic sine of scalar value."""
+    return math.sinh(_to_float(x))
+
+
+def cosh(x: Any) -> float:
+    """Hyperbolic cosine of scalar value."""
+    return math.cosh(_to_float(x))
+
+
+def tanh(x: Any) -> float:
+    """Hyperbolic tangent of scalar value."""
+    return math.tanh(_to_float(x))
+
+
+def exp(x: Any) -> float:
+    """Exponential of scalar value."""
+    return math.exp(_to_float(x))
+
+
+def log(x: Any) -> float:
+    """Natural logarithm of scalar value."""
+    return math.log(_to_float(x))
+
+
+def log10(x: Any) -> float:
+    """Base-10 logarithm of scalar value."""
+    return math.log10(_to_float(x))

{physure-0.2.0 → physure-0.2.1}/physure/repl.py

@@ -24,7 +24,15 @@ _BANNER = (
 def _print_results(results: list[Any]) -> None:
     for result in results:
         if result is not None:
-            print(result)
+            s = str(result)
+            lines = [
+                line
+                for line in s.split("\n")
+                if not line.startswith("[PLOT_IMAGE:")
+            ]
+            clean_str = "\n".join(lines).rstrip()
+            if clean_str:
+                print(clean_str)
 
 
 def _run_source(source: str) -> int:

{physure-0.2.0 → physure-0.2.1}/physure-core/README.md

@@ -1,7 +1,14 @@
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/Alexisrx96/physure/main/assets/logo-horizontal-dark.svg">
+  <img src="https://raw.githubusercontent.com/Alexisrx96/physure/main/assets/logo-horizontal-light.svg" alt="physure" width="380">
+</picture>
+
 # physure 🦀
 
-[![crates.io](https://img.shields.io/crates/v/physure)](https://crates.io/crates/physure)
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/Alexisrx96/physure/blob/main/LICENSE)
+[![crates.io](https://img.shields.io/crates/v/physure?color=F59E0B&labelColor=18181A)](https://crates.io/crates/physure)
+[![docs.rs](https://img.shields.io/docsrs/physure?labelColor=18181A)](https://docs.rs/physure)
+[![CI](https://img.shields.io/github/actions/workflow/status/Alexisrx96/physure/tests.yml?branch=main&labelColor=18181A)](https://github.com/Alexisrx96/physure/actions/workflows/tests.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-F59E0B?labelColor=18181A)](https://github.com/Alexisrx96/physure/blob/main/LICENSE)
 
 **Pure Rust physics engine: dimensional analysis with rational exponents, physical quantities, and uncertainty propagation.**