rust_nurbs ========== .. py:module:: rust_nurbs .. autoapi-nested-parse:: Evaluation of NURBS objects in Python (implemented in Rust) Functions --------- .. autoapisummary:: rust_nurbs.bernstein_poly rust_nurbs.bezier_curve_eval rust_nurbs.bezier_curve_eval_dp rust_nurbs.bezier_curve_dcdt rust_nurbs.bezier_curve_dcdt_dp rust_nurbs.bezier_curve_d2cdt2 rust_nurbs.bezier_curve_d2cdt2_dp rust_nurbs.bezier_curve_eval_grid rust_nurbs.bezier_curve_eval_dp_grid rust_nurbs.bezier_curve_dcdt_grid rust_nurbs.bezier_curve_dcdt_dp_grid rust_nurbs.bezier_curve_d2cdt2_grid rust_nurbs.bezier_curve_d2cdt2_dp_grid rust_nurbs.bezier_curve_eval_tvec rust_nurbs.bezier_curve_eval_dp_tvec rust_nurbs.bezier_curve_dcdt_tvec rust_nurbs.bezier_curve_dcdt_dp_tvec rust_nurbs.bezier_curve_d2cdt2_tvec rust_nurbs.bezier_curve_d2cdt2_dp_tvec rust_nurbs.bezier_surf_eval rust_nurbs.bezier_surf_dsdu rust_nurbs.bezier_surf_dsdv rust_nurbs.bezier_surf_d2sdu2 rust_nurbs.bezier_surf_d2sdv2 rust_nurbs.bezier_surf_eval_dp rust_nurbs.bezier_surf_dsdu_dp rust_nurbs.bezier_surf_dsdv_dp rust_nurbs.bezier_surf_d2sdu2_dp rust_nurbs.bezier_surf_d2sdv2_dp rust_nurbs.bezier_surf_eval_dp_iso_u rust_nurbs.bezier_surf_eval_dp_iso_v rust_nurbs.bezier_surf_dsdu_dp_iso_u rust_nurbs.bezier_surf_dsdu_dp_iso_v rust_nurbs.bezier_surf_dsdv_dp_iso_u rust_nurbs.bezier_surf_dsdv_dp_iso_v rust_nurbs.bezier_surf_d2sdu2_dp_iso_u rust_nurbs.bezier_surf_d2sdu2_dp_iso_v rust_nurbs.bezier_surf_d2sdv2_dp_iso_u rust_nurbs.bezier_surf_d2sdv2_dp_iso_v rust_nurbs.bezier_surf_eval_dp_grid rust_nurbs.bezier_surf_dsdu_dp_grid rust_nurbs.bezier_surf_dsdv_dp_grid rust_nurbs.bezier_surf_d2sdu2_dp_grid rust_nurbs.bezier_surf_d2sdv2_dp_grid rust_nurbs.bezier_surf_eval_iso_u rust_nurbs.bezier_surf_eval_iso_v rust_nurbs.bezier_surf_dsdu_iso_u rust_nurbs.bezier_surf_dsdu_iso_v rust_nurbs.bezier_surf_dsdv_iso_u rust_nurbs.bezier_surf_dsdv_iso_v rust_nurbs.bezier_surf_d2sdu2_iso_u rust_nurbs.bezier_surf_d2sdu2_iso_v rust_nurbs.bezier_surf_d2sdv2_iso_u rust_nurbs.bezier_surf_d2sdv2_iso_v rust_nurbs.bezier_surf_eval_grid rust_nurbs.bezier_surf_dsdu_grid rust_nurbs.bezier_surf_dsdv_grid rust_nurbs.bezier_surf_d2sdu2_grid rust_nurbs.bezier_surf_d2sdv2_grid rust_nurbs.bezier_surf_eval_uvvecs rust_nurbs.bezier_surf_dsdu_uvvecs rust_nurbs.bezier_surf_dsdv_uvvecs rust_nurbs.bezier_surf_d2sdu2_uvvecs rust_nurbs.bezier_surf_d2sdv2_uvvecs rust_nurbs.rational_bezier_curve_eval rust_nurbs.rational_bezier_curve_eval_dp rust_nurbs.rational_bezier_curve_dcdt rust_nurbs.rational_bezier_curve_dcdt_dp rust_nurbs.rational_bezier_curve_d2cdt2 rust_nurbs.rational_bezier_curve_d2cdt2_dp rust_nurbs.rational_bezier_curve_eval_grid rust_nurbs.rational_bezier_curve_eval_dp_grid rust_nurbs.rational_bezier_curve_dcdt_grid rust_nurbs.rational_bezier_curve_dcdt_dp_grid rust_nurbs.rational_bezier_curve_d2cdt2_grid rust_nurbs.rational_bezier_curve_d2cdt2_dp_grid rust_nurbs.rational_bezier_curve_eval_tvec rust_nurbs.rational_bezier_curve_eval_dp_tvec rust_nurbs.rational_bezier_curve_dcdt_tvec rust_nurbs.rational_bezier_curve_dcdt_dp_tvec rust_nurbs.rational_bezier_curve_d2cdt2_tvec rust_nurbs.rational_bezier_curve_d2cdt2_dp_tvec rust_nurbs.rational_bezier_surf_eval rust_nurbs.rational_bezier_surf_dsdu rust_nurbs.rational_bezier_surf_dsdv rust_nurbs.rational_bezier_surf_d2sdu2 rust_nurbs.rational_bezier_surf_d2sdv2 rust_nurbs.rational_bezier_surf_eval_dp rust_nurbs.rational_bezier_surf_dsdu_dp rust_nurbs.rational_bezier_surf_dsdv_dp rust_nurbs.rational_bezier_surf_d2sdu2_dp rust_nurbs.rational_bezier_surf_d2sdv2_dp rust_nurbs.rational_bezier_surf_eval_dp_iso_u rust_nurbs.rational_bezier_surf_eval_dp_iso_v rust_nurbs.rational_bezier_surf_dsdu_dp_iso_u rust_nurbs.rational_bezier_surf_dsdu_dp_iso_v rust_nurbs.rational_bezier_surf_dsdv_dp_iso_u rust_nurbs.rational_bezier_surf_dsdv_dp_iso_v rust_nurbs.rational_bezier_surf_d2sdu2_dp_iso_u rust_nurbs.rational_bezier_surf_d2sdu2_dp_iso_v rust_nurbs.rational_bezier_surf_d2sdv2_dp_iso_u rust_nurbs.rational_bezier_surf_d2sdv2_dp_iso_v rust_nurbs.rational_bezier_surf_eval_dp_grid rust_nurbs.rational_bezier_surf_dsdu_dp_grid rust_nurbs.rational_bezier_surf_dsdv_dp_grid rust_nurbs.rational_bezier_surf_d2sdu2_dp_grid rust_nurbs.rational_bezier_surf_d2sdv2_dp_grid rust_nurbs.rational_bezier_surf_eval_iso_u rust_nurbs.rational_bezier_surf_eval_iso_v rust_nurbs.rational_bezier_surf_dsdu_iso_u rust_nurbs.rational_bezier_surf_dsdu_iso_v rust_nurbs.rational_bezier_surf_dsdv_iso_u rust_nurbs.rational_bezier_surf_dsdv_iso_v rust_nurbs.rational_bezier_surf_d2sdu2_iso_u rust_nurbs.rational_bezier_surf_d2sdu2_iso_v rust_nurbs.rational_bezier_surf_d2sdv2_iso_u rust_nurbs.rational_bezier_surf_d2sdv2_iso_v rust_nurbs.rational_bezier_surf_eval_grid rust_nurbs.rational_bezier_surf_dsdu_grid rust_nurbs.rational_bezier_surf_dsdv_grid rust_nurbs.rational_bezier_surf_d2sdu2_grid rust_nurbs.rational_bezier_surf_d2sdv2_grid rust_nurbs.rational_bezier_surf_eval_uvvecs rust_nurbs.rational_bezier_surf_dsdu_uvvecs rust_nurbs.rational_bezier_surf_dsdv_uvvecs rust_nurbs.rational_bezier_surf_d2sdu2_uvvecs rust_nurbs.rational_bezier_surf_d2sdv2_uvvecs rust_nurbs.bspline_curve_eval rust_nurbs.bspline_curve_eval_dp rust_nurbs.bspline_curve_dcdt rust_nurbs.bspline_curve_dcdt_dp rust_nurbs.bspline_curve_d2cdt2 rust_nurbs.bspline_curve_d2cdt2_dp rust_nurbs.bspline_curve_eval_grid rust_nurbs.bspline_curve_eval_dp_grid rust_nurbs.bspline_curve_dcdt_grid rust_nurbs.bspline_curve_dcdt_dp_grid rust_nurbs.bspline_curve_d2cdt2_grid rust_nurbs.bspline_curve_d2cdt2_dp_grid rust_nurbs.bspline_curve_eval_tvec rust_nurbs.bspline_curve_eval_dp_tvec rust_nurbs.bspline_curve_dcdt_tvec rust_nurbs.bspline_curve_dcdt_dp_tvec rust_nurbs.bspline_curve_d2cdt2_tvec rust_nurbs.bspline_curve_d2cdt2_dp_tvec rust_nurbs.bspline_surf_eval rust_nurbs.bspline_surf_dsdu rust_nurbs.bspline_surf_dsdv rust_nurbs.bspline_surf_d2sdu2 rust_nurbs.bspline_surf_d2sdv2 rust_nurbs.bspline_surf_eval_dp rust_nurbs.bspline_surf_dsdu_dp rust_nurbs.bspline_surf_dsdv_dp rust_nurbs.bspline_surf_d2sdu2_dp rust_nurbs.bspline_surf_d2sdv2_dp rust_nurbs.bspline_surf_eval_iso_u rust_nurbs.bspline_surf_eval_iso_v rust_nurbs.bspline_surf_dsdu_iso_u rust_nurbs.bspline_surf_dsdu_iso_v rust_nurbs.bspline_surf_dsdv_iso_u rust_nurbs.bspline_surf_dsdv_iso_v rust_nurbs.bspline_surf_d2sdu2_iso_u rust_nurbs.bspline_surf_d2sdu2_iso_v rust_nurbs.bspline_surf_d2sdv2_iso_u rust_nurbs.bspline_surf_d2sdv2_iso_v rust_nurbs.bspline_surf_eval_dp_iso_u rust_nurbs.bspline_surf_eval_dp_iso_v rust_nurbs.bspline_surf_dsdu_dp_iso_u rust_nurbs.bspline_surf_dsdu_dp_iso_v rust_nurbs.bspline_surf_dsdv_dp_iso_u rust_nurbs.bspline_surf_dsdv_dp_iso_v rust_nurbs.bspline_surf_d2sdu2_dp_iso_u rust_nurbs.bspline_surf_d2sdu2_dp_iso_v rust_nurbs.bspline_surf_d2sdv2_dp_iso_u rust_nurbs.bspline_surf_d2sdv2_dp_iso_v rust_nurbs.bspline_surf_eval_grid rust_nurbs.bspline_surf_dsdu_grid rust_nurbs.bspline_surf_dsdv_grid rust_nurbs.bspline_surf_d2sdu2_grid rust_nurbs.bspline_surf_d2sdv2_grid rust_nurbs.bspline_surf_eval_uvvecs rust_nurbs.bspline_surf_dsdu_uvvecs rust_nurbs.bspline_surf_dsdv_uvvecs rust_nurbs.bspline_surf_d2sdu2_uvvecs rust_nurbs.bspline_surf_d2sdv2_uvvecs rust_nurbs.bspline_surf_eval_dp_grid rust_nurbs.bspline_surf_dsdu_dp_grid rust_nurbs.bspline_surf_dsdv_dp_grid rust_nurbs.bspline_surf_d2sdu2_dp_grid rust_nurbs.bspline_surf_d2sdv2_dp_grid rust_nurbs.bspline_surf_eval_dp_uvvecs rust_nurbs.bspline_surf_dsdu_dp_uvvecs rust_nurbs.bspline_surf_dsdv_dp_uvvecs rust_nurbs.bspline_surf_d2sdu2_dp_uvvecs rust_nurbs.bspline_surf_d2sdv2_dp_iuvvecs rust_nurbs.nurbs_curve_eval rust_nurbs.nurbs_curve_eval_dp rust_nurbs.nurbs_curve_dcdt rust_nurbs.nurbs_curve_dcdt_dp rust_nurbs.nurbs_curve_d2cdt2 rust_nurbs.nurbs_curve_d2cdt2_dp rust_nurbs.nurbs_curve_eval_grid rust_nurbs.nurbs_curve_eval_dp_grid rust_nurbs.nurbs_curve_dcdt_grid rust_nurbs.nurbs_curve_dcdt_dp_grid rust_nurbs.nurbs_curve_d2cdt2_grid rust_nurbs.nurbs_curve_d2cdt2_dp_grid rust_nurbs.nurbs_curve_eval_tvec rust_nurbs.nurbs_curve_eval_dp_tvec rust_nurbs.nurbs_curve_dcdt_tvec rust_nurbs.nurbs_curve_dcdt_dp_tvec rust_nurbs.nurbs_curve_d2cdt2_tvec rust_nurbs.nurbs_curve_d2cdt2_dp_tvec rust_nurbs.nurbs_surf_eval rust_nurbs.nurbs_surf_dsdu rust_nurbs.nurbs_surf_dsdv rust_nurbs.nurbs_surf_d2sdu2 rust_nurbs.nurbs_surf_d2sdv2 rust_nurbs.nurbs_surf_eval_iso_u rust_nurbs.nurbs_surf_eval_iso_v rust_nurbs.nurbs_surf_dsdu_iso_u rust_nurbs.nurbs_surf_dsdu_iso_v rust_nurbs.nurbs_surf_dsdv_iso_u rust_nurbs.nurbs_surf_dsdv_iso_v rust_nurbs.nurbs_surf_d2sdu2_iso_u rust_nurbs.nurbs_surf_d2sdu2_iso_v rust_nurbs.nurbs_surf_d2sdv2_iso_u rust_nurbs.nurbs_surf_d2sdv2_iso_v rust_nurbs.nurbs_surf_eval_grid rust_nurbs.nurbs_surf_dsdu_grid rust_nurbs.nurbs_surf_dsdv_grid rust_nurbs.nurbs_surf_d2sdu2_grid rust_nurbs.nurbs_surf_d2sdv2_grid rust_nurbs.nurbs_surf_eval_uvvecs rust_nurbs.nurbs_surf_dsdu_uvvecs rust_nurbs.nurbs_surf_dsdv_uvvecs rust_nurbs.nurbs_surf_d2sdu2_uvvecs rust_nurbs.nurbs_surf_d2sdv2_uvvecs Module Contents --------------- .. py:function:: bernstein_poly(n: int, i: int, t: float) -> float Evaluates the Bernstein polynomial at a single :math:`t`-value. The Bernstein polynomial is given by .. math:: B_{i,n}(t)={n \choose i} t^i (1-t)^{n-i} :param n: Degree of the polynomial :type n: int :param i: Index :type i: int :param t: Parameter value :math:`t` at which to evaluate :type t: float :returns: Value of the Bernstein polynomial at :math:`t` :rtype: float .. py:function:: bezier_curve_eval(p: Iterable[Iterable[float]], t: float) -> List[float] Evaluates a Bézier curve with :math:`n+1` control points at a single :math:`t`-value according to .. math:: \mathbf{C}(t) = \sum\limits_{i=0}^n B_{i,n}(t) \mathbf{P}_i where :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param t: Parameter value :math:`t` at which to evaluate :type t: float :returns: Value of the Bézier curve at :math:`t`. Has the same size as the inner dimension of ``p`` :rtype: List[float] .. py:function:: bezier_curve_eval_dp(i: int, n: int, dim: int, t: float) -> List[float] Evaluates the derivative of the Bézier curve with respect to an individual control point at a given :math:`t`-value :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter value at which to evaluate the curve sensitivity :type t: float :returns: 1-D list representing the curve sensitivity at :math:`t` to the control point :math:`\mathbf{P}_i` :rtype: List[float] .. py:function:: bezier_curve_dcdt(p: Iterable[Iterable[float]], t: float) -> List[float] Evaluates the first derivative (with respect to :math:`t`) of a Bézier curve with :math:`n+1` control points at a single :math:`t`-value according to .. math:: \frac{\text{d}}{\text{d}t} \mathbf{C}(t) = \sum\limits_{i=0}^{n-1} B_{i,n-1}(t) \left[n\left( \mathbf{P}_{i+1} - \mathbf{P}_i \right)\right] where :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param t: Parameter value :math:`t` at which to evaluate :type t: float :returns: Value of the Bézier curve first derivative at :math:`t`. Has the same size as the inner dimension of ``p`` :rtype: List[float] .. py:function:: bezier_curve_dcdt_dp(i: int, n: int, dim: int, t: float) -> List[float] Evaluates the derivative of the Bézier curve first derivative with respect to an individual control point :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter value at which to evaluate the curve derivative sensitivity :type t: float :returns: 1-D list representing the curve derivative sensitivity at :math:`t` to the control point :math:`\mathbf{P}_i` :rtype: List[float] .. py:function:: bezier_curve_d2cdt2(p: Iterable[Iterable[float]], t: float) -> List[float] Evaluates the second derivative (with respect to :math:`t`) of a Bézier curve with :math:`n+1` control points at a single :math:`t`-value according to .. math:: \frac{\text{d}^2}{\text{d}t^2} \mathbf{C}(t) = \sum\limits_{i=0}^{n-2} B_{i,n-2}(t) \left[n(n-1)\left(\mathbf{P}_{i+2} - 2 \mathbf{P}_{i+1} + \mathbf{P}_i \right)\right] where :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param t: Parameter value :math:`t` at which to evaluate :type t: float :returns: Value of the Bézier curve first derivative at :math:`t`. Has the same size as the inner dimension of ``p`` :rtype: List[float] .. py:function:: bezier_curve_d2cdt2_dp(i: int, n: int, dim: int, t: float) -> List[float] Evaluates the derivative of the Bézier curve second derivative with respect to an individual control point :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter value at which to evaluate the curve derivative sensitivity :type t: float :returns: 1-D list representing the curve derivative sensitivity at :math:`t` to the control point :math:`\mathbf{P}_i` :rtype: List[float] .. py:function:: bezier_curve_eval_grid(p: Iterable[Iterable[float]], nt: int) -> List[List[float]] Evaluates a Bézier curve with :math:`n+1` control points at :math:`N_t` linearly-spaced points according to .. math:: \mathbf{C}(t) = \sum\limits_{i=0}^n B_{i,n}(t) \mathbf{P}_i where :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the Bézier curve at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_curve_eval_dp_grid(i: int, n: int, dim: int, nt: int) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a Bézier curve with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the control point sensitivity of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the Bézier curve control point sensitivity at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: bezier_curve_dcdt_grid(p: Iterable[Iterable[float]], nt: int) -> List[List[float]] Evaluates the first derivative (with respect to :math:`t`) of a Bézier curve with :math:`n+1` control points at :math:`N_t` linearly-spaced points according to .. math:: \frac{\text{d}}{\text{d}t} \mathbf{C}(t) = \sum\limits_{i=0}^{n-1} B_{i,n-1}(t) \left[n\left( \mathbf{P}_{i+1} - \mathbf{P}_i \right)\right] where :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the Bézier curve first derivative at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_curve_dcdt_dp_grid(i: int, n: int, dim: int, nt: int) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a Bézier curve first derivative with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the control point sensitivity of the curve first derivative at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the Bézier curve first derivative control point sensitivity at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: bezier_curve_d2cdt2_grid(p: Iterable[Iterable[float]], nt: int) -> List[List[float]] Evaluates the second derivative (with respect to :math:`t`) of a Bézier curve with :math:`n+1` control points at :math:`N_t` linearly-spaced points according to .. math:: \frac{\text{d}^2}{\text{d}t^2} \mathbf{C}(t) = \sum\limits_{i=0}^{n-2} B_{i,n-2}(t) \left[n(n-1)\left(\mathbf{P}_{i+2} - 2 \mathbf{P}_{i+1} + \mathbf{P}_i \right)\right] where :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the Bézier curve first derivative at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_curve_d2cdt2_dp_grid(i: int, n: int, dim: int, nt: int) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a Bézier curve second derivative with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the control point sensitivity of the curve second derivative at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the Bézier curve second derivative control point sensitivity at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: bezier_curve_eval_tvec(p: Iterable[Iterable[float]], t: Iterable[float]) -> List[List[float]] Evaluates a Bézier curve with :math:`n+1` control points along a vector of :math:`t`-values according to .. math:: \mathbf{C}(t) = \sum\limits_{i=0}^n B_{i,n}(t) \mathbf{P}_i where :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param t: Parameter vector along which to evaluate the curve :type t: Iterable[float] :returns: Value of the Bézier curve along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_curve_eval_dp_tvec(i: int, n: int, dim: int, t: Iterable[float]) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a Bézier curve with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter vector along which to evaluate the curve control point sensitivity :type t: Iterable[float] :returns: Value of the Bézier curve control point sensitivity along parameter vector :math:`\mathbf{t}`. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: bezier_curve_dcdt_tvec(p: Iterable[Iterable[float]], t: Iterable[float]) -> List[List[float]] Evaluates the first derivative (with respect to :math:`t`) of a Bézier curve with :math:`n+1` control points along a vector of :math:`t`-values according to .. math:: \frac{\text{d}}{\text{d}t} \mathbf{C}(t) = \sum\limits_{i=0}^{n-1} B_{i,n-1}(t) \left[n\left( \mathbf{P}_{i+1} - \mathbf{P}_i \right)\right] where :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param t: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type t: Iterable[float] :returns: Value of the Bézier curve first derivative along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_curve_dcdt_dp_tvec(i: int, n: int, dim: int, t: Iterable[float]) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a Bézier curve first derivative with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter vector along which to evaluate the curve first derivative control point sensitivity :type t: Iterable[float] :returns: Value of the Bézier curve first derivative control point sensitivity along parameter vector :math:`\mathbf{t}`. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: bezier_curve_d2cdt2_tvec(p: Iterable[Iterable[float]], t: Iterable[float]) -> List[List[float]] Evaluates the second derivative (with respect to :math:`t`) of a Bézier curve with :math:`n+1` control points along a vector of :math:`t`-values according to .. math:: \frac{\text{d}^2}{\text{d}t^2} \mathbf{C}(t) = \sum\limits_{i=0}^{n-2} B_{i,n-2}(t) \left[n(n-1)\left(\mathbf{P}_{i+2} - 2 \mathbf{P}_{i+1} + \mathbf{P}_i \right)\right] where :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param t: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type t: Iterable[float] :returns: Value of the Bézier curve first derivative along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_curve_d2cdt2_dp_tvec(i: int, n: int, dim: int, t: Iterable[float]) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a Bézier curve second derivative with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter vector along which to evaluate the curve second derivative control point sensitivity :type t: Iterable[float] :returns: Value of the Bézier curve second derivative control point sensitivity along parameter vector :math:`\mathbf{t}`. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: bezier_surf_eval(p: Iterable[Iterable[Iterable[float]]], u: float, v: float) -> List[float] Evaluates a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair according to .. math:: \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m B_{i,n}(u) B_{j,m}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the Bézier surface at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: bezier_surf_dsdu(p: Iterable[Iterable[Iterable[float]]], u: float, v: float) -> List[float] Evaluates the first derivative with respect to :math:`u` of a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair according to .. math:: \frac{\text{d}}{\text{d}u} \mathbf{S}(u,v) = n \sum\limits_{i=0}^n \sum\limits_{j=0}^m \left[ B_{i - 1,n - 1}(u) - B_{i,n - 1}(u) \right] B_{j,m}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the Bézier surface first derivative with respect to :math:`u` at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: bezier_surf_dsdv(p: Iterable[Iterable[Iterable[float]]], u: float, v: float) -> List[float] Evaluates the first derivative with respect to :math:`v` of a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair according to .. math:: \frac{\text{d}}{\text{d}v} \mathbf{S}(u,v) = m \sum\limits_{i=0}^n \sum\limits_{j=0}^m B_{i,n}(u) \left[ B_{j - 1,m - 1}(v) - B_{j,m - 1}(v) \right] \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the Bézier surface first derivative with respect to :math:`v` at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: bezier_surf_d2sdu2(p: Iterable[Iterable[Iterable[float]]], u: float, v: float) -> List[float] Evaluates the second derivative with respect to :math:`u` of a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair according to .. math:: \frac{\text{d}^2}{\text{d}u^2} \mathbf{S}(u,v) = n(n-1) \sum\limits_{i=0}^n \sum\limits_{j=0}^m \left[ B_{i - 2,n - 2}(u) - 2B_{i - 1,n - 2}(u) + B_{i,n - 2}(u) \right] B_{j,m}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the Bézier surface second derivative with respect to :math:`u` at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: bezier_surf_d2sdv2(p: Iterable[Iterable[Iterable[float]]], u: float, v: float) -> List[float] Evaluates the first derivative with respect to :math:`v` of a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair according to .. math:: \frac{\text{d}^2}{\text{d}v^2} \mathbf{S}(u,v) = m(m - 1) \sum\limits_{i=0}^n \sum\limits_{j=0}^m B_{i,n}(u) \left[ B_{j - 2,m - 2}(v) - 2B_{j - 1,m - 2}(v) - B_{j,m - 2}(v) \right] \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the Bézier surface second derivative with respect to :math:`v` at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: bezier_surf_eval_dp(i: int, j: int, n: int, m: int, dim: int, u: float, v: float) -> List[float] Evaluates the derivative of the Bézier surface with respect to an individual control point at a given :math:`(u,v)`-pair: .. math:: \frac{\partial}{\partial \mathbf{P}_{i,j}} \mathbf{S}(u,v) = B_{i,n}(u) B_{j,m}(v) :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 1-D list representing the surface sensitivity at :math:`(u,v)` to the control point :math:`\mathbf{P}_{i,j}` :rtype: List[float] .. py:function:: bezier_surf_dsdu_dp(i: int, j: int, n: int, m: int, dim: int, u: float, v: float) -> List[float] Evaluates the derivative of the Bézier surface first :math:`u`-derivative with respect to an individual control point at a given :math:`(u,v)`-pair: .. math:: \frac{\partial}{\partial \mathbf{P}_{i,j}} \left(\partial \frac{\mathbf{S}(u,v)}{\partial u} \right) = n \left[ B_{i - 1,n - 1}(u) - B_{i,n - 1}(u) \right] B_{j,m}(v) :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 1-D list representing the surface derivative sensitivity at :math:`(u,v)` to the control point :math:`\mathbf{P}_{i,j}` :rtype: List[float] .. py:function:: bezier_surf_dsdv_dp(i: int, j: int, n: int, m: int, dim: int, u: float, v: float) -> List[float] Evaluates the derivative of the Bézier surface first :math:`v`-derivative with respect to an individual control point at a given :math:`(u,v)`-pair: .. math:: \frac{\partial}{\partial \mathbf{P}_{i,j}} \left(\partial \frac{\mathbf{S}(u,v)}{\partial v} \right) = m B_{i,n}(u) \left[ B_{j - 1,m - 1}(v) - B_{j,m - 1}(v) \right] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 1-D list representing the surface derivative sensitivity at :math:`(u,v)` to the control point :math:`\mathbf{P}_{i,j}` :rtype: List[float] .. py:function:: bezier_surf_d2sdu2_dp(i: int, j: int, n: int, m: int, dim: int, u: float, v: float) -> List[float] Evaluates the derivative of the Bézier surface second :math:`u`-derivative with respect to an individual control point at a given :math:`(u,v)`-pair: .. math:: \frac{\partial}{\partial \mathbf{P}_{i,j}} \left(\partial^2 \frac{\mathbf{S}(u,v)}{\partial u^2} \right) = n (n-1) \left[ B_{i - 2,n - 2}(u) - 2B_{i - 1,n - 2}(u) + B_{i,n - 2}(u) \right] B_{j,m}(v) :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 1-D list representing the surface derivative sensitivity at :math:`(u,v)` to the control point :math:`\mathbf{P}_{i,j}` :rtype: List[float] .. py:function:: bezier_surf_d2sdv2_dp(i: int, j: int, n: int, m: int, dim: int, u: float, v: float) -> List[float] Evaluates the derivative of the Bézier surface second :math:`v`-derivative with respect to an individual control point at a given :math:`(u,v)`-pair: .. math:: \frac{\partial}{\partial \mathbf{P}_{i,j}} \left(\partial^2 \frac{\mathbf{S}(u,v)}{\partial v^2} \right) = m (m-1) B_{i,n}(u) \left[ B_{j - 2,m - 2}(v) - 2B_{j - 1,m - 2}(v) - B_{j,m - 2}(v) \right] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 1-D list representing the surface derivative sensitivity at :math:`(u,v)` to the control point :math:`\mathbf{P}_{i,j}` :rtype: List[float] .. py:function:: bezier_surf_eval_dp_iso_u(i: int, j: int, n: int, m: int, dim: int, u: float, nv: int) -> List[List[float]] Evaluates the derivative of the Bézier surface with respect to an individual control point along a :math:`u`-isoparametric curve :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface sensitiviies :type nv: int :returns: 2-D array of size :math:`N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bezier_surf_eval_dp_iso_v(i: int, j: int, n: int, m: int, dim: int, nu: int, v: float) -> List[List[float]] Evaluates the derivative of the Bézier surface with respect to an individual control point along a :math:`v`-isoparametric curve :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface sensitivities :type nu: int :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 2-D array of size :math:`N_u \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bezier_surf_dsdu_dp_iso_u(i: int, j: int, n: int, m: int, dim: int, u: float, nv: int) -> List[List[float]] Evaluates the derivative of the Bézier surface first :math:`u`-derivative with respect to an individual control point along a :math:`u`-isoparametric curve :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface sensitiviies :type nv: int :returns: 2-D array of size :math:`N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bezier_surf_dsdu_dp_iso_v(i: int, j: int, n: int, m: int, dim: int, nu: int, v: float) -> List[List[float]] Evaluates the derivative of the Bézier surface first :math:`u`-derivative with respect to an individual control point along a :math:`v`-isoparametric curve :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface sensitivities :type nu: int :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 2-D array of size :math:`N_u \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bezier_surf_dsdv_dp_iso_u(i: int, j: int, n: int, m: int, dim: int, u: float, nv: int) -> List[List[float]] Evaluates the derivative of the Bézier surface first :math:`v`-derivative with respect to an individual control point along a :math:`u`-isoparametric curve :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface sensitiviies :type nv: int :returns: 2-D array of size :math:`N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bezier_surf_dsdv_dp_iso_v(i: int, j: int, n: int, m: int, dim: int, nu: int, v: float) -> List[List[float]] Evaluates the derivative of the Bézier surface first :math:`v`-derivative with respect to an individual control point along a :math:`v`-isoparametric curve :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface sensitivities :type nu: int :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 2-D array of size :math:`N_u \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bezier_surf_d2sdu2_dp_iso_u(i: int, j: int, n: int, m: int, dim: int, u: float, nv: int) -> List[List[float]] Evaluates the derivative of the Bézier surface second :math:`u`-derivative with respect to an individual control point along a :math:`u`-isoparametric curve :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface sensitiviies :type nv: int :returns: 2-D array of size :math:`N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bezier_surf_d2sdu2_dp_iso_v(i: int, j: int, n: int, m: int, dim: int, nu: int, v: float) -> List[List[float]] Evaluates the derivative of the Bézier surface second :math:`u`-derivative with respect to an individual control point along a :math:`v`-isoparametric curve :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface sensitivities :type nu: int :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 2-D array of size :math:`N_u \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bezier_surf_d2sdv2_dp_iso_u(i: int, j: int, n: int, m: int, dim: int, u: float, nv: int) -> List[List[float]] Evaluates the derivative of the Bézier surface second :math:`v`-derivative with respect to an individual control point along a :math:`u`-isoparametric curve :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface sensitiviies :type nv: int :returns: 2-D array of size :math:`N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bezier_surf_d2sdv2_dp_iso_v(i: int, j: int, n: int, m: int, dim: int, nu: int, v: float) -> List[List[float]] Evaluates the derivative of the Bézier surface second :math:`v`-derivative with respect to an individual control point along a :math:`v`-isoparametric curve :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface sensitivities :type nu: int :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 2-D array of size :math:`N_u \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bezier_surf_eval_dp_grid(i: int, j: int, n: int, m: int, dim: int, nu: int, nv: int) -> List[List[List[float]]] Evaluates the derivative of the Bézier surface with respect to an individual control point on a :math:`(u,v)` grid :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface sensitiviies :type nu: int :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface sensitiviies :type nv: int :returns: 3-D array of size :math:`N_u \times N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: bezier_surf_dsdu_dp_grid(i: int, j: int, n: int, m: int, dim: int, nu: int, nv: int) -> List[List[List[float]]] Evaluates the derivative of the Bézier surface first :math:`u`-derivative with respect to an individual control point on a :math:`(u,v)` grid :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface derivative sensitiviies :type nu: int :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface derivative sensitiviies :type nv: int :returns: 3-D array of size :math:`N_u \times N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: bezier_surf_dsdv_dp_grid(i: int, j: int, n: int, m: int, dim: int, nu: int, nv: int) -> List[List[List[float]]] Evaluates the derivative of the Bézier surface first :math:`v`-derivative with respect to an individual control point on a :math:`(u,v)` grid :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface derivative sensitiviies :type nu: int :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface derivative sensitiviies :type nv: int :returns: 3-D array of size :math:`N_u \times N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: bezier_surf_d2sdu2_dp_grid(i: int, j: int, n: int, m: int, dim: int, nu: int, nv: int) -> List[List[List[float]]] Evaluates the derivative of the Bézier surface second :math:`u`-derivative with respect to an individual control point on a :math:`(u,v)` grid :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface derivative sensitiviies :type nu: int :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface derivative sensitiviies :type nv: int :returns: 3-D array of size :math:`N_u \times N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: bezier_surf_d2sdv2_dp_grid(i: int, j: int, n: int, m: int, dim: int, nu: int, nv: int) -> List[List[List[float]]] Evaluates the derivative of the Bézier surface second :math:`v`-derivative with respect to an individual control point on a :math:`(u,v)` grid :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface derivative sensitiviies :type nu: int :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface derivative sensitiviies :type nv: int :returns: 3-D array of size :math:`N_u \times N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: bezier_surf_eval_iso_u(p: Iterable[Iterable[Iterable[float]]], u: float, nv: int) -> List[List[float]] Evaluates an isoparametric curve in :math:`u` of a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction according to .. math:: \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m B_{i,n}(u) B_{j,m}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` points along the :math:`u`-isoparametric curve of the Bézier surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_surf_eval_iso_v(p: Iterable[Iterable[Iterable[float]]], nu: int, v: float) -> List[List[float]] Evaluates an isoparametric curve in :math:`v` of a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u` linearly-spaced points along the :math:`u`-direction according to .. math:: \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m B_{i,n}(u) B_{j,m}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` points along the :math:`v`-isoparametric curve of the Bézier surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_surf_dsdu_iso_u(p: Iterable[Iterable[Iterable[float]]], u: float, nv: int) -> List[List[float]] Evaluates the first derivative w.r.t. :math:`u` along an isoparametric curve in :math:`u` of a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction according to .. math:: \frac{\text{d}}{\text{d}u} \mathbf{S}(u,v) = n \sum\limits_{i=0}^n \sum\limits_{j=0}^m \left[ B_{i - 1,n - 1}(u) - B_{i,n - 1}(u) \right] B_{j,m}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` first derivatives w.r.t. :math:`u` along the :math:`u`-isoparametric curve of the Bézier surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_surf_dsdu_iso_v(p: Iterable[Iterable[Iterable[float]]], nu: int, v: float) -> List[List[float]] Evaluates the first derivative w.r.t. :math:`u` along an isoparametric curve in :math:`v` of a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u` linearly-spaced points along the :math:`u`-direction according to .. math:: \frac{\text{d}}{\text{d}u} \mathbf{S}(u,v) = n \sum\limits_{i=0}^n \sum\limits_{j=0}^m \left[ B_{i - 1,n - 1}(u) - B_{i,n - 1}(u) \right] B_{j,m}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` first derivatives w.r.t. :math:`u` along the :math:`v`-isoparametric curve of the Bézier surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_surf_dsdv_iso_u(p: Iterable[Iterable[Iterable[float]]], u: float, nv: int) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`v` along an isoparametric curve in :math:`u` of a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction according to .. math:: \frac{\text{d}}{\text{d}v} \mathbf{S}(u,v) = m \sum\limits_{i=0}^n \sum\limits_{j=0}^m B_{i,n}(u) \left[ B_{j - 1,m - 1}(v) - B_{j,m - 1}(v) \right] \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` first derivatives w.r.t. :math:`v` along the :math:`u`-isoparametric curve of the Bézier surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_surf_dsdv_iso_v(p: Iterable[Iterable[Iterable[float]]], nu: int, v: float) -> List[List[float]] Evaluates the first derivative w.r.t. :math:`u` along an isoparametric curve in :math:`v` of a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u` linearly-spaced points along the :math:`u`-direction according to .. math:: \frac{\text{d}}{\text{d}v} \mathbf{S}(u,v) = m \sum\limits_{i=0}^n \sum\limits_{j=0}^m B_{i,n}(u) \left[ B_{j - 1,m - 1}(v) - B_{j,m - 1}(v) \right] \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` first derivatives w.r.t. :math:`u` along the :math:`v`-isoparametric curve of the Bézier surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_surf_d2sdu2_iso_u(p: Iterable[Iterable[Iterable[float]]], u: float, nv: int) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`u` along an isoparametric curve in :math:`u` of a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction according to .. math:: \frac{\text{d}^2}{\text{d}u^2} \mathbf{S}(u,v) = n(n-1) \sum\limits_{i=0}^n \sum\limits_{j=0}^m \left[ B_{i - 2,n - 2} - 2B_{i - 1,n - 2}(u) + B_{i,n - 2}(u) \right] B_{j,m}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` second derivatives w.r.t. :math:`u` along the :math:`u`-isoparametric curve of the Bézier surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_surf_d2sdu2_iso_v(p: Iterable[Iterable[Iterable[float]]], nu: int, v: float) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`u` along an isoparametric curve in :math:`v` of a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u` linearly-spaced points along the :math:`u`-direction according to .. math:: \frac{\text{d}^2}{\text{d}u^2} \mathbf{S}(u,v) = n(n-1) \sum\limits_{i=0}^n \sum\limits_{j=0}^m \left[ B_{i - 2,n - 2} - 2B_{i - 1,n - 2}(u) + B_{i,n - 2}(u) \right] B_{j,m}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` second derivatives w.r.t. :math:`u` along the :math:`v`-isoparametric curve of the Bézier surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_surf_d2sdv2_iso_u(p: Iterable[Iterable[Iterable[float]]], u: float, nv: int) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`v` along an isoparametric curve in :math:`u` of a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction according to .. math:: \frac{\text{d}^2}{\text{d}v^2} \mathbf{S}(u,v) = m(m - 1) \sum\limits_{i=0}^n \sum\limits_{j=0}^m B_{i,n}(u) \left[ B_{j - 2,m - 2} - 2B_{j - 1,m - 2}(v) - B_{j,m - 2}(v) \right] \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` second derivatives w.r.t. :math:`v` along the :math:`u`-isoparametric curve of the Bézier surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_surf_d2sdv2_iso_v(p: Iterable[Iterable[Iterable[float]]], nu: int, v: float) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`u` along an isoparametric curve in :math:`v` of a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u` linearly-spaced points along the :math:`u`-direction according to .. math:: \frac{\text{d}^2}{\text{d}v^2} \mathbf{S}(u,v) = m(m - 1) \sum\limits_{i=0}^n \sum\limits_{j=0}^m B_{i,n}(u) \left[ B_{j - 2,m - 2} - 2B_{j - 1,m - 2}(v) - B_{j,m - 2}(v) \right] \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` second derivatives w.r.t. :math:`u` along the :math:`v`-isoparametric curve of the Bézier surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bezier_surf_eval_grid(p: Iterable[Iterable[Iterable[float]]], nu: int, nv: int) -> List[List[List[float]]] Evaluates a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space according to .. math:: \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m B_{i,n}(u) B_{j,m}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` points on the Bézier surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: bezier_surf_dsdu_grid(p: Iterable[Iterable[Iterable[float]]], nu: int, nv: int) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`u` on a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space according to .. math:: \frac{\text{d}}{\text{d}u} \mathbf{S}(u,v) = n \sum\limits_{i=0}^n \sum\limits_{j=0}^m \left[ B_{i - 1,n - 1}(u) - B_{i,n - 1}(u) \right] B_{j,m}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`u` on the Bézier surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: bezier_surf_dsdv_grid(p: Iterable[Iterable[Iterable[float]]], nu: int, nv: int) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`v` on a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space according to .. math:: \frac{\text{d}}{\text{d}v} \mathbf{S}(u,v) = m \sum\limits_{i=0}^n \sum\limits_{j=0}^m B_{i,n}(u) \left[ B_{j - 1,m - 1}(v) - B_{j,m - 1}(v) \right] \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`v` on the Bézier surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: bezier_surf_d2sdu2_grid(p: Iterable[Iterable[Iterable[float]]], nu: int, nv: int) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`u` on a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space according to .. math:: \frac{\text{d}^2}{\text{d}u^2} \mathbf{S}(u,v) = n(n-1) \sum\limits_{i=0}^n \sum\limits_{j=0}^m \left[ B_{i - 2,n - 2} - 2B_{i - 1,n - 2}(u) + B_{i,n - 2}(u) \right] B_{j,m}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`u` on the Bézier surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: bezier_surf_d2sdv2_grid(p: Iterable[Iterable[Iterable[float]]], nu: int, nv: int) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`v` on a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space according to .. math:: \frac{\text{d}^2}{\text{d}v^2} \mathbf{S}(u,v) = m(m - 1) \sum\limits_{i=0}^n \sum\limits_{j=0}^m B_{i,n}(u) \left[ B_{j - 2,m - 2} - 2B_{j - 1,m - 2}(v) - B_{j,m - 2}(v) \right] \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`v` on the Bézier surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: bezier_surf_eval_uvvecs(p: Iterable[Iterable[Iterable[float]]], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs according to .. math:: \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m B_{i,n}(u) B_{j,m}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of points on the Bézier surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: bezier_surf_dsdu_uvvecs(p: Iterable[Iterable[Iterable[float]]], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`u` on a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs according to .. math:: \frac{\text{d}}{\text{d}u} \mathbf{S}(u,v) = n \sum\limits_{i=0}^n \sum\limits_{j=0}^m \left[ B_{i - 1,n - 1}(u) - B_{i,n - 1}(u) \right] B_{j,m}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`u` on the Bézier surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: bezier_surf_dsdv_uvvecs(p: Iterable[Iterable[Iterable[float]]], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`v` on a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs according to .. math:: \frac{\text{d}}{\text{d}v} \mathbf{S}(u,v) = m \sum\limits_{i=0}^n \sum\limits_{j=0}^m B_{i,n}(u) \left[ B_{j - 1,m - 1}(v) - B_{j,m - 1}(v) \right] \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`v` on the Bézier surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: bezier_surf_d2sdu2_uvvecs(p: Iterable[Iterable[Iterable[float]]], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`u` on a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs according to .. math:: \frac{\text{d}^2}{\text{d}u^2} \mathbf{S}(u,v) = n(n-1) \sum\limits_{i=0}^n \sum\limits_{j=0}^m \left[ B_{i - 2,n - 2} - 2B_{i - 1,n - 2}(u) + B_{i,n - 2}(u) \right] B_{j,m}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`u` on the Bézier surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: bezier_surf_d2sdv2_uvvecs(p: Iterable[Iterable[Iterable[float]]], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`v` on a Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs according to .. math:: \frac{\text{d}^2}{\text{d}v^2} \mathbf{S}(u,v) = m(m - 1) \sum\limits_{i=0}^n \sum\limits_{j=0}^m B_{i,n}(u) \left[ B_{j - 2,m - 2} - 2B_{j - 1,m - 2}(v) - B_{j,m - 2}(v) \right] \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`v` on the Bézier surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: rational_bezier_curve_eval(p: Iterable[Iterable[float]], w: Iterable[float], t: float) -> List[float] Evaluates a rational Bézier curve with :math:`n+1` control points at a single :math:`t`-value according to .. math:: \mathbf{C}(t) = \frac{\sum_{i=0}^n B_{i,n}(t) w_i \mathbf{P}_i}{\sum_{i=0}^n B_{i,n}(t) w_i} where :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param t: Parameter value :math:`t` at which to evaluate :type t: float :returns: Value of the rational Bézier curve at :math:`t`. Has the same size as the inner dimension of ``p`` :rtype: List[float] .. py:function:: rational_bezier_curve_eval_dp(w: Iterable[float], i: int, n: int, dim: int, t: float) -> List[float] Evaluates the derivative of the rational Bézier curve with respect to an individual control point at a given :math:`t`-value :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter value at which to evaluate the curve sensitivity :type t: float :returns: 1-D list representing the curve sensitivity at :math:`t` to the control point :math:`\mathbf{P}_i` :rtype: List[float] .. py:function:: rational_bezier_curve_dcdt(p: Iterable[Iterable[float]], w: Iterable[float], t: float) -> List[float] Evaluates the first derivative (with respect to :math:`t`) of a rational Bézier curve with :math:`n+1` control points at a single :math:`t`-value according to .. math:: \frac{\text{d}}{\text{d}t} \mathbf{C}(t) = \frac{f'(t)g(t) - f(t)g'(t)}{g^2(t)} where .. math:: \begin{align} f(t) &= \sum\limits_{i=0}^n B_{i,n}(t) w_i \mathbf{P}_i \\ g(t) &= \sum\limits_{i=0}^n B_{i,n}(t) w_i \\ f'(t) &= n \sum\limits_{i=0}^n \left[ B_{i-1,n-1}(t) - B_{i,n-1}(t) \right] w_i \mathbf{P}_i \\ g'(t) &= n \sum\limits_{i=0}^n \left[ B_{i-1,n-1}(t) - B_{i,n-1}(t) \right] w_i \end{align} and :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param t: Parameter value :math:`t` at which to evaluate :type t: float :returns: Value of the rational Bézier curve first derivative at :math:`t`. Has the same size as the inner dimension of ``p`` :rtype: List[float] .. py:function:: rational_bezier_curve_dcdt_dp(w: Iterable[float], i: int, n: int, dim: int, t: float) -> List[float] Evaluates the sensitivity of the rational Bézier curve first derivative with respect to an individual control point at a given :math:`t`-value :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter value at which to evaluate the curve first derivative sensitivity :type t: float :returns: 1-D list representing the curve first derivative sensitivity at :math:`t` to the control point :math:`\mathbf{P}_i` :rtype: List[float] .. py:function:: rational_bezier_curve_d2cdt2(p: Iterable[Iterable[float]], w: Iterable[float], t: float) -> List[float] Evaluates the second derivative (with respect to :math:`t`) of a rational Bézier curve with :math:`n+1` control points at a single :math:`t`-value according to .. math:: \frac{\text{d}^2}{\text{d}t^2} \mathbf{C}(t) = \frac{f''(t)g^2(t) - f(t)g(t)g''(t) - 2f'(t)g(t)g'(t) + 2f(t)[g'(t)]^2}{g^3(t)} where .. math:: \begin{align} f(t) &= \sum\limits_{i=0}^n B_{i,n}(t) w_i \mathbf{P}_i \\ g(t) &= \sum\limits_{i=0}^n B_{i,n}(t) w_i \\ f'(t) &= n \sum\limits_{i=0}^n \left[ B_{i-1,n-1}(t) - B_{i,n-1}(t) \right] w_i \mathbf{P}_i \\ g'(t) &= n \sum\limits_{i=0}^n \left[ B_{i-1,n-1}(t) - B_{i,n-1}(t) \right] w_i \\ f''(t) &= n (n-1) \sum\limits_{i=0}^n \left[ B_{i-2,n-2}(t) - 2B_{i-1,n-2}(t) + B_{i,n-2}(t) \right] w_i \mathbf{P}_i \\ g''(t) &= n (n-1) \sum\limits_{i=0}^n \left[ B_{i-2,n-2}(t) - 2B_{i-1,n-2}(t) + B_{i,n-2}(t) \right] w_i \end{align} and :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param t: Parameter value :math:`t` at which to evaluate :type t: float :returns: Value of the rational Bézier curve first derivative at :math:`t`. Has the same size as the inner dimension of ``p`` :rtype: List[float] .. py:function:: rational_bezier_curve_d2cdt2_dp(w: Iterable[float], i: int, n: int, dim: int, t: float) -> List[float] Evaluates the sensitivity of the rational Bézier curve second derivative with respect to an individual control point at a given :math:`t`-value :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter value at which to evaluate the curve second derivative sensitivity :type t: float :returns: 1-D list representing the curve second derivative sensitivity at :math:`t` to the control point :math:`\mathbf{P}_i` :rtype: List[float] .. py:function:: rational_bezier_curve_eval_grid(p: Iterable[Iterable[float]], w: Iterable[float], nt: int) -> List[List[float]] Evaluates a rational Bézier curve with :math:`n+1` control points at :math:`N_t` linearly-spaced points according to .. math:: \mathbf{C}(t) = \frac{\sum_{i=0}^n B_{i,n}(t) w_i \mathbf{P}_i}{\sum_{i=0}^n B_{i,n}(t) w_i} where :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the rational Bézier curve at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_curve_eval_dp_grid(w: Iterable[float], i: int, n: int, dim: int, nt: int) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a rational Bézier curve with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the control point sensitivity of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the rational Bézier curve control point sensitivity at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_curve_dcdt_grid(p: Iterable[Iterable[float]], w: Iterable[float], nt: int) -> List[List[float]] Evaluates the first derivative (with respect to :math:`t`) of a rational Bézier curve with :math:`n+1` control points at :math:`N_t` linearly-spaced points according to .. math:: \frac{\text{d}}{\text{d}t} \mathbf{C}(t) = \frac{f'(t)g(t) - f(t)g'(t)}{g^2(t)} where .. math:: \begin{align} f(t) &= \sum\limits_{i=0}^n B_{i,n}(t) w_i \mathbf{P}_i \\ g(t) &= \sum\limits_{i=0}^n B_{i,n}(t) w_i \\ f'(t) &= n \sum\limits_{i=0}^n \left[ B_{i-1,n-1}(t) - B_{i,n-1}(t) \right] w_i \mathbf{P}_i \\ g'(t) &= n \sum\limits_{i=0}^n \left[ B_{i-1,n-1}(t) - B_{i,n-1}(t) \right] w_i \end{align} and :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the rational Bézier curve first derivative at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_curve_dcdt_dp_grid(w: Iterable[float], i: int, n: int, dim: int, nt: int) -> List[List[float]] Evaluates the first derivative sensitivity with respect to an individual control point of a rational Bézier curve with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the first derivative control point sensitivity of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the rational Bézier curve first derivative control point sensitivity at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_curve_d2cdt2_grid(p: Iterable[Iterable[float]], w: Iterable[float], nt: int) -> List[List[float]] Evaluates the second derivative (with respect to :math:`t`) of a rational Bézier curve with :math:`n+1` control points at :math:`N_t` linearly-spaced points according to where .. math:: \begin{align} f(t) &= \sum\limits_{i=0}^n B_{i,n}(t) w_i \mathbf{P}_i \\ g(t) &= \sum\limits_{i=0}^n B_{i,n}(t) w_i \\ f'(t) &= n \sum\limits_{i=0}^n \left[ B_{i-1,n-1}(t) - B_{i,n-1}(t) \right] w_i \mathbf{P}_i \\ g'(t) &= n \sum\limits_{i=0}^n \left[ B_{i-1,n-1}(t) - B_{i,n-1}(t) \right] w_i \\ f''(t) &= n (n-1) \sum\limits_{i=0}^n \left[ B_{i-2,n-2}(t) - 2B_{i-1,n-2}(t) + B_{i,n-2}(t) \right] w_i \mathbf{P}_i \\ g''(t) &= n (n-1) \sum\limits_{i=0}^n \left[ B_{i-2,n-2}(t) - 2B_{i-1,n-2}(t) + B_{i,n-2}(t) \right] w_i \end{align} and :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the rational Bézier curve first derivative at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_curve_d2cdt2_dp_grid(w: Iterable[float], i: int, n: int, dim: int, nt: int) -> List[List[float]] Evaluates the second derivative sensitivity with respect to an individual control point of a rational Bézier curve with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the second derivative control point sensitivity of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the rational Bézier curve second derivative control point sensitivity at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_curve_eval_tvec(p: Iterable[Iterable[float]], w: Iterable[float], t: Iterable[float]) -> List[List[float]] Evaluates a rational Bézier curve with :math:`n+1` control points along a vector of :math:`t`-values according to .. math:: \mathbf{C}(t) = \frac{\sum_{i=0}^n B_{i,n}(t) w_i \mathbf{P}_i}{\sum_{i=0}^n B_{i,n}(t) w_i} where :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param t: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type t: Iterable[float] :returns: Value of the rational Bézier curve along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_curve_eval_dp_tvec(w: Iterable[float], i: int, n: int, dim: int, t: Iterable[float]) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a rational Bézier curve with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter vector along which to evaluate the curve control point sensitivity :type t: Iterable[float] :returns: Value of the rational Bézier curve control point sensitivity along parameter vector :math:`\mathbf{t}`. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_curve_dcdt_tvec(p: Iterable[Iterable[float]], w: Iterable[float], t: Iterable[float]) -> List[List[float]] Evaluates the first derivative (with respect to :math:`t`) of a rational Bézier curve with :math:`n+1` control points along a vector of :math:`t`-values according to .. math:: \frac{\text{d}}{\text{d}t} \mathbf{C}(t) = \frac{f'(t)g(t) - f(t)g'(t)}{g^2(t)} where .. math:: \begin{align} f(t) &= \sum\limits_{i=0}^n B_{i,n}(t) w_i \mathbf{P}_i \\ g(t) &= \sum\limits_{i=0}^n B_{i,n}(t) w_i \\ f'(t) &= n \sum\limits_{i=0}^n \left[ B_{i-1,n-1}(t) - B_{i,n-1}(t) \right] w_i \mathbf{P}_i \\ g'(t) &= n \sum\limits_{i=0}^n \left[ B_{i-1,n-1}(t) - B_{i,n-1}(t) \right] w_i \end{align} and :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param t: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type t: Iterable[float] :returns: Value of the rational Bézier curve first derivative along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_curve_dcdt_dp_tvec(w: Iterable[float], i: int, n: int, dim: int, t: Iterable[float]) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a rational Bézier curve first derivative with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter vector along which to evaluate the curve first derivative control point sensitivity :type t: Iterable[float] :returns: Value of the rational Bézier curve first derivative control point sensitivity along parameter vector :math:`\mathbf{t}`. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_curve_d2cdt2_tvec(p: Iterable[Iterable[float]], w: Iterable[float], t: Iterable[float]) -> List[List[float]] Evaluates the second derivative (with respect to :math:`t`) of a rational Bézier curve with :math:`n+1` control points along a vector of :math:`t`-values according to where .. math:: \begin{align} f(t) &= \sum\limits_{i=0}^n B_{i,n}(t) w_i \mathbf{P}_i \\ g(t) &= \sum\limits_{i=0}^n B_{i,n}(t) w_i \\ f'(t) &= n \sum\limits_{i=0}^n \left[ B_{i-1,n-1}(t) - B_{i,n-1}(t) \right] w_i \mathbf{P}_i \\ g'(t) &= n \sum\limits_{i=0}^n \left[ B_{i-1,n-1}(t) - B_{i,n-1}(t) \right] w_i \\ f''(t) &= n (n-1) \sum\limits_{i=0}^n \left[ B_{i-2,n-2}(t) - 2B_{i-1,n-2}(t) + B_{i,n-2}(t) \right] w_i \mathbf{P}_i \\ g''(t) &= n (n-1) \sum\limits_{i=0}^n \left[ B_{i-2,n-2}(t) - 2B_{i-1,n-2}(t) + B_{i,n-2}(t) \right] w_i \end{align} and :math:`B_{i,n}(t)` is the Bernstein polynomial. :param p: 2-D list or array of control points where the inner dimension can have any size, but typical sizes include ``2`` (:math:`x`-:math:`y` space), ``3`` (:math:`x`-:math:`y`-:math:`z` space) and ``4`` (:math:`x`-:math:`y`-:math:`z`-:math:`w` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param t: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type t: Iterable[float] :returns: Value of the rational Bézier curve first derivative along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_curve_d2cdt2_dp_tvec(w: Iterable[float], i: int, n: int, dim: int, t: Iterable[float]) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a rational Bézier curve second derivative with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param i: Index of the control point :type i: int :param n: Degree of the curve (number of control points minus one) :type n: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter vector along which to evaluate the curve second derivative control point sensitivity :type t: Iterable[float] :returns: Value of the rational Bézier curve second derivative control point sensitivity along parameter vector :math:`\mathbf{t}`. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_surf_eval(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], u: float, v: float) -> List[float] Evaluates a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair according to .. math:: \mathbf{S}(u,v) = \frac{\sum_{i=0}^n \sum_{j=0}^m B_{i,n}(u) B_{j,m}(v) w_{i,j} \mathbf{P}_{i,j}}{\sum_{i=0}^n \sum_{j=0}^m B_{i,n}(u) B_{j,m}(v) w_{i,j}} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the rational Bézier surface at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: rational_bezier_surf_dsdu(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], u: float, v: float) -> List[float] Evaluates the first derivative w.r.t. :math:`u` of a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the rational Bézier surface first derivative w.r.t. :math:`u` at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: rational_bezier_surf_dsdv(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], u: float, v: float) -> List[float] Evaluates the first derivative w.r.t. :math:`v` of a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the rational Bézier surface first derivative w.r.t. :math:`v` at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: rational_bezier_surf_d2sdu2(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], u: float, v: float) -> List[float] Evaluates the second derivative w.r.t. :math:`u` of a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the rational Bézier surface second derivative w.r.t. :math:`u` at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: rational_bezier_surf_d2sdv2(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], u: float, v: float) -> List[float] Evaluates the second derivative w.r.t. :math:`v` of a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the rational Bézier surface second derivative w.r.t. :math:`v` at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: rational_bezier_surf_eval_dp(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, u: float, v: float) -> List[float] Evaluates the derivative of the rational Bézier surface with respect to an individual control point at a given :math:`(u,v)`-pair: .. math:: \frac{\partial}{\partial \mathbf{P}_{i,j}} \mathbf{S}(u,v) = \frac{B_{i,n}(u) B_{j,m}(v) w_{i,j}}{\sum\limits_{ii=0}^n \sum\limits_{jj=0}^m B_{ii,n}(u) B_{jj,m}(v) w_{ii,jj}} :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 1-D list representing the surface sensitivity at :math:`(u,v)` to the control point :math:`\mathbf{P}_{i,j}` :rtype: List[float] .. py:function:: rational_bezier_surf_dsdu_dp(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, u: float, v: float) -> List[float] Evaluates the derivative of the rational Bézier surface first :math:`u`-derivative with respect to an individual control point at a given :math:`(u,v)`-pair: .. math:: \frac{\partial}{\partial \mathbf{P}_{i,j}} \left( \frac{\partial \mathbf{S}(u,v)}{\partial u} \right) = \frac{\frac{\partial f(u,v)}{\partial u} g(u,v) - f(u,v) \frac{\partial g(u,v)}{\partial u}}{g^2(u,v)} where .. math:: \begin{align} f(u,v) &= B_{i,n}(u) B_{j,m}(v) w_{i,j} \\ g(u,v) &= \sum\limits_{ii=0}^n \sum\limits_{jj=0}^m B_{ii,n}(u) B_{jj,m}(v) w_{ii,jj} \\ \frac{\partial f(u,v)}{\partial u} &= n [B_{i-1,n-1}(u) - B_{i,n-1}(u)] B_{j,m}(v) w_{i,j} \\ \frac{\partial g(u,v)}{\partial u} &= n \sum\limits_{ii=0}^n \sum\limits_{jj=0}^m [B_{ii-1,n-1}(u) - B_{ii,n-1}(u)] B_{jj,m}(v) w_{ii,jj} \end{align} :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 1-D list representing the surface derivative sensitivity at :math:`(u,v)` to the control point :math:`\mathbf{P}_{i,j}` :rtype: List[float] .. py:function:: rational_bezier_surf_dsdv_dp(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, u: float, v: float) -> List[float] Evaluates the derivative of the rational Bézier surface first :math:`v`-derivative with respect to an individual control point at a given :math:`(u,v)`-pair: .. math:: \frac{\partial}{\partial \mathbf{P}_{i,j}} \left( \frac{\partial \mathbf{S}(u,v)}{\partial v} \right) = \frac{\frac{\partial f(u,v)}{\partial v} g(u,v) - f(u,v) \frac{\partial g(u,v)}{\partial v}}{g^2(u,v)} where .. math:: \begin{align} f(u,v) &= B_{i,n}(u) B_{j,m}(v) w_{i,j} \\ g(u,v) &= \sum\limits_{ii=0}^n \sum\limits_{jj=0}^m B_{ii,n}(u) B_{jj,m}(v) w_{ii,jj} \\ \frac{\partial f(u,v)}{\partial v} &= m B_{i,n}(u) [B_{j-1,m-1}(v) - B_{j,m-1}(v)] w_{i,j} \\ \frac{\partial g(u,v)}{\partial v} &= m \sum\limits_{ii=0}^n \sum\limits_{jj=0}^m B_{ii,n}(u) [B_{jj-1,m-1}(v) - B_{jj,m-1}(v)] w_{ii,jj} \end{align} :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 1-D list representing the surface derivative sensitivity at :math:`(u,v)` to the control point :math:`\mathbf{P}_{i,j}` :rtype: List[float] .. py:function:: rational_bezier_surf_d2sdu2_dp(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, u: float, v: float) -> List[float] Evaluates the derivative of the rational Bézier surface second :math:`u`-derivative with respect to an individual control point at a given :math:`(u,v)`-pair: .. math:: \frac{\partial}{\partial \mathbf{P}_{i,j}} \left( \frac{\partial^2 \mathbf{S}(u,v)}{\partial u^2} \right) = \frac{\frac{\partial^2 f(u,v)}{\partial u^2} g^2(u, v) - f(u, v)g(u, v)\frac{\partial^2 g(u,v)}{\partial u^2} - 2\frac{\partial f(u,v)}{\partial u} g(u,v) \frac{\partial g(u,v)}{\partial u} + 2f(u, v)\left[ \frac{\partial g(u,v)}{\partial u} \right]^2}{g^3(u, v)} where .. math:: \begin{align} f(u,v) &= B_{i,n}(u) B_{j,m}(v) w_{i,j} \\ g(u,v) &= \sum\limits_{ii=0}^n \sum\limits_{jj=0}^m B_{ii,n}(u) B_{jj,m}(v) w_{ii,jj} \\ \frac{\partial f(u,v)}{\partial u} &= n [B_{i-1,n-1}(u) - B_{i,n-1}(u)] B_{j,m}(v) w_{i,j} \\ \frac{\partial g(u,v)}{\partial u} &= n \sum\limits_{ii=0}^n \sum\limits_{jj=0}^m [B_{ii-1,n-1}(u) - B_{ii,n-1}(u)] B_{jj,m}(v) w_{ii,jj} \\ \frac{\partial^2 f(u,v)}{\partial u^2} &= n(n-1) [B_{i-2,n-2}(u) - 2 B_{i-1,n-2}(u) + B_{i,n-2}(u)] B_{j,m}(v) w_{i,j} \\ \frac{\partial^2 g(u,v)}{\partial u^2} &= n(n-1) \sum\limits_{ii=0}^n \sum\limits_{jj=0}^m [B_{ii-2,n-2}(u)-2B_{ii-1,n-2}(u) + B_{ii,n-2}(u)] B_{jj,m}(v) w_{ii,jj} \end{align} :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 1-D list representing the surface derivative sensitivity at :math:`(u,v)` to the control point :math:`\mathbf{P}_{i,j}` :rtype: List[float] .. py:function:: rational_bezier_surf_d2sdv2_dp(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, u: float, v: float) -> List[float] Evaluates the derivative of the rational Bézier surface second :math:`v`-derivative with respect to an individual control point at a given :math:`(u,v)`-pair: .. math:: \frac{\partial}{\partial \mathbf{P}_{i,j}} \left( \frac{\partial^2 \mathbf{S}(u,v)}{\partial v^2} \right) = \frac{\frac{\partial^2 f(u,v)}{\partial v^2} g^2(u, v) - f(u, v)g(u, v)\frac{\partial^2 g(u,v)}{\partial v^2} - 2\frac{\partial f(u,v)}{\partial v} g(u,v) \frac{\partial g(u,v)}{\partial v} + 2f(u, v)\left[ \frac{\partial g(u,v)}{\partial v} \right]^2}{g^3(u, v)} where .. math:: \begin{align} f(u,v) &= B_{i,n}(u) B_{j,m}(v) w_{i,j} \\ g(u,v) &= \sum\limits_{ii=0}^n \sum\limits_{jj=0}^m B_{ii,n}(u) B_{jj,m}(v) w_{ii,jj} \\ \frac{\partial f(u,v)}{\partial v} &= m B_{i,n}(u) [B_{j-1,m-1}(v) - B_{j,m-1}(v)] w_{i,j} \\ \frac{\partial g(u,v)}{\partial v} &= m \sum\limits_{ii=0}^n \sum\limits_{jj=0}^m B_{ii,n}(u) [B_{jj-1,m-1}(v) - B_{jj,m-1}(v)] w_{ii,jj} \\ \frac{\partial^2 f(u,v)}{\partial v^2} &= m(m-1) B_{i,n}(u) [B_{j-2,m-2}(v) - 2 B_{j-1,m-2}(v) + B_{j,m-2}(v)] w_{i,j} \\ \frac{\partial^2 g(u,v)}{\partial v^2} &= m(m-1) \sum\limits_{ii=0}^n \sum\limits_{jj=0}^m B_{ii,n}(u) [B_{jj-2,m-2}(v)-2B_{jj-1,m-2}(v) + B_{jj,m-2}(v)] w_{ii,jj} \end{align} :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 1-D list representing the surface derivative sensitivity at :math:`(u,v)` to the control point :math:`\mathbf{P}_{i,j}` :rtype: List[float] .. py:function:: rational_bezier_surf_eval_dp_iso_u(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, u: float, nv: int) -> List[List[float]] Evaluates the derivative of the rational Bézier surface with respect to an individual control point along a :math:`u`-isoparametric curve :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface sensitiviies :type nv: int :returns: 2-D array of size :math:`N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: rational_bezier_surf_eval_dp_iso_v(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, nu: int, v: float) -> List[List[float]] Evaluates the derivative of the rational Bézier surface with respect to an individual control point along a :math:`v`-isoparametric curve :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface sensitivities :type nu: int :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 2-D array of size :math:`N_u \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: rational_bezier_surf_dsdu_dp_iso_u(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, u: float, nv: int) -> List[List[float]] Evaluates the derivative of the rational Bézier surface first :math:`u`-derivative with respect to an individual control point along a :math:`u`-isoparametric curve :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface sensitiviies :type nv: int :returns: 2-D array of size :math:`N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: rational_bezier_surf_dsdu_dp_iso_v(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, nu: int, v: float) -> List[List[float]] Evaluates the derivative of the rational Bézier surface first :math:`u`-derivative with respect to an individual control point along a :math:`v`-isoparametric curve :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface sensitivities :type nu: int :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 2-D array of size :math:`N_u \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: rational_bezier_surf_dsdv_dp_iso_u(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, u: float, nv: int) -> List[List[float]] Evaluates the derivative of the rational Bézier surface first :math:`v`-derivative with respect to an individual control point along a :math:`u`-isoparametric curve :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface sensitiviies :type nv: int :returns: 2-D array of size :math:`N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: rational_bezier_surf_dsdv_dp_iso_v(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, nu: int, v: float) -> List[List[float]] Evaluates the derivative of the rational Bézier surface first :math:`v`-derivative with respect to an individual control point along a :math:`v`-isoparametric curve :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface sensitivities :type nu: int :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 2-D array of size :math:`N_u \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: rational_bezier_surf_d2sdu2_dp_iso_u(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, u: float, nv: int) -> List[List[float]] Evaluates the derivative of the rational Bézier surface second :math:`u`-derivative with respect to an individual control point along a :math:`u`-isoparametric curve :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface sensitiviies :type nv: int :returns: 2-D array of size :math:`N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: rational_bezier_surf_d2sdu2_dp_iso_v(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, nu: int, v: float) -> List[List[float]] Evaluates the derivative of the rational Bézier surface second :math:`u`-derivative with respect to an individual control point along a :math:`v`-isoparametric curve :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface sensitivities :type nu: int :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 2-D array of size :math:`N_u \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: rational_bezier_surf_d2sdv2_dp_iso_u(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, u: float, nv: int) -> List[List[float]] Evaluates the derivative of the rational Bézier surface second :math:`v`-derivative with respect to an individual control point along a :math:`u`-isoparametric curve :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface sensitivity :type u: float :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface sensitiviies :type nv: int :returns: 2-D array of size :math:`N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: rational_bezier_surf_d2sdv2_dp_iso_v(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, nu: int, v: float) -> List[List[float]] Evaluates the derivative of the rational Bézier surface second :math:`v`-derivative with respect to an individual control point along a :math:`v`-isoparametric curve :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface sensitivities :type nu: int :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface sensitivity :type v: float :returns: 2-D array of size :math:`N_u \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: rational_bezier_surf_eval_dp_grid(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, nu: int, nv: int) -> List[List[List[float]]] Evaluates the derivative of the rational Bézier surface with respect to an individual control point on a :math:`(u,v)` grid :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface sensitiviies :type nu: int :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface sensitiviies :type nv: int :returns: 3-D array of size :math:`N_u \times N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: rational_bezier_surf_dsdu_dp_grid(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, nu: int, nv: int) -> List[List[List[float]]] Evaluates the derivative of the rational Bézier surface first :math:`u`-derivative with respect to an individual control point on a :math:`(u,v)` grid :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface derivative sensitiviies :type nu: int :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface derivative sensitiviies :type nv: int :returns: 3-D array of size :math:`N_u \times N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: rational_bezier_surf_dsdv_dp_grid(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, nu: int, nv: int) -> List[List[List[float]]] Evaluates the derivative of the rational Bézier surface first :math:`v`-derivative with respect to an individual control point on a :math:`(u,v)` grid :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface derivative sensitiviies :type nu: int :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface derivative sensitiviies :type nv: int :returns: 3-D array of size :math:`N_u \times N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: rational_bezier_surf_d2sdu2_dp_grid(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, nu: int, nv: int) -> List[List[List[float]]] Evaluates the derivative of the rational Bézier surface second :math:`u`-derivative with respect to an individual control point on a :math:`(u,v)` grid :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface derivative sensitiviies :type nu: int :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface derivative sensitiviies :type nv: int :returns: 3-D array of size :math:`N_u \times N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: rational_bezier_surf_d2sdv2_dp_grid(w: Iterable[Iterable[float]], i: int, j: int, n: int, m: int, dim: int, nu: int, nv: int) -> List[List[List[float]]] Evaluates the derivative of the rational Bézier surface second :math:`v`-derivative with respect to an individual control point on a :math:`(u,v)` grid :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param n: Degree of the surface in the :math:`u`-direction :type n: int :param m: Degree of the surface in the :math:`v`-direction :type m: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly-spaced :math:`u`-values at which to evaluate the surface derivative sensitiviies :type nu: int :param nv: Number of linearly-spaced :math:`v`-values at which to evaluate the surface derivative sensitiviies :type nv: int :returns: 3-D array of size :math:`N_u \times N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: rational_bezier_surf_eval_iso_u(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], u: float, nv: int) -> List[List[float]] Evaluates an isoparametric curve in :math:`u` of a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` points along the :math:`u`-isoparametric curve of the rational Bézier surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_surf_eval_iso_v(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], nu: int, v: float) -> List[List[float]] Evaluates an isoparametric curve in :math:`v` of a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` points along the :math:`v`-isoparametric curve of the rational Bézier surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_surf_dsdu_iso_u(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], u: float, nv: int) -> List[List[float]] Evaluates the first derivative w.r.t. :math:`u` along an isoparametric curve in :math:`u` of a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` first derivatives w.r.t. :math:`u` along the :math:`u`-isoparametric curve of the rational Bézier surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_surf_dsdu_iso_v(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], nu: int, v: float) -> List[List[float]] Evaluates the first derivative w.r.t. :math:`u` along an isoparametric curve in :math:`v` of a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` first derivatives w.r.t. :math:`u` along the :math:`v`-isoparametric curve of the rational Bézier surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_surf_dsdv_iso_u(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], u: float, nv: int) -> List[List[float]] Evaluates the first derivative w.r.t. :math:`v` along an isoparametric curve in :math:`u` of a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` first derivatives w.r.t. :math:`v` along the :math:`u`-isoparametric curve of the rational Bézier surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_surf_dsdv_iso_v(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], nu: int, v: float) -> List[List[float]] Evaluates the first derivative w.r.t. :math:`v` along an isoparametric curve in :math:`v` of a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` first derivatives w.r.t. :math:`v` along the :math:`v`-isoparametric curve of the rational Bézier surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_surf_d2sdu2_iso_u(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], u: float, nv: int) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`u` along an isoparametric curve in :math:`u` of a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` second derivatives w.r.t. :math:`u` along the :math:`u`-isoparametric curve of the rational Bézier surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_surf_d2sdu2_iso_v(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], nu: int, v: float) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`u` along an isoparametric curve in :math:`v` of a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` second derivatives w.r.t. :math:`u` along the :math:`v`-isoparametric curve of the rational Bézier surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_surf_d2sdv2_iso_u(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], u: float, nv: int) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`v` along an isoparametric curve in :math:`u` of a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` second derivatives w.r.t. :math:`v` along the :math:`u`-isoparametric curve of the rational Bézier surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_surf_d2sdv2_iso_v(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], nu: int, v: float) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`v` along an isoparametric curve in :math:`v` of a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` second derivatives w.r.t. :math:`v` along the :math:`v`-isoparametric curve of the rational Bézier surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: rational_bezier_surf_eval_grid(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], nu: int, nv: int) -> List[List[List[float]]] Evaluates a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space according to .. math:: \mathbf{S}(u,v) = \frac{\sum_{i=0}^n \sum_{j=0}^m B_{i,n}(u) B_{j,m}(v) w_{i,j} \mathbf{P}_{i,j}}{\sum_{i=0}^n \sum_{j=0}^m B_{i,n}(u) B_{j,m}(v) w_{i,j}} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` points on the rational Bézier surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: rational_bezier_surf_dsdu_grid(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], nu: int, nv: int) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`u` on a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`u` on the rational Bézier surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: rational_bezier_surf_dsdv_grid(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], nu: int, nv: int) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`v` on a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`v` on the rational Bézier surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: rational_bezier_surf_d2sdu2_grid(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], nu: int, nv: int) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`u` on a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`u` on the rational Bézier surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: rational_bezier_surf_d2sdv2_grid(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], nu: int, nv: int) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`v` on a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`v` on the rational Bézier surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: rational_bezier_surf_eval_uvvecs(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of points on the rational Bézier surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: rational_bezier_surf_dsdu_uvvecs(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`u` on a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`u` on the rational Bézier surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: rational_bezier_surf_dsdv_uvvecs(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`v` on a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`v` on the rational Bézier surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: rational_bezier_surf_d2sdu2_uvvecs(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`u` on a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`u` on the rational Bézier surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: rational_bezier_surf_d2sdv2_uvvecs(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`v` on a rational Bézier surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`v` on the rational Bézier surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: bspline_curve_eval(p: Iterable[Iterable[float]], k: Iterable[float], t: float) -> List[float] Evaluates a B-spline curve with :math:`n+1` control points at a single :math:`t`-value according to .. math:: \mathbf{C}(t) = \sum\limits_{i=0}^n N_{i,q}(t) \mathbf{P}_i where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`, defined recursively as .. math:: N_{i,q} = \frac{t - t_i}{t_{i+q} - t_i} N_{i,q-1}(t) + \frac{t_{i+q+1} - t}{t_{i+q+1} - t_{i+1}} N_{i+1, q-1}(t) with base case .. math:: N_{i,0} = \begin{cases} 1, & \text{if } t_i \leq t < t_{i+1} \text{ and } t_i < t_{i+1} \\ 0, & \text{otherwise} \end{cases} The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param k: 1-D list or array of knots :type k: Iterable[float] :param t: Parameter value :math:`t` at which to evaluate :type t: float :returns: Value of the B-spline curve at :math:`t`. Has the same size as the inner dimension of ``p`` :rtype: List[float] .. py:function:: bspline_curve_eval_dp(k: Iterable[float], i: int, q: int, dim: int, t: float) -> List[float] Evaluates the derivative of the B-spline curve with respect to an individual control point at a given :math:`t`-value :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter value at which to evaluate the curve sensitivity :type t: float :returns: 1-D list representing the curve sensitivity at :math:`t` to the control point :math:`\mathbf{P}_i` :rtype: List[float] .. py:function:: bspline_curve_dcdt(p: Iterable[Iterable[float]], k: Iterable[float], t: float) -> List[float] Evaluates the first derivative with respect to :math:`t` of a B-spline curve with :math:`n+1` control points at a single :math:`t`-value according to .. math:: \frac{\text{d}}{\text{d}t} \mathbf{C}(t) = \sum\limits_{i=0}^n N'_{i,q}(t) \mathbf{P}_i where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q` and its derivative is given by .. math:: N'_{i,q}(t) = \frac{q}{k_{i+q} - k_i} N_{i,q-1}(t) - \frac{q}{k_{i+q+1} - k_{i+1}} N_{i+1,q-1}(t) The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param k: 1-D list or array of knots :type k: Iterable[float] :param t: Parameter value :math:`t` at which to evaluate :type t: float :returns: Value of the first derivative w.r.t. :math:`t` of the B-spline curve at :math:`t`. Has the same size as the inner dimension of ``p`` :rtype: List[float] .. py:function:: bspline_curve_dcdt_dp(k: Iterable[float], i: int, q: int, dim: int, t: float) -> List[float] Evaluates the derivative of the B-spline curve first derivative with respect to an individual control point :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter value at which to evaluate the curve derivative sensitivity :type t: float :returns: 1-D list representing the curve derivative sensitivity at :math:`t` to the control point :math:`\mathbf{P}_i` :rtype: List[float] .. py:function:: bspline_curve_d2cdt2(p: Iterable[Iterable[float]], k: Iterable[float], t: float) -> List[float] Evaluates the second derivative with respect to :math:`t` of a B-spline curve with :math:`n+1` control points at a single :math:`t`-value according to .. math:: \frac{\text{d}^2}{\text{d}t^2} \mathbf{C}(t) = \sum\limits_{i=0}^n N''_{i,q}(t) \mathbf{P}_i where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q` and its second derivative is given by .. math:: N''_{i,q}(t) = \frac{q}{k_{i+q} - k_i} \left[ \frac{q-1}{k_{i+q-1}-k_i} N_{i,q-2}(t) - \frac{q-1}{k_{i+q}-k_{i+1}} N_{i+1,q-2}(t) \right] - \frac{q}{k_{i+q+1} - k_{i+1}} \left[ \frac{q-1}{k_{i+q}-k_{i+1}} N_{i+1,q-2}(t) - \frac{q-1}{k_{i+q+1}-k_{i+2}} N_{i+2,q-2}(t) \right] The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param k: 1-D list or array of knots :type k: Iterable[float] :param t: Parameter value :math:`t` at which to evaluate :type t: float :returns: Value of the second derivative w.r.t. :math:`t` of the B-spline curve at :math:`t`. Has the same size as the inner dimension of ``p`` :rtype: List[float] .. py:function:: bspline_curve_d2cdt2_dp(k: Iterable[float], i: int, q: int, dim: int, t: float) -> List[float] Evaluates the derivative of the Bézier curve second derivative with respect to an individual control point :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter value at which to evaluate the curve derivative sensitivity :type t: float :returns: 1-D list representing the curve derivative sensitivity at :math:`t` to the control point :math:`\mathbf{P}_i` :rtype: List[float] .. py:function:: bspline_curve_eval_grid(p: Iterable[Iterable[float]], k: Iterable[float], nt: int) -> List[List[float]] Evaluates a B-spline curve with :math:`n+1` control points on a grid of linearly-spaced :math:`t`-values according to .. math:: \mathbf{C}(t) = \sum\limits_{i=0}^n N_{i,q}(t) \mathbf{P}_i where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param k: 1-D list or array of knots :type k: Iterable[float] :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the B-spline curve at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_curve_eval_dp_grid(k: Iterable[float], i: int, q: int, dim: int, nt: int) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a B-spline curve with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the control point sensitivity of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the B-spline curve control point sensitivity at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: bspline_curve_dcdt_grid(p: Iterable[Iterable[float]], k: Iterable[float], nt: int) -> List[List[float]] Evaluates the first derivative with respect to :math:`t` of a B-spline curve with :math:`n+1` control points on a grid of linearly-spaced :math:`t`-values according to .. math:: \frac{\text{d}}{\text{d}t} \mathbf{C}(t) = \sum\limits_{i=0}^n N'_{i,q}(t) \mathbf{P}_i where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q` and its derivative is given by .. math:: N'_{i,q}(t) = \frac{q}{k_{i+q} - k_i} N_{i,q-1}(t) - \frac{q}{k_{i+q+1} - k_{i+1}} N_{i+1,q-1}(t) The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param k: 1-D list or array of knots :type k: Iterable[float] :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the B-spline curve first derivatve w.r.t. :math:`t` at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_curve_dcdt_dp_grid(k: Iterable[float], i: int, q: int, dim: int, nt: int) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a B-spline curve first derivative with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the control point sensitivity of the curve first derivative at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the B-spline curve first derivative control point sensitivity at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: bspline_curve_d2cdt2_grid(p: Iterable[Iterable[float]], k: Iterable[float], nt: int) -> List[List[float]] Evaluates the second derivative with respect to :math:`t` of a B-spline curve with :math:`n+1` control points on a grid of linearly-spaced :math:`t`-values according to .. math:: \frac{\text{d}^2}{\text{d}t^2} \mathbf{C}(t) = \sum\limits_{i=0}^n N''_{i,q}(t) \mathbf{P}_i where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q` and its second derivative is given by .. math:: N''_{i,q}(t) = \frac{q}{k_{i+q} - k_i} \left[ \frac{q-1}{k_{i+q-1}-k_i} N_{i,q-2}(t) - \frac{q-1}{k_{i+q}-k_{i+1}} N_{i+1,q-2}(t) \right] - \frac{q}{k_{i+q+1} - k_{i+1}} \left[ \frac{q-1}{k_{i+q}-k_{i+1}} N_{i+1,q-2}(t) - \frac{q-1}{k_{i+q+1}-k_{i+2}} N_{i+2,q-2}(t) \right] The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param k: 1-D list or array of knots :type k: Iterable[float] :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the B-spline curve second derivative w.r.t. :math:`t` at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_curve_d2cdt2_dp_grid(k: Iterable[float], i: int, q: int, dim: int, nt: int) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a B-spline curve second derivative with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the control point sensitivity of the curve second derivative at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the B-spline curve second derivative control point sensitivity at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: bspline_curve_eval_tvec(p: Iterable[Iterable[float]], k: Iterable[float], t: Iterable[float]) -> List[List[float]] Evaluates a B-spline curve with :math:`n+1` control points on a grid of linearly-spaced :math:`t`-values according to .. math:: \mathbf{C}(t) = \sum\limits_{i=0}^n N_{i,q}(t) \mathbf{P}_i where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param k: 1-D list or array of knots :type k: Iterable[float] :param t: Vector of parameter values :type t: Iterable[float] :returns: Value of the B-spline curve along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_curve_eval_dp_tvec(k: Iterable[float], i: int, q: int, dim: int, t: Iterable[float]) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a B-spline curve with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Vector of parameter values :type t: Iterable[float] :returns: Value of the B-spline curve control point sensitivity along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: bspline_curve_dcdt_tvec(p: Iterable[Iterable[float]], k: Iterable[float], t: Iterable[float]) -> List[List[float]] Evaluates the first derivative with respect to :math:`t` of a B-spline curve with :math:`n+1` control points on a grid of linearly-spaced :math:`t`-values according to .. math:: \frac{\text{d}}{\text{d}t} \mathbf{C}(t) = \sum\limits_{i=0}^n N'_{i,q}(t) \mathbf{P}_i where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q` and its derivative is given by .. math:: N'_{i,q}(t) = \frac{q}{k_{i+q} - k_i} N_{i,q-1}(t) - \frac{q}{k_{i+q+1} - k_{i+1}} N_{i+1,q-1}(t) The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param k: 1-D list or array of knots :type k: Iterable[float] :param t: Vector of parameter values :type t: Iterable[float] :returns: Value of the B-spline curve first derivatve w.r.t. :math:`t` along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_curve_dcdt_dp_tvec(k: Iterable[float], i: int, q: int, dim: int, t: Iterable[float]) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a B-spline curve first derivative with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Vector of parameter values :type t: Iterable[float] :returns: Value of the B-spline curve first derivative control point sensitivity along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: bspline_curve_d2cdt2_tvec(p: Iterable[Iterable[float]], k: Iterable[float], t: Iterable[float]) -> List[List[float]] Evaluates the second derivative with respect to :math:`t` of a B-spline curve with :math:`n+1` control points on a grid of linearly-spaced :math:`t`-values according to .. math:: \frac{\text{d}^2}{\text{d}t^2} \mathbf{C}(t) = \sum\limits_{i=0}^n N''_{i,q}(t) \mathbf{P}_i where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q` and its second derivative is given by .. math:: N''_{i,q}(t) = \frac{q}{k_{i+q} - k_i} \left[ \frac{q-1}{k_{i+q-1}-k_i} N_{i,q-2}(t) - \frac{q-1}{k_{i+q}-k_{i+1}} N_{i+1,q-2}(t) \right] - \frac{q}{k_{i+q+1} - k_{i+1}} \left[ \frac{q-1}{k_{i+q}-k_{i+1}} N_{i+1,q-2}(t) - \frac{q-1}{k_{i+q+1}-k_{i+2}} N_{i+2,q-2}(t) \right] The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param k: 1-D list or array of knots :type k: Iterable[float] :param t: Vector of parameter values :type t: Iterable[float] :returns: Value of the B-spline curve second derivative w.r.t. :math:`t` along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_curve_d2cdt2_dp_tvec(k: Iterable[float], i: int, q: int, dim: int, t: Iterable[float]) -> List[List[float]] Evaluates the sensitivity with respect to an individual control point of a B-spline curve second derivative with :math:`n+1` control points at :math:`N_t` linearly-spaced points in :math:`t` :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Vector of parameter values :type t: Iterable[float] :returns: Value of the B-spline curve second derivative control point sensitivity along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``2`` or ``3``) :rtype: List[List[float]] .. py:function:: bspline_surf_eval(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], u: float, v: float) -> List[float] Evaluates a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair according to .. math:: \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N_{i,q}(u) N_{j,r}(v) \mathbf{P}_{i,j} where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline in the :math:`u`-direction is computed as ``q = len(ku) - len(p) - 1``, and the degree of the B-spline surface in the :math:`v`-direction is computed as ``r = len(kv) - len(p[0]) - 1``. :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the B-spline surface at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: bspline_surf_dsdu(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], u: float, v: float) -> List[float] Evaluates a the first derivative w.r.t. :math:`u` of a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair according to .. math:: \frac{\partial}{\partial u} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N'_{i,q}(u) N_{j,r}(v) \mathbf{P}_{i,j} where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline in the :math:`u`-direction is computed as ``q = len(ku) - len(p) - 1``, and the degree of the B-spline surface in the :math:`v`-direction is computed as ``r = len(kv) - len(p[0]) - 1``. :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the first derivative w.r.t. :math:`u` of the B-spline surface at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: bspline_surf_dsdv(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], u: float, v: float) -> List[float] Evaluates a the first derivative w.r.t. :math:`v` of a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair according to .. math:: \frac{\partial}{\partial v} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N_{i,q}(u) N'_{j,r}(v) \mathbf{P}_{i,j} where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline in the :math:`u`-direction is computed as ``q = len(ku) - len(p) - 1``, and the degree of the B-spline surface in the :math:`v`-direction is computed as ``r = len(kv) - len(p[0]) - 1``. :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the first derivative w.r.t. :math:`v` of the B-spline surface at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: bspline_surf_d2sdu2(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], u: float, v: float) -> List[float] Evaluates a the second derivative w.r.t. :math:`u` of a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair according to .. math:: \frac{\partial^2}{\partial u^2} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N''_{i,q}(u) N_{j,r}(v) \mathbf{P}_{i,j} where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline in the :math:`u`-direction is computed as ``q = len(ku) - len(p) - 1``, and the degree of the B-spline surface in the :math:`v`-direction is computed as ``r = len(kv) - len(p[0]) - 1``. :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the second derivative w.r.t. :math:`u` of the B-spline surface at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: bspline_surf_d2sdv2(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], u: float, v: float) -> List[float] Evaluates a the second derivative w.r.t. :math:`v` of a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair according to .. math:: \frac{\partial^2}{\partial v^2} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N_{i,q}(u) N''_{j,r}(v) \mathbf{P}_{i,j} where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline in the :math:`u`-direction is computed as ``q = len(ku) - len(p) - 1``, and the degree of the B-spline surface in the :math:`v`-direction is computed as ``r = len(kv) - len(p[0]) - 1``. :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the second derivative w.r.t. :math:`v` of the B-spline surface at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: bspline_surf_eval_dp(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, u: float, v: float) -> List[float] Evaluates the sensitivity of a B-spline surface with respect to control point :math:`\mathbf{P}_{i,j}` at a :math:`(u,v)` parameter pair :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the B-spline surface sensitivity at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: bspline_surf_dsdu_dp(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, u: float, v: float) -> List[float] Evaluates the sensitivity of a B-spline surface first derivative with respect to control point :math:`\mathbf{P}_{i,j}` at a :math:`(u,v)` parameter pair :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the sensitivity of the first derivative w.r.t. :math:`u` of the B-spline surface at :math:`(u,v)` with respect to control point :math:`\mathbf{P}_{i,j}`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: bspline_surf_dsdv_dp(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, u: float, v: float) -> List[float] Evaluates the sensitivity of a B-spline surface first derivative with respect to control point :math:`\mathbf{P}_{i,j}` at a :math:`(u,v)` parameter pair :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the sensitivity of the first derivative w.r.t. :math:`v` of the B-spline surface at :math:`(u,v)` with respect to control point :math:`\mathbf{P}_{i,j}`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: bspline_surf_d2sdu2_dp(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, u: float, v: float) -> List[float] Evaluates the sensitivity of a B-spline surface second derivative with respect to control point :math:`\mathbf{P}_{i,j}` at a :math:`(u,v)` parameter pair :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the sensitivity of the second derivative w.r.t. :math:`u` of the B-spline surface at :math:`(u,v)` with respect to control point :math:`\mathbf{P}_{i,j}`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: bspline_surf_d2sdv2_dp(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, u: float, v: float) -> List[float] Evaluates the sensitivity of a B-spline surface second derivative with respect to control point :math:`\mathbf{P}_{i,j}` at a :math:`(u,v)` parameter pair :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the sensitivity of the second derivative w.r.t. :math:`v` of the B-spline surface at :math:`(u,v)` with respect to control point :math:`\mathbf{P}_{i,j}`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: bspline_surf_eval_iso_u(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], u: float, nv: int) -> List[List[float]] Evaluates an isoparametric curve in :math:`u` of a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction according to .. math:: \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N_{i,q}(u) N_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` points along the :math:`u`-isoparametric curve of the B-spline surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_surf_eval_iso_v(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], nu: int, v: float) -> List[List[float]] Evaluates an isoparametric curve in :math:`v` of a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u` linearly-spaced points along the :math:`u`-direction according to .. math:: \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N_{i,q}(u) N_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` points along the :math:`v`-isoparametric curve of the B-spline surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_surf_dsdu_iso_u(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], u: float, nv: int) -> List[List[float]] Evaluates the first derivative w.r.t. :math:`u` along an isoparametric curve in :math:`u` of a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction according to .. math:: \frac{\partial}{\partial u} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N'_{i,q}(u) N_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` first derivatives w.r.t. :math:`u` along the :math:`u`-isoparametric curve of the B-spline surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_surf_dsdu_iso_v(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], nu: int, v: float) -> List[List[float]] Evaluates the first derivative w.r.t. :math:`u` along an isoparametric curve in :math:`v` of a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u` linearly-spaced points along the :math:`u`-direction according to .. math:: \frac{\partial}{\partial u} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N'_{i,q}(u) N_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` first derivatives w.r.t. :math:`u` along the :math:`v`-isoparametric curve of the B-spline surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_surf_dsdv_iso_u(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], u: float, nv: int) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`v` along an isoparametric curve in :math:`u` of a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction according to .. math:: \frac{\partial}{\partial v} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N_{i,q}(u) N'_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` first derivatives w.r.t. :math:`v` along the :math:`u`-isoparametric curve of the B-spline surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_surf_dsdv_iso_v(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], nu: int, v: float) -> List[List[float]] Evaluates the first derivative w.r.t. :math:`u` along an isoparametric curve in :math:`v` of a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u` linearly-spaced points along the :math:`u`-direction according to .. math:: \frac{\partial}{\partial v} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N_{i,q}(u) N'_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` first derivatives w.r.t. :math:`u` along the :math:`v`-isoparametric curve of the B-spline surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_surf_d2sdu2_iso_u(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], u: float, nv: int) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`u` along an isoparametric curve in :math:`u` of a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction according to .. math:: \frac{\partial^2}{\partial u^2} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N''_{i,q}(u) N_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` second derivatives w.r.t. :math:`u` along the :math:`u`-isoparametric curve of the B-spline surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_surf_d2sdu2_iso_v(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], nu: int, v: float) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`u` along an isoparametric curve in :math:`v` of a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u` linearly-spaced points along the :math:`u`-direction according to .. math:: \frac{\partial^2}{\partial u^2} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N''_{i,q}(u) N_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` second derivatives w.r.t. :math:`u` along the :math:`v`-isoparametric curve of the B-spline surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_surf_d2sdv2_iso_u(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], u: float, nv: int) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`v` along an isoparametric curve in :math:`u` of a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction according to .. math:: \frac{\partial^2}{\partial v^2} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N_{i,q}(u) N''_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` second derivatives w.r.t. :math:`v` along the :math:`u`-isoparametric curve of the B-spline surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_surf_d2sdv2_iso_v(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], nu: int, v: float) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`u` along an isoparametric curve in :math:`v` of a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u` linearly-spaced points along the :math:`u`-direction according to .. math:: \frac{\partial^2}{\partial v^2} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N_{i,q}(u) N''_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` second derivatives w.r.t. :math:`u` along the :math:`v`-isoparametric curve of the B-spline surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: bspline_surf_eval_dp_iso_u(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, u: float, nv: int) Evaluates the sensitivity of a B-spline surface with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param nv: Number of linearly spaced points in the :math:`v`-direction :type nv: int :returns: 2-D array of size :math:`N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bspline_surf_eval_dp_iso_v(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, nu: int, v: float) Evaluates the sensitivity of a B-spline surface with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_u` linearly-spaced points along the :math:`u`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly spaced points in the :math:`u`-direction :type nu: int :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: 2-D array of size :math:`N_u \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bspline_surf_dsdu_dp_iso_u(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, u: float, nv: int) Evaluates the sensitivity of a B-spline surface first derivative w.r.t. :math:`u` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param nv: Number of linearly spaced points in the :math:`v`-direction :type nv: int :returns: 2-D array of size :math:`N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bspline_surf_dsdu_dp_iso_v(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, nu: int, v: float) Evaluates the sensitivity of a B-spline surface first derivative w.r.t. :math:`u` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_u` linearly-spaced points along the :math:`u`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly spaced points in the :math:`u`-direction :type nu: int :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: 2-D array of size :math:`N_u \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bspline_surf_dsdv_dp_iso_u(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, u: float, nv: int) Evaluates the sensitivity of a B-spline surface first derivative w.r.t. :math:`v` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param nv: Number of linearly spaced points in the :math:`v`-direction :type nv: int :returns: 2-D array of size :math:`N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bspline_surf_dsdv_dp_iso_v(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, nu: int, v: float) Evaluates the sensitivity of a B-spline surface first derivative w.r.t. :math:`v` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_u` linearly-spaced points along the :math:`u`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly spaced points in the :math:`u`-direction :type nu: int :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: 2-D array of size :math:`N_u \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bspline_surf_d2sdu2_dp_iso_u(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, u: float, nv: int) Evaluates the sensitivity of a B-spline surface second derivative w.r.t. :math:`u` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param nv: Number of linearly spaced points in the :math:`v`-direction :type nv: int :returns: 2-D array of size :math:`N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bspline_surf_d2sdu2_dp_iso_v(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, nu: int, v: float) Evaluates the sensitivity of a B-spline surface second derivative w.r.t. :math:`u` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_u` linearly-spaced points along the :math:`u`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly spaced points in the :math:`u`-direction :type nu: int :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: 2-D array of size :math:`N_u \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bspline_surf_d2sdv2_dp_iso_u(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, u: float, nv: int) Evaluates the sensitivity of a B-spline surface second derivative w.r.t. :math:`v` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param nv: Number of linearly spaced points in the :math:`v`-direction :type nv: int :returns: 2-D array of size :math:`N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bspline_surf_d2sdv2_dp_iso_v(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, nu: int, v: float) Evaluates the sensitivity of a B-spline surface second derivative w.r.t. :math:`v` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_u` linearly-spaced points along the :math:`u`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly spaced points in the :math:`u`-direction :type nu: int :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: 2-D array of size :math:`N_u \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[float]] .. py:function:: bspline_surf_eval_grid(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], nu: int, nv: int) -> List[List[List[float]]] Evaluates a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space according to .. math:: \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N_{i,q}(u) N_{j,r}(v) \mathbf{P}_{i,j} where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline in the :math:`u`-direction is computed as ``q = len(ku) - len(p) - 1``, and the degree of the B-spline surface in the :math:`v`-direction is computed as ``r = len(kv) - len(p[0]) - 1``. :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` points on the B-spline surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: bspline_surf_dsdu_grid(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], nu: int, nv: int) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`u` on a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space according to .. math:: \frac{\partial}{\partial u} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N'_{i,q}(u) N_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`u` on the B-spline surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: bspline_surf_dsdv_grid(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], nu: int, nv: int) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`v` on a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space according to .. math:: \frac{\partial}{\partial v} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N_{i,q}(u) N'_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`v` on the B-spline surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: bspline_surf_d2sdu2_grid(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], nu: int, nv: int) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`u` on a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space according to .. math:: \frac{\partial^2}{\partial u^2} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N''_{i,q}(u) N_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`u` on the B-spline surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: bspline_surf_d2sdv2_grid(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], nu: int, nv: int) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`v` on a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space according to .. math:: \frac{\partial^2}{\partial v^2} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N_{i,q}(u) N''_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`v` on the B-spline surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: bspline_surf_eval_uvvecs(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs according to .. math:: \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N_{i,q}(u) N_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of points on the B-spline surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: bspline_surf_dsdu_uvvecs(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`u` on a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs according to .. math:: \frac{\partial}{\partial u} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N'_{i,q}(u) N_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`u` on the B-spline surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: bspline_surf_dsdv_uvvecs(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`v` on a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs according to .. math:: \frac{\partial}{\partial v} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N_{i,q}(u) N'_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`v` on the B-spline surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: bspline_surf_d2sdu2_uvvecs(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`u` on a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs according to .. math:: \frac{\partial^2}{\partial u^2} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N''_{i,q}(u) N_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`u` on the B-spline surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: bspline_surf_d2sdv2_uvvecs(p: Iterable[Iterable[Iterable[float]]], ku: Iterable[float], kv: Iterable[float], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`v` on a B-spline surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs according to .. math:: \frac{\partial^2}{\partial v^2} \mathbf{S}(u,v) = \sum\limits_{i=0}^n \sum\limits_{j=0}^m N_{i,q}(u) N''_{j,r}(v) \mathbf{P}_{i,j} :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`v` on the B-spline surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: bspline_surf_eval_dp_grid(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, nu: int, nv: int) -> List[List[List[float]]] Evaluates the sensitivity of a B-spline surface with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly spaced points in the :math:`u`-direction :type nu: int :param nv: Number of linearly spaced points in the :math:`v`-direction :type nv: int :returns: 3-D array of size :math:`N_u \times N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: bspline_surf_dsdu_dp_grid(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, nu: int, nv: int) -> List[List[List[float]]] Evaluates the sensitivity of a B-spline surface with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_u` linearly-spaced points along the :math:`u`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly spaced points in the :math:`u`-direction :type nu: int :param nv: Number of linearly spaced points in the :math:`v`-direction :type nv: int :returns: 3-D array of size :math:`N_u \times N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: bspline_surf_dsdv_dp_grid(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, nu: int, nv: int) -> List[List[List[float]]] Evaluates the sensitivity of a B-spline surface first derivative w.r.t. :math:`u` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly spaced points in the :math:`u`-direction :type nu: int :param nv: Number of linearly spaced points in the :math:`v`-direction :type nv: int :returns: 3-D array of size :math:`N_u \times N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: bspline_surf_d2sdu2_dp_grid(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, nu: int, nv: int) -> List[List[List[float]]] Evaluates the sensitivity of a B-spline surface first derivative w.r.t. :math:`u` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_u` linearly-spaced points along the :math:`u`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly spaced points in the :math:`u`-direction :type nu: int :param nv: Number of linearly spaced points in the :math:`v`-direction :type nv: int :returns: 3-D array of size :math:`N_u \times N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: bspline_surf_d2sdv2_dp_grid(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, nu: int, nv: int) -> List[List[List[float]]] Evaluates the sensitivity of a B-spline surface first derivative w.r.t. :math:`v` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param nu: Number of linearly spaced points in the :math:`u`-direction :type nu: int :param nv: Number of linearly spaced points in the :math:`v`-direction :type nv: int :returns: 3-D array of size :math:`N_u \times N_v \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: bspline_surf_eval_dp_uvvecs(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the sensitivity of a B-spline surface first derivative w.r.t. :math:`v` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_u` linearly-spaced points along the :math:`u`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter vector in the :math:`u`-direction :type u: Iterable[float]: :param v: Parameter vector in the :math:`v`-direction :type v: Iterable[float]: :returns: 3-D array of size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: bspline_surf_dsdu_dp_uvvecs(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the sensitivity of a B-spline surface second derivative w.r.t. :math:`u` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter vector in the :math:`u`-direction :type u: Iterable[float]: :param v: Parameter vector in the :math:`v`-direction :type v: Iterable[float]: :returns: 3-D array of size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: bspline_surf_dsdv_dp_uvvecs(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the sensitivity of a B-spline surface second derivative w.r.t. :math:`u` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_u` linearly-spaced points along the :math:`u`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter vector in the :math:`u`-direction :type u: Iterable[float]: :param v: Parameter vector in the :math:`v`-direction :type v: Iterable[float]: :returns: 3-D array of size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: bspline_surf_d2sdu2_dp_uvvecs(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the sensitivity of a B-spline surface second derivative w.r.t. :math:`v` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter vector in the :math:`u`-direction :type u: Iterable[float]: :param v: Parameter vector in the :math:`v`-direction :type v: Iterable[float]: :returns: 3-D array of size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: bspline_surf_d2sdv2_dp_iuvvecs(ku: Iterable[float], kv: Iterable[float], i: int, j: int, q: int, r: int, dim: int, u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the sensitivity of a B-spline surface second derivative w.r.t. :math:`v` with respect to control point :math:`\mathbf{P}_{i,j}` at :math:`N_u` linearly-spaced points along the :math:`u`-direction :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param i: Index :math:`i` (:math:`u`-direction) of the control point :type i: int :param j: Index :math:`j` (:math:`v`-direction) of the control point :type j: int :param q: Degree of the surface in the :math:`u`-direction :type q: int :param r: Degree of the surface in the :math:`v`-direction :type r: int :param dim: Number of spatial dimensions in the surface. Usually ``3`` :type dim: int :param u: Parameter vector in the :math:`u`-direction :type u: Iterable[float]: :param v: Parameter vector in the :math:`v`-direction :type v: Iterable[float]: :returns: 3-D array of size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the number of spatial dimensions :rtype: List[List[List[float]]] .. py:function:: nurbs_curve_eval(p: Iterable[Iterable[float]], w: Iterable[float], k: Iterable[float], t: float) -> List[float] Evaluates a Non-Uniform Rational B-Spline (NURBS) curve with :math:`n+1` control points at a single :math:`t`-value according to .. math:: \mathbf{C}(t) = \frac{\sum_{i=0}^n N_{i,q}(t) w_i \mathbf{P}_i}{\sum_{i=0}^n N_{i,q}(t) w_i} where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param t: Parameter value :math:`t` at which to evaluate :type t: float :returns: Value of the NURBS curve at :math:`t`. Has the same size as the inner dimension of ``p`` :rtype: List[float] .. py:function:: nurbs_curve_eval_dp(w: Iterable[float], k: Iterable[float], i: int, q: int, dim: int, t: float) -> List[float] Evaluates the derivative of the NURBS curve with respect to an individual control point at a given :math:`t`-value :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter value at which to evaluate the curve sensitivity :type t: float :returns: 1-D list representing the curve sensitivity at :math:`t` to the control point :math:`\mathbf{P}_i` :rtype: List[float] .. py:function:: nurbs_curve_dcdt(p: Iterable[Iterable[float]], w: Iterable[float], k: Iterable[float], t: float) -> List[float] Evaluates a the first derivative with respect to :math:`t` of a Non-Uniform Rational B-Spline (NURBS) curve with :math:`n+1` control points at a single :math:`t`-value according to .. math:: \frac{\text{d}}{\text{d}t} \mathbf{C}(t) = \frac{f'(t)g(t)-f(t)g'(t)}{g^2(t)} where .. math:: \begin{align} f(t) &= \sum\limits_{i=0}^n N_{i,q}(t) w_i \mathbf{P}_i \\ g(t) &= \sum\limits_{i=0}^n N_{i,q}(t) w_i \\ f'(t) &= \sum\limits_{i=0}^n N'_{i,q}(t) w_i \mathbf{P}_i \\ g'(t) &= \sum\limits_{i=0}^n N'_{i,q}(t) w_i \\ N'_{i,q}(t) &= \frac{q}{k_{i+q} - k_i} N_{i,q-1}(t) - \frac{q}{k_{i+q+1} - k_{i+1}} N_{i+1,q-1}(t) \\ \end{align} and :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param t: Parameter value :math:`t` at which to evaluate :type t: float :returns: Value of the NURBS curve derivative w.r.t. :math:`t` at :math:`t`. Has the same size as the inner dimension of ``p`` :rtype: List[float] .. py:function:: nurbs_curve_dcdt_dp(w: Iterable[float], k: Iterable[float], i: int, q: int, dim: int, t: float) -> List[float] Evaluates the sensitivity of the NURBS curve first derivative with respect to an individual control point at a given :math:`t`-value :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter value at which to evaluate the curve sensitivity :type t: float :returns: 1-D list representing the curve first derivative sensitivity at :math:`t` to the control point :math:`\mathbf{P}_i` :rtype: List[float] .. py:function:: nurbs_curve_d2cdt2(p: Iterable[Iterable[float]], w: Iterable[float], k: Iterable[float], t: float) -> List[float] Evaluates a the second derivative with respect to :math:`t` of a Non-Uniform Rational B-Spline (NURBS) curve with :math:`n+1` control points at a single :math:`t`-value according to .. math:: \frac{\text{d}^2}{\text{d}t^2} \mathbf{C}(t) = \frac{f''(t)g^2(t) - f(t)g(t)g''(t) - 2f'(t)g(t)g'(t) + 2f(t)[g'(t)]^2}{g^3(t)} where .. math:: \begin{align} f(t) &= \sum\limits_{i=0}^n N_{i,q}(t) w_i \mathbf{P}_i \\ g(t) &= \sum\limits_{i=0}^n N_{i,q}(t) w_i \\ f'(t) &= \sum\limits_{i=0}^n N'_{i,q}(t) w_i \mathbf{P}_i \\ g'(t) &= \sum\limits_{i=0}^n N'_{i,q}(t) w_i \\ f''(t) &= \sum\limits_{i=0}^n N''_{i,q}(t) w_i \mathbf{P}_i \\ g''(t) &= \sum\limits_{i=0}^n N''_{i,q}(t) w_i \\ N'_{i,q}(t) &= \frac{q}{k_{i+q} - k_i} N_{i,q-1}(t) - \frac{q}{k_{i+q+1} - k_{i+1}} N_{i+1,q-1}(t) \\ N''_{i,q}(t) &= \frac{q}{k_{i+q} - k_i} \left[ \frac{q-1}{k_{i+q-1}-k_i} N_{i,q-2}(t) - \frac{q-1}{k_{i+q}-k_{i+1}} N_{i+1,q-2}(t) \right] - \frac{q}{k_{i+q+1} - k_{i+1}} \left[ \frac{q-1}{k_{i+q}-k_{i+1}} N_{i+1,q-2}(t) - \frac{q-1}{k_{i+q+1}-k_{i+2}} N_{i+2,q-2}(t) \right] \end{align} and :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param t: Parameter value :math:`t` at which to evaluate :type t: float :returns: Value of the NURBS curve second derivative w.r.t. :math:`t` at :math:`t`. Has the same size as the inner dimension of ``p`` :rtype: List[float] .. py:function:: nurbs_curve_d2cdt2_dp(w: Iterable[float], k: Iterable[float], i: int, q: int, dim: int, t: float) -> List[float] Evaluates the sensitivity of the NURBS curve second derivative with respect to an individual control point at a given :math:`t`-value :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Parameter value at which to evaluate the curve sensitivity :type t: float :returns: 1-D list representing the curve second derivative sensitivity at :math:`t` to the control point :math:`\mathbf{P}_i` :rtype: List[float] .. py:function:: nurbs_curve_eval_grid(p: Iterable[Iterable[float]], w: Iterable[float], k: Iterable[float], nt: int) -> List[List[float]] Evaluates a Non-Uniform Rational B-Spline (NURBS) curve with :math:`n+1` control points on a grid of linearly-spaced :math:`t`-values according to .. math:: \mathbf{C}(t) = \frac{\sum_{i=0}^n N_{i,q}(t) w_i \mathbf{P}_i}{\sum_{i=0}^n N_{i,q}(t) w_i} where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the NURBS curve at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_curve_eval_dp_grid(w: Iterable[float], k: Iterable[float], i: int, q: int, dim: int, nt: int) -> List[float] Evaluates the derivative of the NURBS curve with respect to an individual control point at a given :math:`t`-value :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the NURBS curve sensitivity w.r.t. :math:`\mathbf{P}_i` at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_curve_dcdt_grid(p: Iterable[Iterable[float]], w: Iterable[float], k: Iterable[float], nt: int) -> List[List[float]] Evaluates a the first derivative with respect to :math:`t` of a Non-Uniform Rational B-Spline (NURBS) curve with :math:`n+1` control points on a grid of linearly-spaced :math:`t`-values according to .. math:: \frac{\text{d}}{\text{d}t} \mathbf{C}(t) = \frac{f'(t)g(t)-f(t)g'(t)}{g^2(t)} where .. math:: \begin{align} f(t) &= \sum\limits_{i=0}^n N_{i,q}(t) w_i \mathbf{P}_i \\ g(t) &= \sum\limits_{i=0}^n N_{i,q}(t) w_i \\ f'(t) &= \sum\limits_{i=0}^n N'_{i,q}(t) w_i \mathbf{P}_i \\ g'(t) &= \sum\limits_{i=0}^n N'_{i,q}(t) w_i \\ N'_{i,q}(t) &= \frac{q}{k_{i+q} - k_i} N_{i,q-1}(t) - \frac{q}{k_{i+q+1} - k_{i+1}} N_{i+1,q-1}(t) \\ \end{align} and :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the NURBS curve first derivatve w.r.t. :math:`t` at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_curve_dcdt_dp_grid(w: Iterable[float], k: Iterable[float], i: int, q: int, dim: int, nt: int) -> List[float] Evaluates the sensitivity of the NURBS curve first derivative with respect to an individual control point at a given :math:`t`-value :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the NURBS curve first derivative sensitivity w.r.t. :math:`\mathbf{P}_i` at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_curve_d2cdt2_grid(p: Iterable[Iterable[float]], w: Iterable[float], k: Iterable[float], nt: int) -> List[List[float]] Evaluates a the second derivative with respect to :math:`t` of a Non-Uniform Rational B-Spline (NURBS) curve with :math:`n+1` control points on a grid of linearly-spaced :math:`t`-values according to .. math:: \frac{\text{d}^2}{\text{d}t^2} \mathbf{C}(t) = \frac{f''(t)g^2(t) - f(t)g(t)g''(t) - 2f'(t)g(t)g'(t) + 2f(t)[g'(t)]^2}{g^3(t)} where .. math:: \begin{align} f(t) &= \sum\limits_{i=0}^n N_{i,q}(t) w_i \mathbf{P}_i \\ g(t) &= \sum\limits_{i=0}^n N_{i,q}(t) w_i \\ f'(t) &= \sum\limits_{i=0}^n N'_{i,q}(t) w_i \mathbf{P}_i \\ g'(t) &= \sum\limits_{i=0}^n N'_{i,q}(t) w_i \\ f''(t) &= \sum\limits_{i=0}^n N''_{i,q}(t) w_i \mathbf{P}_i \\ g''(t) &= \sum\limits_{i=0}^n N''_{i,q}(t) w_i \\ N'_{i,q}(t) &= \frac{q}{k_{i+q} - k_i} N_{i,q-1}(t) - \frac{q}{k_{i+q+1} - k_{i+1}} N_{i+1,q-1}(t) \\ N''_{i,q}(t) &= \frac{q}{k_{i+q} - k_i} \left[ \frac{q-1}{k_{i+q-1}-k_i} N_{i,q-2}(t) - \frac{q-1}{k_{i+q}-k_{i+1}} N_{i+1,q-2}(t) \right] - \frac{q}{k_{i+q+1} - k_{i+1}} \left[ \frac{q-1}{k_{i+q}-k_{i+1}} N_{i+1,q-2}(t) - \frac{q-1}{k_{i+q+1}-k_{i+2}} N_{i+2,q-2}(t) \right] \end{align} and :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the NURBS curve second derivative w.r.t. :math:`t` at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_curve_d2cdt2_dp_grid(w: Iterable[float], k: Iterable[float], i: int, q: int, dim: int, nt: int) -> List[float] Evaluates the sensitivity of the NURBS curve second derivative with respect to an individual control point at a given :math:`t`-value :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` 1-D list or array of knots :type dim: int :param nt: Number of linearly-spaced points in :math:`t`. E.g., ``nt=3`` outputs the evaluation of the curve at :math:`t=0.0`, :math:`t=0.5`, and :math:`t=1.0`. :type nt: int :returns: Value of the NURBS curve second derivative sensitivity w.r.t. :math:`\mathbf{P}_i` at :math:`N_t` linearly-spaced points. Output array has size :math:`N_t \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_curve_eval_tvec(p: Iterable[Iterable[float]], w: Iterable[float], k: Iterable[float], t: Iterable[float]) -> List[List[float]] Evaluates a Non-Uniform Rational B-Spline (NURBS) curve with :math:`n+1` control points on a grid of linearly-spaced :math:`t`-values according to .. math:: \mathbf{C}(t) = \frac{\sum_{i=0}^n N_{i,q}(t) w_i \mathbf{P}_i}{\sum_{i=0}^n N_{i,q}(t) w_i} where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param t: Vector of parameter values :type t: Iterable[float] :returns: Value of the NURBS curve along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_curve_eval_dp_tvec(w: Iterable[float], k: Iterable[float], i: int, q: int, dim: int, t: Iterable[float]) -> List[float] Evaluates the derivative of the NURBS curve with respect to an individual control point at a given :math:`t`-value :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Vector of parameter values :type t: Iterable[float] :returns: Value of the NURBS curve sensitivity w.r.t. :math:`\mathbf{P}_i` along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_curve_dcdt_tvec(p: Iterable[Iterable[float]], w: Iterable[float], k: Iterable[float], t: Iterable[float]) -> List[List[float]] Evaluates a the first derivative with respect to :math:`t` of a Non-Uniform Rational B-Spline (NURBS) curve with :math:`n+1` control points on a grid of linearly-spaced :math:`t`-values according to .. math:: \frac{\text{d}}{\text{d}t} \mathbf{C}(t) = \frac{f'(t)g(t)-f(t)g'(t)}{g^2(t)} where .. math:: \begin{align} f(t) &= \sum\limits_{i=0}^n N_{i,q}(t) w_i \mathbf{P}_i \\ g(t) &= \sum\limits_{i=0}^n N_{i,q}(t) w_i \\ f'(t) &= \sum\limits_{i=0}^n N'_{i,q}(t) w_i \mathbf{P}_i \\ g'(t) &= \sum\limits_{i=0}^n N'_{i,q}(t) w_i \\ N'_{i,q}(t) &= \frac{q}{k_{i+q} - k_i} N_{i,q-1}(t) - \frac{q}{k_{i+q+1} - k_{i+1}} N_{i+1,q-1}(t) \\ \end{align} and :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param t: Vector of parameter values :type t: Iterable[float] :returns: Value of the NURBS curve first derivatve w.r.t. :math:`t` along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_curve_dcdt_dp_tvec(w: Iterable[float], k: Iterable[float], i: int, q: int, dim: int, t: Iterable[float]) -> List[float] Evaluates the sensitivity of the NURBS curve first derivative with respect to an individual control point at a given :math:`t`-value :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` :type dim: int :param t: Vector of parameter values :type t: Iterable[float] :returns: Value of the NURBS curve first derivative sensitivity w.r.t. :math:`\mathbf{P}_i` along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_curve_d2cdt2_tvec(p: Iterable[Iterable[float]], w: Iterable[float], k: Iterable[float], t: Iterable[float]) -> List[List[float]] Evaluates a the second derivative with respect to :math:`t` of a Non-Uniform Rational B-Spline (NURBS) curve with :math:`n+1` control points on a grid of linearly-spaced :math:`t`-values according to .. math:: \frac{\text{d}^2}{\text{d}t^2} \mathbf{C}(t) = \frac{f''(t)g^2(t) - f(t)g(t)g''(t) - 2f'(t)g(t)g'(t) + 2f(t)[g'(t)]^2}{g^3(t)} where .. math:: \begin{align} f(t) &= \sum\limits_{i=0}^n N_{i,q}(t) w_i \mathbf{P}_i \\ g(t) &= \sum\limits_{i=0}^n N_{i,q}(t) w_i \\ f'(t) &= \sum\limits_{i=0}^n N'_{i,q}(t) w_i \mathbf{P}_i \\ g'(t) &= \sum\limits_{i=0}^n N'_{i,q}(t) w_i \\ f''(t) &= \sum\limits_{i=0}^n N''_{i,q}(t) w_i \mathbf{P}_i \\ g''(t) &= \sum\limits_{i=0}^n N''_{i,q}(t) w_i \\ N'_{i,q}(t) &= \frac{q}{k_{i+q} - k_i} N_{i,q-1}(t) - \frac{q}{k_{i+q+1} - k_{i+1}} N_{i+1,q-1}(t) \\ N''_{i,q}(t) &= \frac{q}{k_{i+q} - k_i} \left[ \frac{q-1}{k_{i+q-1}-k_i} N_{i,q-2}(t) - \frac{q-1}{k_{i+q}-k_{i+1}} N_{i+1,q-2}(t) \right] - \frac{q}{k_{i+q+1} - k_{i+1}} \left[ \frac{q-1}{k_{i+q}-k_{i+1}} N_{i+1,q-2}(t) - \frac{q-1}{k_{i+q+1}-k_{i+2}} N_{i+2,q-2}(t) \right] \end{align} and :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline is computed as ``q = len(k) - len(p) - 1``. :param p: 2-D list or array of control points where the inner dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[float]] :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param t: Vector of parameter values :type t: Iterable[float] :returns: Value of the NURBS curve second derivative w.r.t. :math:`t` along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_curve_d2cdt2_dp_tvec(w: Iterable[float], k: Iterable[float], i: int, q: int, dim: int, t: Iterable[float]) -> List[float] Evaluates the sensitivity of the NURBS curve second derivative with respect to an individual control point at a given :math:`t`-value :param w: 1-D list or array of weights corresponding to each of control points. Must have length equal to the outer dimension of ``p``. :type w: Iterable[float] :param k: 1-D list or array of knots :type k: Iterable[float] :param i: Index of the control point :type i: int :param q: Degree of the curve :type q: int :param dim: Number of spatial dimensions in the curve. Usually ``2`` or ``3`` 1-D list or array of knots :type dim: int :param t: Vector of parameter values :type t: Iterable[float] :returns: Value of the NURBS curve second derivative sensitivity w.r.t. :math:`\mathbf{P}_i` along a vector of :math:`t`-values. Output array has size :math:`\text{len}(t) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_surf_eval(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], u: float, v: float) -> List[float] Evaluates a Non-Uniform Rational B-Spline (NURBS) surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair according to .. math:: \mathbf{S}(u,v) = \frac{\sum_{i=0}^n \sum_{j=0}^m N_{i,q}(u) N_{j,r}(v) w_{i,j} \mathbf{P}_{i,j}}{\sum_{i=0}^n \sum_{j=0}^m N_{i,q}(u) N_{j,r}(v) w_{i,j}} where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline in the :math:`u`-direction is computed as ``q = len(ku) - len(p) - 1``, and the degree of the B-spline surface in the :math:`v`-direction is computed as ``r = len(kv) - len(p[0]) - 1``. :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the NURBS surface at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: nurbs_surf_dsdu(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], u: float, v: float) -> List[float] Evaluates the first derivative w.r.t. :math:`u` of a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the NURBS surface first derivative w.r.t. :math:`u` at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: nurbs_surf_dsdv(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], u: float, v: float) -> List[float] Evaluates the first derivative w.r.t. :math:`v` of a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the NURBS surface first derivative w.r.t. :math:`v` at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: nurbs_surf_d2sdu2(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], u: float, v: float) -> List[float] Evaluates the second derivative w.r.t. :math:`u` of a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the NURBS surface second derivative w.r.t. :math:`u` at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: nurbs_surf_d2sdv2(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], u: float, v: float) -> List[float] Evaluates the second derivative w.r.t. :math:`v` of a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at a :math:`(u,v)` parameter pair :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction at which to evaluate the surface :type u: float :param v: Parameter value in the :math:`v`-direction at which to evaluate the surface :type v: float :returns: Value of the NURBS surface second derivative w.r.t. :math:`v` at :math:`(u,v)`. Has the same size as the innermost dimension of ``p`` :rtype: List[float] .. py:function:: nurbs_surf_eval_iso_u(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], u: float, nv: int) -> List[List[float]] Evaluates an isoparametric curve in :math:`u` of a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` points along the :math:`u`-isoparametric curve of the NURBS surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_surf_eval_iso_v(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], nu: int, v: float) -> List[List[float]] Evaluates an isoparametric curve in :math:`v` of a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` points along the :math:`v`-isoparametric curve of the NURBS surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_surf_dsdu_iso_u(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], u: float, nv: int) -> List[List[float]] Evaluates the first derivative w.r.t. :math:`u` along an isoparametric curve in :math:`u` of a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` first derivatives w.r.t. :math:`u` along the :math:`u`-isoparametric curve of the NURBS surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_surf_dsdu_iso_v(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], nu: int, v: float) -> List[List[float]] Evaluates the first derivative w.r.t. :math:`u` along an isoparametric curve in :math:`v` of a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` first derivatives w.r.t. :math:`u` along the :math:`v`-isoparametric curve of the NURBS surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_surf_dsdv_iso_u(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], u: float, nv: int) -> List[List[float]] Evaluates the first derivative w.r.t. :math:`v` along an isoparametric curve in :math:`u` of a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` first derivatives w.r.t. :math:`v` along the :math:`u`-isoparametric curve of the NURBS surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_surf_dsdv_iso_v(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], nu: int, v: float) -> List[List[float]] Evaluates the first derivative w.r.t. :math:`v` along an isoparametric curve in :math:`v` of a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` first derivatives w.r.t. :math:`v` along the :math:`v`-isoparametric curve of the NURBS surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_surf_d2sdu2_iso_u(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], u: float, nv: int) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`u` along an isoparametric curve in :math:`u` of a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` second derivatives w.r.t. :math:`u` along the :math:`u`-isoparametric curve of the NURBS surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_surf_d2sdu2_iso_v(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], nu: int, v: float) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`u` along an isoparametric curve in :math:`v` of a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` second derivatives w.r.t. :math:`u` along the :math:`v`-isoparametric curve of the NURBS surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_surf_d2sdv2_iso_u(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], u: float, nv: int) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`v` along an isoparametric curve in :math:`u` of a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Parameter value in the :math:`u`-direction defining the isoparametric curve :type u: float :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_v` second derivatives w.r.t. :math:`v` along the :math:`u`-isoparametric curve of the NURBS surface. Output array has size :math:`N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_surf_d2sdv2_iso_v(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], nu: int, v: float) -> List[List[float]] Evaluates the second derivative w.r.t. :math:`v` along an isoparametric curve in :math:`v` of a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_v` linearly-spaced points along the :math:`v`-direction :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param v: Parameter value in the :math:`v`-direction defining the isoparametric curve :type v: float :returns: Values of :math:`N_u` second derivatives w.r.t. :math:`v` along the :math:`v`-isoparametric curve of the NURBS surface. Output array has size :math:`N_u \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[float]] .. py:function:: nurbs_surf_eval_grid(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], nu: int, nv: int) -> List[List[List[float]]] Evaluates a Non-Uniform Rational B-Spline (NURBS) surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space according to .. math:: \mathbf{S}(u,v) = \frac{\sum_{i=0}^n \sum_{j=0}^m N_{i,q}(u) N_{j,r}(v) w_{i,j} \mathbf{P}_{i,j}}{\sum_{i=0}^n \sum_{j=0}^m N_{i,q}(u) N_{j,r}(v) w_{i,j}} where :math:`N_{i,q}(t)` is the B-spline basis function of degree :math:`q`. The degree of the B-spline in the :math:`u`-direction is computed as ``q = len(ku) - len(p) - 1``, and the degree of the B-spline surface in the :math:`v`-direction is computed as ``r = len(kv) - len(p[0]) - 1``. :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` points on the NURBS surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: nurbs_surf_dsdu_grid(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], nu: int, nv: int) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`u` on a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`u` on the NURBS surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: nurbs_surf_dsdv_grid(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], nu: int, nv: int) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`v` on a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`v` on the NURBS surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: nurbs_surf_d2sdu2_grid(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], nu: int, nv: int) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`u` on a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`u` on the NURBS surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: nurbs_surf_d2sdv2_grid(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], nu: int, nv: int) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`v` on a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at :math:`N_u \times N_v` points along a linearly-spaced rectangular grid in :math:`(u,v)`-space :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param nu: Number of linearly-spaced points in the :math:`u`-direction. E.g., ``nu=3`` outputs the evaluation of the surface at :math:`u=0.0`, :math:`u=0.5`, and :math:`u=1.0`. :type nu: int :param nv: Number of linearly-spaced points in the :math:`v`-direction. E.g., ``nv=3`` outputs the evaluation of the surface at :math:`v=0.0`, :math:`v=0.5`, and :math:`v=1.0`. :type nv: int :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`v` on the NURBS surface at :math:`(u,v)`. Output array has size :math:`N_u \times N_v \times d`, where :math:`d` is the spatial dimension (usually either ``2``, ``3``, or ``4``) :rtype: List[List[List[float]]] .. py:function:: nurbs_surf_eval_uvvecs(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of points on the NURBS surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: nurbs_surf_dsdu_uvvecs(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`u` on a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`u` on the NURBS surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: nurbs_surf_dsdv_uvvecs(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the first derivative with respect to :math:`v` on a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` first derivatives with respsect to :math:`v` on the NURBS surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: nurbs_surf_d2sdu2_uvvecs(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`u` on a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`u` on the NURBS surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]] .. py:function:: nurbs_surf_d2sdv2_uvvecs(p: Iterable[Iterable[Iterable[float]]], w: Iterable[Iterable[float]], ku: Iterable[float], kv: Iterable[float], u: Iterable[float], v: Iterable[float]) -> List[List[List[float]]] Evaluates the second derivative with respect to :math:`v` on a NURBS surface with :math:`n+1` control points in the :math:`u`-direction and :math:`m+1` control points in the :math:`v`-direction at any number of :math:`(u,v)` pairs :param p: 3-D list or array of control points where the innermost dimension can have any size, but the typical size is ``3`` (:math:`x`-:math:`y`-:math:`z` space) :type p: Iterable[Iterable[Iterable[float]]] :param w: 2-D list or array of weights corresponding to each of control points. The size of the array must be equal to the size of the first two dimensions of ``p`` (:math:`n+1 \times m+1`) :type w: Iterable[Iterable[float]] :param ku: 1-D list or array of knots in the :math:`u`-parametric direction :type ku: Iterable[float] :param kv: 1-D list or array of knots in the :math:`v`-parametric direction :type kv: Iterable[float] :param u: Vector of :math:`u`-values at which to evaluate the surface :type u: Iterable[float] :param v: Vector of :math:`v`-values at which to evaluate the surface :type v: Iterable[float] :returns: Values of :math:`N_u \times N_v` second derivatives with respsect to :math:`v` on the NURBS surface at each of the :math:`(u,v)` pairs. Output array has size :math:`\text{len}(u) \times \text{len}(v) \times d`, where :math:`d` is the spatial dimension (usually ``3``) :rtype: List[List[List[float]]]