splineops 0.3.4__py3-none-any.whl

splineops/__init__.py

@@ -0,0 +1,3 @@
+import importlib.metadata
+
+__version__ = importlib.metadata.version("splineops")

splineops/bases/bspline0basis.py

@@ -0,0 +1,60 @@
+import numpy as np
+import numpy.typing as npt
+
+from splineops.bases.splinebasis import SplineBasis
+
+
+class BSpline0Basis(SplineBasis):
+    def __init__(self) -> None:
+
+        # Support and degree (no poles)
+        support = 1
+        degree = support - 1
+
+        # Call super constructor
+        super(BSpline0Basis, self).__init__(support=support, degree=degree)
+
+    # Methods
+    @staticmethod
+    def eval(x: npt.NDArray) -> npt.NDArray:
+
+        # Case 1/2 < |x|
+        y = np.zeros_like(x)
+
+        # Case -1/2 <= x < 1/2
+        # Note: Asymmetry introduced. This is a standard strategy to compute
+        #  the indexes while keeping the smallest support length by avoiding
+        #  averaging two values in special cases at interval limits [-1/2, 1/2].
+        #  The exact symmetric case with a longer support is provided below.
+        y = np.where(np.logical_and(x >= -1 / 2, x < 1 / 2), 1, y)
+
+        return y
+
+
+class BSpline0SymBasis(SplineBasis):
+    def __init__(self) -> None:
+
+        # Support and degree (no poles)
+        support = 2
+        degree = 0
+
+        # Call super constructor
+        super(BSpline0SymBasis, self).__init__(support=support, degree=degree)
+
+    # Methods
+    @staticmethod
+    def eval(x: npt.NDArray) -> npt.NDArray:
+
+        # Pre-computations
+        x_abs = np.abs(x)
+
+        # Case 1/2 < |x|
+        y = np.zeros_like(x)
+
+        # Case |x| < 1/2 (i.e. 0 < |x| < 1/2)
+        y = np.where(x_abs < 1 / 2, 1, y)
+
+        # Case |x| == 1/2
+        y = np.where(x_abs == 1 / 2, 1 / 2, y)
+
+        return y

splineops/bases/bspline1basis.py

@@ -0,0 +1,30 @@
+import numpy as np
+import numpy.typing as npt
+
+from splineops.bases.splinebasis import SplineBasis
+
+
+class BSpline1Basis(SplineBasis):
+    def __init__(self) -> None:
+
+        # Support and degree (no poles)
+        support = 2
+        degree = support - 1
+
+        # Call super constructor
+        super(BSpline1Basis, self).__init__(support=support, degree=degree)
+
+    # Methods
+    @staticmethod
+    def eval(x: npt.NDArray) -> npt.NDArray:
+
+        # Pre-computations
+        x_abs = np.abs(x)
+
+        # Case 1 <= |x|
+        y = np.zeros_like(x)
+
+        # Case |x| < 1 (i.e. 0 <= |x| < 1)
+        y = np.where(x_abs < 1, 1 - x_abs, y)
+
+        return y

splineops/bases/bspline2basis.py

@@ -0,0 +1,39 @@
+import numpy as np
+import numpy.typing as npt
+
+from splineops.bases.splinebasis import SplineBasis
+
+
+class BSpline2Basis(SplineBasis):
+    def __init__(self) -> None:
+
+        # Support, degree and poles
+        support = 3
+        degree = support - 1
+        poles = (2 * np.sqrt(2) - 3,)
+
+        # Call super constructor
+        super(BSpline2Basis, self).__init__(support=support, degree=degree, poles=poles)
+
+    # Methods
+    @staticmethod
+    def eval(x: npt.NDArray) -> npt.NDArray:
+
+        # Pre-computations
+        x_abs = np.abs(x)
+
+        # Case 3/2 <= |x|
+        y = np.zeros_like(x)
+
+        # Case |x| < 3/2 (i.e. 1/2 <= |x| < 3/2)
+        y = np.where(
+            np.logical_and(x_abs >= 1 / 2, x_abs < 3 / 2),
+            # 1 / 8 * (3 - 2 * x_abs) * (3 - 2 * x_abs),
+            9 / 8 - (3 * x_abs) / 2 + x_abs * x_abs / 2,
+            y,
+        )
+
+        # Case |x| < 1/2 (i.e. 0 <= |x| < 1/2)
+        y = np.where(x_abs < 1 / 2, 3 / 4 - x_abs * x_abs, y)
+
+        return y

