mopt 0.0.1__py3-none-any.whl

mopt/__init__.py

@@ -0,0 +1,12 @@
+"""MOpt: mathematical optimization solvers.
+
+Implements solvers for linear programming (Simplex, ...), nonlinear
+programming (line search, Newton's method, ...), and other classes of
+optimization problems.
+"""
+
+from mopt.base_classes import BaseOptimizer, OptimizeResult
+
+__version__ = "0.0.1"
+
+__all__ = ["BaseOptimizer", "OptimizeResult"]

mopt/autodiff/__init__.py

@@ -0,0 +1,5 @@
+"""Automatic differentiation helpers (optional backends)."""
+
+from mopt.autodiff.torch_adapter import from_torch, torch_function, torch_gradient
+
+__all__ = ["from_torch", "torch_function", "torch_gradient"]

mopt/autodiff/torch_adapter.py

@@ -0,0 +1,75 @@
+"""Exact gradients via PyTorch autodiff, behind a NumPy-facing interface.
+
+PyTorch is an optional dependency (``pip install mopt[torch]``); it is
+imported lazily so the rest of mopt works without it. Functions passed to
+this module must be written with torch operations — autodiff cannot see
+through plain-NumPy code.
+"""
+
+from __future__ import annotations
+
+from typing import Callable
+
+import numpy as np
+
+from mopt.nonlinear import NLPProblem
+
+
+def _torch():
+    try:
+        import torch
+    except ImportError as exc:  # pragma: no cover
+        raise ImportError(
+            "PyTorch is required for mopt.autodiff.torch_adapter; "
+            "install it with: pip install mopt[torch]"
+        ) from exc
+    return torch
+
+
+def torch_function(f) -> Callable[[np.ndarray], float]:
+    """Wrap a torch-written scalar function as a NumPy-facing objective."""
+
+    def f_np(x: np.ndarray) -> float:
+        torch = _torch()
+        with torch.no_grad():
+            return float(f(torch.as_tensor(np.asarray(x, dtype=float))))
+
+    return f_np
+
+
+def torch_gradient(f) -> Callable[[np.ndarray], np.ndarray]:
+    """Wrap a torch-written scalar function as a NumPy-facing gradient.
+
+    The returned callable evaluates the exact gradient of ``f`` by reverse-
+    mode autodiff: one forward pass builds the computation graph, one
+    backward pass applies the chain rule — the full gradient costs roughly
+    one extra evaluation of ``f`` regardless of the dimension.
+
+    Parameters
+    ----------
+    f : callable
+        Maps a 1-D float64 torch tensor to a scalar torch tensor, using
+        torch operations throughout.
+
+    Returns
+    -------
+    callable
+        ``grad(x: np.ndarray) -> np.ndarray`` with float64 precision.
+    """
+
+    def grad(x: np.ndarray) -> np.ndarray:
+        torch = _torch()
+        xt = torch.tensor(np.asarray(x, dtype=float), requires_grad=True)
+        (g,) = torch.autograd.grad(f(xt), xt)
+        return g.numpy()
+
+    return grad
+
+
+def from_torch(f, x0) -> NLPProblem:
+    """Build an :class:`~mopt.nonlinear.NLPProblem` from a torch-written ``f``.
+
+    The objective and its exact autodiff gradient are both wired in, so the
+    resulting problem never falls back to finite differences.
+    """
+    return NLPProblem(f=torch_function(f), x0=x0, grad=torch_gradient(f))

mopt/base_classes.py

