rtc-tools 2.5.2rc4__tar.gz → 2.6.0__tar.gz

{rtc-tools-2.5.2rc4/src/rtc_tools.egg-info → rtc-tools-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rtc-tools
-Version: 2.5.2rc4
+Version: 2.6.0
 Summary: Toolbox for control and optimization of water systems.
 Home-page: https://oss.deltares.nl/web/rtc-tools/home
 Author: Deltares
@@ -24,7 +24,7 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS
-Requires-Python: >=3.5
+Requires-Python: >=3.8
 Provides-Extra: netcdf
 Provides-Extra: all
 License-File: COPYING.LESSER

rtc-tools-2.6.0/README.md

@@ -0,0 +1,53 @@
+# Deltares RTC-Tools
+
+[![Pipeline](https://gitlab.com/deltares/rtc-tools/badges/master/pipeline.svg)](https://gitlab.com/deltares/rtc-tools/commits/master)
+[![Coverage](https://codecov.io/gl/deltares/rtc-tools/branch/master/graph/badge.svg)](https://codecov.io/gl/deltares/rtc-tools)
+
+
+RTC-Tools is an open-source Python package for simulation and optimization of cyber-physical systems.  It can be used for model-predictive control and operational decision making of water and energy systems.  It is developed and maintained by Deltares, in collaboration with partners.
+
+RTC-Tools offers the following functionalities:
+
+- **Model building using extensible libraries**: Build complex system models using extensible libraries of model components. Modelers can also implement their custom modeling components, for instance, using the [Modelica language](https://modelica.org/language/) or Python script.
+
+    RTC-Tools can be used with the following libraries and packages for specific applications:
+    - [rtc-tools-channel-flow](https://gitlab.com/deltares/rtc-tools-channel-flow): water system models
+    - [rtc-tools-hydraulic-structures](https://gitlab.com/deltares/rtc-tools-channel-flow): hydraulic assets, such as weirs and pumps
+    - [rtc-tools-heat-network](https://github.com/Nieuwe-Warmte-Nu/rtc-tools-heat-network): heat networks
+
+Please note that this list is not exhaustive. Users can also create libraries for other types of applications.
+
+- **Running simulations**: Simulate a given model.
+
+- **Specifying and solving optimization problems**: Define optimization goals, constraints and decision variables to specify the optimization problem for a given model. RTC-Tools supports both open-source solvers (CBC, HiGHS, Ipopt) and commercial solvers (Gurobi, CPLEX) for solving several types of optimization problems:
+
+    - **Linear, non-linear**:  RTC-Tools supports both linear and non-linear optimization problems.
+
+    - **Continuous and discrete**:  RTC-Tools can handle both continuous and discrete decision variables. This makes it suitable for optimizing systems with a mix of continuous controls (such as pump speeds or gate positions) and discrete decisions (such as on/off states of equipment).
+
+    - **Goal programming**: When multiple, and perhaps conflicting, objectives are to be considered (e.g., minimize operational costs while minimizing deviations of water levels from a given range), RTC-Tools offers two approaches to multi-objective optimization: The **Weighting Method**, which assigns weights to each objective and optimizes them simultaneously, and the **Lexicographic Goal Programming method**, which optimizes different objectives sequentially. 
+
+    - **Optimization under uncertainty**: RTC-Tools supports the use of ensemble forecasts for optimization under uncertainty. To reduce the size of the optimization problem, ensemble members can be automatically aggregated using a scenario tree reduction method.
+
+To streamline the integration with user interfaces and data management systems (such as Delft-FEWS), RTC-Tools supports CSV and XML file formats for reading/writing timeseries and other model parameters. Support for other formats can be implemented using mixins.
+
+RTC-Tools uses [CasADi](https://web.casadi.org/) as a symbolic framework for algorithmic differentiation, as well as for interfacing with numerical optimization solvers.
+
+
+## Install
+
+```bash
+pip install rtc-tools
+```
+
+## Documentation
+
+Documentation and examples can be found on [readthedocs](https://rtc-tools.readthedocs.io).
+
+
+## License
+RTC-Tools is licensed under the **[GNU Lesser General Public License v3.0](https://gitlab.com/deltares/rtc-tools/-/blob/guidelines_contributions/COPYING)**, and can be used free of charge. Deltares offers support packages for users who require assistance.
+
+
+## Acknowledgment
+If you use RTC-Tools in your work, please acknowledge it in any resulting publications. You can do this by citing RTC-Tools and providing a link to our [website](https://oss.deltares.nl/web/rtc-tools/home) or [Gitlab repository](https://gitlab.com/deltares/rtc-tools).

rtc-tools-2.6.0/pyproject.toml

@@ -0,0 +1,22 @@
+[tool.black]
+line-length = 100
+target-version = ['py38', 'py39', 'py310', 'py311']
+exclude = '''
+	(
+		src/rtctools/_version.py
+	)
+'''
+
+[tool.ruff]
+ignore = [
+	"B904", # Fix someday: raising exceptions within except
+]
+line-length = 100
+select = [
+    "B", # flake8-bugbear
+    "C4", # flake8-comprehensions
+    "E", # default / pycodestyle
+    "F", # default / pyflakes
+    "I", # isort
+    "W", # pycodestyle
+]

{rtc-tools-2.5.2rc4 → rtc-tools-2.6.0}/setup.cfg

@@ -12,12 +12,6 @@ versionfile_build = rtctools/_version.py
 tag_prefix = 
 parentdir_prefix = rtctools-
 
-[flake8]
-max-line-length = 120
-exclude = 
-	src/rtctools/_version.py
-	src/rtctools/data/interpolation/__init__.py
-
 [egg_info]
 tag_build = 
 tag_date = 0

{rtc-tools-2.5.2rc4 → rtc-tools-2.6.0}/setup.py

@@ -3,12 +3,14 @@
 RTC-Tools is the Deltares toolbox for control and optimization of water systems.
 
 """
-from setuptools import setup, find_packages
-import versioneer
 import sys
 
-if sys.version_info < (3, 5):
-    sys.exit("Sorry, Python 3.5 or newer is required.")
+from setuptools import find_packages, setup
+
+import versioneer
+
+if sys.version_info < (3, 8):
+    sys.exit("Sorry, Python 3.8 or newer is required.")
 
 DOCLINES = __doc__.split("\n")
 
@@ -29,34 +31,36 @@ Operating System :: MacOS
 """
 
 setup(
-    name='rtc-tools',
+    name="rtc-tools",
     version=versioneer.get_version(),
-    maintainer='Deltares',
-    author='Deltares',
+    maintainer="Deltares",
+    author="Deltares",
     description=DOCLINES[0],
-    long_description='\n'.join(DOCLINES[2:]),
-    url='https://oss.deltares.nl/web/rtc-tools/home',
-    download_url='http://gitlab.com/deltares/rtc-tools/',
-    classifiers=[_f for _f in CLASSIFIERS.split('\n') if _f],
-    platforms=['Windows', 'Linux', 'Mac OS-X', 'Unix'],
+    long_description="\n".join(DOCLINES[2:]),
+    url="https://oss.deltares.nl/web/rtc-tools/home",
+    download_url="http://gitlab.com/deltares/rtc-tools/",
+    classifiers=[_f for _f in CLASSIFIERS.split("\n") if _f],
+    platforms=["Windows", "Linux", "Mac OS-X", "Unix"],
     packages=find_packages("src"),
     package_dir={"": "src"},
-    install_requires=["casadi == 3.5.*",
-                      "numpy >= 1.16.0, <1.23",
-                      "scipy >= 1.0.0, <1.11",
-                      "pymoca == 0.9.*",
-                      "rtc-tools-channel-flow >= 1.1.0"],
-    tests_require=['pytest', 'pytest-runner'],
+    install_requires=[
+        "casadi >= 3.6.3, == 3.6.*",
+        "numpy >= 1.16.0, <1.26",
+        "scipy >= 1.0.0, <1.11",
+        "pymoca == 0.9.1",
+        "rtc-tools-channel-flow >= 1.1.0",
+    ],
+    tests_require=["pytest", "pytest-runner", "netCDF4"],
     extras_require={
-        'netcdf':  ["netCDF4"],
-        'all': ["netCDF4"],
+        "netcdf": ["netCDF4"],
+        "all": ["netCDF4"],
     },
-    python_requires='>=3.5',
+    python_requires=">=3.8",
     cmdclass=versioneer.get_cmdclass(),
     entry_points={
-        'console_scripts': [
-            'rtc-tools-download-examples = rtctools.rtctoolsapp:download_examples',
-            'rtc-tools-copy-libraries = rtctools.rtctoolsapp:copy_libraries',
+        "console_scripts": [
+            "rtc-tools-download-examples = rtctools.rtctoolsapp:download_examples",
+            "rtc-tools-copy-libraries = rtctools.rtctoolsapp:copy_libraries",
         ]
     },
 )

{rtc-tools-2.5.2rc4 → rtc-tools-2.6.0/src/rtc_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rtc-tools
-Version: 2.5.2rc4
+Version: 2.6.0
 Summary: Toolbox for control and optimization of water systems.
 Home-page: https://oss.deltares.nl/web/rtc-tools/home
 Author: Deltares
@@ -24,7 +24,7 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS
-Requires-Python: >=3.5
+Requires-Python: >=3.8
 Provides-Extra: netcdf
 Provides-Extra: all
 License-File: COPYING.LESSER

{rtc-tools-2.5.2rc4 → rtc-tools-2.6.0}/src/rtc_tools.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 COPYING.LESSER
 MANIFEST.in
 README.md
+pyproject.toml
 setup.cfg
 setup.py
 versioneer.py
@@ -46,6 +47,7 @@ src/rtctools/optimization/modelica_mixin.py
 src/rtctools/optimization/netcdf_mixin.py
 src/rtctools/optimization/optimization_problem.py
 src/rtctools/optimization/pi_mixin.py
+src/rtctools/optimization/planning_mixin.py
 src/rtctools/optimization/single_pass_goal_programming_mixin.py
 src/rtctools/optimization/timeseries.py
 src/rtctools/simulation/__init__.py

{rtc-tools-2.5.2rc4 → rtc-tools-2.6.0}/src/rtc_tools.egg-info/requires.txt

@@ -1,7 +1,7 @@
-casadi==3.5.*
-numpy<1.23,>=1.16.0
+casadi==3.6.*,>=3.6.3
+numpy<1.26,>=1.16.0
 scipy<1.11,>=1.0.0
-pymoca==0.9.*
+pymoca==0.9.1
 rtc-tools-channel-flow>=1.1.0
 
 [all]

{rtc-tools-2.5.2rc4 → rtc-tools-2.6.0}/src/rtctools/__init__.py

@@ -1,4 +1,5 @@
 # Get version
 from ._version import get_versions
-__version__ = get_versions()['version']
+
+__version__ = get_versions()["version"]
 del get_versions

{rtc-tools-2.5.2rc4 → rtc-tools-2.6.0}/src/rtctools/_internal/alias_tools.py

@@ -13,8 +13,8 @@ class OrderedSet(MutableSet):
 
     def __init__(self, iterable=None):
         self.end = end = []
-        end += [None, end, end]         # sentinel node for doubly linked list
-        self.map = {}                   # key --> [key, prev, next]
+        end += [None, end, end]  # sentinel node for doubly linked list
+        self.map = {}  # key --> [key, prev, next]
         if iterable is not None:
             self |= iterable
 
@@ -25,11 +25,11 @@ class OrderedSet(MutableSet):
         return key in self.map
 
     def __getstate__(self):
-        """ Avoids max depth RecursionError when using pickle """
+        """Avoids max depth RecursionError when using pickle"""
         return list(self)
 
     def __setstate__(self, state):
-        """ Tells pickle how to restore instance """
+        """Tells pickle how to restore instance"""
         self.__init__(state)
 
     def __getitem__(self, index):
@@ -45,7 +45,7 @@ class OrderedSet(MutableSet):
                     return curr[0]
                 curr = curr[2]
                 i += 1
-            raise IndexError('set index {} out of range with length {}'.format(index, len(self)))
+            raise IndexError("set index {} out of range with length {}".format(index, len(self)))
 
     def add(self, key):
         if key not in self.map:
@@ -75,25 +75,27 @@ class OrderedSet(MutableSet):
 
     def pop(self, last=True):
         if not self:
-            raise KeyError('set is empty')
+            raise KeyError("set is empty")
         key = self.end[1][0] if last else self.end[2][0]
         self.discard(key)
         return key
 
     def __repr__(self):
         if not self:
-            return '%s()' % (self.__class__.__name__,)
-        return '%s(%r)' % (self.__class__.__name__, list(self))
+            return "%s()" % (self.__class__.__name__,)
+        return "%s(%r)" % (self.__class__.__name__, list(self))
 
     def __eq__(self, other):
         if isinstance(other, OrderedSet):
             return len(self) == len(other) and list(self) == list(other)
         return set(self) == set(other)
+
+
 # End snippet
 
 
-KT = TypeVar('KT')
-VT = TypeVar('VT')
+KT = TypeVar("KT")
+VT = TypeVar("VT")
 
 
 class AliasDict(Generic[KT, VT]):

{rtc-tools-2.5.2rc4 → rtc-tools-2.6.0}/src/rtctools/_internal/caching.py

@@ -5,14 +5,15 @@ def cached(f):
                 return f(self, ensemble_member)
             else:
                 return f(self)
+
         # Add a check so that caching is applied to the 'toplevel'
         # method implementation in the class hierarchy only.
-        call_in_progress = '__' + f.__name__ + '_in_progress'
+        call_in_progress = "__" + f.__name__ + "_in_progress"
         if hasattr(self, call_in_progress):
             return call()
-        cache_name = '__' + f.__name__
+        cache_name = "__" + f.__name__
         if ensemble_member is not None:
-            cache_name = '{}[{}]'.format(cache_name, ensemble_member)
+            cache_name = "{}[{}]".format(cache_name, ensemble_member)
         if hasattr(self, cache_name):
             return getattr(self, cache_name)
         setattr(self, call_in_progress, True)
@@ -20,4 +21,5 @@ def cached(f):
         setattr(self, cache_name, value)
         delattr(self, call_in_progress)
         return value
+
     return wrapper

rtc-tools-2.6.0/src/rtctools/_internal/casadi_helpers.py

@@ -0,0 +1,55 @@
+import logging
+
+import casadi as ca
+
+logger = logging.getLogger("rtctools")
+
+
+def is_affine(e, v):
+    try:
+        Af = ca.Function("f", [v], [ca.jacobian(e, v)]).expand()
+    except RuntimeError as e:
+        if "'eval_sx' not defined for" in str(e):
+            Af = ca.Function("f", [v], [ca.jacobian(e, v)])
+        else:
+            raise
+    return Af.sparsity_jac(0, 0).nnz() == 0
+
+
+def nullvertcat(*L):
+    """
+    Like vertcat, but creates an MX with consistent dimensions even if L is empty.
+    """
+    if len(L) == 0:
+        return ca.DM(0, 1)
+    else:
+        return ca.vertcat(*L)
+
+
+def reduce_matvec(e, v):
+    """
+    Reduces the MX graph e of linear operations on p into a matrix-vector product.
+
+    This reduces the number of nodes required to represent the linear operations.
+    """
+    Af = ca.Function("Af", [ca.MX()], [ca.jacobian(e, v)])
+    A = Af(ca.DM())
+    return ca.reshape(ca.mtimes(A, v), e.shape)
+
+
+def substitute_in_external(expr, symbols, values):
+    if len(symbols) == 0 or all(isinstance(x, ca.DM) for x in expr):
+        return expr
+    else:
+        f = ca.Function("f", symbols, expr)
+        return f.call(values, True, False)
+
+
+def interpolate(ts, xs, t, equidistant, mode=0):
+    if mode == 0:
+        mode_str = "linear"
+    elif mode == 1:
+        mode_str = "floor"
+    else:
+        mode_str = "ceil"
+    return ca.interp1d(ts, xs, t, mode_str, equidistant)

{rtc-tools-2.5.2rc4 → rtc-tools-2.6.0}/src/rtctools/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-07-25T11:51:05+0200",
+ "date": "2024-01-30T12:56:46+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "9fc120016a7880faa74859883466fade1d15ca08",
- "version": "2.5.2rc4"
+ "full-revisionid": "7f078d793396303774d150ae5ebabb7534420ace",
+ "version": "2.6.0"
 }
 '''  # END VERSION_JSON
 

rtc-tools-2.6.0/src/rtctools/data/__init__.py

@@ -0,0 +1,4 @@
+import xml.etree.ElementTree as ET
+
+ET.register_namespace("fews", "http://www.wldelft.nl/fews")
+ET.register_namespace("pi", "http://www.wldelft.nl/fews/PI")

{rtc-tools-2.5.2rc4 → rtc-tools-2.6.0}/src/rtctools/data/csv.py

@@ -22,15 +22,18 @@ def _boolean_to_nan(data, fname):
     convert_to_nan = []
     dtypes_out = []
     for i, name in enumerate(data.dtype.names):
-        if dtypes_in[i][1][1] == 'b':
+        if dtypes_in[i][1][1] == "b":
             convert_to_nan.append(name)
-            dtypes_out.append((dtypes_in[i][0], '<f8'))
+            dtypes_out.append((dtypes_in[i][0], "<f8"))
         else:
             dtypes_out.append(dtypes_in[i])
 
     if convert_to_nan:
-        logger.warning("Column(s) {} were detected as boolean in '{}'; converting to NaN".format(
-            ", ".join(["'{}'".format(name) for name in convert_to_nan]), fname))
+        logger.warning(
+            "Column(s) {} were detected as boolean in '{}'; converting to NaN".format(
+                ", ".join(["'{}'".format(name) for name in convert_to_nan]), fname
+            )
+        )
         data = data.astype(dtypes_out)
         for name in convert_to_nan:
             data[name] = np.nan
@@ -38,7 +41,7 @@ def _boolean_to_nan(data, fname):
     return data
 
 
-def load(fname, delimiter=',', with_time=False):
+def load(fname, delimiter=",", with_time=False):
     """
     Check delimiter of csv and read contents to an array. Assumes no date-time conversion needed.
 
@@ -50,56 +53,68 @@ def load(fname, delimiter=',', with_time=False):
     """
     c = {}
     if with_time:
-        c.update({0: lambda str: datetime.strptime(
-            str.decode("utf-8"), '%Y-%m-%d %H:%M:%S')})
+        c.update({0: lambda str: datetime.strptime(str.decode("utf-8"), "%Y-%m-%d %H:%M:%S")})
 
     # Check delimiter of csv file. If semicolon, check if decimal separator is
     # a comma.
-    if delimiter == ';':
-        with open(fname, 'rb') as csvfile:
+    if delimiter == ";":
+        with open(fname, "rb") as csvfile:
             # Read the first line, this should be a header. Count columns by
             # counting separator.
             sample_csvfile = csvfile.readline()
-            n_semicolon = sample_csvfile.count(b';')
-            # We actually only need one number to evaluate if commas are used as decimal separator, but
-            # certain csv writers don't use a decimal when the value has no meaningful decimal
-            # (e.g. 12.0 becomes 12) so we read the next 1024 bytes to make sure we catch a number.
+            n_semicolon = sample_csvfile.count(b";")
+            # We actually only need one number to evaluate if commas are used as decimal
+            # separator, but certain csv writers don't use a decimal when the value has
+            # no meaningful decimal(e.g. 12.0 becomes 12) so we read the next 1024 bytes
+            # to make sure we catch a number.
             sample_csvfile = csvfile.read(1024)
             # Count the commas
-            n_comma_decimal = sample_csvfile.count(b',')
+            n_comma_decimal = sample_csvfile.count(b",")
             # If commas are used as decimal separator, we need additional
             # converters.
             if n_comma_decimal:
-                c.update({i + len(c): lambda str: float(str.decode("utf-8").replace(',', '.'))
-                          for i in range(1 + n_semicolon - len(c))})
+                c.update(
+                    {
+                        i + len(c): lambda str: float(str.decode("utf-8").replace(",", "."))
+                        for i in range(1 + n_semicolon - len(c))
+                    }
+                )
 
     # Read the csv file and convert to array
     try:
         if len(c):  # Converters exist, so use them.
             try:
-                data = np.genfromtxt(fname, delimiter=delimiter, deletechars='', dtype=None, names=True, converters=c)
+                data = np.genfromtxt(
+                    fname, delimiter=delimiter, deletechars="", dtype=None, names=True, converters=c
+                )
                 return _boolean_to_nan(data, fname)
-            except np.lib._iotools.ConverterError:  # value does not conform to expected date-time format
+            except (
+                np.lib._iotools.ConverterError
+            ):  # value does not conform to expected date-time format
                 type, value, traceback = sys.exc_info()
                 logger.error(
-                    'CSVMixin: converter of csv reader failed on {}: {}'.format(fname, value))
+                    "CSVMixin: converter of csv reader failed on {}: {}".format(fname, value)
+                )
                 raise ValueError(
-                    'CSVMixin: wrong date time or value format in {}. '
-                    'Should be %Y-%m-%d %H:%M:%S and numerical values everywhere.'.format(fname))
+                    "CSVMixin: wrong date time or value format in {}. "
+                    "Should be %Y-%m-%d %H:%M:%S and numerical values everywhere.".format(fname)
+                )
         else:
-            data = np.genfromtxt(fname, delimiter=delimiter, deletechars='', dtype=None, names=True)
+            data = np.genfromtxt(fname, delimiter=delimiter, deletechars="", dtype=None, names=True)
             return _boolean_to_nan(data, fname)
-    except ValueError:  # can occur when delimiter changes after first 1024 bytes of file, or delimiter is not , or ;
+    except ValueError:
+        # can occur when delimiter changes after first 1024 bytes of file,
+        # or delimiter is not , or ;
         type, value, traceback = sys.exc_info()
-        logger.error(
-            'CSV: Value reader of csv reader failed on {}: {}'.format(fname, value))
+        logger.error("CSV: Value reader of csv reader failed on {}: {}".format(fname, value))
         raise ValueError(
             "CSV: could not read all values from {}. Used delimiter '{}'. "
             "Please check delimiter (should be ',' or ';' throughout the file) "
-            "and if all values are numbers.".format(fname, delimiter))
+            "and if all values are numbers.".format(fname, delimiter)
+        )
 
 
-def save(fname, data, delimiter=',', with_time=False):
+def save(fname, data, delimiter=",", with_time=False):
     """
     Write the contents of an array to a csv file.
 
@@ -109,10 +124,16 @@ def save(fname, data, delimiter=',', with_time=False):
     :param with_time: Whether to output the first column of the data as time stamps.
     """
     if with_time:
-        data['time'] = [t.strftime("%Y-%m-%d %H:%M:%S") for t in data['time']]
-        fmt = ['%s'] + (len(data.dtype.names) - 1) * ['%f']
+        data["time"] = [t.strftime("%Y-%m-%d %H:%M:%S") for t in data["time"]]
+        fmt = ["%s"] + (len(data.dtype.names) - 1) * ["%f"]
     else:
-        fmt = len(data.dtype.names) * ['%f']
-
-    np.savetxt(fname, data, delimiter=delimiter, header=delimiter.join(
-        data.dtype.names), fmt=fmt, comments='')
+        fmt = len(data.dtype.names) * ["%f"]
+
+    np.savetxt(
+        fname,
+        data,
+        delimiter=delimiter,
+        header=delimiter.join(data.dtype.names),
+        fmt=fmt,
+        comments="",
+    )

{rtc-tools-2.5.2rc4 → rtc-tools-2.6.0}/src/rtctools/data/interpolation/bspline.py

@@ -14,7 +14,8 @@ class BSpline:
         :param k: Order of the basis function.
         :param i: Knot number.
 
-        :returns: The B-Spline basis function of the given order, at the given knot, evaluated at the given point.
+        :returns: The B-Spline basis function of the given order, at the given knot, evaluated at
+            the given point.
         """
         if k == 0:
             return if_else(logic_and(t[i] <= x, x < t[i + 1]), 1.0, 0.0)
@@ -24,8 +25,7 @@ class BSpline:
             else:
                 a = 0.0
             if t[i + 1] < t[i + k + 1]:
-                b = (t[i + k + 1] - x) / (t[i + k + 1] - t[i + 1]) * \
-                    self.basis(t, x, k - 1, i + 1)
+                b = (t[i + k + 1] - x) / (t[i + k + 1] - t[i + 1]) * self.basis(t, x, k - 1, i + 1)
             else:
                 b = 0.0
             return a + b