splineops/bases/bspline3basis.py

@@ -0,0 +1,38 @@
+import numpy as np
+import numpy.typing as npt
+
+from splineops.bases.splinebasis import SplineBasis
+
+
+class BSpline3Basis(SplineBasis):
+    def __init__(self) -> None:
+
+        # Support, degree and poles
+        support = 4
+        degree = support - 1
+        poles = (np.sqrt(3) - 2,)
+
+        # Call super constructor
+        super(BSpline3Basis, self).__init__(support=support, degree=degree, poles=poles)
+
+    # Methods
+    @staticmethod
+    def eval(x: npt.NDArray) -> npt.NDArray:
+
+        # Pre-computations
+        x_abs = np.abs(x)
+
+        # Case 2 <= |x|
+        y = np.zeros_like(x)
+
+        # Case |x| < 2 (i.e. 1 <= |x| < 2)
+        y = np.where(
+            np.logical_and(x_abs >= 1, x_abs < 2),
+            1 / 6 * (2 - x_abs) * (2 - x_abs) * (2 - x_abs),
+            y,
+        )
+
+        # Case |x| < 1 (i.e. 0 <= |x| < 1)
+        y = np.where(x_abs < 1, 2 / 3 - 1 / 2 * x_abs * x_abs * (2 - x_abs), y)
+
+        return y

splineops/bases/bspline4basis.py

@@ -0,0 +1,54 @@
+import numpy as np
+import numpy.typing as npt
+
+from splineops.bases.splinebasis import SplineBasis
+
+
+class BSpline4Basis(SplineBasis):
+    def __init__(self) -> None:
+
+        # Support, degree and poles
+        support = 5
+        degree = support - 1
+        poles = (
+            np.sqrt(664 - np.sqrt(438976)) + np.sqrt(304) - 19,
+            np.sqrt(664 + np.sqrt(438976)) - np.sqrt(304) - 19,
+        )
+
+        # Call super constructor
+        super(BSpline4Basis, self).__init__(support=support, degree=degree, poles=poles)
+
+    # Methods
+    @staticmethod
+    def eval(x: npt.NDArray) -> npt.NDArray:
+
+        # Pre-computations
+        x_abs = np.abs(x)
+
+        # Case 5/2 <= |x|
+        y = np.zeros_like(x)
+
+        # Case |x| < 5/2 (i.e. 3/2 <= |x| < 5/2)
+        y = np.where(
+            np.logical_and(x_abs >= 3 / 2, x_abs < 5 / 2),
+            1
+            / 384
+            * (625 + x_abs * (-1000 + x_abs * (600 + x_abs * (-160 + 16 * x_abs)))),
+            y,
+        )
+
+        # Case |x| < 3/2 (i.e. 1/2 <= |x| < 3/2)
+        y = np.where(
+            np.logical_and(x_abs >= 1 / 2, x_abs < 3 / 2),
+            1 / 96 * (55 + x_abs * (20 + x_abs * (-120 + x_abs * (80 - 16 * x_abs)))),
+            y,
+        )
+
+        # Case |x| < 1/2 (i.e. 0 <= |x| < 1/2)
+        y = np.where(
+            x_abs < 1 / 2,
+            1 / 192 * (115 + x_abs * x_abs * (-120 + 48 * x_abs * x_abs)),
+            y,
+        )
+
+        return y

splineops/bases/bspline5basis.py

@@ -0,0 +1,63 @@
+import numpy as np
+import numpy.typing as npt
+
+from splineops.bases.splinebasis import SplineBasis
+
+
+class BSpline5Basis(SplineBasis):
+    def __init__(self) -> None:
+
+        # Support, degree and poles
+        support = 6
+        degree = support - 1
+        poles = (
+            np.sqrt(135 / 2 - np.sqrt(17745 / 4)) + np.sqrt(105 / 4) - 13 / 2,
+            np.sqrt(135 / 2 + np.sqrt(17745 / 4)) - np.sqrt(105 / 4) - 13 / 2,
+        )
+
+        # Call super constructor
+        super(BSpline5Basis, self).__init__(support=support, degree=degree, poles=poles)
+
+    # Methods
+    @staticmethod
+    def eval(x: npt.NDArray) -> npt.NDArray:
+
+        # Pre-computations
+        x_abs = np.abs(x)
+
+        # Case 3 <= |x|
+        y = np.zeros_like(x)
+
+        # Case |x| < 3 (i.e. 2 <= |x| < 3)
+        y = np.where(
+            np.logical_and(x_abs >= 2, x_abs < 3),
+            1
+            / 120
+            * (
+                243
+                + x_abs * (-405 + x_abs * (270 + x_abs * (-90 + x_abs * (15 - x_abs))))
+            ),
+            y,
+        )
+
+        # Case |x| < 2 (i.e. 1 <= |x| < 2)
+        y = np.where(
+            np.logical_and(x_abs >= 1, x_abs < 2),
+            1
+            / 120
+            * (
+                51
+                + x_abs
+                * (75 + x_abs * (-210 + x_abs * (150 + x_abs * (-45 + x_abs * 5))))
+            ),
+            y,
+        )
+
+        # Case |x| < 1 (i.e. 0 <= |x| < 1)
+        y = np.where(
+            x_abs < 1,
+            1 / 60 * (33 + x_abs * x_abs * (-30 + x_abs * x_abs * (15 - 5 * x_abs))),
+            y,
+        )
+
+        return y

