bspy 1.5.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

bspy/_spline_fitting.py

@@ -2,170 +2,56 @@ import numpy as np
 import bspy.spline
 import math
 
-def least_squares(nInd, nDep, order, dataPoints, knotList = None, compression = 0, metadata = {}):
-    if not(nInd >= 0): raise ValueError("nInd < 0")
-    if not(nDep >= 0): raise ValueError("nDep < 0")
-    if not(len(order) == nInd): raise ValueError("len(order) != nInd")
-    if not(0 <= compression < 100): raise ValueError("compression not between 0 and 99")
-    totalOrder = 1
-    for ord in order:
-        totalOrder *= ord
-
-    totalDataPoints = len(dataPoints)
-    for point in dataPoints:
-        if not(len(point) == nInd + nDep or len(point) == nInd + nDep * (nInd + 1)): raise ValueError(f"Data points do not have {nInd + nDep} values")
-        if len(point) == nInd + nDep * (nInd + 1):
-            totalDataPoints += nInd
-
-    if knotList is None:
-        # Compute the target number of coefficients and the actual number of samples in each independent variable.
-        targetTotalCoef = len(dataPoints) * (100 - compression) / 100.0
-        totalCoef = 1
-        knotSamples = np.array([point[:nInd] for point in dataPoints], type(dataPoints[0][0])).T
-        knotList = []
-        for knotSample in knotSamples:
-            knots = np.unique(knotSample)
-            knotList.append(knots)
-            totalCoef *= len(knots)
-        
-        # Scale the number of coefficients for each independent variable so that the total closely matches the target.
-        scaling = min((targetTotalCoef / totalCoef) ** (1.0 / nInd), 1.0)
-        nCoef = []
-        totalCoef = 1
-        for knots in knotList:
-            nCf = int(math.ceil(len(knots) * scaling))
-            nCoef.append(nCf)
-            totalCoef *= nCf
-        
-        # Compute "ideal" knots for each independent variable, based on the number of coefficients and the sample values.
-        # Piegl, Les A., and Wayne Tiller. "Surface approximation to scanned data." The visual computer 16 (2000): 386-395.
-        newKnotList = []
-        for iInd, ord, nCf, knots in zip(range(nInd), order, nCoef, knotList):
-            degree = ord - 1
-            newKnots = [knots[0]] * ord
-            inc = len(knots)/nCf
-            low = 0
-            d = -1
-            w = np.empty((nCf,), float)
-            for i in range(nCf):
-                d += inc
-                high = int(d + 0.5 + 1) # Paper's algorithm sets high to d + 0.5, but only references high + 1
-                w[i] = np.mean(knots[low:high])
-                low = high
-            for i in range(1, nCf - degree):
-                newKnots.append(np.mean(w[i:i + degree]))
-            newKnots += [knots[-1]] * ord
-            newKnotList.append(np.array(newKnots, knots.dtype))
-        knotList = newKnotList
-    else:
-        if not(len(knotList) == nInd): raise ValueError("len(knots) != nInd") # The documented interface uses the argument 'knots' instead of 'knotList'
-        nCoef = [len(knotList[i]) - order[i] for i in range(nInd)]
-        totalCoef = 1
-        newKnotList = []
-        for knots, ord, nCf in zip(knotList, order, nCoef):
-            for i in range(nCf):
-                if not(knots[i] <= knots[i + 1] and knots[i] < knots[i + ord]): raise ValueError("Improperly ordered knot sequence")
-            totalCoef *= nCf
-            newKnotList.append(np.array(knots))
-        if not(totalCoef <= totalDataPoints): raise ValueError(f"Insufficient number of data points. You need at least {totalCoef}.")
-        knotList = newKnotList
-    
-    # Initialize A and b from the likely overdetermined equation, A x = b, where A contains the bspline values at the independent variables,
-    # b contains point values for the dependent variables, and the x contains the desired coefficients.
-    A = np.zeros((totalDataPoints, totalCoef), type(dataPoints[0][0]))
-    b = np.empty((totalDataPoints, nDep), A.dtype)
-
-    # Fill in the bspline values in A and the dependent point values in b at row at a time.
-    # Note that if a data point also specifies first derivatives, it fills out nInd + 1 rows (the point and its derivatives).
-    row = 0
-    for point in dataPoints:
-        hasDerivatives = len(point) == nInd + nDep * (nInd + 1)
-
-        # Compute the bspline values (and their first derivatives as needed).
-        bValueData = []
-        for knots, ord, nCf, u in zip(knotList, order, nCoef, point[:nInd]):
-            ix = np.searchsorted(knots, u, 'right')
-            ix = min(ix, nCf)
-            bValueData.append((ix, bspy.Spline.bspline_values(ix, knots, ord, u), \
-                bspy.Spline.bspline_values(ix, knots, ord, u, 1) if hasDerivatives else None))
-        
-        # Compute the values for the A array.
-        # It's a little tricky because we have to multiply nInd different bspline arrays of different sizes
-        # and index into flattened A array. The solution is to loop through the total number of entries
-        # being changed (totalOrder), and compute the array indices via mods and multiplies.
-        indices = [0] * nInd
-        for i in range(totalOrder):
-            column = 0
-            bValues = np.ones((nInd + 1,), A.dtype)
-            for j, ord, nCf, index, (ix, values, dValues) in zip(range(1, nInd + 1), order, nCoef, indices, bValueData):
-                column = column * nCf + ix - ord + index
-                # Compute the bspline value for this specific element of A.
-                bValues[0] *= values[index]
-                if hasDerivatives:
-                    # Compute the first derivative values for each independent variable.
-                    for k in range(1, nInd + 1):
-                        bValues[k] *= dValues[index] if k == j else values[index]
-
-            # Assign all the values and derivatives.
-            A[row, column] = bValues[0]
-            if hasDerivatives:
-                for k in range(1, nInd + 1):
-                    A[row + k, column] = bValues[k]
-
-            # Increment the bspline indices.
-            for j in range(nInd - 1, -1, -1):
-                indices[j] = (indices[j] + 1) % order[j]
-                if indices[j] > 0:
-                    break
-
-        # Assign values for the b array.
-        b[row, :] = point[nInd:nInd + nDep]
-        if hasDerivatives:
-            for k in range(1, nInd + 1):
-                b[row + k, :] = point[nInd + nDep * k:nInd + nDep * (k + 1)]
-
-        # Increment the row before filling in the next data point
-        row += nInd + 1 if hasDerivatives else 1
-    
-    # Yay, the A and b arrays are ready to solve.
-    # Now, we call numpy's least squares solver.
-    coefs, residuals, rank, s = np.linalg.lstsq(A, b, rcond=None)
-
-    # Reshape the coefs array to match nCoef (un-flatten) and move the dependent variables to the front.
-    coefs = np.moveaxis(coefs.reshape((*nCoef, nDep)), -1, 0)
-
-    # Return the resulting spline, computing the accuracy based on system epsilon and the norm of the residuals.
-    maxError = np.finfo(coefs.dtype).eps
-    if residuals.size > 0:
-        maxError = max(maxError, residuals.sum())
-    return bspy.Spline(nInd, nDep, order, nCoef, knotList, coefs, np.sqrt(maxError), metadata)
-
-# From Lowan, Arnold N., Norman Davids, and Arthur Levenson. "Table of the zeros of the Legendre polynomials of 
-# order 1-16 and the weight coefficients for Gauss' mechanical quadrature formula." (1942): 739-743.
-_legendre_polynomial_zeros = [
-    [0.000000000000000],
-    [0.577350269189626],
-    [0.000000000000000,0.774596669241483],
-    [0.339981043584856,0.861136311594053],
-    [0.000000000000000,0.538469310105683,0.906179845938664],
-    [0.238619186083197,0.661209386466265,0.932469514203152],
-    [0.000000000000000,0.405845151377397,0.741531185599394,0.949107912342759],
-    [0.183434642495650,0.525532409916329,0.796666477413627,0.960289856497536],
-    [0.000000000000000,0.324253423403809,0.613371432700590,0.836031107326636,0.968160239507626],
-    [0.148874338981631,0.433395394129247,0.679409568299024,0.865063366688985,0.973906528517172],
-    [0.000000000000000,0.269543155952345,0.519096129110681,0.730152005574049,0.887062599768095,0.978228658146057],
-    [0.125333408511469,0.367831498918180,0.587317954286617,0.769902674194305,0.904117256370475,0.981560634246719],
-    [0.000000000000000,0.230458315955135,0.448492751036447,0.642349339440340,0.801578090733310,0.917598399222978,0.984183054718588],
-    [0.108054948707344,0.319112368927890,0.515248636358154,0.687292904811685,0.827201315069765,0.928434883663574,0.986283808696812],
-    [0.000000000000000,0.201194093997435,0.394151347077563,0.570972172608539,0.724417731360170,0.848206583410427,0.937273392400706,0.987992518020485],
-    [0.095012509837637,0.281603550779259,0.458016777657227,0.617876244402644,0.755404408355003,0.865631202387832,0.944575023073233,0.989400934991650],
-    ]
+def circular_arc(radius, angle, tolerance = None):
+    if tolerance is None:
+        tolerance = np.finfo(float).eps
+    if radius < 0.0 or angle < 0.0 or tolerance < 0.0: raise ValueError("The radius, angle, and tolerance must be positive.")
+
+    samples = int(max(np.ceil(((1.1536e-5 * radius / tolerance)**(1/8)) * angle / 90), 2.0)) + 1
+    return bspy.Spline.section([(radius * np.cos(u * angle * np.pi / 180), radius * np.sin(u * angle * np.pi / 180), 90 + u * angle, 1.0 / radius) for u in np.linspace(0.0, 1.0, samples)])
+
+# Courtesy of Michael Epton - Translated from his F77 code lgnzro
+def _legendre_polynomial_zeros(degree):
+    def legendre(degree, x):
+        p = [1.0, x]
+        pd = [0.0, 1.0]
+        for n in range(2, degree + 1):
+            alfa = (2 * n - 1) / n
+            beta = (n - 1) / n
+            pd.append(alfa * (p[-1] + x * pd[-1]) - beta * pd[-2])
+            p.append(alfa * x * p[-1] - beta * p[-2])
+        return p, pd
+    zval = 1.0
+    z = []
+    for iRoot in range(degree // 2):
+        done = False
+        while True:
+            p, pd = legendre(degree, zval)
+            sum = 0.0
+            for zRoot in z:
+                sum += 1.0 / (zval - zRoot)
+            dz = p[-1] / (pd[-1] - sum * p[-1])
+            zval -= dz
+            if done:
+                break
+            if dz < 1.0e-10:
+                done = True
+        z.append(zval)
+        zval -= 0.001
+    if degree % 2 == 1:
+        z.append(0.0)
+    z.reverse()
+    w = []
+    for zval in z:
+        p, pd = legendre(degree, zval)
+        w.append(2.0 / ((1.0 - zval ** 2) * pd[-1] ** 2))
+    return z, w
 
 def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
     # Set up parameters for initial guess of x(t) and validate arguments.
     order = 4
     degree = order - 1
-    rhos = _legendre_polynomial_zeros[degree - 1 - 1]
+    rhos, gaussWeights = _legendre_polynomial_zeros(degree - 1)
     if not(len(knownXValues) >= 2): raise ValueError("There must be at least 2 known x values.")
     m = len(knownXValues) - 1
     nCoef = m * (degree - 1) + 2
@@ -390,6 +276,156 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
         spline = spline.confine(F.domain())
     return spline
 
+def least_squares(nInd, nDep, order, dataPoints, knotList = None, compression = 0, metadata = {}):
+    if not(nInd >= 0): raise ValueError("nInd < 0")
+    if not(nDep >= 0): raise ValueError("nDep < 0")
+    if not(len(order) == nInd): raise ValueError("len(order) != nInd")
+    if not(0 <= compression < 100): raise ValueError("compression not between 0 and 99")
+    totalOrder = 1
+    for ord in order:
+        totalOrder *= ord
+
+    totalDataPoints = len(dataPoints)
+    for point in dataPoints:
+        if not(len(point) == nInd + nDep or len(point) == nInd + nDep * (nInd + 1)): raise ValueError(f"Data points do not have {nInd + nDep} values")
+        if len(point) == nInd + nDep * (nInd + 1):
+            totalDataPoints += nInd
+
+    if knotList is None:
+        # Compute the target number of coefficients and the actual number of samples in each independent variable.
+        targetTotalCoef = len(dataPoints) * (100 - compression) / 100.0
+        totalCoef = 1
+        knotSamples = np.array([point[:nInd] for point in dataPoints], type(dataPoints[0][0])).T
+        knotList = []
+        for knotSample in knotSamples:
+            knots = np.unique(knotSample)
+            knotList.append(knots)
+            totalCoef *= len(knots)
+        
+        # Scale the number of coefficients for each independent variable so that the total closely matches the target.
+        scaling = min((targetTotalCoef / totalCoef) ** (1.0 / nInd), 1.0)
+        nCoef = []
+        totalCoef = 1
+        for knots in knotList:
+            nCf = int(math.ceil(len(knots) * scaling))
+            nCoef.append(nCf)
+            totalCoef *= nCf
+        
+        # Compute "ideal" knots for each independent variable, based on the number of coefficients and the sample values.
+        # Piegl, Les A., and Wayne Tiller. "Surface approximation to scanned data." The visual computer 16 (2000): 386-395.
+        newKnotList = []
+        for iInd, ord, nCf, knots in zip(range(nInd), order, nCoef, knotList):
+            degree = ord - 1
+            newKnots = [knots[0]] * ord
+            inc = len(knots)/nCf
+            low = 0
+            d = -1
+            w = np.empty((nCf,), float)
+            for i in range(nCf):
+                d += inc
+                high = int(d + 0.5 + 1) # Paper's algorithm sets high to d + 0.5, but only references high + 1
+                w[i] = np.mean(knots[low:high])
+                low = high
+            for i in range(1, nCf - degree):
+                newKnots.append(np.mean(w[i:i + degree]))
+            newKnots += [knots[-1]] * ord
+            newKnotList.append(np.array(newKnots, knots.dtype))
+        knotList = newKnotList
+    else:
+        if not(len(knotList) == nInd): raise ValueError("len(knots) != nInd") # The documented interface uses the argument 'knots' instead of 'knotList'
+        nCoef = [len(knotList[i]) - order[i] for i in range(nInd)]
+        totalCoef = 1
+        newKnotList = []
+        for knots, ord, nCf in zip(knotList, order, nCoef):
+            for i in range(nCf):
+                if not(knots[i] <= knots[i + 1] and knots[i] < knots[i + ord]): raise ValueError("Improperly ordered knot sequence")
+            totalCoef *= nCf
+            newKnotList.append(np.array(knots))
+        if not(totalCoef <= totalDataPoints): raise ValueError(f"Insufficient number of data points. You need at least {totalCoef}.")
+        knotList = newKnotList
+    
+    # Initialize A and b from the likely overdetermined equation, A x = b, where A contains the bspline values at the independent variables,
+    # b contains point values for the dependent variables, and the x contains the desired coefficients.
+    A = np.zeros((totalDataPoints, totalCoef), type(dataPoints[0][0]))
+    b = np.empty((totalDataPoints, nDep), A.dtype)
+
+    # Fill in the bspline values in A and the dependent point values in b at row at a time.
+    # Note that if a data point also specifies first derivatives, it fills out nInd + 1 rows (the point and its derivatives).
+    row = 0
+    for point in dataPoints:
+        hasDerivatives = len(point) == nInd + nDep * (nInd + 1)
+
+        # Compute the bspline values (and their first derivatives as needed).
+        bValueData = []
+        for knots, ord, nCf, u in zip(knotList, order, nCoef, point[:nInd]):
+            ix = np.searchsorted(knots, u, 'right')
+            ix = min(ix, nCf)
+            bValueData.append((ix, bspy.Spline.bspline_values(ix, knots, ord, u), \
+                bspy.Spline.bspline_values(ix, knots, ord, u, 1) if hasDerivatives else None))
+        
+        # Compute the values for the A array.
+        # It's a little tricky because we have to multiply nInd different bspline arrays of different sizes
+        # and index into flattened A array. The solution is to loop through the total number of entries
+        # being changed (totalOrder), and compute the array indices via mods and multiplies.
+        indices = [0] * nInd
+        for i in range(totalOrder):
+            column = 0
+            bValues = np.ones((nInd + 1,), A.dtype)
+            for j, ord, nCf, index, (ix, values, dValues) in zip(range(1, nInd + 1), order, nCoef, indices, bValueData):
+                column = column * nCf + ix - ord + index
+                # Compute the bspline value for this specific element of A.
+                bValues[0] *= values[index]
+                if hasDerivatives:
+                    # Compute the first derivative values for each independent variable.
+                    for k in range(1, nInd + 1):
+                        bValues[k] *= dValues[index] if k == j else values[index]
+
+            # Assign all the values and derivatives.
+            A[row, column] = bValues[0]
+            if hasDerivatives:
+                for k in range(1, nInd + 1):
+                    A[row + k, column] = bValues[k]
+
+            # Increment the bspline indices.
+            for j in range(nInd - 1, -1, -1):
+                indices[j] = (indices[j] + 1) % order[j]
+                if indices[j] > 0:
+                    break
+
+        # Assign values for the b array.
+        b[row, :] = point[nInd:nInd + nDep]
+        if hasDerivatives:
+            for k in range(1, nInd + 1):
+                b[row + k, :] = point[nInd + nDep * k:nInd + nDep * (k + 1)]
+
+        # Increment the row before filling in the next data point
+        row += nInd + 1 if hasDerivatives else 1
+    
+    # Yay, the A and b arrays are ready to solve.
+    # Now, we call numpy's least squares solver.
+    coefs, residuals, rank, s = np.linalg.lstsq(A, b, rcond=None)
+
+    # Reshape the coefs array to match nCoef (un-flatten) and move the dependent variables to the front.
+    coefs = np.moveaxis(coefs.reshape((*nCoef, nDep)), -1, 0)
+
+    # Return the resulting spline, computing the accuracy based on system epsilon and the norm of the residuals.
+    maxError = np.finfo(coefs.dtype).eps
+    if residuals.size > 0:
+        maxError = max(maxError, residuals.sum())
+    return bspy.Spline(nInd, nDep, order, nCoef, knotList, coefs, np.sqrt(maxError), metadata)
+
+def revolve(self, angle):
+    if self.nDep != 2: raise ValueError("Spline must have 2 dependent variables")
+
+    maxRadius = max(abs(self.coefs[0].min()), self.coefs[0].max())
+    arc = ((1.0 / maxRadius, 0.0),
+            (0.0, 1.0 / maxRadius),
+            (0.0, 0.0)) @ bspy.Spline.circular_arc(maxRadius, angle) + (0.0, 0.0, 1.0)
+    radiusHeight = ((1.0, 0.0),
+            (1.0, 0.0),
+            (0.0, 1.0)) @ self
+    return arc.multiply(radiusHeight)
+
 def ruled_surface(curve1, curve2):
     # Ensure that the splines are compatible
     if curve1.nInd != curve2.nInd:  raise ValueError("Splines must have the same number of independent variables")
@@ -419,6 +455,10 @@ def section(xytk):
         dotTangents = startTangent @ endTangent
         theta = math.atan2(crossTangents, dotTangents)
 
+        # Make sure angle is less than 180 degrees
+        if theta * startKappa < 0.0 or theta * endKappa < 0.0 or abs(theta) == math.pi:
+            raise ValueError("Angle >= 180 degrees for two point section")
+        
         # Check data consistency
         crossCheck = startTangent[0] * pointDiff[1] - startTangent[1] * pointDiff[0]
         if crossCheck * startKappa < 0.0 or crossCheck * endKappa < 0.0:  raise ValueError("Inconsistent start angle")
@@ -428,7 +468,7 @@ def section(xytk):
  
         # Compute intersection point of tangent directions
         tangentDistances = np.linalg.solve(np.array([startTangent, endTangent]).T, pointDiff)
-        frustrum = startPoint + tangentDistances[0] * startTangent
+        frustum = startPoint + tangentDistances[0] * startTangent
 
         # Compute critical values for section algorithm
         onePlusCosTheta = 1.0 + math.cos(theta)
@@ -453,10 +493,10 @@ def section(xytk):
 
         # Generate the quartic section which interpolates the data
         pt0 = startPoint
-        pt1 = (1.0 - rho) * startPoint + rho * frustrum
-        pt3 = (1.0 - rho) * endPoint + rho * frustrum
+        pt1 = (1.0 - rho) * startPoint + rho * frustum
+        pt3 = (1.0 - rho) * endPoint + rho * frustum
         pt4 = endPoint
-        pt2 = alpha0 * pt1 + alpha1 * pt3 + (1.0 - alpha0 - alpha1) * frustrum
+        pt2 = alpha0 * pt1 + alpha1 * pt3 + (1.0 - alpha0 - alpha1) * frustum
         return bspy.Spline(1, 2, (5,), (5,), ((0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0),), (pt0, pt1, pt2, pt3, pt4))
 
     # Check that the input data is the right size and shape

bspy/_spline_operations.py

@@ -198,7 +198,7 @@ def contract(self, uvw):
 
 def cross(self, vector):
     if isinstance(vector, bspy.Spline):
-        return self.multiply(vector, None, 'C')
+        return self.multiply(vector, [(ix, ix) for ix in range(min(self.nInd, vector.nInd))], 'C')
     elif self.nDep == 3:
         if not(len(vector) == self.nDep): raise ValueError("Invalid vector")
 
@@ -241,7 +241,7 @@ def differentiate(self, with_respect_to = 0):
 
 def dot(self, vector):
     if isinstance(vector, bspy.Spline):
-        return self.multiply(vector, None, 'D')
+        return self.multiply(vector, [(ix, ix) for ix in range(min(self.nInd, vector.nInd))], 'D')
     else:
         if not(len(vector) == self.nDep): raise ValueError("Invalid vector")
 
@@ -252,6 +252,20 @@ def dot(self, vector):
             coefs = coefs.reshape(1, *coefs.shape)
         return type(self)(self.nInd, 1, self.order, self.nCoef, self.knots, coefs, self.accuracy, self.metadata)
 
+def graph(self):
+    splineDomain = self.domain()
+    uvwSplines = [bspy.Spline(1, 1, [2], [2], [[uLow, uLow, uHigh, uHigh]],
+                              [[uLow, uHigh]]) for uLow, uHigh in splineDomain]
+    graphSpline = uvwSplines[0]
+    for nextSpline in uvwSplines[1:]:
+        graphMat = list(np.block([[np.identity(graphSpline.nInd)], [0.0]]))
+        nextMat = list(np.block([[np.zeros((graphSpline.nInd, 1))], [1.0]]))
+        graphSpline = (graphMat @ graphSpline).add(nextMat @ nextSpline)
+    graphMat = list(np.block([[np.identity(graphSpline.nInd)], [np.zeros((self.nDep, graphSpline.nInd))]]))
+    selfMat = list(np.block([[np.zeros((graphSpline.nInd, self.nDep))], [np.identity(self.nDep)]]))
+    finalGraph = graphMat @ graphSpline + selfMat @ self
+    return finalGraph
+
 def integrate(self, with_respect_to = 0):
     if not(0 <= with_respect_to < self.nInd): raise ValueError("Invalid with_respect_to")
 
@@ -285,7 +299,7 @@ def multiplyAndConvolve(self, other, indMap = None, productType = 'S'):
 
     if not(productType != 'D' or self.nDep == other.nDep): raise ValueError("Mismatched dimensions")
     if not(productType != 'C' or (self.nDep == other.nDep and 2 <= self.nDep <= 3)): raise ValueError("Mismatched dimensions")
-    if not(productType != 'S' or self.nDep == 1 or other.nDep == 1): raise ValueError("Mismatched dimensions")
+    if not(productType != 'S' or self.nDep == 1 or other.nDep == 1 or self.nDep == other.nDep): raise ValueError("Mismatched dimensions")
 
     # Ensure scalar spline (if any) comes first (simplifies array processing).
     if other.nDep == 1 and self.nDep > 1:
@@ -321,8 +335,11 @@ def multiplyAndConvolve(self, other, indMap = None, productType = 'S'):
             coefs += outer[i,i]
         coefs = np.expand_dims(coefs, axis=0)
         nDep = 1
-    else: # Scalar product, where self is the scalar
-        coefs = outer[0]
+    else: # Scalar product
+        coefs = outer
+        for i in range(1, self.nDep):
+            coefs[0,i] = coefs[i,i]
+        coefs = coefs[0]
 
     if indMap is not None:
         indMap = indMap.copy() # Make a copy, since we change the list as we combine independent variables
@@ -702,29 +719,39 @@ def normal_spline(self, indices=None):
 
 def scale(self, multiplier):
     if isinstance(multiplier, bspy.Spline):
-        return self.multiply(multiplier, None, 'S')
+        return self.multiply(multiplier, [(ix, ix) for ix in range(min(self.nInd, multiplier.nInd))], 'S')
     else:
-        if not(np.isscalar(multiplier) or len(multiplier) == self.nDep): raise ValueError("Invalid multiplier")
-
         if np.isscalar(multiplier):
             accuracy = abs(multiplier) * self.accuracy
+            nDep = self.nDep
             coefs = multiplier * self.coefs
-        else:
+        elif len(multiplier) == self.nDep:
             accuracy = np.linalg.norm(multiplier) * self.accuracy
+            nDep = self.nDep
             coefs = np.array(self.coefs)
-            for i in range(self.nDep):
+            for i in range(nDep):
                 coefs[i] *= multiplier[i]
-        return type(self)(self.nInd, self.nDep, self.order, self.nCoef, self.knots, coefs, accuracy, self.metadata)
+        elif self.nDep == 1:
+            accuracy = np.linalg.norm(multiplier) * self.accuracy
+            nDep = len(multiplier)
+            coefs = np.empty((nDep, *self.coefs.shape[1:]), self.coefs.dtype)
+            for i in range(nDep):
+                coefs[i] = multiplier[i] * self.coefs[0]
+        else:
+            raise ValueError("Invalid multiplier")
+        return type(self)(self.nInd, nDep, self.order, self.nCoef, self.knots, coefs, accuracy, self.metadata)
 
 def transform(self, matrix, maxSingularValue=None):
     if not(matrix.ndim == 2 and matrix.shape[1] == self.nDep): raise ValueError("Invalid matrix")
 
     if maxSingularValue is None:
         maxSingularValue = np.linalg.svd(matrix, compute_uv=False)[0]
-
-    return type(self)(self.nInd, matrix.shape[0], self.order, self.nCoef, self.knots, matrix @ self.coefs, maxSingularValue * self.accuracy, self.metadata)
+    swapped = np.swapaxes(self.coefs, 0, -2)
+    newCoefs = np.swapaxes(matrix @ swapped, 0, -2)
+    return type(self)(self.nInd, matrix.shape[0], self.order, self.nCoef, self.knots, newCoefs, maxSingularValue * self.accuracy, self.metadata)
 
 def translate(self, translationVector):
+    translationVector = np.atleast_1d(translationVector)
     if not(len(translationVector) == self.nDep): raise ValueError("Invalid translationVector")
 
     coefs = np.array(self.coefs)