@@ -0,0 +1,66 @@
+"""Base classes shared by every MOpt optimizer.
+
+All solvers follow one contract: a Problem object describes *what* to
+optimize, and each optimizer implements ``solve(problem) -> OptimizeResult``.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+
+@dataclass
+class OptimizeResult:
+    """Outcome of an optimization run, returned by every solver.
+
+    Attributes
+    ----------
+    x : np.ndarray or None
+        The solution found, or None when the run failed (e.g. the problem
+        is infeasible or unbounded).
+    fun : float or None
+        Objective value at ``x``, or None when there is no solution.
+    success : bool
+        Whether the solver terminated with a valid solution.
+    message : str
+        Human-readable description of the termination cause.
+    n_iter : int
+        Number of iterations performed.
+    """
+
+    x: np.ndarray | None
+    fun: float | None
+    success: bool
+    message: str = ""
+    n_iter: int = 0
+
+
+class BaseOptimizer(ABC):
+    """Abstract base class that all MOpt optimizers must inherit.
+
+    Subclasses implement :meth:`solve`; they must not mutate the problem
+    they are given, and must report failures (infeasible, unbounded,
+    iteration limit, ...) via ``OptimizeResult.success`` and
+    ``OptimizeResult.message`` rather than by raising.
+    """
+
+    @abstractmethod
+    def solve(self, problem: Any) -> OptimizeResult:
+        """Solve the given problem.
+
+        Parameters
+        ----------
+        problem : Any
+            A problem description understood by this solver. Concrete
+            Problem classes are introduced alongside the first solver for
+            each problem class.
+
+        Returns
+        -------
+        OptimizeResult
+            The solution and termination details.
+        """

mopt/linear/__init__.py

@@ -0,0 +1,6 @@
+"""Linear programming problems and solvers."""
+
+from mopt.linear.problem import LPProblem
+from mopt.linear.simplex import Simplex
+
+__all__ = ["LPProblem", "Simplex"]

mopt/linear/problem.py

@@ -0,0 +1,59 @@
+"""Linear programming problem description."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+
+@dataclass
+class LPProblem:
+    """A linear program.
+
+    Describes the problem
+
+    .. math::
+
+        \\min_x \\; c^T x
+        \\quad \\text{s.t.} \\quad
+        A_{ub} x \\le b_{ub}, \\;
+        A_{eq} x = b_{eq}, \\;
+        x \\ge 0
+
+    Attributes
+    ----------
+    c : np.ndarray, shape (n,)
+        Objective coefficients (minimized).
+    A_ub, b_ub : np.ndarray or None
+        Inequality constraints ``A_ub @ x <= b_ub``, shapes (m_ub, n) and (m_ub,).
+    A_eq, b_eq : np.ndarray or None
+        Equality constraints ``A_eq @ x == b_eq``, shapes (m_eq, n) and (m_eq,).
+    """
+
+    c: np.ndarray
+    A_ub: np.ndarray | None = None
+    b_ub: np.ndarray | None = None
+    A_eq: np.ndarray | None = None
+    b_eq: np.ndarray | None = None
+
+    def __post_init__(self):
+        self.c = np.atleast_1d(np.asarray(self.c, dtype=float))
+        if self.c.ndim != 1:
+            raise ValueError("c must be a 1-D array.")
+        n = self.c.size
+        for name in ("ub", "eq"):
+            A = getattr(self, f"A_{name}")
+            b = getattr(self, f"b_{name}")
+            if (A is None) != (b is None):
+                raise ValueError(f"A_{name} and b_{name} must be given together.")
+            if A is None:
+                continue
+            A = np.atleast_2d(np.asarray(A, dtype=float))
+            b = np.atleast_1d(np.asarray(b, dtype=float))
+            if A.shape != (b.size, n):
+                raise ValueError(
+                    f"A_{name} has shape {A.shape}, expected ({b.size}, {n})."
+                )
+            setattr(self, f"A_{name}", A)
+            setattr(self, f"b_{name}", b)

mopt/linear/simplex.py

