bspy 3.0.1__py3-none-any.whl → 4.1__py3-none-any.whl

bspy/_spline_operations.py

@@ -35,9 +35,9 @@ def add(self, other, indMap = None):
             permutation.append(i + 1) # Add 1 to account for dependent variables.
     for i in range(other.nInd - 1, -1, -1):
         if i not in otherMapped:
-            order.append(other.order[i])
-            nCoef.append(other.nCoef[i])
-            knots.append(other.knots[i])
+            order.append(other.order[other.nInd - 1 - i])
+            nCoef.append(other.nCoef[other.nInd - 1 - i])
+            knots.append(other.knots[other.nInd - 1 - i])
             permutation.append(self.nInd + i + 1) # Add 1 to account for dependent variables.
             nInd += 1
         else:
@@ -67,19 +67,19 @@ def confine(self, range_bounds):
     degree = order - 1
     domain = spline.domain()
     unique, counts = np.unique(spline.knots[0], return_counts=True)
-    machineEpsilon = 10.0 * np.finfo(self.coefs.dtype).eps
+    machineEpsilon = np.finfo(self.coefs.dtype).eps
     epsilon = np.sqrt(machineEpsilon)
     intersections = [] # List of tuples (u, boundaryPoint, headingOutside)
 
     def addIntersection(u, headedOutside = False):
         boundaryPoint = spline(np.atleast_1d(u))
         for i in range(spline.nDep):
-            if boundaryPoint[i] < range_bounds[i][0] + machineEpsilon:
+            if boundaryPoint[i] < range_bounds[i][0]:
                 headedOutside = True if boundaryPoint[i] < range_bounds[i][0] - epsilon else headedOutside
-                boundaryPoint[i] = range_bounds[i][0] + machineEpsilon # Avoids error in spline evaluation
-            if boundaryPoint[i] > range_bounds[i][1] - machineEpsilon:
+                boundaryPoint[i] = range_bounds[i][0]
+            if boundaryPoint[i] > range_bounds[i][1]:
                 headedOutside = True if boundaryPoint[i] > range_bounds[i][1] + epsilon else headedOutside
-                boundaryPoint[i] = range_bounds[i][1] - machineEpsilon # Avoids error in spline evaluation
+                boundaryPoint[i] = range_bounds[i][1]
         intersections.append((u, boundaryPoint, headedOutside))
 
     def intersectBoundary(i, j):
@@ -163,7 +163,7 @@ def confine(self, range_bounds):
 def contract(self, uvw):
     domain = self.domain()
     section = [slice(None)]
-    indices = []
+    bValues = []
     contracting = False
     for iv in range(self.nInd):
         if uvw[iv] is not None:
@@ -171,12 +171,12 @@ def contract(self, uvw):
                 raise ValueError(f"Spline evaluation outside domain: {uvw}")
 
             # Grab all of the appropriate coefficients
-            ix = np.searchsorted(self.knots[iv], uvw[iv], 'right')
-            ix = min(ix, self.nCoef[iv])
-            indices.append(ix)
+            ix, indValues = bspy.Spline.bspline_values(None, self.knots[iv], self.order[iv], uvw[iv])
+            bValues.append(indValues)
             section.append(slice(ix - self.order[iv], ix))
             contracting = True
         else:
+            bValues.append([])
             section.append(slice(None))
 
     if not contracting:
@@ -194,9 +194,8 @@ def contract(self, uvw):
             del order[ix]
             del nCoef[ix]
             del knots[ix]
-            bValues = bspy.Spline.bspline_values(indices.pop(0), self.knots[iv], self.order[iv], uvw[iv])
             coefs = np.moveaxis(coefs, ix + 1, -1)
-            coefs = coefs @ bValues
+            coefs = coefs @ bValues[iv]
         else:
             ix += 1
     
@@ -267,14 +266,6 @@ def graph(self):
             dep[i] = knotAverage
     return type(self)(self.nInd, self.nInd + self.nDep, self.order, self.nCoef, self.knots, coefs, self.metadata)
 
-def greville(self, ind = 0):
-    if ind < 0 or ind >= self.nInd:  raise ValueError("Invalid independent variable")
-    myKnots = self.knots[ind]
-    knotAverages = 0
-    for ix in range(1, self.order[ind]):
-        knotAverages = knotAverages + myKnots[ix : ix + self.nCoef[ind]]
-    return knotAverages / (self.order[ind] - 1)
-
 def integrate(self, with_respect_to = 0):
     if not(0 <= with_respect_to < self.nInd): raise ValueError("Invalid with_respect_to")
 
@@ -317,6 +308,8 @@ def multiplyAndConvolve(self, other, indMap = None, productType = 'S'):
     # Construct new spline parameters.
     nInd = self.nInd + other.nInd
     nDep = other.nDep
+    if productType == 'C' and nDep == 2:
+        nDep = 1
     order = [*self.order, *other.order]
     nCoef = [*self.nCoef, *other.nCoef]
     knots = [*self.knots, *other.knots]
@@ -521,12 +514,12 @@ def multiplyAndConvolve(self, other, indMap = None, productType = 'S'):
                         taylorCoefs = (coefs[ix1 - order1:ix1, ix2 - order2:ix2]).T # Transpose so we multiply on the left (due to matmul rules)
                         bValues = np.empty((order1, order1), knots1.dtype)
                         for derivativeOrder in range(order1):
