feectools 0.1.5__tar.gz → 0.1.6__tar.gz

{feectools-0.1.5/feectools.egg-info → feectools-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: feectools
-Version: 0.1.5
+Version: 0.1.6
 Summary: Slimmed-down fork of Psydac (https://github.com/pyccel/psydac) with less functionality and fewer dependencies.
 Author-email: Psydac development team <psydac@googlegroups.com>
 Maintainer-email: Stefan Possanner <stefan.possanner@ipp.mpg.de>, Max Lindqvist <max.lindqvist@ipp.mpg.de>, Yaman Güçlü <yaman.guclu@gmail.com>, Martin Campos Pinto <martin.campos-pinto@ipp.mpg.de>, Ahmed Ratnani <ratnaniahmed@gmail.com>
@@ -42,6 +42,7 @@ Requires-Dist: matplotlib
 Requires-Dist: pyyaml>=5.1
 Requires-Dist: packaging
 Requires-Dist: pyevtk
+Requires-Dist: cunumpy
 Requires-Dist: pyccel>=2.1.0
 Requires-Dist: h5py
 Requires-Dist: tblib

{feectools-0.1.5 → feectools-0.1.6}/feectools/api/fem_bilinear_form.py

@@ -2,7 +2,7 @@ import sys
 import os
 import importlib
 
-import numpy as np
+import cunumpy as xp
 
 from sympy                  import ImmutableDenseMatrix, Matrix, Symbol, sympify
 from sympy.tensor.indexed   import Indexed, IndexedBase
@@ -465,8 +465,8 @@ class DiscreteBilinearForm:
 
         expr            = self.kernel_expr.expr
         target          = self.kernel_expr.target
-        test_degree     = np.array(self.test_basis.space.degree)
-        trial_degree    = np.array(self.trial_basis.space.degree)
+        test_degree     = xp.array(self.test_basis.space.degree)
+        trial_degree    = xp.array(self.trial_basis.space.degree)
         test_space      = self.spaces[1].coeff_space
         trial_space     = self.spaces[0].coeff_space
         test_fem_space  = self.spaces[1]
@@ -476,20 +476,20 @@ class DiscreteBilinearForm:
         is_conformal    = True
 
         if isinstance(expr, (ImmutableDenseMatrix, Matrix)):
-            if not isinstance(test_degree[0],(list, tuple, np.ndarray)):
+            if not isinstance(test_degree[0],(list, tuple, xp.ndarray)):
                 test_degree = [test_degree]
 
-            if not isinstance(trial_degree[0],(list, tuple, np.ndarray)):
+            if not isinstance(trial_degree[0],(list, tuple, xp.ndarray)):
                 trial_degree = [trial_degree]
 
-            pads = np.empty((len(test_degree),len(trial_degree),len(test_degree[0])), dtype=int)
+            pads = xp.empty((len(test_degree),len(trial_degree),len(test_degree[0])), dtype=int)
             for i in range(len(test_degree)):
                 for j in range(len(trial_degree)):
                     td  = test_degree[i]
                     trd = trial_degree[j]
-                    pads[i,j][:] = np.array([td, trd]).max(axis=0)
+                    pads[i,j][:] = xp.array([td, trd]).max(axis=0)
         else:
-            pads = np.maximum(test_degree, trial_degree)
+            pads = xp.maximum(test_degree, trial_degree)
 
         if self._matrix is None and (is_broken or isinstance(expr, (ImmutableDenseMatrix, Matrix))):
             self._matrix = BlockLinearOperator(trial_space, test_space)
@@ -714,8 +714,8 @@ class DiscreteBilinearForm:
                     bs, d, s, p, mult = construct_test_space_arguments(basis_v)
                     basis   += bs
                     spans   += s
-                    degrees += [np.int64(a) for a in d]
-                    pads    += [np.int64(a) for a in p]
+                    degrees += [xp.int64(a) for a in d]
+                    pads    += [xp.int64(a) for a in p]
                     if v.space.is_multipatch or v.space.is_vector_valued:
                         coeffs += (e._data for e in v.coeffs)
                     else:
@@ -1382,12 +1382,12 @@ class DiscreteBilinearForm:
             I_1 = f'int(floor(i_1/{test_mult[0]})*{trial_mult[0]})' if max(test_mult[0], trial_mult[0]) > 1 else 'i_1'
             I_2 = f'int(floor(i_2/{test_mult[1]})*{trial_mult[1]})' if max(test_mult[1], trial_mult[1]) > 1 else 'i_2'
             I_3 = f'int(floor(i_3/{test_mult[2]})*{trial_mult[2]})' if max(test_mult[2], trial_mult[2]) > 1 else 'i_3'
-            #MAX_P1 = max(int( ( MAX_P1 + np.floor(MAX_P1 / test_mult[0]) * trial_mult[0] ) / 2 ), MAX_P1) if max(test_mult[0], trial_mult[0]) > 1 else MAX_P1
-            #MAX_P2 = max(int( ( MAX_P2 + np.floor(MAX_P2 / test_mult[1]) * trial_mult[1] ) / 2 ), MAX_P2) if max(test_mult[1], trial_mult[1]) > 1 else MAX_P2
-            #MAX_P3 = max(int( ( MAX_P3 + np.floor(MAX_P3 / test_mult[2]) * trial_mult[2] ) / 2 ), MAX_P3) if max(test_mult[2], trial_mult[2]) > 1 else MAX_P3
-            n_cols_x1 = max( int(MAX_P1 + 1 + np.floor(MAX_P1 / test_mult[0]) * trial_mult[0]), 2*MAX_P1+1 )
-            n_cols_x2 = max( int(MAX_P2 + 1 + np.floor(MAX_P2 / test_mult[1]) * trial_mult[1]), 2*MAX_P2+1 )
-            n_cols_x3 = max( int(MAX_P3 + 1 + np.floor(MAX_P3 / test_mult[2]) * trial_mult[2]), 2*MAX_P3+1 )
+            #MAX_P1 = max(int( ( MAX_P1 + xp.floor(MAX_P1 / test_mult[0]) * trial_mult[0] ) / 2 ), MAX_P1) if max(test_mult[0], trial_mult[0]) > 1 else MAX_P1
+            #MAX_P2 = max(int( ( MAX_P2 + xp.floor(MAX_P2 / test_mult[1]) * trial_mult[1] ) / 2 ), MAX_P2) if max(test_mult[1], trial_mult[1]) > 1 else MAX_P2
+            #MAX_P3 = max(int( ( MAX_P3 + xp.floor(MAX_P3 / test_mult[2]) * trial_mult[2] ) / 2 ), MAX_P3) if max(test_mult[2], trial_mult[2]) > 1 else MAX_P3
+            n_cols_x1 = max( int(MAX_P1 + 1 + xp.floor(MAX_P1 / test_mult[0]) * trial_mult[0]), 2*MAX_P1+1 )
+            n_cols_x2 = max( int(MAX_P2 + 1 + xp.floor(MAX_P2 / test_mult[1]) * trial_mult[1]), 2*MAX_P2+1 )
+            n_cols_x3 = max( int(MAX_P3 + 1 + xp.floor(MAX_P3 / test_mult[2]) * trial_mult[2]), 2*MAX_P3+1 )
             MAX_P1 = n_cols_x1 - MAX_P1 - 1
             MAX_P2 = n_cols_x2 - MAX_P2 - 1
             MAX_P3 = n_cols_x3 - MAX_P3 - 1
@@ -2024,9 +2024,9 @@ class DiscreteBilinearForm:
 
             # keys_2[(u[0], v[1])][3] = (1,2) means that the fourth sub-expression corresponding to the trial-test-function-component-product
             # u[0] * v[1] involves a first derivative in x2 direction of the trial function and a second derivative in x2 direction of the test function            
-            keys_1[block] = np.array([(alpha_1, beta_1) for alpha_1, beta_1 in zip(x1_trial_keys[block], x1_test_keys[block])])
-            keys_2[block] = np.array([(alpha_2, beta_2) for alpha_2, beta_2 in zip(x2_trial_keys[block], x2_test_keys[block])])
-            keys_3[block] = np.array([(alpha_3, beta_3) for alpha_3, beta_3 in zip(x3_trial_keys[block], x3_test_keys[block])])
+            keys_1[block] = xp.array([(alpha_1, beta_1) for alpha_1, beta_1 in zip(x1_trial_keys[block], x1_test_keys[block])])
+            keys_2[block] = xp.array([(alpha_2, beta_2) for alpha_2, beta_2 in zip(x2_trial_keys[block], x2_test_keys[block])])
+            keys_3[block] = xp.array([(alpha_3, beta_3) for alpha_3, beta_3 in zip(x3_trial_keys[block], x3_test_keys[block])])
 
             # Those are the function values in each direction of a particular component of the trial/test function
             global_basis_u_1, global_basis_u_2, global_basis_u_3 = global_basis_u[u_i]
@@ -2056,9 +2056,9 @@ class DiscreteBilinearForm:
             # of non-zero product.
             # Hence, we assign zeros for each element, each quadrature point on the element, each test and trial function combination,
             # and each (or even more than required) appearing partial derivative combination of these functions - in each direction
-            test_trial_1 = np.zeros((n_element_1, k1, test_v_p1 + 1, trial_u_p1 + 1, max_block_trial_x1_derivative+1, max_block_test_x1_derivative+1), dtype='float64')
-            test_trial_2 = np.zeros((n_element_2, k2, test_v_p2 + 1, trial_u_p2 + 1, max_block_trial_x2_derivative+1, max_block_test_x2_derivative+1), dtype='float64')
-            test_trial_3 = np.zeros((n_element_3, k3, test_v_p3 + 1, trial_u_p3 + 1, max_block_trial_x3_derivative+1, max_block_test_x3_derivative+1), dtype='float64')
+            test_trial_1 = xp.zeros((n_element_1, k1, test_v_p1 + 1, trial_u_p1 + 1, max_block_trial_x1_derivative+1, max_block_test_x1_derivative+1), dtype='float64')
+            test_trial_2 = xp.zeros((n_element_2, k2, test_v_p2 + 1, trial_u_p2 + 1, max_block_trial_x2_derivative+1, max_block_test_x2_derivative+1), dtype='float64')
+            test_trial_3 = xp.zeros((n_element_3, k3, test_v_p3 + 1, trial_u_p3 + 1, max_block_trial_x3_derivative+1, max_block_test_x3_derivative+1), dtype='float64')
 
             # And that's how we fill the test_trial arrays
             if self._pyccelize_test_trial_computation and assembly_backend['name'] == 'pyccel':
@@ -2068,7 +2068,7 @@ class DiscreteBilinearForm:
                                 [max_block_trial_x1_derivative, max_block_trial_x2_derivative, max_block_trial_x3_derivative], [max_block_test_x1_derivative, max_block_test_x2_derivative, max_block_test_x3_derivative], 
                                 [test_trial_1, test_trial_2, test_trial_3]):
                     
-                    args = tuple(np.int64(a) if isinstance(a, int) else a for a in args)
+                    args = tuple(xp.int64(a) if isinstance(a, int) else a for a in args)
 
                     test_trial_func(*args)
             else:
@@ -2118,13 +2118,13 @@ class DiscreteBilinearForm:
             # to store local information correctly. 2*degree+1 in the simplest case.
             n_funs_x2 = n_element_2 + test_v_p2 + (test_mult[1]-1)*(n_element_2-1)
             n_funs_x3 = n_element_3 + test_v_p3 + (test_mult[2]-1)*(n_element_3-1)
-            n_cols_x2 = max( int(max_p_2 + 1 + np.floor(max_p_2 / test_mult[1]) * trial_mult[1]), 2*max_p_2+1 )
-            n_cols_x3 = max( int(max_p_3 + 1 + np.floor(max_p_3 / test_mult[2]) * trial_mult[2]), 2*max_p_3+1 )
+            n_cols_x2 = max( int(max_p_2 + 1 + xp.floor(max_p_2 / test_mult[1]) * trial_mult[1]), 2*max_p_2+1 )
+            n_cols_x3 = max( int(max_p_3 + 1 + xp.floor(max_p_3 / test_mult[2]) * trial_mult[2]), 2*max_p_3+1 )
             
-            a3[block] = np.zeros((n_expr, n_funs_x3, n_cols_x3), dtype='float64')
-            a2[block] = np.zeros((n_expr, n_funs_x2, n_funs_x3, n_cols_x2, n_cols_x3), dtype='float64')
+            a3[block] = xp.zeros((n_expr, n_funs_x3, n_cols_x3), dtype='float64')
+            a2[block] = xp.zeros((n_expr, n_funs_x2, n_funs_x3, n_cols_x2, n_cols_x3), dtype='float64')
 
-            coupling_terms[block] = np.zeros((n_element_2, k2, n_element_3, k3, n_expr), dtype='float64')
+            coupling_terms[block] = xp.zeros((n_element_2, k2, n_element_3, k3, n_expr), dtype='float64')
 
         # We gather the socalled new args - all other args are being obtained in a similar way using the old assembly implementation
         new_args = (*list(test_trial_1s.values()), 
@@ -2158,8 +2158,8 @@ class DiscreteBilinearForm:
         
         threads_args = ()
 
-        args = tuple(np.int64(a) if isinstance(a, int) else a for a in args)
-        threads_args = tuple(np.int64(a) if isinstance(a, int) else a for a in threads_args)
+        args = tuple(xp.int64(a) if isinstance(a, int) else a for a in args)
+        threads_args = tuple(xp.int64(a) if isinstance(a, int) else a for a in threads_args)
 
         #---------- We now generate the assembly file ----------
 

{feectools-0.1.5 → feectools-0.1.6}/feectools/api/fem_common.py

@@ -2,7 +2,7 @@ from typing import Iterable
 
 from sympy import Expr, ImmutableDenseMatrix, Matrix
 
-import numpy as np
+import cunumpy as xp
 
 from sympde.expr.basic           import BasicForm
 from sympde.expr.evaluation      import KernelExpression
@@ -215,8 +215,8 @@ def collect_spaces(space, *args):
 
 #==============================================================================
 def compute_diag_len(p, md, mc):
-    n = ((np.ceil((p+1)/mc)-1)*md).astype('int')
-    n = n-np.minimum(0, n-p)+p+1
+    n = ((xp.ceil((p+1)/mc)-1)*md).astype('int')
+    n = n-xp.minimum(0, n-p)+p+1
     return n.astype('int')
 
 #==============================================================================

{feectools-0.1.5 → feectools-0.1.6}/feectools/api/fem_sum_form.py

@@ -1,4 +1,4 @@
-import numpy as np
+import cunumpy as xp
 
 from sympde.expr.expr import (
     BilinearForm as sym_BilinearForm,
@@ -119,5 +119,5 @@ class DiscreteSumForm(BasicDiscrete):
             return self._operator
         else:
             M = [form.assemble(**kwargs) for form in self.forms]
-            M = np.sum(M)
+            M = sum(M)
             return M

{feectools-0.1.5 → feectools-0.1.6}/feectools/core/bsplines.py

@@ -15,7 +15,8 @@ References:
    - [2] SELALIB, Semi-Lagrangian Library. http://selalib.gforge.inria.fr
 
 """
-import numpy as np
+import cunumpy as xp
+from cunumpy.xp import array_backend
 
 from feectools.core.bsplines_kernels import (find_span_p,
                                           find_spans_p,
@@ -82,7 +83,7 @@ def find_span(knots, degree, x):
         Knot span index.
     """
     x = float(x)
-    knots = np.ascontiguousarray(knots, dtype=float)
+    knots = xp.ascontiguousarray(knots, dtype=float)
     return find_span_p(knots, degree, x)
 
 #==============================================================================
@@ -114,12 +115,12 @@ def find_spans(knots, degree, x, out=None):
     spans : array of ints
         Knots span indexes.
     """
-    knots = np.ascontiguousarray(knots, dtype=float)
-    x = np.ascontiguousarray(x, dtype=float)
+    knots = xp.ascontiguousarray(knots, dtype=float)
+    x = xp.ascontiguousarray(x, dtype=float)
     if out is None:
-        out = np.zeros_like(x, dtype=int)
+        out = xp.zeros_like(x, dtype=int)
     else:
-        assert out.shape == x.shape and out.dtype == np.dtype('int')
+        assert out.shape == x.shape and out.dtype == xp.dtype('int')
 
     find_spans_p(knots, degree, x, out)
     return out
@@ -153,13 +154,13 @@ def basis_funs(knots, degree, x, span, out=None):
         1D array containing the values of ``degree + 1`` non-zero
         Bsplines at location ``x``.
     """
-    knots = np.ascontiguousarray(knots, dtype=float)
+    knots = xp.ascontiguousarray(knots, dtype=float)
     # Get native float
     x = float(x)
     if out is None:
-        out = np.zeros(degree + 1, dtype=float)
+        out = xp.zeros(degree + 1, dtype=float)
     else:
-        assert out.shape == (degree + 1,) and out.dtype == np.dtype('float')
+        assert out.shape == (degree + 1,) and out.dtype == xp.dtype('float')
     basis_funs_p(knots, degree, x, span, out)
     return out
 
@@ -191,12 +192,12 @@ def basis_funs_array(knots, degree, span, x, out=None):
         2D array of shape ``(len(x), degree + 1)`` containing the values of ``degree + 1`` non-zero
         Bsplines at each location in ``x``.
     """
-    knots = np.ascontiguousarray(knots, dtype=float)
-    x = np.ascontiguousarray(x, dtype=float)
+    knots = xp.ascontiguousarray(knots, dtype=float)
+    x = xp.ascontiguousarray(x, dtype=float)
     if out is None:
-        out = np.zeros(x.shape + (degree + 1,), dtype=float)
+        out = xp.zeros(x.shape + (degree + 1,), dtype=float)
     else:
-        assert out.shape == x.shape + (degree + 1,) and out.dtype == np.dtype('float')
+        assert out.shape == x.shape + (degree + 1,) and out.dtype == xp.dtype('float')
     basis_funs_array_p(knots, degree, x, span,  out)
     return out
 
@@ -238,13 +239,13 @@ def basis_funs_1st_der(knots, degree, x, span, out=None):
     ----------
     .. [2] SELALIB, Semi-Lagrangian Library. http://selalib.gforge.inria.fr
     """
-    knots = np.ascontiguousarray(knots, dtype=float)
+    knots = xp.ascontiguousarray(knots, dtype=float)
     # Get native float to work on windows
     x = float(x)
     if out is None:
-        out = np.zeros(degree + 1, dtype=float)
+        out = xp.zeros(degree + 1, dtype=float)
     else:
-        assert out.shape == (degree + 1,) and out.dtype == np.dtype('float')
+        assert out.shape == (degree + 1,) and out.dtype == xp.dtype('float')
 
     basis_funs_1st_der_p(knots, degree, x, span, out)
     return out
@@ -289,13 +290,13 @@ def basis_funs_all_ders(knots, degree, x, span, n, normalization='B', out=None):
         ders[i,j] = (d/dx)^i B_k(x) with k=(span-degree+j),
         for 0 <= i <= n and 0 <= j <= degree+1.
     """
-    knots = np.ascontiguousarray(knots, dtype=float)
+    knots = xp.ascontiguousarray(knots, dtype=float)
     # Get native float to work on windows
     x = float(x)
     if out is None:
-        out = np.zeros((n + 1, degree + 1), dtype=float)
+        out = xp.zeros((n + 1, degree + 1), dtype=float)
     else:
-        assert out.shape == (n + 1, degree + 1) and out.dtype == np.dtype('float')
+        assert out.shape == (n + 1, degree + 1) and out.dtype == xp.dtype('float')
 
     basis_funs_all_ders_p(knots, degree, x, span, n, normalization == 'M', out)
     return out
@@ -342,18 +343,18 @@ def collocation_matrix(knots, degree, periodic, normalization, xgrid, out=None,
     values of each B-spline basis function :math:`B_j` at all locations :math:`x_i`.
     """
     if xgrid.size == 1:
-        return np.ones((1, 1), dtype=float)
+        return xp.ones((1, 1), dtype=float)
 
-    knots = np.ascontiguousarray(knots, dtype=float)
-    xgrid = np.ascontiguousarray(xgrid, dtype=float)
+    knots = xp.ascontiguousarray(knots, dtype=float)
+    xgrid = xp.ascontiguousarray(xgrid, dtype=float)
     if out is None:
         nb = len(knots) - degree - 1
         if periodic:
             nb -= degree + 1 - multiplicity
 
-        out = np.zeros((xgrid.shape[0], nb), dtype=float)
+        out = xp.zeros((int(xgrid.shape[0]), int(nb)), dtype=float)
     else:
-        assert out.shape == ((xgrid.shape[0], nb)) and out.dtype == np.dtype('float')
+        assert out.shape == ((int(xgrid.shape[0]), int(nb))) and out.dtype == xp.dtype('float')
 
     bool_normalization = normalization == "M"
     multiplicity = int(multiplicity)
@@ -407,11 +408,11 @@ def histopolation_matrix(knots, degree, periodic, normalization, xgrid, multipli
     two successive grid points.
     """
     # Check that knots are ordered (but allow repeated knots)
-    if not np.all(np.diff(knots) >= 0):
+    if not xp.all(xp.diff(knots) >= 0):
         raise ValueError("Cannot accept knot sequence: {}".format(knots))
 
     # Check that spline degree is non-negative integer
-    if not isinstance(degree, (int, np.integer)):
+    if not isinstance(degree, (int, xp.integer)):
         raise TypeError("Degree {} must be integer, got type {} instead".format(degree, type(degree)))
     if degree < 0:
         raise ValueError("Cannot accept negative degree: {}".format(degree))
@@ -425,26 +426,26 @@ def histopolation_matrix(knots, degree, periodic, normalization, xgrid, multipli
         raise ValueError("Cannot accept 'normalization' parameter: {}".format(normalization))
 
     # Check that grid points are ordered, and do not allow repetitions
-    if not np.all(np.diff(xgrid) > 0):
+    if not xp.all(xp.diff(xgrid) > 0):
         raise ValueError("Grid points must be ordered, with no repetitions: {}".format(xgrid))
 
-    knots = np.ascontiguousarray(knots, dtype=float)
-    xgrid = np.ascontiguousarray(xgrid, dtype=float)
+    knots = xp.ascontiguousarray(knots, dtype=float)
+    xgrid = xp.ascontiguousarray(xgrid, dtype=float)
     elevated_knots = elevate_knots(knots, degree, periodic, multiplicity=multiplicity)
 
     normalization = normalization == "M"
 
     if out is None:
         if periodic:
-            out = np.zeros((len(xgrid), len(knots) - 2 * degree - 2 + multiplicity), dtype=float)
+            out = xp.zeros((len(xgrid), len(knots) - 2 * int(degree) - 2 + int(multiplicity)), dtype=float)
         else:
-            out = np.zeros((len(xgrid) - 1, len(elevated_knots) - (degree + 1) - 1 - 1), dtype=float)
+            out = xp.zeros((len(xgrid) - 1, len(elevated_knots) - (int(degree) + 1) - 1 - 1), dtype=float)
     else:
         if periodic:
             assert out.shape == (len(xgrid), len(knots) - 2 * degree - 2 + multiplicity)
         else:
             assert out.shape == (len(xgrid) - 1, len(elevated_knots) - (degree + 1) - 1 - 1)
-        assert out.dtype == np.dtype('float')
+        assert out.dtype == xp.dtype('float')
     multiplicity = int(multiplicity)
     histopolation_matrix_p(knots, degree, periodic, normalization, xgrid, check_boundary, elevated_knots, out, multiplicity = multiplicity)
     return out
@@ -475,11 +476,11 @@ def breakpoints(knots, degree, tol=1e-15, out=None):
     breaks : numpy.ndarray (1D)
         Abscissas of all breakpoints.
     """
-    knots = np.ascontiguousarray(knots, dtype=float)
+    knots = xp.ascontiguousarray(knots, dtype=float)
     if out is None:
-        out = np.zeros(len(knots), dtype=float)
+        out = xp.zeros(len(knots), dtype=float)
     else:
-        assert out.shape == knots.shape and out.dtype == np.dtype('float')
+        assert out.shape == knots.shape and out.dtype == xp.dtype('float')
     i_final = breakpoints_p(knots, degree, out, tol)
     return out[:i_final]
 
@@ -513,10 +514,10 @@ def greville(knots, degree, periodic, out=None, multiplicity=1):
         Abscissas of all Greville points.
 
     """
-    knots = np.ascontiguousarray(knots, dtype=float)
+    knots = xp.ascontiguousarray(knots, dtype=float)
     if out is None:
         n = len(knots) - 2 * degree - 2 + multiplicity if periodic else len(knots) - degree - 1
-        out = np.zeros(n)
+        out = xp.zeros(int(n))
     multiplicity = int(multiplicity)
     greville_p(knots, degree, periodic, out, multiplicity)
     return out
@@ -546,11 +547,11 @@ def elements_spans(knots, degree, out=None):
 
     Examples
     --------
-    >>> import numpy as np
+    >>> import cunumpy as xp
     >>> from feectools.core.bsplines import make_knots, elements_spans
 
     >>> p = 3 ; n = 8
-    >>> grid  = np.arange( n-p+1 )
+    >>> grid  = xp.arange( n-p+1 )
     >>> knots = make_knots( breaks=grid, degree=p, periodic=False )
     >>> spans = elements_spans( knots=knots, degree=p )
     >>> spans
@@ -562,14 +563,14 @@ def elements_spans(knots, degree, out=None):
     2) This function could be written in two lines:
 
        breaks = breakpoints( knots, degree )
-       spans  = np.searchsorted( knots, breaks[:-1], side='right' ) - 1
+       spans  = xp.searchsorted( knots, breaks[:-1], side='right' ) - 1
 
     """
-    knots = np.ascontiguousarray(knots, dtype=float)
+    knots = xp.ascontiguousarray(knots, dtype=float)
     if out is None:
-        out = np.zeros(len(knots), dtype=np.int64)
+        out = xp.zeros(len(knots), dtype=xp.int64)
     else:
-        assert out.shape == knots.shape and out.dtype == np.dtype('int64')
+        assert out.shape == knots.shape and out.dtype == xp.dtype('int64')
     i_final = elements_spans_p(knots, degree, out)
     return out[:i_final]
 
@@ -616,7 +617,7 @@ def make_knots(breaks, degree, periodic, multiplicity=1, out=None):
 
     # Consistency checks
     assert len(breaks) > 1
-    assert all( np.diff(breaks) > 0 )
+    assert all( xp.diff(breaks) > 0 )
     assert degree >= 0
     assert 1 <= multiplicity and multiplicity <= degree + 1
     # Cast potential numpy.int64 into python native int
@@ -625,12 +626,12 @@ def make_knots(breaks, degree, periodic, multiplicity=1, out=None):
     if periodic:
         assert len(breaks) > degree
 
-    breaks = np.ascontiguousarray(breaks, dtype=float)
+    breaks = xp.ascontiguousarray(breaks, dtype=float)
     if out is None:
-        out = np.zeros(multiplicity * len(breaks[1:-1]) + 2 + 2 * degree)
+        out = xp.zeros(multiplicity * len(breaks[1:-1]) + 2 + 2 * degree)
     else:
         assert out.shape == (multiplicity * len(breaks[1:-1]) + 2 + 2 * degree,) \
-            and out.dtype == np.dtype('float')
+            and out.dtype == xp.dtype('float')
     make_knots_p(breaks, degree, periodic, out, multiplicity)
 
     return out
@@ -675,25 +676,25 @@ def elevate_knots(knots, degree, periodic, multiplicity=1, tol=1e-15, out=None):
         Knots sequence of spline space of degree p+1.
     """
     multiplicity = int(multiplicity)
-    knots = np.ascontiguousarray(knots, dtype=float)
+    knots = xp.ascontiguousarray(knots, dtype=float)
     if out is None:
         if periodic:
-            out = np.zeros(knots.shape[0] + 2, dtype=float)
+            out = xp.zeros(knots.shape[0] + 2, dtype=float)
         else:
             shape = 2*(degree + 2)
             if len(knots) - 2 * (degree + 1) > 0:
-                uniques = (np.diff(knots[degree + 1:-degree - 1]) > tol).nonzero()
+                uniques = (xp.diff(knots[degree + 1:-degree - 1]) > tol).nonzero()
                 shape += multiplicity * (1 + uniques[0].shape[0])
-            out = np.zeros(shape, dtype=float)
+            out = xp.zeros(shape, dtype=float)
     else:
         if periodic:
-            assert out.shape == (knots.shape[0] + 2,) and out.dtype == np.dtype('float')
+            assert out.shape == (knots.shape[0] + 2,) and out.dtype == xp.dtype('float')
         else:
             shape = 2*(degree + 2)
             if len(knots) - 2 * (degree + 1) > 0:
-                uniques = (np.diff(knots[degree + 1:-degree - 1]) > tol).nonzero()
+                uniques = (xp.diff(knots[degree + 1:-degree - 1]) > tol).nonzero()
                 shape += multiplicity * (1 + uniques[0].shape[0])
-            assert out.shape == shape and out.dtype == np.dtype('float')
+            assert out.shape == shape and out.dtype == xp.dtype('float')
 
     elevate_knots_p(knots, degree, periodic, out, multiplicity, tol)
     return out
@@ -750,13 +751,18 @@ def quadrature_grid(breaks, quad_rule_x, quad_rule_w):
     assert min(quad_rule_x) >= -1
     assert max(quad_rule_x) <= +1
 
-    breaks = np.ascontiguousarray(breaks, dtype=float)
+    breaks = xp.ascontiguousarray(breaks, dtype=float)
 
-    quad_rule_x = np.ascontiguousarray( quad_rule_x, dtype=float )
-    quad_rule_w = np.ascontiguousarray( quad_rule_w, dtype=float )
+    if array_backend.backend == "cupy":
+        quad_rule_x = xp.ascontiguousarray(xp.array(quad_rule_x), dtype=float)
+        quad_rule_w = xp.ascontiguousarray( xp.array(quad_rule_w), dtype=float )
+    else:
+        quad_rule_x = xp.ascontiguousarray(quad_rule_x, dtype=float)
+        quad_rule_w = xp.ascontiguousarray( quad_rule_w, dtype=float )
+    
 
-    out1 = np.zeros((len(breaks) - 1, len(quad_rule_x)))
-    out2 = np.zeros_like(out1)
+    out1 = xp.zeros((len(breaks) - 1, len(quad_rule_x)))
+    out2 = xp.zeros_like(out1)
     
     quadrature_grid_p(breaks, quad_rule_x, quad_rule_w, out1, out2)
 
@@ -805,10 +811,10 @@ def basis_ders_on_quad_grid(knots, degree, quad_grid, nders, normalization, offs
 
     Examples
     --------
-    >>> knots = np.array([0.0, 0.0, 0.25, 0.5, 0.75, 1., 1.])
+    >>> knots = xp.array([0.0, 0.0, 0.25, 0.5, 0.75, 1., 1.])
     >>> degree = 2
     >>> bk = breakpoints(knots, degree)
-    >>> grid = np.array([np.linspace(bk[i], bk[i+1], 4, endpoint=False) for i in range(len(bk) - 1)])
+    >>> grid = xp.array([xp.linspace(bk[i], bk[i+1], 4, endpoint=False) for i in range(len(bk) - 1)])
     >>> basis_ders_on_quad_grid(knots, degree, grid, 0, "B")
     array([[[[0.5, 0.28125, 0.125, 0.03125]],
             [[0.5, 0.6875 , 0.75 , 0.6875 ]],
@@ -819,12 +825,12 @@ def basis_ders_on_quad_grid(knots, degree, quad_grid, nders, normalization, offs
     """
     offset = int(offset)
     ne, nq = quad_grid.shape
-    knots = np.ascontiguousarray(knots, dtype=float)
-    quad_grid = np.ascontiguousarray(quad_grid, dtype=float)
+    knots = xp.ascontiguousarray(knots, dtype=float)
+    quad_grid = xp.ascontiguousarray(quad_grid, dtype=float)
     if out is None:
-        out = np.zeros((ne, degree + 1, nders + 1, nq), dtype=float)
+        out = xp.zeros((ne, degree + 1, nders + 1, nq), dtype=float)
     else:
-        assert out.shape == (ne, degree + 1, nders + 1, nq) and out.dtype == np.dtype('float')
+        assert out.shape == (ne, degree + 1, nders + 1, nq) and out.dtype == xp.dtype('float')
     basis_ders_on_quad_grid_p(knots, degree, quad_grid, nders, normalization == 'M', offset, out)
     return out
 
@@ -863,11 +869,11 @@ def basis_integrals(knots, degree, out=None):
     to (len(knots)-degree-1). In the periodic case the last (degree) values in
     the array are redundant, as they are a copy of the first (degree) values.
     """
-    knots = np.ascontiguousarray(knots, dtype=float)
+    knots = xp.ascontiguousarray(knots, dtype=float)
     if out is None:
-        out = np.zeros(len(knots) - degree - 1, dtype=float)
+        out = xp.zeros(len(knots) - degree - 1, dtype=float)
     else:
-        assert out.shape is (len(knots) - degree - 1,) and out.dtype == np.dtype('float')
+        assert out.shape is (len(knots) - degree - 1,) and out.dtype == xp.dtype('float')
     basis_integrals_p(knots, degree, out)
     return out
 
@@ -905,12 +911,12 @@ def cell_index(breaks, i_grid, tol=1e-15, out=None):
         ``cell_index[i]`` is the index of the cell in which
         ``i_grid[i]`` belong.
     """
-    breaks = np.ascontiguousarray(breaks, dtype=float)
-    i_grid = np.ascontiguousarray(i_grid, dtype=float)
+    breaks = xp.ascontiguousarray(breaks, dtype=float)
+    i_grid = xp.ascontiguousarray(i_grid, dtype=float)
     if out is None:
-        out = np.zeros_like(i_grid, dtype=np.int64)
+        out = xp.zeros_like(i_grid, dtype=xp.int64)
     else:
-        assert out.shape == i_grid.shape and out.dtype == np.dtype('int64')
+        assert out.shape == i_grid.shape and out.dtype == xp.dtype('int64')
     status = cell_index_p(breaks, i_grid, tol, out)
     if status == -1:
         raise ValueError("Encountered a point that was outside of the domain")
@@ -961,13 +967,13 @@ def basis_ders_on_irregular_grid(knots, degree, i_grid, cell_index, nders, norma
         . il: local basis function   (0 <= il <= degree)
         . id: derivative             (0 <= id <= nders )
     """
-    knots = np.ascontiguousarray(knots, dtype=float)
-    i_grid = np.ascontiguousarray(i_grid, dtype=float)
+    knots = xp.ascontiguousarray(knots, dtype=float)
+    i_grid = xp.ascontiguousarray(i_grid, dtype=float)
     if out is None:
         nx = i_grid.shape[0]
-        out = np.zeros((nx, degree + 1, nders + 1), dtype=float)
+        out = xp.zeros((nx, degree + 1, nders + 1), dtype=float)
     else:
-        assert out.shape == (nx, degree + 1, nders + 1) and out.dtype == np.dtype('float')
+        assert out.shape == (nx, degree + 1, nders + 1) and out.dtype == xp.dtype('float')
     basis_ders_on_irregular_grid_p(knots, degree, i_grid, cell_index, nders, normalization == 'M', out)
     return out
 
@@ -994,7 +1000,7 @@ def _refinement_matrix_one_stage(t, p, knots):
 
     Returns
     -------
-    mat : np.array[:,:]
+    mat : xp.array[:,:]
         h-refinement matrix.
 
     new_knots : array_like
@@ -1017,7 +1023,7 @@ def _refinement_matrix_one_stage(t, p, knots):
 
     n = len(knots) - p - 1
 
-    mat = np.zeros((n+1,n))
+    mat = xp.zeros((n+1,n))
 
     left = find_span( knots, p, t )
 
@@ -1037,7 +1043,7 @@ def _refinement_matrix_one_stage(t, p, knots):
     # ...
 
     # ...
-    new_knots = np.zeros(n+1+p+1)
+    new_knots = xp.zeros(n+1+p+1)
 
     new_knots[:left+1] = knots[:left+1]
     new_knots[left+1] = t
@@ -1058,7 +1064,7 @@ def hrefinement_matrix(ts, p, knots):
 
     Parameters
     ----------
-    ts: np.array
+    ts: xp.array
         array containing the knots to be inserted
 
     p: int
@@ -1069,18 +1075,18 @@ def hrefinement_matrix(ts, p, knots):
 
     Returns
     -------
-    mat : np.array[:,:]
+    mat : xp.array[:,:]
         h-refinement matrix
 
     Examples
     --------
-    >>> import numpy as np
+    >>> import cunumpy as xp
     >>> from feectools.core.bsplines import make_knots
     >>> from feectools.core.bsplines import hrefinement_matrix
-    >>> grid = np.linspace(0.,1.,5)
+    >>> grid = xp.linspace(0.,1.,5)
     >>> degree = 2
     >>> knots = make_knots(grid, degree, periodic=False)
-    >>> ts    = np.array([0.1, 0.2, 0.4, 0.5, 0.7, 0.8])
+    >>> ts    = xp.array([0.1, 0.2, 0.4, 0.5, 0.7, 0.8])
     >>> hrefinement_matrix(ts, p, knots)
     array([[1.  , 0.  , 0.  , 0.  , 0.  , 0.  ],
            [0.6 , 0.4 , 0.  , 0.  , 0.  , 0.  ],
@@ -1098,11 +1104,11 @@ def hrefinement_matrix(ts, p, knots):
 
     m = len(ts)
     n = len(knots) - p - 1
-    out = np.eye(n)
+    out = xp.eye(n)
 
     for i in range(m):
         t = ts[i]
         mat, knots = _refinement_matrix_one_stage(t, p, knots)
-        out = np.matmul(mat, out)
+        out = xp.matmul(mat, out)
 
     return out