splineops/bases/bspline6basis.py

@@ -0,0 +1,98 @@
+import numpy as np
+import numpy.typing as npt
+
+from splineops.bases.splinebasis import SplineBasis
+
+
+class BSpline6Basis(SplineBasis):
+    def __init__(self) -> None:
+
+        # Support, degree and poles
+        support = 7
+        degree = support - 1
+        poles = (
+            -0.48829458930304475513011803888378906211227916123938,
+            -0.081679271076237512597937765737059080653379610398148,
+            -0.0014141518083258177510872439765585925278641690553467,
+        )
+
+        # Call super constructor
+        super(BSpline6Basis, self).__init__(support=support, degree=degree, poles=poles)
+
+    # Methods
+    @staticmethod
+    def eval(x: npt.NDArray) -> npt.NDArray:
+
+        # Pre-computations
+        x_abs = np.abs(x)
+
+        # Case 7/2 <= |x|
+        y = np.zeros_like(x)
+
+        # Case 5/2 <= |x| < 7/2
+        # (7 - 2 x)^6/46080
+        # x^6/720 - (7 x^5)/240 + (49 x^4)/192 - (343 x^3)/288 + (2401 x^2)/768 - (16807 x)/3840 + 117649/46080
+        y = np.where(
+            np.logical_and(x_abs >= 5 / 2, x_abs < 7 / 2),
+            1 / 46080 * (7 - 2 * x_abs) ** 6,
+            y,
+        )
+
+        # Case 3/2 <= |x| < 5/2
+        # -(192 x^6 - 2688 x^5 + 15120 x^4 - 42560 x^3 + 59220 x^2 - 30408 x - 4137)/23040
+        # (4137 - 4 x (x (4 x (3 x (4 (x - 14) x + 315) - 2660) + 14805) - 7602))/23040
+        y = np.where(
+            np.logical_and(x_abs >= 3 / 2, x_abs < 5 / 2),
+            1
+            / 23040
+            * (
+                4137
+                - 4
+                * x_abs
+                * (
+                    x_abs
+                    * (
+                        4
+                        * x_abs
+                        * (3 * x_abs * (4 * (x_abs - 14) * x_abs + 315) - 2660)
+                        + 14805
+                    )
+                    - 7602
+                )
+            ),
+            y,
+        )
+
+        # Case 1/2 <= |x| < 3/2
+        # (23583 - 420 x - 16380 x^2 - 5600 x^3 + 15120 x^4 - 6720 x^5 + 960 x^6)/46080
+        # (20 x (x (4 x (3 x (4 (x - 7) x + 63) - 70) - 819) - 21) + 23583)/46080
+        y = np.where(
+            np.logical_and(x_abs >= 1 / 2, x_abs < 3 / 2),
+            1
+            / 46080
+            * (
+                20
+                * x_abs
+                * (
+                    x_abs
+                    * (
+                        4 * x_abs * (3 * x_abs * (4 * (x_abs - 7) * x_abs + 63) - 70)
+                        - 819
+                    )
+                    - 21
+                )
+                + 23583
+            ),
+            y,
+        )
+
+        # Case |x| < 1/2 (i.e., -(1/2) < x < 1/2)
+        # -(320 x^6 - 1680 x^4 + 4620 x^2 - 5887)/11520
+        # (5887 - 20 x^2 (16 x^4 - 84 x^2 + 231))/11520
+        y = np.where(
+            x_abs < 1 / 2,
+            1 / 11520 * (5887 - 20 * x_abs**2 * (16 * x_abs**4 - 84 * x_abs**2 + 231)),
+            y,
+        )
+
+        return y