-                            bValues[:,derivativeOrder] = bspy.Spline.bspline_values(ix1, self.knots[ind1], order1, knot, derivativeOrder, True)
+                            ix1, bValues[:,derivativeOrder] = bspy.Spline.bspline_values(ix1, self.knots[ind1], order1, knot, derivativeOrder, True)
                         taylorCoefs = taylorCoefs @ bValues
                         taylorCoefs = np.moveaxis(taylorCoefs, -1, 0) # Move ind1's taylor coefficients to the left side so we can compute ind2's
                         bValues = np.empty((order2, order2), knots2.dtype)
                         for derivativeOrder in range(order2):
-                            bValues[:,derivativeOrder] = bspy.Spline.bspline_values(ix2, other.knots[ind2], order2, yLeft, derivativeOrder, True)
+                            ix2, bValues[:,derivativeOrder] = bspy.Spline.bspline_values(ix2, other.knots[ind2], order2, yLeft, derivativeOrder, True)
                         taylorCoefs = taylorCoefs @ bValues
                         taylorCoefs = (np.moveaxis(taylorCoefs, 0, -1)).T # Move ind1's taylor coefficients back to the right side, and re-transpose
 
@@ -597,22 +590,20 @@ def multiplyAndConvolve(self, other, indMap = None, productType = 'S'):
                     # Next step in multiply:
                     # 2) Convert each spline segment into a polynomial (Taylor series).
                     # Isolate the appropriate segment coefficients
-                    ix1 = np.searchsorted(self.knots[ind1], knot, 'right')
-                    ix1 = min(ix1, self.nCoef[ind1])
-                    ix2 = np.searchsorted(other.knots[ind2], knot, 'right')
-                    ix2 = min(ix2, other.nCoef[ind2])
+                    ix1 = None
+                    ix2 = None
 
                     # Compute taylor coefficients for the segment
-                    taylorCoefs = (coefs[ix1 - order1:ix1, ix2 - order2:ix2]).T # Transpose so we multiply on the left (due to matmul rules)
-                    bValues = np.empty((order1, order1), knots1.dtype)
+                    bValues1 = np.empty((order1, order1), knots1.dtype)
                     for derivativeOrder in range(order1):
-                        bValues[:,derivativeOrder] = bspy.Spline.bspline_values(ix1, self.knots[ind1], order1, knot, derivativeOrder, True)
-                    taylorCoefs = taylorCoefs @ bValues
-                    taylorCoefs = np.moveaxis(taylorCoefs, -1, 0) # Move ind1's taylor coefficients to the left side so we can compute ind2's
-                    bValues = np.empty((order2, order2), knots2.dtype)
+                        ix1, bValues1[:,derivativeOrder] = bspy.Spline.bspline_values(ix1, self.knots[ind1], order1, knot, derivativeOrder, True)
+                    bValues2 = np.empty((order2, order2), knots2.dtype)
                     for derivativeOrder in range(order2):
-                        bValues[:,derivativeOrder] = bspy.Spline.bspline_values(ix2, other.knots[ind2], order2, knot, derivativeOrder, True)
-                    taylorCoefs = taylorCoefs @ bValues
+                        ix2, bValues2[:,derivativeOrder] = bspy.Spline.bspline_values(ix2, other.knots[ind2], order2, knot, derivativeOrder, True)
+                    taylorCoefs = (coefs[ix1 - order1:ix1, ix2 - order2:ix2]).T # Transpose so we multiply on the left (due to matmul rules)
+                    taylorCoefs = taylorCoefs @ bValues1
+                    taylorCoefs = np.moveaxis(taylorCoefs, -1, 0) # Move ind1's taylor coefficients to the left side so we can compute ind2's
+                    taylorCoefs = taylorCoefs @ bValues2
                     taylorCoefs = (np.moveaxis(taylorCoefs, 0, -1)).T # Move ind1's taylor coefficients back to the right side, and re-transpose
 
                     # 3) Sum coefficients of matching polynomial degree (the coefficients have already been multiplied together by the outer product).
@@ -703,7 +694,12 @@ def normal_spline(self, indices=None):
         # using that calculation to span uvw from the starting knot to the end for each variable.
         nCoef = len(newKnots[-1]) - newOrder[-1]
         totalCoefs.append(totalCoefs[-1] * nCoef)
-        uvwValues.append(bspy.Spline(1, 0, [newOrd], [nCoef], [newKnots[-1]], []).greville())
+        knotAverages = bspy.Spline(1, 0, [newOrd], [nCoef], [newKnots[-1]], []).greville()
+        for iKnot in range(1, len(knotAverages) - 1):
+            if knotAverages[iKnot] == knotAverages[iKnot + 1]:
+                knotAverages[iKnot] = 0.5 * (knotAverages[iKnot - 1] + knotAverages[iKnot])
+                knotAverages[iKnot + 1] = 0.5 * (knotAverages[iKnot + 1] + knotAverages[iKnot + 2])
+        uvwValues.append(knotAverages)
         nCoefs.append(nCoef)
     points = []
     ijk = [0 for order in self.order]
@@ -721,7 +717,6 @@ def normal_spline(self, indices=None):
     points = np.reshape(points, [nDep] + nCoefs)
     points = np.transpose(points, [0] + list(range(self.nInd, 0, -1)))
     return bspy.Spline.least_squares(uvwValues, points, order = newOrder, knots = newKnots, metadata = self.metadata)
-#    return bspy.Spline.least_squares(self.nInd, nDep, newOrder, points, newKnots, 0, self.metadata)
 
 def rotate(self, vector, angle):
     vector = np.atleast_1d(vector)