rtc-tools 2.5.2rc4__py3-none-any.whl → 2.6.0__py3-none-any.whl

{rtc_tools-2.5.2rc4.dist-info → rtc_tools-2.6.0.dist-info}/METADATA

@@ -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,13 +24,13 @@ 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
 License-File: COPYING.LESSER
-Requires-Dist: casadi (==3.5.*)
-Requires-Dist: numpy (<1.23,>=1.16.0)
-Requires-Dist: scipy (<1.11,>=1.0.0)
-Requires-Dist: pymoca (==0.9.*)
-Requires-Dist: rtc-tools-channel-flow (>=1.1.0)
+Requires-Dist: casadi ==3.6.*,>=3.6.3
+Requires-Dist: numpy <1.26,>=1.16.0
+Requires-Dist: scipy <1.11,>=1.0.0
+Requires-Dist: pymoca ==0.9.1
+Requires-Dist: rtc-tools-channel-flow >=1.1.0
 Provides-Extra: all
 Requires-Dist: netCDF4 ; extra == 'all'
 Provides-Extra: netcdf

rtc_tools-2.6.0.dist-info/RECORD

@@ -0,0 +1,50 @@
+rtctools/__init__.py,sha256=91hvS2-ryd2Pvw0COpsUzTwJwSnTZ035REiej-1hNI4,107
+rtctools/_version.py,sha256=Ew8vUIDrRgybDaHsPu1sREz91JeynwrSLqOvc2B4Ts8,497
+rtctools/rtctoolsapp.py,sha256=A6M0v6vymAZWdBPLzgRVyAUfahD0knC8B4IptJ7_sBM,4097
+rtctools/util.py,sha256=PaeKfDUA174ODZbY5fZjCTf-F-TdhW7yEuP189Ro190,9075
+rtctools/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rtctools/_internal/alias_tools.py,sha256=XuQSAhhFuVtwn0yrAObZWIKPsSF4j2axXRtEmitIFPs,5310
+rtctools/_internal/caching.py,sha256=p4gqSL7kCI7Hff-KjMEP7mhJCQSiU_lYm2MR7E18gBM,905
+rtctools/_internal/casadi_helpers.py,sha256=oAf5zyFkZbaMhvhgMnQkOi2A6dBOzj-VAUkYwBf-Jxk,1410
+rtctools/_internal/debug_check_helpers.py,sha256=UgQTEPw4PyR7MbYLewSSWQqTwQj7xr5yUBk820O9Kk4,1084
+rtctools/data/__init__.py,sha256=EllgSmCdrlvQZSd1VilvjPaeYJGhY9ErPiQtedmuFoA,157
+rtctools/data/csv.py,sha256=iYOEED3AaNxt4ews_aAkHfl9Tq9a-9vjxvYwjVR_lQE,5231
+rtctools/data/netcdf.py,sha256=xpk4Ggl7gItNG6lO7p3OJPR-elK8_CiCtxUI7cX0gwk,19109
+rtctools/data/pi.py,sha256=yyuLHpCYrfAqL9dZWEXn4IgQ7yeAOUMpg8GD7Sh-kN4,45341
+rtctools/data/rtc.py,sha256=FBuUQ6aL4D3y6puKudyuLAeP_vmpDiliqzJg8f1kd7g,9043
+rtctools/data/storage.py,sha256=67J4BRTl0AMEzlKNZ8Xdpy_4cGtwx8Lo_tL2n0G4S9w,13206
+rtctools/data/interpolation/__init__.py,sha256=GBubCIT5mFoSTV-lOk7cpwvZekNMEe5bvqSQJ9HE34M,73
+rtctools/data/interpolation/bspline.py,sha256=qevB842XWCH3fWlWMBqKMy1mw37ust-0YtSnb9PKCEc,948
+rtctools/data/interpolation/bspline1d.py,sha256=hQrok4rrBcJV_HciuFjZYSwrSP8w_VufQRP6JLZhA7U,6106
+rtctools/data/interpolation/bspline2d.py,sha256=ScmX0fPDxbUVtj3pbUE0L7UJocqroD_6fUT-4cvdRMc,1693
+rtctools/optimization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rtctools/optimization/collocated_integrated_optimization_problem.py,sha256=Bv1a1O4QTAdIpe9SOA9_oEDDph-oj-9q5yfN4SFMdW8,131343
+rtctools/optimization/control_tree_mixin.py,sha256=CC6TWp3kFQgMokx6213pRLx9iY17Fd0VcwG4Wpwa0Uo,8974
+rtctools/optimization/csv_lookup_table_mixin.py,sha256=xiyOKpPT3kQ6yuxSJRorGYW_QwnlBzW6vvrtvQNhHsE,17264
+rtctools/optimization/csv_mixin.py,sha256=sRp5paHWfCw2bz-23Nw-HdFLS3CZTpVwaBdFo98DbvE,12252
+rtctools/optimization/goal_programming_mixin.py,sha256=GK25DrbAY_rMsra080pSCDZwzLQNN2Ppd-2d0_FEllg,32999
+rtctools/optimization/goal_programming_mixin_base.py,sha256=oh9CsEiyYTmthcfvRbX-9Z9bIo6SHv_DCiVt9kx0sjI,43781
+rtctools/optimization/homotopy_mixin.py,sha256=Kh0kMfxB-Fo1FBGW5tPOQk24Xx_Mmw_p0YuSQotdkMU,6905
+rtctools/optimization/initial_state_estimation_mixin.py,sha256=74QYfG-VYYTNVg-kAnCG6QoY3_sUmaID0ideF7bPkkY,3116
+rtctools/optimization/io_mixin.py,sha256=AsZQ7YOUcUbWoczmjTXaSje5MUEsPNbQyZBJ6qzSjzU,11821
+rtctools/optimization/linearization_mixin.py,sha256=mG5S7uwvwDydw-eBPyQKnLyKoy08EBjQh25vu97afhY,1049
+rtctools/optimization/linearized_order_goal_programming_mixin.py,sha256=LQ2qpYt0YGLpEoerif4FJ5wwzq16q--27bsRjcqIU5A,9087
+rtctools/optimization/min_abs_goal_programming_mixin.py,sha256=WMOv9EF8cfDJgTunzXfI_cUmBSQK26u1HJB_9EAarfM,14031
+rtctools/optimization/modelica_mixin.py,sha256=ysVMayNA4sSFoHkSdhjWOxT6UzOVbN0ZeM4v-RpvZXE,17161
+rtctools/optimization/netcdf_mixin.py,sha256=-zkXh3sMYE50c3kHsrmUVGWMSFm-0cXQpGrCm0yn-Tc,7563
+rtctools/optimization/optimization_problem.py,sha256=qzpc81NaZMeoXKuayFmBF15iXYuNAk5yxmaER_Gcz_A,44131
+rtctools/optimization/pi_mixin.py,sha256=63qda6i7hjtDuP3hL6RO29vCCP11aUpR9B4KoqlLFVI,11314
+rtctools/optimization/planning_mixin.py,sha256=O_Y74X8xZmaNZR4iYOe7BR06s9hnmcapbuHYHQTBPPQ,724
+rtctools/optimization/single_pass_goal_programming_mixin.py,sha256=Zb9szg3PGT2o6gkGsXluSfEaAswkw3TKfPQDzUrj_Y4,25784
+rtctools/optimization/timeseries.py,sha256=nCrsGCJThBMh9lvngEpbBDa834_QvklVvkxJqwX4a1M,1734
+rtctools/simulation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rtctools/simulation/csv_mixin.py,sha256=rGDUFPsqGHmF0_dWdXeWzWzMpkPmwCNweTBVrwSh31g,6704
+rtctools/simulation/io_mixin.py,sha256=SJasNGI--OQ9Y-Z61oeeaGCxSrNddYz4AOVfJYbmf74,6209
+rtctools/simulation/pi_mixin.py,sha256=uwl61LYjb8dmMz910EB2-bC0KSuhLzsrJzk0hxWYEhk,9359
+rtctools/simulation/simulation_problem.py,sha256=gTAimG2MLw_TTkeHLkIMxpYgAmR-voqzvje7pcFnw4U,44556
+rtc_tools-2.6.0.dist-info/COPYING.LESSER,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+rtc_tools-2.6.0.dist-info/METADATA,sha256=jn_eXPKFLJnhDwsGUgbGcqff27OfYGJkt8llDEyT4ws,1450
+rtc_tools-2.6.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+rtc_tools-2.6.0.dist-info/entry_points.txt,sha256=-x622IB_l1duw2M6t6syfQ4yzOiQTp0IZxKGcYRgWgk,151
+rtc_tools-2.6.0.dist-info/top_level.txt,sha256=pnBrb58PFPd1kp1dqa-JHU7R55h3alDNJIJnF3Jf9Dw,9
+rtc_tools-2.6.0.dist-info/RECORD,,

