bspy 4.2__py3-none-any.whl → 4.3__py3-none-any.whl

bspy/_spline_operations.py

@@ -13,47 +13,55 @@ def _shiftPolynomial(polynomial, delta):
 
 def add(self, other, indMap = None):
     if not(self.nDep == other.nDep): raise ValueError("self and other must have same nDep")
-    selfMapped = []
-    otherMapped = []
+    selfMapped = set()
     otherToSelf = {}
     if indMap is not None:
         (self, other) = bspy.Spline.common_basis((self, other), indMap)
         for map in indMap:
-            selfMapped.append(map[0])
-            otherMapped.append(map[1])
+            selfMapped.add(map[0])
             otherToSelf[map[1]] = map[0]
 
     # Construct new spline parameters.
-    # We index backwards because we're adding transposed coefficients (see below). 
     nInd = self.nInd
     order = [*self.order]
     nCoef = [*self.nCoef]
     knots = list(self.knots)
-    permutation = [] # Used to transpose coefs to match other.coefs.T.
-    for i in range(self.nInd - 1, -1, -1):
-        if i not in selfMapped:
-            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[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.
+    for i in range(other.nInd):
+        if i not in otherToSelf:
+            order.append(other.order[i])
+            nCoef.append(other.nCoef[i])
+            knots.append(other.knots[i])
             nInd += 1
-        else:
-            permutation.append(otherToSelf[i] + 1) # Add 1 to account for dependent variables.
-    permutation.append(0) # Account for dependent variables.
-    permutation = np.array(permutation)
+
+    # Build coefs array.
     coefs = np.zeros((self.nDep, *nCoef), self.coefs.dtype)
 
-    # Build coefs array by transposing the changing coefficients to the end, including the dependent variables.
-    # First, add in self.coefs.
+    # Add in self.coefs (you need to transpose coefs for the addition to work properly).
     coefs = coefs.T
     coefs += self.coefs.T
-    # Permutation for other.coefs.T accounts for coefs being transposed by subtracting permutation from ndim - 1.
-    coefs = coefs.transpose((coefs.ndim - 1) - permutation)
-    # Add in other.coefs. 
+    coefs = coefs.T
+
+    # Construct permutation of coefs to transpose coefs to match other.coefs.
+    otherUnmappedCount = 0
+    permutation = [0] # Account for dependent variables
+    for i in range(other.nInd):
+        if i in otherToSelf:
+            permutation.append(otherToSelf[i] + 1) # Add 1 to account for dependent variables.
+        else:
+            permutation.append(self.nInd + otherUnmappedCount + 1) # Add 1 to account for dependent variables.
+            otherUnmappedCount += 1
+    for i in range(self.nInd):
+        if i not in selfMapped:
+            permutation.append(i + 1) # Add 1 to account for dependent variables.
+
+    # Permute coefs to match other.coefs
+    coefs = coefs.transpose(permutation)
+
+    # Add in other.coefs (you need to transpose coefs for the addition to work properly).
+    coefs = coefs.T
     coefs += other.coefs.T
+    coefs = coefs.T
+
     # Reverse the permutation.
     coefs = coefs.transpose(np.argsort(permutation)) 
     
@@ -116,9 +124,9 @@ def confine(self, range_bounds):
         if unique[ix] == knot:
             count = (order - 1) - counts[ix]
             if count > 0:
-                spline = spline.insert_knots(([knot] * count,))
+                spline = spline.insert_knots(((knot, count),))
         else:
-            spline = spline.insert_knots(([knot] * (order - 1),))
+            spline = spline.insert_knots(((knot, order - 1),))
 
     # Go through the boundary points, assigning boundary coefficients, interpolating between boundary points, 
     # and removing knots and coefficients where the curve stalls.
@@ -643,21 +651,20 @@ def normal_spline(self, indices=None):
         knots = None
         counts = None
         maxOrder = 0
-        startInd = 0
-        endInd = 0
+        maxMap = []
         # First, collect the order, knots, and number of relevant columns for this independent variable.
         for row in self.block:
-            rowInd = 0
-            for spline in row:
-                if rowInd <= nInd < rowInd + spline.nInd:
-                    ind = nInd - rowInd
+            for map, spline in row:
+                if nInd in map:
+                    ind = map.index(nInd)
                     order = spline.order[ind]
                     k, c = np.unique(spline.knots[ind][order-1:spline.nCoef[ind]+1], return_counts=True)
                     if knots:
                         if maxOrder < order:
                             counts += order - maxOrder
                             maxOrder = order
-                        endInd = max(endInd, rowInd + spline.nInd)
+                        if len(maxMap) < len(map):
+                            maxMap = map
                         for knot, count in zip(k[1:-1], c[1:-1]):
                             ix = np.searchsorted(knots, knot)
                             if knots[ix] == knot:
@@ -669,30 +676,27 @@ def normal_spline(self, indices=None):
                         knots = k
                         counts = c
                         maxOrder = order
-                        startInd = rowInd
-                        endInd = rowInd + spline.nInd
-                    
+                        maxMap = map
+                  
                     break
 
-                rowInd += spline.nInd
-
         # Next, calculate the order of the normal for this independent variable.
         # Note that the total order will be one less than usual, because one of 
         # the tangents is the derivative with respect to that independent variable.
         if self.nInd < self.nDep:
             # If this normal involves all tangents, simply add the degree of each,
             # so long as that tangent contains the independent variable.
-            order = (maxOrder - 1) * (endInd - startInd)
+            order = (maxOrder - 1) * len(maxMap)
         else:
             # If this normal doesn't involve all tangents, find the max order of
             # each returned combination (as defined by the indices).
             order = 0
-            for index in range(startInd, endInd) if indices is None else indices:
+            for index in maxMap if indices is None else indices:
                 # The order will be one larger if this independent variable's tangent is excluded by the index.
                 ord = 0 if index != nInd else 1
                 # Add the degree of each tangent, so long as that tangent contains the 
                 # independent variable and is not excluded by the index.  
-                for ind in range(startInd, endInd):
+                for ind in maxMap:
                     ord += maxOrder - 1 if index != ind else 0
                 order = max(order, ord)
         

bspy/hyperplane.py

@@ -18,6 +18,9 @@ class Hyperplane(Manifold):
     
     tangentSpace : array-like
         A array of tangents that are linearly independent and orthogonal to the normal.
+
+    metadata : `dict`, optional
+        A dictionary of ancillary data to store with the hyperplane. Default is {}.
     
     Notes
     -----
@@ -28,11 +31,12 @@ class Hyperplane(Manifold):
     maxAlignment = 0.9999 # 1 - 1/10^4
     """ If the absolute value of the dot product of two unit normals is greater than maxAlignment, the manifolds are parallel."""
 
-    def __init__(self, normal, point, tangentSpace):
+    def __init__(self, normal, point, tangentSpace, metadata = {}):
         self._normal = np.atleast_1d(normal)
         self._point = np.atleast_1d(point)
         self._tangentSpace = np.atleast_1d(tangentSpace)
         if not np.allclose(self._tangentSpace.T @ self._normal, 0.0): raise ValueError("normal must be orthogonal to tangent space")
+        self.metadata = dict(metadata)
 
     def __repr__(self):
         return "Hyperplane({0}, {1}, {2})".format(self._normal, self._point, self._tangentSpace)
@@ -207,7 +211,7 @@ class Hyperplane(Manifold):
         --------
         `to_dict` : Return a `dict` with `Hyperplane` data.
         """
-        return Hyperplane(dictionary["normal"], dictionary["point"], dictionary["tangentSpace"])
+        return Hyperplane(dictionary["normal"], dictionary["point"], dictionary["tangentSpace"], dictionary.get("metadata", {}))
 
     def full_domain(self):
         """
@@ -455,7 +459,7 @@ class Hyperplane(Manifold):
         --------
         `from_dict` : Create a `Hyperplane` from a data in a `dict`.
         """
-        return {"type" : "Hyperplane", "normal" : self._normal, "point" : self._point, "tangentSpace" : self._tangentSpace}
+        return {"type" : "Hyperplane", "normal" : self._normal, "point" : self._point, "tangentSpace" : self._tangentSpace, "metadata" : self.metadata}
 
     def transform(self, matrix, matrixInverseTranspose = None):
         """

bspy/manifold.py

@@ -5,6 +5,11 @@ class Manifold:
     """
     A manifold is an abstract base class for differentiable functions with
     normals and tangent spaces whose range is one dimension higher than their domain.
+
+    Parameters
+    ----------
+    metadata : `dict`, optional
+        A dictionary of ancillary data to store with the manifold. Default is {}.
     """
 
     minSeparation = 0.0001
@@ -17,8 +22,8 @@ class Manifold:
     factory = {}
     """Factory dictionary for creating manifolds."""
 
-    def __init__(self):
-        pass
+    def __init__(self, metadata = {}):
+        self.metadata = dict(metadata)
 
     def cached_intersect(self, other, cache = None):
         """
@@ -322,7 +327,7 @@ class Manifold:
         --------
         `from_dict` : Create a `Manifold` from a data in a `dict`.
         """
-        return None
+        return {"metadata" : self.metadata}
 
     def transform(self, matrix, matrixInverseTranspose = None):
         """

bspy/solid.py

@@ -59,6 +59,9 @@ class Solid:
     
     containsInfinity : `bool`
         Indicates whether or not the solid contains infinity.
+
+    metadata : `dict`, optional
+        A dictionary of ancillary data to store with the solid. Default is {}.
     
     See also
     --------
@@ -70,10 +73,11 @@ class Solid:
 
     Solids can be of zero dimension, typically acting as the domain of boundary endpoints. Zero-dimension solids have no boundaries, they only contain infinity or not.
     """
-    def __init__(self, dimension, containsInfinity):
+    def __init__(self, dimension, containsInfinity, metadata = {}):
         assert dimension >= 0
         self.dimension = dimension
         self.containsInfinity = containsInfinity
+        self.metadata = dict(metadata)
         self.boundaries = []
         self.bounds = None
 
@@ -356,7 +360,7 @@ class Solid:
         `save` : Save a solids and/or manifolds in json format to the specified filename (full path).
         """
         def from_dict(dictionary):
-            solid = Solid(dictionary["dimension"], dictionary["containsInfinity"])
+            solid = Solid(dictionary["dimension"], dictionary["containsInfinity"], dictionary.get("metadata", {}))
             for boundary in dictionary["boundaries"]:
                 manifold = boundary["manifold"]
                 solid.add_boundary(Boundary(Manifold.factory[manifold.get("type", "Spline")].from_dict(manifold), from_dict(boundary["domain"])))
@@ -428,7 +432,7 @@ class Solid:
                 if isinstance(obj, Boundary):
                     return {"type" : "Boundary", "manifold" : obj.manifold, "domain" : obj.domain}
                 if isinstance(obj, Solid):
-                    return {"type" : "Solid", "dimension" : obj.dimension, "containsInfinity" : obj.containsInfinity, "boundaries" : obj.boundaries}
+                    return {"type" : "Solid", "dimension" : obj.dimension, "containsInfinity" : obj.containsInfinity, "boundaries" : obj.boundaries, "metadata" : obj.metadata}
                 return super().default(obj)
 
         with open(fileName, 'w', encoding='utf-8') as file:

bspy/spline.py

@@ -79,7 +79,7 @@ class Spline(Manifold):
 
     def __repr__(self):
         return f"Spline({self.nInd}, {self.nDep}, {self.order}, " + \
-               f"{self.nCoef}, {self.knots} {self.coefs}, {self.metadata})"
+               f"{self.nCoef}, {self.knots}, {self.coefs}, {self.metadata})"
 
     def __add__(self, other):
         if isinstance(other, Spline):
@@ -969,7 +969,10 @@ class Spline(Manifold):
         
         f : Python function
             The function to approximate.  It is a vector-valued function of nDep
-            components in nInd variables.
+            components in nInd variables.  Alternatively, it can return a spline of any
+            number independent variables and nDep dependent variables.  In this case, the
+            resulting spline function will have nInd + number of independent variables
+            in the splines returned independent variables and nDep dependent variables.
         
         order : `array-like`
             An optional integer array of length nInd which specifies the polynomial
@@ -1109,7 +1112,7 @@ class Spline(Manifold):
         `to_dict` : Return a `dict` with `Spline` data.
         """
         return Spline(dictionary["nInd"], dictionary["nDep"], dictionary["order"], dictionary["nCoef"],
-                [np.array(knots) for knots in dictionary["knots"]], np.array(dictionary["coefs"]), dictionary["metadata"])
+                [np.array(knots) for knots in dictionary["knots"]], np.array(dictionary["coefs"]), dictionary.get("metadata", {}))
 
     def full_domain(self):
         """
@@ -1211,7 +1214,12 @@ class Spline(Manifold):
         ----------
         newKnots : `iterable` of length `nInd`
             An iterable that specifies the knots to be added to each independent variable's knots. 
-            len(newKnots[ind]) == 0 if no knots are to be added for the `ind` independent variable.
+            len(newKnots[ind]) == 0 if no knots are to be added for the `ind` independent variable. 
+            
+            Each knot may be specified as its knot value or a tuple indicating the knot value and its multiplicity. 
+            For example, spline.insert_knots([[0.1, (0.3, 2)], [(.5, 3), .2, .5]]) will insert 0.1 once and 0.3 twice into 
+            the knots of the first independent variable, and will insert 0.2 once and 0.5 four times into the knots of the 
+            second independent variable. Knots do not need to be sorted.
 
         Returns
         -------
@@ -2065,7 +2073,11 @@ class Spline(Manifold):
         --------
         `join` : Join a list of splines together into a single spline.
         """
-        return bspy._spline_domain.split(self, minContinuity, breaks)
+        splineArray = bspy.spline_block.SplineBlock(self).split(minContinuity, breaks)
+        splines = splineArray.ravel()
+        for i, block in enumerate(splines):
+            splines[i] = block.block[0][0][1]
+        return splines.reshape(splineArray.shape)
     
     def subtract(self, other, indMap = None):
         """