splineops/bases/bspline7basis.py

@@ -0,0 +1,96 @@
+import numpy as np
+import numpy.typing as npt
+
+from splineops.bases.splinebasis import SplineBasis
+
+
+class BSpline7Basis(SplineBasis):
+    def __init__(self) -> None:
+
+        # Support, degree and poles
+        support = 8
+        degree = support - 1
+        poles = (
+            -0.53528043079643816554240378168164607183392315234269,
+            -0.12255461519232669051527226435935734360548654942730,
+            -0.0091486948096082769285930216516478534156925639545994,
+        )
+
+        # Call super constructor
+        super(BSpline7Basis, self).__init__(support=support, degree=degree, poles=poles)
+
+    # Methods
+    @staticmethod
+    def eval(x: npt.NDArray) -> npt.NDArray:
+
+        # Pre-computations
+        x_abs = np.abs(x)
+
+        # Case 4 <= |x|
+        y = np.zeros_like(x)
+
+        # Case 3 <= x < 4
+        # -(-4 + x)^7/5040
+        y = np.where(
+            np.logical_and(x_abs >= 3, x_abs < 4), -1 / 5040 * (-4 + x_abs) ** 7, y
+        )
+
+        # Case 2 <= x < 3
+        # x^7/720 - x^6/36 + (7 x^5)/30 - (19 x^4)/18 + (49 x^3)/18 - (23 x^2)/6 + (217 x)/90 - 139/630
+        # (7 x (x (x (x (x ((x - 20) x + 168) - 760) + 1960) - 2760) + 1736) - 1112)/5040
+        y = np.where(
+            np.logical_and(x_abs >= 2, x_abs < 3),
+            1
+            / 5040
+            * (
+                7
+                * x_abs
+                * (
+                    x_abs
+                    * (
+                        x_abs
+                        * (x_abs * (x_abs * ((x_abs - 20) * x_abs + 168) - 760) + 1960)
+                        - 2760
+                    )
+                    + 1736
+                )
+                - 1112
+            ),
+            y,
+        )
+
+        # Case 1 <= x < 2
+        # -(21 x^7 - 252 x^6 + 1176 x^5 - 2520 x^4 + 1960 x^3 + 504 x^2 + 392 x - 2472)/5040
+        # (2472 - 7 x (x (x (3 (x - 6) x ((x - 6) x + 20) + 280) + 72) + 56))/5040
+        y = np.where(
+            np.logical_and(x_abs >= 1, x_abs < 2),
+            1
+            / 5040
+            * (
+                2472
+                - 7
+                * x_abs
+                * (
+                    x_abs
+                    * (
+                        x_abs
+                        * (3 * (x_abs - 6) * x_abs * ((x_abs - 6) * x_abs + 20) + 280)
+                        + 72
+                    )
+                    + 56
+                )
+            ),
+            y,
+        )
+
+        # Case |x| < 1 (i.e., -1 < x < 1)
+        # (35 x^7 - 140 x^6 + 560 x^4 - 1680 x^2 + 2416)/5040
+        # 1/144 (x^5 - 4 x^4 + 16 x^2 - 48) x^2 + 151/315
+        y = np.where(
+            x_abs < 1,
+            1 / 144 * (x_abs**5 - 4 * x_abs**4 + 16 * x_abs**2 - 48) * x_abs**2
+            + 151 / 315,
+            y,
+        )
+
+        return y

splineops/bases/bspline8basis.py