{rtc_tools-2.5.2rc4.dist-info → rtc_tools-2.6.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.40.0)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

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

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]):

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

rtctools/_internal/casadi_helpers.py

@@ -4,22 +4,16 @@ import casadi as ca
 
 logger = logging.getLogger("rtctools")
 
-try:
-    from casadi import interp1d
-except ImportError:
-    logger.warning('interp1d not available in this version of CasADi.  Linear interpolation will not work.')
-    interp1d = None
-
 
 def is_affine(e, v):
     try:
-        Af = ca.Function('f', [v], [ca.jacobian(e, v)]).expand()
+        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)])
+            Af = ca.Function("f", [v], [ca.jacobian(e, v)])
         else:
             raise
-    return (Af.sparsity_jac(0, 0).nnz() == 0)
+    return Af.sparsity_jac(0, 0).nnz() == 0
 
 
 def nullvertcat(*L):
@@ -38,7 +32,7 @@ def reduce_matvec(e, v):
 
     This reduces the number of nodes required to represent the linear operations.
     """
-    Af = ca.Function('Af', [ca.MX()], [ca.jacobian(e, v)])
+    Af = ca.Function("Af", [ca.MX()], [ca.jacobian(e, v)])
     A = Af(ca.DM())
     return ca.reshape(ca.mtimes(A, v), e.shape)
 
@@ -47,30 +41,15 @@ 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)
+        f = ca.Function("f", symbols, expr)
         return f.call(values, True, False)
 
 
 def interpolate(ts, xs, t, equidistant, mode=0):
-    if interp1d is not None:
-        if mode == 0:
-            mode_str = 'linear'
-        elif mode == 1:
-            mode_str = 'floor'
-        else:
-            mode_str = 'ceil'
-        return interp1d(ts, xs, t, mode_str, equidistant)
+    if mode == 0:
+        mode_str = "linear"
+    elif mode == 1:
+        mode_str = "floor"
     else:
-        if mode == 1:
-            xs = xs[:-1]  # block-forward
-        else:
-            xs = xs[1:]  # block-backward
-        t = ca.MX(t)
-        if t.size1() > 1:
-            t_ = ca.MX.sym('t')
-            xs_ = ca.MX.sym('xs', xs.size1())
-            f = ca.Function('interpolant', [t_, xs_], [ca.mtimes(ca.transpose((t_ >= ts[:-1]) * (t_ < ts[1:])), xs_)])
-            f = f.map(t.size1(), 'serial')
-            return ca.transpose(f(ca.transpose(t), ca.repmat(xs, 1, t.size1())))
-        else:
-            return ca.mtimes(ca.transpose((t >= ts[:-1]) * (t < ts[1:])), xs)
+        mode_str = "ceil"
+    return ca.interp1d(ts, xs, t, mode_str, equidistant)

rtctools/_internal/debug_check_helpers.py

@@ -13,7 +13,6 @@ class DebugLevel(IntEnum):
 
 
 def debug_check(level):
-
     def noop(*args, **kwargs):
         pass
 
@@ -38,4 +37,5 @@ def debug_check(level):
                 return noop(*args, **kwargs)
 
         return func_wrapper
+
     return wrap

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
 

rtctools/data/__init__.py

@@ -1,4 +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')
+ET.register_namespace("fews", "http://www.wldelft.nl/fews")
+ET.register_namespace("pi", "http://www.wldelft.nl/fews/PI")

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="",
+    )

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

rtctools/data/interpolation/bspline1d.py

@@ -1,13 +1,13 @@
-from casadi import Function, SX, if_else, inf, jacobian, logic_and, nlpsol, sum2, vertcat
-
 import numpy as np
+from casadi import SX, Function, if_else, inf, jacobian, logic_and, nlpsol, sum2, vertcat
 
 from .bspline import BSpline
 
 
 class BSpline1D(BSpline):
     """