@@ -0,0 +1,161 @@
+"""Two-phase primal simplex method on a dense tableau.
+
+The problem is first brought to standard form ``A x = b, x >= 0, b >= 0`` by
+adding one slack variable per inequality row and negating rows with negative
+right-hand sides. Phase 1 then minimizes the sum of artificial variables to
+find a basic feasible solution (a positive optimum proves infeasibility);
+phase 2 minimizes the original objective from that starting basis. Pivots
+follow Bland's rule (smallest-index entering and leaving variable), which
+guarantees termination even on degenerate problems.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from mopt.base_classes import BaseOptimizer, OptimizeResult
+from mopt.linear.problem import LPProblem
+
+
+def _pivot(T: np.ndarray, basis: list[int], row: int, col: int) -> None:
+    """Pivot the tableau so that ``col`` becomes basic in ``row``."""
+    T[row] /= T[row, col]
+    factors = T[:, col].copy()
+    factors[row] = 0.0
+    T -= np.outer(factors, T[row])
+    basis[row] = col
+
+
+class Simplex(BaseOptimizer):
+    """Two-phase tableau simplex solver for :class:`LPProblem`.
+
+    Parameters
+    ----------
+    max_iter : int
+        Maximum number of pivots across both phases.
+    tol : float
+        Numerical tolerance for optimality, ratio, and feasibility tests.
+    """
+
+    def __init__(self, max_iter: int = 10_000, tol: float = 1e-9):
+        self.max_iter = max_iter
+        self.tol = tol
+
+    def solve(self, problem: LPProblem) -> OptimizeResult:
+        c, A, b = self._standard_form(problem)
+        m, n_total = A.shape
+
+        # Phase 1: minimize the sum of one artificial variable per row,
+        # starting from the all-artificial basis. Tableau layout: one row per
+        # constraint plus a reduced-cost row; last column is the RHS, and
+        # T[-1, -1] holds minus the current objective value.
+        T = np.zeros((m + 1, n_total + m + 1))
+        T[:m, :n_total] = A
+        T[:m, n_total:-1] = np.eye(m)
+        T[:m, -1] = b
+        T[-1, :n_total] = -A.sum(axis=0)
+        T[-1, -1] = -b.sum()
+        basis = list(range(n_total, n_total + m))
+
+        status, it1 = self._iterate(T, basis, self.max_iter)
+        if status == "maxiter":
+            return OptimizeResult(
+                x=None, fun=None, success=False,
+                message="Iteration limit reached in phase 1.", n_iter=it1,
+            )
+        if -T[-1, -1] > self.tol * (1.0 + np.abs(b).sum()):
+            return OptimizeResult(
+                x=None, fun=None, success=False,
+                message="Problem is infeasible.", n_iter=it1,
+            )
+
+        # Drive leftover artificials out of the basis (they sit at value 0
+        # after a feasible phase 1); a row with no usable pivot is redundant.
+        drop = []
+        for i in range(m):
+            if basis[i] >= n_total:
+                j = int(np.argmax(np.abs(T[i, :n_total])))
+                if abs(T[i, j]) > self.tol:
+                    _pivot(T, basis, i, j)
+                else:
+                    drop.append(i)
+        if drop:
+            T = np.delete(T, drop, axis=0)
+            basis = [bj for i, bj in enumerate(basis) if i not in drop]
+        T = np.hstack([T[:, :n_total], T[:, -1:]])
+
+        # Phase 2: restore the original objective, priced out over the basis.
+        T[-1, :-1] = c
+        T[-1, -1] = 0.0
+        for i, j in enumerate(basis):
+            if c[j] != 0.0:
+                T[-1] -= c[j] * T[i]
+
+        status, it2 = self._iterate(T, basis, self.max_iter - it1)
+        n_iter = it1 + it2
+        if status == "unbounded":
+            return OptimizeResult(
+                x=None, fun=None, success=False,
+                message="Problem is unbounded.", n_iter=n_iter,
+            )
+        if status == "maxiter":
+            return OptimizeResult(
+                x=None, fun=None, success=False,
+                message="Iteration limit reached in phase 2.", n_iter=n_iter,
+            )
+
+        x_full = np.zeros(n_total)
+        x_full[basis] = T[:-1, -1]
+        x = x_full[: problem.c.size]
+        return OptimizeResult(
+            x=x, fun=float(problem.c @ x), success=True,
+            message="Optimal solution found.", n_iter=n_iter,
+        )
+
+    def _iterate(self, T: np.ndarray, basis: list[int], max_iter: int):
+        """Run simplex pivots until optimal, unbounded, or out of budget."""
+        m = len(basis)
+        for it in range(max_iter):
+            negative = np.where(T[-1, :-1] < -self.tol)[0]
+            if negative.size == 0:
+                return "optimal", it
+            col = int(negative[0])  # Bland's rule: smallest index enters
+            column = T[:m, col]
+            eligible = column > self.tol
+            if not eligible.any():
+                return "unbounded", it
+            ratios = np.full(m, np.inf)
+            ratios[eligible] = T[:m, -1][eligible] / column[eligible]
+            ties = np.where(ratios <= ratios.min() + self.tol)[0]
+            row = int(min(ties, key=lambda i: basis[i]))  # smallest leaves
+            _pivot(T, basis, row, col)
+        return "maxiter", max_iter
+
+    @staticmethod
+    def _standard_form(problem: LPProblem):
+        """Return ``(c, A, b)`` for the equivalent ``A x = b, x >= 0, b >= 0``.
+
+        One slack variable is appended per inequality row; rows with a
+        negative right-hand side are negated.
+        """
+        n = problem.c.size
+        m_ub = 0 if problem.A_ub is None else problem.A_ub.shape[0]
+        rows, rhs = [], []
+        if m_ub:
+            rows.append(np.hstack([problem.A_ub, np.eye(m_ub)]))
+            rhs.append(problem.b_ub)
+        if problem.A_eq is not None:
+            m_eq = problem.A_eq.shape[0]
+            rows.append(np.hstack([problem.A_eq, np.zeros((m_eq, m_ub))]))
+            rhs.append(problem.b_eq)
+        if rows:
+            A = np.vstack(rows)
+            b = np.concatenate(rhs).astype(float)
+        else:
+            A = np.empty((0, n + m_ub))
+            b = np.empty(0)
+        neg = b < 0
+        A[neg] *= -1
+        b[neg] *= -1
+        c = np.concatenate([problem.c, np.zeros(m_ub)])
+        return c, A, b

mopt/nonlinear/__init__.py

@@ -0,0 +1,6 @@
+"""Nonlinear programming problems and solvers."""
+
+from mopt.nonlinear.finite_diff import finite_difference_gradient
+from mopt.nonlinear.problem import NLPProblem
+
+__all__ = ["NLPProblem", "finite_difference_gradient"]

mopt/nonlinear/finite_diff.py

@@ -0,0 +1,53 @@
+"""Numerical differentiation by central finite differences."""
+
+from __future__ import annotations
+
+from typing import Callable
+
+import numpy as np
+
+
+def finite_difference_gradient(
+    f: Callable[[np.ndarray], float],
+    x: np.ndarray,
+    h: float | None = None,
+) -> np.ndarray:
+    """Approximate the gradient of ``f`` at ``x`` by central differences.
+
+    Each component is estimated as
+
+    .. math::
+
+        \\partial_i f(x) \\approx
+        \\frac{f(x + h_i e_i) - f(x - h_i e_i)}{2 h_i},
+
+    with a per-coordinate step ``h_i = h * (1 + |x_i|)`` so the step scales
+    with the magnitude of ``x``. The truncation error is O(h^2), at the cost
+    of ``2 n`` evaluations of ``f``.
+
+    Parameters
+    ----------
+    f : callable
+        Scalar-valued function of a 1-D array.
+    x : np.ndarray, shape (n,)
+        Point at which to differentiate.
+    h : float, optional
+        Base step size. Defaults to ``eps ** (1/3)`` (about 6e-6), the
+        rule-of-thumb optimum balancing truncation and rounding error for
+        central differences.
+
+    Returns
+    -------
+    np.ndarray, shape (n,)
+        Gradient estimate.
+    """
+    x = np.asarray(x, dtype=float)
+    if h is None:
+        h = float(np.finfo(float).eps) ** (1 / 3)
+    steps = h * (1.0 + np.abs(x))
+    g = np.empty(x.size)
+    for i in range(x.size):
+        e = np.zeros_like(x)
+        e[i] = steps[i]
+        g[i] = (f(x + e) - f(x - e)) / (2.0 * steps[i])
+    return g

mopt/nonlinear/problem.py

@@ -0,0 +1,58 @@
+"""Nonlinear programming problem description."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+import numpy as np
+
+from mopt.nonlinear.finite_diff import finite_difference_gradient
+
+
+@dataclass
+class NLPProblem:
+    """An unconstrained nonlinear program.
+
+    Describes the problem
+
+    .. math::
+
+        \\min_{x \\in \\mathbb{R}^n} \\; f(x)
+
+    Attributes
+    ----------
+    f : callable
+        Objective ``f(x) -> float`` for a 1-D array ``x``.
+    x0 : np.ndarray, shape (n,)
+        Starting point; also fixes the problem dimension.
+    grad : callable or None
+        Gradient ``grad(x) -> np.ndarray`` of shape (n,). When None,
+        :meth:`gradient` falls back to central finite differences of ``f``.
+    hess : callable or None
+        Hessian ``hess(x) -> np.ndarray`` of shape (n, n). Optional; needed
+        only by second-order solvers such as Newton's method.
+    """
+
+    f: Callable[[np.ndarray], float]
+    x0: np.ndarray
+    grad: Callable[[np.ndarray], np.ndarray] | None = None
+    hess: Callable[[np.ndarray], np.ndarray] | None = None
+
+    def __post_init__(self):
+        if not callable(self.f):
+            raise TypeError("f must be callable.")
+        self.x0 = np.atleast_1d(np.asarray(self.x0, dtype=float))
+        if self.x0.ndim != 1:
+            raise ValueError("x0 must be a 1-D array.")
+
+    def gradient(self, x: np.ndarray) -> np.ndarray:
+        """Gradient of ``f`` at ``x``.
+
+        Uses the user-supplied ``grad`` when given, otherwise central
+        finite differences of ``f``. Solvers should call this rather than
+        ``grad`` directly so the fallback applies uniformly.
+        """
+        if self.grad is not None:
+            return np.asarray(self.grad(x), dtype=float)
+        return finite_difference_gradient(self.f, x)

