qilisdk 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

qilisdk/backends/backend.py

@@ -89,7 +89,11 @@ class Backend(ABC):
 
         def evaluate_sample(parameters: list[float]) -> float:
             param_names = functional.functional.get_parameter_names()
-            functional.functional.set_parameters({param_names[i]: param for i, param in enumerate(parameters)})
+            param_dict = {param_names[i]: param for i, param in enumerate(parameters)}
+            err = functional.check_parameter_constraints(param_dict)
+            if err > 0:
+                return err
+            functional.functional.set_parameters(param_dict)
             results = self.execute(functional.functional)
             final_results = functional.cost_function.compute_cost(results)
             if isinstance(final_results, float):

qilisdk/backends/cuda_backend.py

@@ -24,7 +24,8 @@ from loguru import logger
 
 from qilisdk.analog.hamiltonian import Hamiltonian, PauliI, PauliOperator, PauliX, PauliY, PauliZ
 from qilisdk.backends.backend import Backend
-from qilisdk.common.qtensor import QTensor
+from qilisdk.core.qtensor import QTensor
+from qilisdk.digital.circuit_transpiler_passes import DecomposeMultiControlledGatesPass
 from qilisdk.digital.exceptions import UnsupportedGateError
 from qilisdk.digital.gates import RX, RY, RZ, SWAP, U1, U2, U3, Adjoint, BasicGate, Controlled, H, I, M, S, T, X, Y, Z
 from qilisdk.functionals.sampling_result import SamplingResult
@@ -137,13 +138,14 @@ class CudaBackend(Backend):
         kernel = cudaq.make_kernel()
         qubits = kernel.qalloc(functional.circuit.nqubits)
 
-        for gate in functional.circuit.gates:
+        transpiled_circuit = DecomposeMultiControlledGatesPass().run(functional.circuit)
+        for gate in transpiled_circuit.gates:
             if isinstance(gate, Controlled):
                 self._handle_controlled(kernel, gate, qubits[gate.control_qubits[0]], qubits[gate.target_qubits[0]])
             elif isinstance(gate, Adjoint):
                 self._handle_adjoint(kernel, gate, qubits[gate.target_qubits[0]])
             elif isinstance(gate, M):
-                self._handle_M(kernel, gate, functional.circuit, qubits)
+                self._handle_M(kernel, gate, transpiled_circuit, qubits)
             else:
                 handler = self._basic_gate_handlers.get(type(gate), None)
                 if handler is None:
@@ -158,12 +160,14 @@ class CudaBackend(Backend):
         logger.info("Executing TimeEvolution (T={}, dt={})", functional.schedule.T, functional.schedule.dt)
         cudaq.set_target("dynamics")
 