-    Arbitrary order, one-dimensional, non-uniform B-Spline implementation using Cox-de Boor recursion.
+    Arbitrary order, one-dimensional, non-uniform B-Spline implementation using Cox-de Boor
+    recursion.
     """
 
     def __init__(self, t, w, k=3):
@@ -36,13 +36,26 @@ class BSpline1D(BSpline):
         """
         y = 0.0
         for i in range(len(self.__t) - self.__k - 1):
-            y += if_else(logic_and(x >= self.__t[i], x <= self.__t[i + self.__k + 1]), self.__w[
-                         i] * self.basis(self.__t, x, self.__k, i), 0.0)
+            y += if_else(
+                logic_and(x >= self.__t[i], x <= self.__t[i + self.__k + 1]),
+                self.__w[i] * self.basis(self.__t, x, self.__k, i),
+                0.0,
+            )
         return y
 
     @classmethod
-    def fit(cls, x, y, k=3, monotonicity=0, curvature=0,
-            num_test_points=100, epsilon=1e-7, delta=1e-4, interior_pts=None):
+    def fit(
+        cls,
+        x,
+        y,
+        k=3,
+        monotonicity=0,
+        curvature=0,
+        num_test_points=100,
+        epsilon=1e-7,
+        delta=1e-4,
+        interior_pts=None,
+    ):
         """
         fit() returns a tck tuple like scipy.interpolate.splrep, but adjusts
         the weights to meet the desired constraints to the curvature of the spline curve.
@@ -86,33 +99,33 @@ class BSpline1D(BSpline):
             # Generate knots: This algorithm is based on the Fitpack algorithm by p.dierckx
             # The original code lives here: http://www.netlib.org/dierckx/
             if k % 2 == 1:
-                interior_pts = x[k // 2 + 1:-k // 2]
+                interior_pts = x[k // 2 + 1 : -k // 2]
             else:
-                interior_pts = (x[k // 2 + 1:-k // 2] + x[k // 2:-k // 2 - 1]) / 2
+                interior_pts = (x[k // 2 + 1 : -k // 2] + x[k // 2 : -k // 2 - 1]) / 2
         t = np.concatenate(
-            (np.full(k + 1, x[0] - delta), interior_pts, np.full(k + 1, x[-1] + delta)))
+            (np.full(k + 1, x[0] - delta), interior_pts, np.full(k + 1, x[-1] + delta))
+        )
         num_knots = len(t)
 
         # Casadi Variable Symbols
-        c = SX.sym('c', num_knots)
-        x_sym = SX.sym('x')
+        c = SX.sym("c", num_knots)
+        x_sym = SX.sym("x")
 
         # Casadi Representation of Spline Function & Derivatives
         expr = cls(t, c, k)(x_sym)
         free_vars = [c, x_sym]
-        bspline = Function('bspline', free_vars, [expr])
+        bspline = Function("bspline", free_vars, [expr])
         J = jacobian(expr, x_sym)
         # bspline_prime = Function('bspline_prime', free_vars, [J])
         H = jacobian(J, x_sym)
-        bspline_prime_prime = Function('bspline_prime_prime', free_vars, [H])
+        bspline_prime_prime = Function("bspline_prime_prime", free_vars, [H])
 
         # Objective Function
-        xpt = SX.sym('xpt')
-        ypt = SX.sym('ypt')
-        sq_diff = Function('sq_diff', [xpt, ypt], [
-            (ypt - bspline(c, xpt))**2])
-        sq_diff = sq_diff.map(N, 'serial')
-        f = sum2(sq_diff(SX(x), SX(y)))
+        xpt = SX.sym("xpt")
+        ypt = SX.sym("ypt")
+        sq_diff = Function("sq_diff", [c, xpt, ypt], [(ypt - bspline(c, xpt)) ** 2])
+        sq_diff = sq_diff.map(N, "serial")
+        f = sum2(sq_diff(c, SX(x), SX(y)))
 
         # Setup Curvature Constraints
         delta_c_max = np.full(num_knots - 1, inf)
@@ -129,24 +142,24 @@ class BSpline1D(BSpline):
                 max_slope_slope = np.full(num_test_points, -epsilon)
             else:
                 min_slope_slope = np.full(num_test_points, epsilon)
-        monotonicity_constraints = vertcat(*[
-            c[i + 1] - c[i] for i in range(num_knots - 1)])
+        monotonicity_constraints = vertcat(*[c[i + 1] - c[i] for i in range(num_knots - 1)])
         x_linspace = np.linspace(x[0], x[-1], num_test_points)
-        curvature_constraints = vertcat(*[
-            bspline_prime_prime(c, SX(x)) for x in x_linspace])
+        curvature_constraints = vertcat(*[bspline_prime_prime(c, SX(x)) for x in x_linspace])
         g = vertcat(monotonicity_constraints, curvature_constraints)
         lbg = np.concatenate((delta_c_min, min_slope_slope))
         ubg = np.concatenate((delta_c_max, max_slope_slope))
 
         # Perform mini-optimization problem to calculate the the values of c
-        nlp = {'x': c, 'f': f, 'g': g}
+        nlp = {"x": c, "f": f, "g": g}
         my_solver = "ipopt"
-        solver = nlpsol("solver", my_solver, nlp, {'print_time': 0, 'expand': True, 'ipopt': {'print_level': 0}})
+        solver = nlpsol(
+            "solver", my_solver, nlp, {"print_time": 0, "expand": True, "ipopt": {"print_level": 0}}
+        )
         sol = solver(lbg=lbg, ubg=ubg)
         stats = solver.stats()
-        return_status = stats['return_status']
-        if return_status not in ['Solve_Succeeded', 'Solved_To_Acceptable_Level', 'SUCCESS']:
+        return_status = stats["return_status"]
+        if return_status not in ["Solve_Succeeded", "Solved_To_Acceptable_Level", "SUCCESS"]:
             raise Exception("Spline fitting failed with status {}".format(return_status))
 
         # Return the new tck tuple
-        return (t, np.array(sol['x']).ravel(), k)
+        return (t, np.array(sol["x"]).ravel(), k)

rtctools/data/interpolation/bspline2d.py

@@ -39,10 +39,16 @@ class BSpline2D(BSpline):
         """
         z = 0.0
         for i in range(len(self.__tx) - self.__kx - 1):
-            bx = if_else(logic_and(x >= self.__tx[i], x <= self.__tx[
-                         i + self.__kx + 1]), self.basis(self.__tx, x, self.__kx, i), 0.0)
+            bx = if_else(
+                logic_and(x >= self.__tx[i], x <= self.__tx[i + self.__kx + 1]),
+                self.basis(self.__tx, x, self.__kx, i),
+                0.0,
+            )
             for j in range(len(self.__ty) - self.__ky - 1):
-                by = if_else(logic_and(y >= self.__ty[j], y <= self.__ty[
-                             j + self.__ky + 1]), self.basis(self.__ty, y, self.__ky, j), 0.0)
+                by = if_else(
+                    logic_and(y >= self.__ty[j], y <= self.__ty[j + self.__ky + 1]),
+                    self.basis(self.__ty, y, self.__ky, j),
+                    0.0,
+                )
                 z += self.__w[i * (len(self.__ty) - self.__ky - 1) + j] * bx * by
         return z