cmenpy 2026a0__py3-none-any.whl

cmenpy/__init__.py

@@ -0,0 +1,29 @@
+__version__ = "2026a0"
+
+from cmenpy.bounds import Bounds
+from cmenpy.epoch import EpochIteration, Epoch
+from cmenpy.functools import is_best, is_worst, best_of, worst_of
+from cmenpy.kernel import KernelSize, KernelBuffer
+from cmenpy.model import declare, template, template_check
+from cmenpy.model.optimizer import FunctionOptimizerModel, TemplateOptimizerModel
+from cmenpy.model.optimizer.variables import Argument, Variable
+from cmenpy.population.swarm import PopulationSwarm
+
+__all__ = [
+    "declare",
+    "template",
+    "template_check",
+    "is_best",
+    "is_worst",
+    "best_of",
+    "worst_of",
+    "Argument",
+    "Variable",
+    "EpochIteration",
+    "Epoch",
+    "KernelBuffer",
+    "KernelSize",
+    "PopulationSwarm",
+    "FunctionOptimizerModel",
+    "TemplateOptimizerModel",
+]

cmenpy/bounds/__init__.py

@@ -0,0 +1,40 @@
+import functools
+import typing
+
+from cmenpy.hints import ScalarType
+
+InnerSequence = typing.Union[typing.Tuple[ScalarType, ...], typing.List[ScalarType]]
+SequenceStructure = typing.List[InnerSequence[ScalarType]]
+
+
+class Bounds:
+    def __init__(self, bounds: SequenceStructure[ScalarType]):
+        self.__bounds = bounds
+
+    @functools.cached_property
+    def ndim(self):
+        return len(self.__bounds)
+
+    @property
+    def low(self):
+        return self.__bounds[0][0]
+
+    @property
+    def up(self):
+        return self.__bounds[0][1]
+
+    def __iter__(self):
+        return (b for b in self.__bounds)
+
+    def __len__(self):
+        return len(self.__bounds)
+
+    def __class_getitem__(cls, params):
+        return create_bounds(params)
+
+
+def create_bounds(bounds: SequenceStructure[ScalarType] | Bounds) -> Bounds:
+    if isinstance(bounds, Bounds):
+        return bounds
+
+    return Bounds(bounds)

cmenpy/context/__init__.py

@@ -0,0 +1,96 @@
+import typing
+
+import numpy as np
+
+from cmenpy.bounds import Bounds
+from cmenpy.epoch import EpochIteration
+from cmenpy.generator import DefaultGenerator
+from cmenpy.kernel import KernelBuffer, KernelSize
+from cmenpy.target import Target, TargetFunction
+from cmenpy.tracker import Tracker
+from cmenpy.hints.option import SenseType
+
+
+class Context:
+    def __init__(
+        self,
+        f: Target,
+        bounds: Bounds,
+        buffer: KernelBuffer,
+        generator: DefaultGenerator,
+        sense: SenseType,
+    ):
+        self.__target = TargetFunction(f, bounds)
+        self.__bounds = bounds
+        self.__buff = buffer
+        self.__generator = generator
+        self.__sense = sense
+
+    @property
+    def target(self) -> TargetFunction:
+        return self.__target
+
+    @property
+    def bounds(self) -> Bounds:
+        return self.__bounds
+
+    @property
+    def buff(self) -> KernelBuffer:
+        return self.__buff
+
+    @property
+    def rng(self) -> np.random.Generator:
+        return self.__generator.rng
+
+    @property
+    def sense(self) -> SenseType:
+        return self.__sense
+
+
+class MainContextManager:
+    def __init__(
+        self,
+        f: Target,
+        bounds: Bounds,
+        epochs: int,
+        size: KernelSize,
+        seed: typing.Optional[int] = None,
+        debug: bool = False,
+        sense: SenseType = "min",
+    ):
+        self.__size = size
+        self.__target = TargetFunction(f, bounds)
+        self.__bounds = bounds
+        self.__sense = sense
+        self.__k_buff = KernelBuffer(size, self.__bounds, self.__target, self.__sense)
+        self.__generator = DefaultGenerator(seed=seed)
+        self.__tracker = Tracker(self.__k_buff)
+        self.__epoch_it = EpochIteration(epochs, self.__tracker, self.__target, debug)
+
+    @property
+    def sense(self):
+        return self.__sense
+
+    @property
+    def epoch_it(self) -> EpochIteration:
+        return self.__epoch_it
+
+    @property
+    def buffer(self) -> KernelBuffer:
+        return self.__k_buff
+
+    @property
+    def target(self) -> TargetFunction:
+        return self.__target
+
+    @property
+    def bounds(self) -> Bounds:
+        return self.__bounds
+
+    @property
+    def default_generator(self) -> DefaultGenerator:
+        return self.__generator
+
+    @property
+    def tracker(self) -> Tracker:
+        return self.__tracker