mopt-0.0.1.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: mopt
+Version: 0.0.1
+Summary: Mathematical optimization solvers: linear programming, nonlinear programming, and more
+Project-URL: Homepage, https://github.com/Trminh06-work/MOpt
+Project-URL: Issues, https://github.com/Trminh06-work/MOpt/issues
+Author-email: Trần Bảo Minh <trminh06.work@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Provides-Extra: torch
+Requires-Dist: torch; extra == 'torch'
+Description-Content-Type: text/markdown
+
+# MOpt
+
+Mathematical optimization solvers in Python, implemented from scratch.
+
+MOpt aims to cover the major classes of optimization problems behind a single,
+consistent solver interface:
+
+- **Linear programming** — Simplex method, and more
+- **Nonlinear programming** — line search, gradient descent, Newton's method, and more
+- **Planned** — convex optimization, metaheuristics, matheuristics
+
+> ⚠️ Early development. The API is not yet stable and solvers are being added
+> incrementally.
+
+## Installation
+
+```bash
+pip install mopt
+```
+
+Or install the latest development version from GitHub:
+
+```bash
+pip install git+https://github.com/Trminh06-work/MOpt.git
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

mopt-0.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+mopt/__init__.py,sha256=c3DcEd7efBYI5KbUz4QCLd6XjyKl6bws8hq9uHp49as,341
+mopt/base_classes.py,sha256=-MjilgUoCRfVic1xHg4X8Fp5Xf-qGUuaquV3KVUPHrQ,1871
+mopt/autodiff/__init__.py,sha256=J7S3MxhTNjhvHHMuVptjNEdyvpGuoNEXeBxqHhayM24,207
+mopt/autodiff/torch_adapter.py,sha256=S0SxHR2wD7D_rUo1M7U44dZ9CqHLMy0CGKq7tj1GeU0,2315
+mopt/linear/__init__.py,sha256=Rj3yfcXO59_KJaBuJlUCXQW83RV-l5auNyhYxlWzRyo,166
+mopt/linear/problem.py,sha256=TiIaYBS3YaxraueTC4F1RY6dm-4Cmrc0lmqP6vwuCe4,1756
+mopt/linear/simplex.py,sha256=I_8gcIz7I9cRGFJ9k1U6QqLItBSAtFuJfRkz0kRUzY8,6118
+mopt/nonlinear/__init__.py,sha256=s0qiVw9a65iokxLF66xkz49GqfZKQKHN1loIAkCWWng,219
+mopt/nonlinear/finite_diff.py,sha256=Xoo_-nBO7EiXP8gZCoN2LOKNS6sQ67j4iXv35JXSUak,1455
+mopt/nonlinear/problem.py,sha256=h_pTKs95F741Tx9h8x37MUwIWAf13IT6YMkhU9t820E,1838
+mopt-0.0.1.dist-info/METADATA,sha256=O8Q-7_OQRR46Ln-9uznXvkT-WkarpPpE95FUxmlC0O0,1452
+mopt-0.0.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+mopt-0.0.1.dist-info/licenses/LICENSE,sha256=koiPNKlqANQS_0wef1_Koe6Yf5XchsqGw0bsVqZ95KY,1074
+mopt-0.0.1.dist-info/RECORD,,

mopt-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mopt-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Trần Bảo Minh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.