@@ -0,0 +1,141 @@
+import numpy as np
+import numpy.typing as npt
+
+from splineops.bases.splinebasis import SplineBasis
+
+
+class BSpline8Basis(SplineBasis):
+    def __init__(self) -> None:
+
+        # Support, degree and poles
+        support = 9
+        degree = support - 1
+        poles = (
+            -0.57468690924876543053013930412874542429066157804125,
+            -0.16303526929728093524055189686073705223476814550830,
+            -0.023632294694844850023403919296361320612665920854629,
+            -0.00015382131064169091173935253018402160762964054070043,
+        )
+
+        # Call super constructor
+        super(BSpline8Basis, self).__init__(support=support, degree=degree, poles=poles)
+
+    # Methods
+    @staticmethod
+    def eval(x: npt.NDArray) -> npt.NDArray:
+
+        # Pre-computations
+        x_abs = np.abs(x)
+
+        # Case 9/2 <= |x|
+        y = np.zeros_like(x)
+
+        # Case 7/2 <= |x| < 9/2
+        # (9 - 2 x)^8/10321920
+        # x^8/40320 - x^7/1120 + (9 x^6)/640 - (81 x^5)/640 + (729 x^4)/1024 - (6561 x^3)/2560 + (59049 x^2)/10240 - (531441 x)/71680 + 4782969/1146880
+        y = np.where(
+            np.logical_and(x_abs >= 7 / 2, x_abs < 9 / 2),
+            1 / 10321920 * (9 - 2 * x_abs) ** 8,
+            y,
+        )
+
+        # Case 5/2 <= |x| < 7/2
+        # -(256 x^8 - 6912 x^7 + 80640 x^6 - 528192 x^5 + 2106720 x^4 - 5163984 x^3 + 7383600 x^2 - 5257836 x + 1104561)/1290240
+        # -((4 x (2 x (2 (x - 15) x + 171) - 879) + 3441) (8 x (x (2 (x - 12) x + 99) - 150) + 321))/1290240
+        y = np.where(
+            np.logical_and(x_abs >= 5 / 2, x_abs < 7 / 2),
+            -1
+            / 1290240
+            * (
+                (
+                    4 * x_abs * (2 * x_abs * (2 * (x_abs - 15) * x_abs + 171) - 879)
+                    + 3441
+                )
+                * (8 * x_abs * (x_abs * (2 * (x_abs - 12) * x_abs + 99) - 150) + 321)
+            ),
+            y,
+        )
+
+        # Case 3/2 <= |x| < 5/2
+        # x^8/1440 - x^7/80 + (3 x^6)/32 - (119 x^5)/320 + (207 x^4)/256 - (1127 x^3)/1280 + (195 x^2)/512 - (1457 x)/5120 + 145167/286720
+        # (56 x (2 x (2 x (x (4 x (2 x ((x - 18) x + 135) - 1071) + 9315) - 10143) + 8775) - 13113) + 1306503)/2580480
+        y = np.where(
+            np.logical_and(x_abs >= 3 / 2, x_abs < 5 / 2),
+            1
+            / 2580480
+            * (
+                56
+                * x_abs
+                * (
+                    2
+                    * x_abs
+                    * (
+                        2
+                        * x_abs
+                        * (
+                            x_abs
+                            * (
+                                4
+                                * x_abs
+                                * (2 * x_abs * ((x_abs - 18) * x_abs + 135) - 1071)
+                                + 9315
+                            )
+                            - 10143
+                        )
+                        + 8775
+                    )
+                    - 13113
+                )
+                + 1306503
+            ),
+            y,
+        )
+
+        # Case 1/2 <= |x| < 3/2
+        # -(1792 x^8 - 16128 x^7 + 48384 x^6 - 28224 x^5 - 90720 x^4 - 7056 x^3 + 365904 x^2 - 252 x - 584361)/1290240
+        # (584361 - 28 x (4 x (x (2 x (2 x (4 x ((x - 9) x + 27) - 63) - 405) - 63) + 3267) - 9))/1290240
+        y = np.where(
+            np.logical_and(x_abs >= 1 / 2, x_abs < 3 / 2),
+            1
+            / 1290240
+            * (
+                584361
+                - 28
+                * x_abs
+                * (
+                    4
+                    * x_abs
+                    * (
+                        x_abs
+                        * (
+                            2
+                            * x_abs
+                            * (
+                                2
+                                * x_abs
+                                * (4 * x_abs * ((x_abs - 9) * x_abs + 27) - 63)
+                                - 405
+                            )
+                            - 63
+                        )
+                        + 3267
+                    )
+                    - 9
+                )
+            ),
+            y,
+        )
+
+        # Case |x| < 1/2 (i.e., -(1/2) < x < 1/2)
+        # (8960 x^8 - 80640 x^6 + 433440 x^4 - 1456560 x^2 + 2337507)/5160960
+        # ((16 x^6 - 144 x^4 + 774 x^2 - 2601) x^2)/9216 + 259723/573440
+        y = np.where(
+            x_abs < 1 / 2,
+            1
+            / 9216
+            * ((16 * x_abs**6 - 144 * x_abs**4 + 774 * x_abs**2 - 2601) * x_abs**2)
+            + 259723 / 573440,
+            y,
+        )
+
+        return y