cmenpy/epoch/__init__.py

@@ -0,0 +1,60 @@
+import time
+
+from cmenpy.target import Target, TargetFunction
+from cmenpy.tracker import Tracker
+
+
+class Epoch:
+    def __init__(self, e: int):
+        self.__e: int = e
+
+    def __int__(self):
+        return self.__e
+
+    def __float__(self):
+        return float(self.__e)
+
+    def __repr__(self):
+        return f"Epoch({self.__e})"
+
+
+class EpochIteration:
+    def __init__(
+        self,
+        epochs: int,
+        tracker: Tracker,
+        target: TargetFunction,
+        debug: bool = False,
+    ):
+        if epochs <= 0:
+            raise ValueError("Epochs must be a positive integer.")
+
+        self.__epochs: int = epochs
+        self.__current_epoch: int = 0
+        self.__cpu_time: float = 0
+        self.__tracker: Tracker = tracker
+        self.__target: TargetFunction = target
+        self.__debug: bool = debug
+
+    def __iter__(self):
+        for e in range(0, self.__epochs):
+            self.__current_epoch = e
+
+            start = time.process_time()
+            yield e
+            self.__cpu_time = time.process_time() - start
+
+            if self.__debug:
+                self.__tracker.track(e, self.cpu_time, self.__target.nfe)
+
+    @property
+    def current(self):
+        return self.__current_epoch
+
+    @property
+    def max(self) -> int:
+        return self.__epochs
+
+    @property
+    def cpu_time(self):
+        return self.__cpu_time

cmenpy/functools/__init__.py

@@ -0,0 +1,44 @@
+import typing
+
+import numpy as np
+
+from cmenpy.hints.option import SenseType
+
+A = typing.TypeVar("A")
+B = typing.TypeVar("B")
+AB = tuple[A, B]
+
+
+def is_best(ab: AB, sense: SenseType = "min"):
+    a, b = ab
+
+    if sense == "min":
+        mask = np.array(a) < np.array(b)
+    else:
+        mask = np.array(a) > np.array(b)
+
+    return np.flatnonzero(mask)
+
+
+def is_worst(ab: AB, sense: SenseType = "min"):
+    a, b = ab
+
+    if sense == "min":
+        mask = np.array(a) > np.array(b)
+    else:
+        mask = np.array(a) < np.array(b)
+
+    return np.flatnonzero(mask)
+
+
+
+def best_of(a: A) -> int:
+    return a.best
+
+
+
+def worst_of(a: A) -> int:
+    return a.worst
+
+
+__all__ = ["is_best", "is_worst", "best_of", "worst_of"]

cmenpy/generator/__init__.py

@@ -0,0 +1,17 @@
+import typing
+
+import numpy as np
+
+
+class DefaultGenerator:
+    def __init__(self, seed: typing.Optional[int] = None) -> None:
+        self.__seed = seed
+        self.__rng = np.random.default_rng(self.__seed)
+
+    @property
+    def seed(self) -> typing.Optional[int]:
+        return self.__seed
+
+    @property
+    def rng(self) -> np.random.Generator:
+        return self.__rng

cmenpy/hints/__init__.py