-        steps = np.linspace(0, functional.schedule.T, (round(functional.schedule.T / functional.schedule.dt) + 1))
+        steps = np.linspace(0, functional.schedule.T, (round(functional.schedule.T // functional.schedule.dt) + 1))
+        tlist = np.array(functional.schedule.tlist)
+        steps = np.union1d(steps, tlist)
 
         cuda_schedule = CudaSchedule(steps, ["t"])
 
-        def get_schedule(key: str) -> Callable:
-            return lambda t: (functional.schedule.get_coefficient(t.real, key))
+        def get_schedule(key: str) -> Callable[[complex], float]:
+            return lambda t: (functional.schedule.coefficients[key][t.real])
 
         cuda_hamiltonian = sum(
             ScalarOperator(get_schedule(key)) * self._hamiltonian_to_cuda(ham)

qilisdk/backends/qutip_backend.py

@@ -25,15 +25,15 @@ from qutip_qip.operations.gateclass import SingleQubitGate, is_qutip5
 
 from qilisdk.analog.hamiltonian import Hamiltonian, PauliI, PauliOperator
 from qilisdk.backends.backend import Backend
-from qilisdk.common.qtensor import QTensor, tensor_prod
+from qilisdk.core.qtensor import QTensor, tensor_prod
 from qilisdk.digital import RX, RY, RZ, SWAP, U1, U2, U3, Circuit, H, I, M, S, T, X, Y, Z
+from qilisdk.digital.circuit_transpiler_passes import DecomposeMultiControlledGatesPass
 from qilisdk.digital.exceptions import UnsupportedGateError
 from qilisdk.digital.gates import Adjoint, BasicGate, Controlled
 from qilisdk.functionals.sampling_result import SamplingResult
 from qilisdk.functionals.time_evolution_result import TimeEvolutionResult
 
 if TYPE_CHECKING:
-    from qilisdk.common.variables import Number
     from qilisdk.functionals.sampling import Sampling
     from qilisdk.functionals.time_evolution import TimeEvolution
 
@@ -118,18 +118,17 @@ class QutipBackend(Backend):
 
         """
         logger.info("Executing Sampling (shots={})", functional.nshots)
-        qutip_circuit = self._get_qutip_circuit(functional.circuit)
 
-        counts: Counter[str] = Counter()
         init_state = tensor(*[basis(2, 0) for _ in range(functional.circuit.nqubits)])
 
         measurements_set = set()
         for m in functional.circuit.gates:
             if isinstance(m, M):
                 measurements_set.update(list(m.target_qubits))
-
         measurements = sorted(measurements_set)
 
+        transpiled_circuit = DecomposeMultiControlledGatesPass().run(functional.circuit)
+        qutip_circuit = self._get_qutip_circuit(transpiled_circuit)
         sim = CircuitSimulator(qutip_circuit)
 
         res = sim.run_statistics(init_state)  # runs the full circuit for one shot
@@ -173,7 +172,9 @@ class QutipBackend(Backend):
             ValueError: if the initial state provided is invalid.
         """
         logger.info("Executing TimeEvolution (T={}, dt={})", functional.schedule.T, functional.schedule.dt)
-        tlist = np.linspace(0, functional.schedule.T, int(functional.schedule.T / functional.schedule.dt))
+        steps = np.linspace(0, functional.schedule.T, int(functional.schedule.T // functional.schedule.dt))
+        tlist = np.array(functional.schedule.tlist)
+        steps = np.union1d(steps, tlist)
 
         qutip_hamiltonians = []
         for hamiltonian in functional.schedule.hamiltonians.values():
@@ -183,28 +184,10 @@ class QutipBackend(Backend):
                 )
             )
 
-        def get_hamiltonian_schedule(
-            hamiltonian: str, dt: float, schedule: dict[int, dict[str, Number]], T: float
-        ) -> Callable:
-            def get_coeff(t: float) -> Number:
-                if int(t / dt) in schedule:
-                    return schedule[int(t / dt)][hamiltonian]
-                time_step = int(t / dt)
-                while time_step > 0:
-                    time_step -= 1
-                    if time_step in schedule:
-                        return schedule[time_step][hamiltonian]
-                return 0
-
-            return get_coeff
-            # return lambda t: schedule[int(t / dt)][ham] if int(t / dt) < int(T / dt) else schedule[int(T / dt)][ham]
-
         H_t = [
             [
                 qutip_hamiltonians[i],
-                get_hamiltonian_schedule(
-                    h, functional.schedule.dt, functional.schedule.schedule, functional.schedule.T
-                ),
+                np.array([functional.schedule.coefficients[h][t] for t in tlist]),
             ]
             for i, h in enumerate(functional.schedule.hamiltonians)
         ]
@@ -327,10 +310,10 @@ class QutipBackend(Backend):
 
     def _handle_controlled(self, circuit: QubitCircuit, gate: Controlled) -> None:  # noqa: PLR6301
         """
-        Handle a controlled gate operation.
+        Handle a controlled gate operation by registering a custom QuTiP gate.
 
-        This method processes a controlled gate by creating a temporary kernel for the basic gate,
-        applying its handler, and then integrating it into the main kernel as a controlled operation.
+        For non-native controlled gates we construct the block-matrix explicitly, mirroring
+        the approach recommended in the QuTiP QIP documentation for custom controlled rotations.
 
         Raises:
             UnsupportedGateError: If the number of control qubits is not equal to one or if the basic gate is unsupported.
@@ -339,13 +322,22 @@ class QutipBackend(Backend):
             logger.error("Controlled gate with {} control qubits not supported", len(gate.control_qubits))
             raise UnsupportedGateError
 
-        def qutip_controlled_gate() -> Qobj:
-            return QutipGates.controlled_gate(Qobj(gate.basic_gate.matrix), controls=0, targets=1)
-
         if gate.name == "CNOT":
             circuit.add_gate("CNOT", targets=[*gate.target_qubits], controls=[*gate.control_qubits])
         else:
-            gate_name = "Controlled_" + gate.name
+            base_matrix = gate.basic_gate.matrix
+            dim_target = base_matrix.shape[0]
+            dim_total = 2 * dim_target
+            dims = [[2] + [2] * len(gate.target_qubits), [2] + [2] * len(gate.target_qubits)]
+
+            def qutip_controlled_gate() -> Qobj:
+                mat = np.zeros((dim_total, dim_total), dtype=np.complex128)
+                mat[:dim_target, :dim_target] = np.eye(dim_target, dtype=np.complex128)
+                mat[dim_target:, dim_target:] = base_matrix
+                return Qobj(mat, dims=dims)
+
+            matrix_digest = base_matrix.tobytes().hex()[:16]
+            gate_name = f"{gate.name}_{matrix_digest}"
             if gate_name not in circuit.user_gates:
                 circuit.user_gates[gate_name] = qutip_controlled_gate
             circuit.add_gate(gate_name, targets=[*gate.control_qubits, *gate.target_qubits])

qilisdk/{common → core}/__init__.py

@@ -22,6 +22,7 @@ from .variables import (
     LT,
     NEQ,
     BinaryVariable,
+    Domain,
     Equal,
     GreaterThan,
     GreaterThanOrEqual,
@@ -30,6 +31,7 @@ from .variables import (
     NotEqual,
     Parameter,
     SpinVariable,
+    Term,
     Variable,
 )
 
@@ -42,6 +44,7 @@ __all__ = [
     "NEQ",
     "BinaryVariable",
     "Constraint",
+    "Domain",
     "Equal",
     "GreaterThan",
     "GreaterThanOrEqual",
@@ -54,6 +57,7 @@ __all__ = [
     "Parameter",
     "QTensor",
     "SpinVariable",
+    "Term",
     "Variable",
     "basis_state",
     "bra",

qilisdk/core/interpolator.py

@@ -0,0 +1,406 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+import inspect
+from bisect import bisect_right
+from collections.abc import Callable
+from copy import copy
+from enum import Enum
+from typing import Any, Mapping
+
+import numpy as np
+
+from qilisdk.core.parameterizable import Parameterizable
+from qilisdk.core.variables import LEQ, BaseVariable, Number, Parameter, Term
+from qilisdk.yaml import yaml
+
+_TIME_PARAMETER_NAME = "t"
+PARAMETERIZED_NUMBER = float | Parameter | Term
+
+# type aliases just to keep this short
+TimeDict = dict[PARAMETERIZED_NUMBER | tuple[float, float], PARAMETERIZED_NUMBER | Callable[..., PARAMETERIZED_NUMBER]]
+
+
+class Interpolation(str, Enum):
+    STEP = "Step function interpolation between schedule points"
+    LINEAR = "linear interpolation between schedule points"
+
+
+def _process_callable(
+    function: Callable[[], PARAMETERIZED_NUMBER], current_time: Parameter, **kwargs: Any
+) -> tuple[PARAMETERIZED_NUMBER, dict[str, Parameter]]:
+    # Define variables
+    parameters: dict[str, Parameter] = {}
+
+    # get callable parameters
+    c_params = inspect.signature(function).parameters
+    EMPTY = inspect.Parameter.empty
+    # process callable parameters
+    for param_name, param_info in c_params.items():
+        # parameter type extraction
+        if param_info.annotation is not EMPTY and param_info.annotation is Parameter:
+            if param_info.default is not EMPTY:
+                parameters[param_info.default.label] = copy(param_info.default)
+            else:
+                value = kwargs.get(param_name, 0)
+                if isinstance(value, (float, int)):
+                    parameters[param_name] = Parameter(param_name, value)
+                elif isinstance(value, Parameter):
+                    parameters[value.label] = value
+
+    if _TIME_PARAMETER_NAME in c_params:
+        kwargs[_TIME_PARAMETER_NAME] = current_time
+    term = function(**kwargs)
+    if isinstance(term, Term) and not all(
+        (isinstance(v, Parameter) or v.label == _TIME_PARAMETER_NAME) for v in term.variables()
+    ):
+        raise ValueError("function contains variables that are not time. Only Parameters are allowed.")
+    if isinstance(term, BaseVariable) and not (isinstance(term, Parameter) or term.label == _TIME_PARAMETER_NAME):
+        raise ValueError("function contains variables that are not time. Only Parameters are allowed.")
+    return term, parameters
+
+
+@yaml.register_class
+class Interpolator(Parameterizable):
+    """It's a dictionary that can interpolate between defined indecies."""
+
+    def __init__(
+        self,
+        time_dict: TimeDict,
+        interpolation: Interpolation = Interpolation.LINEAR,
+        nsamples: int = 100,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize an interpolator over discrete points or intervals.
+
+        Args:
+            time_dict (TimeDict): Mapping from time points or intervals to coefficients or callables.
+            interpolation (Interpolation): Interpolation rule between provided points (``LINEAR`` or ``STEP``).
+            nsamples (int): Number of samples used to expand interval definitions.
+            **kwargs: Extra arguments forwarded to callable coefficient processing.
+
+        Raises:
+            ValueError:if the time intervals contain a number of points different than 2.
+        """
+        super(Interpolator, self).__init__()
+        self._interpolation = interpolation
+        self._time_dict: dict[PARAMETERIZED_NUMBER, PARAMETERIZED_NUMBER] = {}
+        self._current_time = Parameter("t", 0)
+        self._total_time: float | None = None
+        self.iter_time_step = 0
+        self._cached = False
+        self._cached_time: dict[PARAMETERIZED_NUMBER, PARAMETERIZED_NUMBER | Number] = {}
+        self._tlist: list[PARAMETERIZED_NUMBER] | None = None
+        self._fixed_tlist: list[float] | None = None
+        self._max_time: PARAMETERIZED_NUMBER | None = None
+        self._time_scale_cache: float | None = None
+
+        for time, coefficient in time_dict.items():
+            if isinstance(time, tuple):
+                if len(time) != 2:  # noqa: PLR2004
+                    raise ValueError(
+                        f"time intervals need to be defined by two points, but this interval was provided: {time}"
+                    )
+                for t in np.linspace(0, 1, (max(2, nsamples))):
+                    time_point = (1 - float(t)) * time[0] + float(t) * time[1]
+                    if isinstance(time_point, (Parameter, Term)):
+                        self._extract_parameters(time_point)
+                    self.add_time_point(time_point, coefficient, **kwargs)
+
+            else:
+                self.add_time_point(time, coefficient, **kwargs)
+        self._tlist = self._generate_tlist()
+
+        time_insertion_list = sorted(
+            [k for item in time_dict for k in (item if isinstance(item, tuple) else (item,))],
+            key=self._get_value,
+        )
+        l = len(time_insertion_list)
+        for i in range(l):
+            t = time_insertion_list[i]
+            if isinstance(t, (Parameter, Term)):
+                if i > 0:
+                    term = LEQ(time_insertion_list[i - 1], t)
+                    if term not in self._parameter_constraints:
+                        self._parameter_constraints.append(term)
+                if i < l - 1:
+                    term = LEQ(t, time_insertion_list[i + 1])
+                    if term not in self._parameter_constraints:
+                        self._parameter_constraints.append(term)
+
+    def _generate_tlist(self) -> list[PARAMETERIZED_NUMBER]:
+        return sorted((self._time_dict.keys()), key=self._get_value)
+
+    @property
+    def tlist(self) -> list[PARAMETERIZED_NUMBER]:
+        if self._tlist is None:
+            self._tlist = self._generate_tlist()
+        if self._max_time is not None:
+            if self._time_scale_cache is None:
+                max_t = self._get_value(max(self._tlist, key=self._get_value)) or 1
+                max_t = max_t if max_t != 0 else 1
+                self._time_scale_cache = self._get_value(self._max_time) / max_t
+            return [t * self._time_scale_cache for t in self._tlist]
+        return self._tlist
+
+    @property
+    def fixed_tlist(self) -> list[float]:
+        if self._fixed_tlist:
+            return self._fixed_tlist
+        self._fixed_tlist = [self._get_value(k) for k in self.tlist]
+        return self._fixed_tlist
+
+    @property
+    def total_time(self) -> float:
+        if not self._total_time:
+            self._total_time = max(self.fixed_tlist)
+        return self._total_time
+
+    def items(self) -> list[tuple[PARAMETERIZED_NUMBER, PARAMETERIZED_NUMBER]]:
+        if self._max_time is not None and self._tlist is not None:
+            if self._time_scale_cache is None:
+                self._time_scale_cache = self._get_value(self._max_time) / self._get_value(
+                    max(self._tlist, key=self._get_value)
+                )
+            return [(k * self._time_scale_cache, v) for k, v in self._time_dict.items()]
+        return list(self._time_dict.items())
+
+    def fixed_items(self) -> list[tuple[float, float]]:
+        return [(t, self._get_value(self[t], t)) for t in self.fixed_tlist]
+
+    @property
+    def coefficients(self) -> list[PARAMETERIZED_NUMBER]:
+        return [self._time_dict[t] for t in self.tlist]
+
+    @property
+    def coefficients_dict(self) -> dict[PARAMETERIZED_NUMBER, PARAMETERIZED_NUMBER]:
+        return copy(self._time_dict)
+
+    @property
+    def fixed_coefficeints(self) -> list[float]:
+        return [self._get_value(self[t]) for t in self.fixed_tlist]
+
+    @property
+    def parameters(self) -> dict[str, Parameter]:
+        return self._parameters
+
+    def set_max_time(self, max_time: PARAMETERIZED_NUMBER) -> None:
+        """
+        Rescale all time points to a new maximum duration while keeping relative spacing.
+
+        Raises:
+            ValueError: If the max time is set to zero.
+        """
+        if self._get_value(max_time) == 0:
+            raise ValueError("Setting the max time to zero.")
+        self._delete_cache()
+        self._max_time = max_time
+
+    def _delete_cache(self) -> None:
+        self._cached = False
+        self._total_time = None
+        self._cached_time = {}
+        self._tlist = None
+        self._fixed_tlist = None
+        self._time_scale_cache = None
+
+    def _get_value(self, value: PARAMETERIZED_NUMBER | complex, t: float | None = None) -> float:
+        if isinstance(value, (int, float)):
+            return value
+        if isinstance(value, complex):
+            return value.real
+        if isinstance(value, Parameter):
+            if value.label == _TIME_PARAMETER_NAME:
+                if t is None:
+                    raise ValueError("Can't evaluate Parameter because time is not provided.")
+                value.set_value(t)
+            return float(value.evaluate())
+        if isinstance(value, Term):
+            ctx: Mapping[BaseVariable, list[int] | int | float] = {self._current_time: t} if t is not None else {}
+            aux = value.evaluate(ctx)
+
+            return aux.real if isinstance(aux, complex) else float(aux)
+        raise ValueError(f"Invalid value of type {type(value)} is being evaluated.")
+
+    def _extract_parameters(self, element: PARAMETERIZED_NUMBER) -> None:
+        if isinstance(element, Parameter) and element.label != _TIME_PARAMETER_NAME:
+            self._parameters[element.label] = element
+        elif isinstance(element, Term):
+            if not element.is_parameterized_term():
+                raise ValueError(
+                    f"Tlist can only contain parameters and no variables, but the term {element} contains objects other than parameters."
+                )
+            for p in element.variables():
+                if isinstance(p, Parameter) and p.label != _TIME_PARAMETER_NAME:
+                    self._parameters[p.label] = p
+
+    def add_time_point(
+        self,
+        time: PARAMETERIZED_NUMBER,
+        coefficient: PARAMETERIZED_NUMBER | Callable[..., PARAMETERIZED_NUMBER],
+        **kwargs: Any,
+    ) -> None:
+        self._extract_parameters(time)
+        coeff = coefficient
+        if callable(coeff):
+            self._current_time.set_value(self._get_value(time))
+            coeff, _params = _process_callable(coeff, self._current_time, **kwargs)
+            self._extract_parameters(coeff)
+            if len(_params) > 0:
+                self._parameters.update(_params)
+        elif isinstance(coeff, (int, float, Parameter, Term)):
+            self._extract_parameters(coeff)
+        else:
+            raise ValueError
+        if self._max_time is not None and self._tlist is not None:
+            if self._time_scale_cache is None:
+                self._time_scale_cache = self._get_value(self._max_time) / self._get_value(
+                    max(self._tlist, key=self._get_value)
+                )
+            time /= self._time_scale_cache
+        self._time_dict[time] = coeff
+        self._delete_cache()
+
+    def set_parameter_values(self, values: list[float]) -> None:
+        self._delete_cache()
+        super().set_parameter_values(values)
+
+    def set_parameters(self, parameters: dict[str, int | float]) -> None:
+        self._delete_cache()
+        super().set_parameters(parameters)
+
+    def set_parameter_bounds(self, ranges: dict[str, tuple[float, float]]) -> None:
+        self._delete_cache()
+        super().set_parameter_bounds(ranges)
+
+    def get_coefficient(self, time_step: float) -> float:
+        time_step = time_step.item() if isinstance(time_step, np.generic) else self._get_value(time_step)
+        val = self.get_coefficient_expression(time_step=time_step)
+
+        if self._max_time is not None and self._tlist is not None:
+            if self._time_scale_cache is None:
+                self._time_scale_cache = self._get_value(self._max_time) / self._get_value(
+                    max(self._tlist, key=self._get_value)
+                )
+            time_step /= self._time_scale_cache
+
+        return self._get_value(val, time_step)
+
+    def get_coefficient_expression(self, time_step: float) -> Number | Term | Parameter:
+        time_step = time_step.item() if isinstance(time_step, np.generic) else self._get_value(time_step)
+
+        # generate the tlist
+        self._tlist = self._generate_tlist()
+
+        if time_step in self.fixed_tlist:
+            indx = self.fixed_tlist.index(time_step)
+            return self._time_dict[self._tlist[indx]]
+        if time_step in self._cached_time:
+            return self._cached_time[time_step]
+
+        if self._max_time is not None and self._tlist is not None:
+            if self._time_scale_cache is None:
+                self._time_scale_cache = self._get_value(self._max_time) / self._get_value(
+                    max(self._tlist, key=self._get_value)
+                )
+            time_step /= self._time_scale_cache
+        factor = self._time_scale_cache or 1.0
+
+        result = None
+        if self._interpolation is Interpolation.STEP:
+            result = self._get_coefficient_expression_step(time_step)
+        if self._interpolation is Interpolation.LINEAR:
+            result = self._get_coefficient_expression_linear(time_step)
+
+        if result is None:
+            raise ValueError(f"interpolation {self._interpolation.value} is not supported!")
+        self._cached_time[time_step * factor] = result
+        return result
+
+    def _get_coefficient_expression_step(self, time_step: float) -> Number | Term | Parameter:
+        self._tlist = self._generate_tlist()
+        prev_indx = bisect_right(self._tlist, time_step, key=self._get_value) - 1
+        if prev_indx >= len(self._tlist):
+            prev_indx = -1
+        prev_time_step = self._tlist[prev_indx]
+        return self._time_dict[prev_time_step]
+
+    def _get_coefficient_expression_linear(self, time_step: float) -> Number | Term | Parameter:
+        self._tlist = self._generate_tlist()
+        insert_pos = bisect_right(self._tlist, time_step, key=self._get_value)
+
+        prev_idx = self._tlist[insert_pos - 1] if insert_pos else None
+        next_idx = self._tlist[insert_pos] if insert_pos < len(self._tlist) else None
+        prev_expr = self._time_dict[prev_idx] if prev_idx is not None else None
+        next_expr = self._time_dict[next_idx] if next_idx is not None else None
+
+        def _linear_value(
+            t0: PARAMETERIZED_NUMBER, v0: PARAMETERIZED_NUMBER, t1: PARAMETERIZED_NUMBER, v1: PARAMETERIZED_NUMBER
+        ) -> PARAMETERIZED_NUMBER:
+            t0_val = self._get_value(t0)
+            t1_val = self._get_value(t1)
+            if t0_val == t1_val:
+                raise ValueError(
+                    f"Ambigous evaluation: The same time step {t0_val} has two different coefficient assignation ({v0} and {v1})."
+                )
+            alpha: float = (time_step - t0_val) / (t1_val - t0_val)
+            next_is_term = isinstance(v1, (Term, Parameter))
+            prev_is_term = isinstance(v0, (Term, Parameter))
+            if next_is_term and prev_is_term and v1 != v0:
+                v1 = self._get_value(v1, t1_val)
+                v0 = self._get_value(v0, t0_val)
+            elif next_is_term and not prev_is_term:
+                v1 = self._get_value(v1, t1_val)
+            elif prev_is_term and not next_is_term:
+                v0 = self._get_value(v0, t0_val)
+
+            return v1 * alpha + v0 * (1 - alpha)
+
+        if prev_expr is None and next_expr is not None:
+            if len(self._tlist) == 1:
+                return next_expr
+            first_idx = self._tlist[0]
+            second_idx = self._tlist[1]
+            return _linear_value(first_idx, self._time_dict[first_idx], second_idx, self._time_dict[second_idx])
+
+        if next_expr is None and prev_expr is not None:
+            if len(self._tlist) == 1:
+                return prev_expr
+            last_idx = self._tlist[-1]
+            penultimate_idx = self._tlist[-2]
+            return _linear_value(penultimate_idx, self._time_dict[penultimate_idx], last_idx, self._time_dict[last_idx])
+        if prev_expr is None and next_expr is None:
+            return 0
+
+        if next_idx is None or prev_idx is None or prev_expr is None or next_expr is None:
+            raise ValueError("Something unexpected happened while retrieving the coefficient.")
+        return _linear_value(prev_idx, prev_expr, next_idx, next_expr)
+
+    def __getitem__(self, time_step: float) -> float:
+        return self.get_coefficient(time_step)
+
+    def __len__(self) -> int:
+        return len(self.tlist)
+
+    def __iter__(self) -> "Interpolator":
+        self.iter_time_step = 0
+        return self
+
+    def __next__(self) -> float:
+        if self.iter_time_step < self.__len__():
+            result = self[self.fixed_tlist[self.iter_time_step]]
+            self.iter_time_step += 1
+            return result
+        raise StopIteration

qilisdk/{common → core}/model.py

@@ -103,8 +103,8 @@ class Constraint:
     Example:
         .. code-block:: python
 
-            from qilisdk.common.model import Constraint
-            from qilisdk.common.variables import BinaryVariable, LEQ
+            from qilisdk.core.model import Constraint
+            from qilisdk.core.variables import BinaryVariable, LEQ
 
             x = BinaryVariable("x")
             constraint = Constraint("limit", LEQ(x, 1))
@@ -195,8 +195,8 @@ class Objective:
     Example:
         .. code-block:: python
 
-            from qilisdk.common.model import Objective, ObjectiveSense
-            from qilisdk.common.variables import BinaryVariable
+            from qilisdk.core.model import Objective, ObjectiveSense
+            from qilisdk.core.variables import BinaryVariable
 
             x = BinaryVariable("x")
             obj = Objective("profit", 3 * x, sense=ObjectiveSense.MAXIMIZE)
@@ -275,7 +275,7 @@ class Model:
     Example:
         .. code-block:: python
 
-            from qilisdk.common import BinaryVariable, LEQ, Model
+            from qilisdk.core import BinaryVariable, LEQ, Model
 
             num_items = 4
             values = [1, 3, 5, 2]
@@ -517,8 +517,8 @@ class QUBO(Model):
     Example:
         .. code-block:: python
 
-            from qilisdk.common.model import QUBO
-            from qilisdk.common.variables import BinaryVariable
+            from qilisdk.core.model import QUBO
+            from qilisdk.core.variables import BinaryVariable
 
             x0, x1 = BinaryVariable("x0"), BinaryVariable("x1")
             qubo = QUBO("Example")