@@ -0,0 +1,4 @@
+from cmenpy.hints.array import NDArrayType, ArrayFloatType, ArrayIntegerType
+from cmenpy.hints.primitives import ScalarType
+
+__all__ = ["ScalarType", "NDArrayType", "ArrayFloatType", "ArrayIntegerType"]

cmenpy/hints/array.py

@@ -0,0 +1,8 @@
+import typing
+
+import numpy as np
+import numpy.typing as npt
+
+NDArrayType = npt.NDArray[np.number[typing.Any]]
+ArrayFloatType = npt.NDArray[np.floating[typing.Any]]
+ArrayIntegerType = npt.NDArray[np.integer[typing.Any]]

cmenpy/hints/dynamic.py

@@ -0,0 +1,8 @@
+from collections.abc import Iterable
+
+from cmenpy.population.agent.base import BaseAgent
+from cmenpy.hints import NDArrayType
+
+Source = NDArrayType | Iterable[float | int]
+SourceIterable = BaseAgent | NDArrayType
+DualSource = tuple[SourceIterable, SourceIterable]

cmenpy/hints/option.py

@@ -0,0 +1,3 @@
+import typing
+
+SenseType = typing.Literal["min", "max"]

cmenpy/hints/primitives.py

@@ -0,0 +1,5 @@
+import typing
+
+import numpy as np
+
+ScalarType = typing.TypeVar("ScalarType", bound=np.number[typing.Any])

cmenpy/kernel/__init__.py

@@ -0,0 +1,5 @@
+from cmenpy.kernel.buffer import KernelBuffer
+from cmenpy.kernel.mask import KernelMask
+from cmenpy.kernel.size import KernelSize
+
+__all__ = ["KernelBuffer", "KernelSize", "KernelMask"]

cmenpy/kernel/buffer.py

@@ -0,0 +1,86 @@
+import typing
+
+import numpy as np
+
+from cmenpy.bounds import Bounds
+from cmenpy.kernel.index import BufferIndex
+from cmenpy.kernel.low import init_buffer
+from cmenpy.kernel.mask import KernelMask
+from cmenpy.kernel.size import KernelSize
+from cmenpy.target import TargetFunction
+from cmenpy.hints import NDArrayType
+from cmenpy.hints.option import SenseType
+
+
+class KernelBuffer:
+    def __init__(
+        self,
+        size: KernelSize,
+        bounds: Bounds,
+        target: TargetFunction,
+        sense: SenseType,
+    ):
+        self.__size = size
+        self.__bounds = bounds
+        self.__target = target
+        self.__sense = sense
+
+        self.__buffer: NDArrayType = init_buffer(self.__size.max, bounds.ndim)
+        self.__mask = KernelMask(self.__size)
+
+    def apply(
+        self,
+        x: NDArrayType,
+        idx: typing.Union[int, slice, typing.List[int], None] = None,
+    ) -> None:
+        """Vectorizes the target function to evaluate and update the solutions matrix.
+
+        The internal buffer stores "fitness" in column 0 and "solutions" or "x"
+        from column 1 onwards. Supports updating a single row, a slice, a list/array
+        of indices, or the entire active matrix if `idx` is None.
+
+        Parameters
+        ----------
+        x : NDArrayType
+            An array containing the new solution data to be inserted into the buffer.
+        idx : int, slice, NDArrayType, list, optional
+            The row index, slice, or index mask to update. If None, defaults to
+            the internal mask.
+
+        Returns
+        -------
+        None
+        """
+        rows = self.__mask.founds if idx is None else idx
+        self.__buffer[rows, 1:] = x
+
+        if isinstance(idx, int):
+            self.__buffer[rows, 0] = self.__target.evaluate(x)
+        else:
+            self.__buffer[rows, 0] = np.apply_along_axis(
+                self.__target, 1, self.__buffer[rows, 1:]
+            )
+
+    @property
+    def shape(self):
+        return self.__buffer.shape
+
+    @property
+    def mask(self) -> KernelMask:
+        return self.__mask
+
+    @property
+    def raw(self) -> NDArrayType:
+        return self.__buffer
+
+    @property
+    def idx(self) -> BufferIndex:
+        return BufferIndex(self.__buffer, self.__mask, self.__sense)
+
+    @property
+    def size(self) -> KernelSize:
+        return self.__size
+
+    @property
+    def snapshot(self) -> "KernelBuffer":
+        return KernelBuffer(self.__size, self.__bounds, self.__target, self.__sense)

cmenpy/kernel/index.py

@@ -0,0 +1,43 @@
+import numpy as np
+
+from cmenpy.kernel.mask import KernelMask
+from cmenpy.hints import NDArrayType
+from cmenpy.hints.option import SenseType
+
+
+class BufferIndex:
+    def __init__(self, buffer: NDArrayType, mask: KernelMask, sense: SenseType):
+        self.__buffer = buffer
+        self.__sense = sense
+        self.__mask = mask
+
+    def __iter__(self):
+        pop_size, _ = self.__buffer.shape
+
+        return iter(range(0, pop_size))
+
+    def __invert__(self):
+        return np.where(~np.isnan(self.__buffer[:, 0]))[0].astype(int)
+
+    @property
+    def sort(self):
+        _idx = np.argsort(self.__buffer[:, 0])
+
+        if self.__sense == "max":
+            return _idx[::-1]
+
+        return _idx
+
+    @property
+    def best(self):
+        if self.__sense == "max":
+            return self.sort[-1]
+
+        return self.sort[0]
+
+    @property
+    def worst(self):
+        if self.__sense == "max":
+            return self.sort[0]
+
+        return self.sort[-1]

cmenpy/kernel/low/__init__.py

@@ -0,0 +1,17 @@
+import numpy as np
+
+from cmenpy.hints import NDArrayType
+
+
+def expand_buffer(
+    n: int,
+    ndim: int,
+) -> NDArrayType:
+    return np.hstack(([n], np.full((ndim + 1), np.nan)))
+
+
+def init_buffer(
+    n_pop: int,
+    ndim: int,
+) -> NDArrayType:
+    return np.full((n_pop, ndim + 1), np.nan)

cmenpy/kernel/mask.py

@@ -0,0 +1,42 @@
+import typing
+
+import numpy as np
+
+from cmenpy.kernel.size import KernelSize
+
+
+class KernelMask:
+    def __init__(
+        self,
+        size: KernelSize,
+    ):
+        self.__size: KernelSize = size
+        self.__mask = np.fromiter((False for _ in range(0, size.max)), dtype=bool)
+        self.__mask[0 : self.__size.size] = True
+
+    def __iter__(self):
+        return iter(map(bool, self.__mask))
+
+    def __setitem__(
+        self,
+        key: typing.Union[int, slice, typing.List[int], None],
+        value: bool,
+    ):
+        self.__mask[key] = value
+
+    def __getitem__(
+        self, key: typing.Union[int, slice, typing.List[int], None]
+    ) -> typing.Any:
+        return self.__mask[key]
+
+    @property
+    def active(self):
+        return sum(self.__mask)
+
+    @property
+    def passive(self):
+        return len(self.__mask) - sum(self.__mask)
+
+    @property
+    def founds(self) -> list[bool]:
+        return [*map(bool, self.__mask)]

cmenpy/kernel/size.py

@@ -0,0 +1,34 @@
+import typing
+
+
+class KernelSize:
+    def __init__(
+        self,
+        size: int,
+        min_size: typing.Optional[int] = None,
+        max_size: typing.Optional[int] = None,
+    ):
+        if min_size is None:
+            min_size = size
+
+        if max_size is None:
+            max_size = size
+
+        if size < min_size or size > max_size:
+            raise ValueError("Size must be between 'min_size' and 'max_size'.")
+
+        self.__size = size
+        self.__min = min_size
+        self.__max = max_size
+
+    @property
+    def max(self) -> int:
+        return self.__max
+
+    @property
+    def min(self) -> int:
+        return self.__min
+
+    @property
+    def size(self) -> int:
+        return self.__size