Datasets:

---

jqop

/

python-code-dataset

like 0

[ "def", "surface_subdivide1", "(", ")", ":", "if", "NO_IMAGES", ":", "return", "surface", "=", "bezier", ".", "Surface", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "0.0", ",", "1.0", ",", "0.0", "]", ",", "[", "0.0", ",", "0.0", ",", "1.0", "]", "]", ")", ")", "surf_a", ",", "surf_b", ",", "surf_c", ",", "surf_d", "=", "surface", ".", "subdivide", "(", ")", "figure", ",", "(", "(", "ax1", ",", "ax2", ")", ",", "(", "ax3", ",", "ax4", ")", ")", "=", "plt", ".", "subplots", "(", "2", ",", "2", ")", "for", "ax", "in", "(", "ax1", ",", "ax2", ",", "ax3", ",", "ax4", ")", ":", "surface", ".", "plot", "(", "2", ",", "ax", "=", "ax", ")", "surf_a", ".", "plot", "(", "2", ",", "ax", "=", "ax1", ")", "ax1", ".", "text", "(", "1.0", "/", "6.0", ",", "1.0", "/", "6.0", ",", "r\"$A$\"", ",", "fontsize", "=", "20", ",", "verticalalignment", "=", "\"center\"", ",", "horizontalalignment", "=", "\"center\"", ",", ")", "surf_b", ".", "plot", "(", "2", ",", "ax", "=", "ax2", ")", "ax2", ".", "text", "(", "1.0", "/", "3.0", ",", "1.0", "/", "3.0", ",", "r\"$B$\"", ",", "fontsize", "=", "20", ",", "verticalalignment", "=", "\"center\"", ",", "horizontalalignment", "=", "\"center\"", ",", ")", "surf_c", ".", "plot", "(", "2", ",", "ax", "=", "ax3", ")", "ax3", ".", "text", "(", "2.0", "/", "3.0", ",", "1.0", "/", "6.0", ",", "r\"$C$\"", ",", "fontsize", "=", "20", ",", "verticalalignment", "=", "\"center\"", ",", "horizontalalignment", "=", "\"center\"", ",", ")", "surf_d", ".", "plot", "(", "2", ",", "ax", "=", "ax4", ")", "ax4", ".", "text", "(", "1.0", "/", "6.0", ",", "2.0", "/", "3.0", ",", "r\"$D$\"", ",", "fontsize", "=", "20", ",", "verticalalignment", "=", "\"center\"", ",", "horizontalalignment", "=", "\"center\"", ",", ")", "for", "ax", "in", "(", "ax1", ",", "ax2", ",", "ax3", ",", "ax4", ")", ":", "ax", ".", "axis", "(", "\"scaled\"", ")", "save_image", "(", "figure", ",", "\"surface_subdivide1\"", ")" ]

[ "Image", "for", ":", "meth", ".", "Surface", ".", "subdivide", "docstring", "." ]

[ "def", "surface_subdivide2", "(", "surface", ",", "sub_surface_b", ")", ":", "if", "NO_IMAGES", ":", "return", "# Plot set-up.", "figure", "=", "plt", ".", "figure", "(", ")", "ax", "=", "figure", ".", "gca", "(", ")", "colors", "=", "seaborn", ".", "husl_palette", "(", "6", ")", "N", "=", "128", "s_vals", "=", "np", ".", "linspace", "(", "0.0", ",", "1.0", ",", "N", "+", "1", ")", "# Add edges from surface.", "add_edges", "(", "ax", ",", "surface", ",", "s_vals", ",", "colors", "[", "4", "]", ")", "# Now do the same for surface B.", "add_edges", "(", "ax", ",", "sub_surface_b", ",", "s_vals", ",", "colors", "[", "0", "]", ")", "# Add the control points polygon for the original surface.", "nodes", "=", "surface", ".", "_nodes", "[", ":", ",", "(", "0", ",", "2", ",", "4", ",", "5", ",", "0", ")", "]", "add_patch", "(", "ax", ",", "nodes", ",", "colors", "[", "2", "]", ",", "with_nodes", "=", "False", ")", "# Add the control points polygon for the sub-surface.", "nodes", "=", "sub_surface_b", ".", "_nodes", "[", ":", ",", "(", "0", ",", "1", ",", "2", ",", "5", ",", "3", ",", "0", ")", "]", "add_patch", "(", "ax", ",", "nodes", ",", "colors", "[", "1", "]", ",", "with_nodes", "=", "False", ")", "# Plot **all** the nodes.", "sub_nodes", "=", "sub_surface_b", ".", "_nodes", "ax", ".", "plot", "(", "sub_nodes", "[", "0", ",", ":", "]", ",", "sub_nodes", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ",", ")", "# Take those same points and add the boundary.", "ax", ".", "plot", "(", "nodes", "[", "0", ",", ":", "]", ",", "nodes", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"dashed\"", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "1.125", ",", "2.125", ")", "ax", ".", "set_ylim", "(", "-", "0.125", ",", "4.125", ")", "save_image", "(", "ax", ".", "figure", ",", "\"surface_subdivide2\"", ")" ]

[ "Image", "for", ":", "meth", ".", "Surface", ".", "subdivide", "docstring", "." ]

[ "def", "curved_polygon_constructor1", "(", "curved_poly", ")", ":", "if", "NO_IMAGES", ":", "return", "ax", "=", "curved_poly", ".", "plot", "(", "256", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "0.125", ",", "2.125", ")", "ax", ".", "set_ylim", "(", "-", "0.625", ",", "1.625", ")", "save_image", "(", "ax", ".", "figure", ",", "\"curved_polygon_constructor1.png\"", ")" ]

[ "Image", "for", ":", "class", ".", "CurvedPolygon", "docstring", "." ]

[ "def", "curve_specialize", "(", "curve", ",", "new_curve", ")", ":", "if", "NO_IMAGES", ":", "return", "ax", "=", "curve", ".", "plot", "(", "256", ")", "interval", "=", "r\"$\\left[0, 1\\right]$\"", "line", "=", "ax", ".", "lines", "[", "-", "1", "]", "line", ".", "set_label", "(", "interval", ")", "color1", "=", "line", ".", "get_color", "(", ")", "new_curve", ".", "plot", "(", "256", ",", "ax", "=", "ax", ")", "interval", "=", "r\"$\\left[-\\frac{1}{4}, \\frac{3}{4}\\right]$\"", "line", "=", "ax", ".", "lines", "[", "-", "1", "]", "line", ".", "set_label", "(", "interval", ")", "ax", ".", "plot", "(", "curve", ".", "_nodes", "[", "0", ",", "(", "0", ",", "-", "1", ")", "]", ",", "curve", ".", "_nodes", "[", "1", ",", "(", "0", ",", "-", "1", ")", "]", ",", "color", "=", "color1", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ",", ")", "ax", ".", "plot", "(", "new_curve", ".", "_nodes", "[", "0", ",", "(", "0", ",", "-", "1", ")", "]", ",", "new_curve", ".", "_nodes", "[", "1", ",", "(", "0", ",", "-", "1", ")", "]", ",", "color", "=", "line", ".", "get_color", "(", ")", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ",", ")", "ax", ".", "legend", "(", "loc", "=", "\"lower right\"", ",", "fontsize", "=", "12", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "0.375", ",", "1.125", ")", "ax", ".", "set_ylim", "(", "-", "0.75", ",", "0.625", ")", "save_image", "(", "ax", ".", "figure", ",", "\"curve_specialize.png\"", ")" ]

[ "Image", "for", ":", "meth", ".", "Curve", ".", "specialize", "docstring", "." ]

[ "def", "newton_refine_surface", "(", "surface", ",", "x_val", ",", "y_val", ",", "s", ",", "t", ",", "new_s", ",", "new_t", ")", ":", "if", "NO_IMAGES", ":", "return", "figure", ",", "(", "ax1", ",", "ax2", ")", "=", "plt", ".", "subplots", "(", "1", ",", "2", ")", "# Plot features of the parameter space in ax1.", "tri_surf", "=", "bezier", ".", "Surface", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "0.0", ",", "1.0", ",", "0.0", "]", ",", "[", "0.0", ",", "0.0", ",", "1.0", "]", "]", ")", ")", "tri_surf", ".", "plot", "(", "2", ",", "ax", "=", "ax1", ")", "ax1", ".", "plot", "(", "[", "0.25", "]", ",", "[", "0.5", "]", ",", "marker", "=", "\"H\"", ")", "ax1", ".", "plot", "(", "[", "s", "]", ",", "[", "t", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ")", "ax1", ".", "plot", "(", "[", "new_s", "]", ",", "[", "new_t", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ",", "markeredgewidth", "=", "1", ",", "markerfacecolor", "=", "\"None\"", ",", ")", "# Plot the equivalent output in ax2.", "surface", ".", "plot", "(", "256", ",", "ax", "=", "ax2", ")", "points", "=", "surface", ".", "evaluate_cartesian_multi", "(", "np", ".", "asfortranarray", "(", "[", "[", "s", ",", "t", "]", ",", "[", "new_s", ",", "new_t", "]", "]", ")", ")", "ax2", ".", "plot", "(", "[", "x_val", "]", ",", "[", "y_val", "]", ",", "marker", "=", "\"H\"", ")", "ax2", ".", "plot", "(", "points", "[", "0", ",", "[", "0", "]", "]", ",", "points", "[", "1", ",", "[", "0", "]", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ",", ")", "ax2", ".", "plot", "(", "points", "[", "0", ",", "[", "1", "]", "]", ",", "points", "[", "1", ",", "[", "1", "]", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ",", "markeredgewidth", "=", "1", ",", "markerfacecolor", "=", "\"None\"", ",", ")", "# Set the axis bounds / scaling.", "ax1", ".", "axis", "(", "\"scaled\"", ")", "ax1", ".", "set_xlim", "(", "-", "0.0625", ",", "1.0625", ")", "ax1", ".", "set_ylim", "(", "-", "0.0625", ",", "1.0625", ")", "ax2", ".", "axis", "(", "\"scaled\"", ")", "ax2", ".", "set_xlim", "(", "-", "0.125", ",", "2.125", ")", "ax2", ".", "set_ylim", "(", "-", "0.125", ",", "2.125", ")", "save_image", "(", "figure", ",", "\"newton_refine_surface.png\"", ")" ]

[ "Image", "for", ":", "func", ":", ".", "_surface_helpers", ".", "newton_refine", "docstring", "." ]

[ "def", "classify_intersection1", "(", "s", ",", "curve1", ",", "tangent1", ",", "curve2", ",", "tangent2", ")", ":", "if", "NO_IMAGES", ":", "return", "surface1", "=", "bezier", ".", "Surface", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "1.0", ",", "1.75", ",", "2.0", ",", "1.0", ",", "1.5", ",", "1.0", "]", ",", "[", "0.0", ",", "0.25", ",", "1.0", ",", "1.0", ",", "1.5", ",", "2.0", "]", "]", ")", ")", "surface2", "=", "bezier", ".", "Surface", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "0.0", ",", "1.6875", ",", "2.0", ",", "0.25", ",", "1.25", ",", "0.5", "]", ",", "[", "0.0", ",", "0.0625", ",", "0.5", ",", "1.0", ",", "1.25", ",", "2.0", "]", ",", "]", ")", ")", "ax", "=", "classify_help", "(", "s", ",", "curve1", ",", "surface1", ",", "curve2", ",", "surface2", ",", "0", ")", "(", "int_x", ",", ")", ",", "(", "int_y", ",", ")", "=", "curve1", ".", "evaluate", "(", "s", ")", "# Remove the alpha from the color", "color1", "=", "ax", ".", "patches", "[", "0", "]", ".", "get_facecolor", "(", ")", "[", ":", "3", "]", "color2", "=", "ax", ".", "patches", "[", "1", "]", ".", "get_facecolor", "(", ")", "[", ":", "3", "]", "ax", ".", "plot", "(", "[", "int_x", ",", "int_x", "+", "tangent1", "[", "0", ",", "0", "]", "]", ",", "[", "int_y", ",", "int_y", "+", "tangent1", "[", "1", ",", "0", "]", "]", ",", "color", "=", "color1", ",", "linestyle", "=", "\"dashed\"", ",", ")", "ax", ".", "plot", "(", "[", "int_x", ",", "int_x", "+", "tangent2", "[", "0", ",", "0", "]", "]", ",", "[", "int_y", ",", "int_y", "+", "tangent2", "[", "1", ",", "0", "]", "]", ",", "color", "=", "color2", ",", "linestyle", "=", "\"dashed\"", ",", ")", "ax", ".", "plot", "(", "[", "int_x", "]", ",", "[", "int_y", "]", ",", "color", "=", "color1", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "0.125", ",", "2.125", ")", "ax", ".", "set_ylim", "(", "-", "0.125", ",", "1.125", ")", "save_image", "(", "ax", ".", "figure", ",", "\"classify_intersection1.png\"", ")" ]

[ "Image", "for", ":", "func", ":", ".", "_surface_helpers", ".", "classify_intersection", "docstring", "." ]

[ "def", "classify_intersection2", "(", "s", ",", "curve1", ",", "curve2", ")", ":", "if", "NO_IMAGES", ":", "return", "surface1", "=", "bezier", ".", "Surface", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "1.0", ",", "1.5", ",", "2.0", ",", "1.25", ",", "1.75", ",", "1.5", "]", ",", "[", "0.0", ",", "1.0", ",", "0.0", ",", "1.0", ",", "1.0", ",", "2.0", "]", "]", ")", ")", "surface2", "=", "bezier", ".", "Surface", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "0.0", ",", "1.5", ",", "3.0", ",", "0.75", ",", "2.25", ",", "1.5", "]", ",", "[", "0.0", ",", "1.0", ",", "0.0", ",", "2.0", ",", "2.0", ",", "4.0", "]", "]", ")", ")", "ax", "=", "classify_help", "(", "s", ",", "curve1", ",", "surface1", ",", "curve2", ",", "surface2", ",", "1", ")", "ax", ".", "set_xlim", "(", "-", "0.0625", ",", "3.0625", ")", "ax", ".", "set_ylim", "(", "-", "0.0625", ",", "0.5625", ")", "save_image", "(", "ax", ".", "figure", ",", "\"classify_intersection2.png\"", ")" ]

[ "Image", "for", ":", "func", ":", ".", "_surface_helpers", ".", "classify_intersection", "docstring", "." ]

[ "def", "classify_intersection5", "(", "s", ",", "curve1", ",", "curve2", ")", ":", "if", "NO_IMAGES", ":", "return", "surface1", "=", "bezier", ".", "Surface", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "1.0", ",", "1.5", ",", "2.0", ",", "1.25", ",", "1.75", ",", "1.5", "]", ",", "[", "0.0", ",", "1.0", ",", "0.0", ",", "0.9375", ",", "0.9375", ",", "1.875", "]", ",", "]", ")", ")", "surface2", "=", "bezier", ".", "Surface", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "3.0", ",", "1.5", ",", "0.0", ",", "2.25", ",", "0.75", ",", "1.5", "]", ",", "[", "0.0", ",", "1.0", ",", "0.0", ",", "-", "2.0", ",", "-", "2.0", ",", "-", "4.0", "]", ",", "]", ")", ")", "figure", ",", "(", "ax1", ",", "ax2", ")", "=", "plt", ".", "subplots", "(", "2", ",", "1", ")", "classify_help", "(", "s", ",", "curve1", ",", "surface1", ",", "curve2", ",", "surface2", ",", "0", ",", "ax", "=", "ax1", ")", "classify_help", "(", "s", ",", "curve1", ",", "surface1", ",", "curve2", ",", "surface2", ",", "1", ",", "ax", "=", "ax2", ")", "# Remove the alpha from the color", "color1", "=", "ax1", ".", "patches", "[", "0", "]", ".", "get_facecolor", "(", ")", "[", ":", "3", "]", "color2", "=", "ax1", ".", "patches", "[", "1", "]", ".", "get_facecolor", "(", ")", "[", ":", "3", "]", "# Now add the \"degenerate\" intersection polygons. The first", "# comes from specializing to", "# left1(0.5, 1.0)-left2(0.0, 0.25)-right1(0.375, 0.5)", "surface3", "=", "bezier", ".", "Surface", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "1.5", ",", "1.75", ",", "2.0", ",", "1.6875", ",", "1.9375", ",", "1.875", "]", ",", "[", "0.5", ",", "0.5", ",", "0.0", ",", "0.5", ",", "0.234375", ",", "0.46875", "]", ",", "]", ")", ")", "# NOTE: We don't require the intersection polygon be valid.", "surface3", ".", "plot", "(", "256", ",", "ax", "=", "ax1", ")", "# The second comes from specializing to", "# left1(0.0, 0.5)-right1(0.5, 0.625)-left3(0.75, 1.0)", "surface4", "=", "bezier", ".", "Surface", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "1.0", ",", "1.25", ",", "1.5", ",", "1.0625", ",", "1.3125", ",", "1.125", "]", ",", "[", "0.0", ",", "0.5", ",", "0.5", ",", "0.234375", ",", "0.5", ",", "0.46875", "]", ",", "]", ")", ")", "# NOTE: We don't require the intersection polygon be valid.", "surface4", ".", "plot", "(", "256", ",", "ax", "=", "ax2", ")", "(", "int_x", ",", ")", ",", "(", "int_y", ",", ")", "=", "curve1", ".", "evaluate", "(", "s", ")", "ax1", ".", "plot", "(", "[", "int_x", "]", ",", "[", "int_y", "]", ",", "color", "=", "color1", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ")", "ax2", ".", "plot", "(", "[", "int_x", "]", ",", "[", "int_y", "]", ",", "color", "=", "color2", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ")", "for", "ax", "in", "(", "ax1", ",", "ax2", ")", ":", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "0.0625", ",", "3.0625", ")", "ax", ".", "set_ylim", "(", "-", "0.0625", ",", "0.5625", ")", "plt", ".", "setp", "(", "ax1", ".", "get_xticklabels", "(", ")", ",", "visible", "=", "False", ")", "figure", ".", "tight_layout", "(", "h_pad", "=", "-", "7.0", ")", "save_image", "(", "figure", ",", "\"classify_intersection5.png\"", ")" ]

[ "Image", "for", ":", "func", ":", ".", "_surface_helpers", ".", "classify_intersection", "docstring", "." ]

[ "def", "classify_intersection7", "(", "s", ",", "curve1a", ",", "curve1b", ",", "curve2", ")", ":", "if", "NO_IMAGES", ":", "return", "surface1", "=", "bezier", ".", "Surface", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "0.0", ",", "4.5", ",", "9.0", ",", "0.0", ",", "4.5", ",", "0.0", "]", ",", "[", "0.0", ",", "0.0", ",", "2.25", ",", "1.25", ",", "2.375", ",", "2.5", "]", ",", "]", ")", ")", "surface2", "=", "bezier", ".", "Surface", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "11.25", ",", "9.0", ",", "2.75", ",", "8.125", ",", "3.875", ",", "5.0", "]", ",", "[", "0.0", ",", "4.5", ",", "1.0", ",", "-", "0.75", ",", "-", "0.25", ",", "-", "1.5", "]", ",", "]", ")", ")", "figure", ",", "(", "ax1", ",", "ax2", ")", "=", "plt", ".", "subplots", "(", "2", ",", "1", ")", "classify_help", "(", "s", ",", "curve1a", ",", "surface1", ",", "curve2", ",", "surface2", ",", "None", ",", "ax", "=", "ax1", ")", "surface1", ".", "_nodes", "=", "np", ".", "asfortranarray", "(", "surface1", ".", "_nodes", "[", ":", ",", "(", "2", ",", "4", ",", "5", ",", "1", ",", "3", ",", "0", ")", "]", ")", "surface1", ".", "_edges", "=", "None", "classify_help", "(", "0.0", ",", "curve1b", ",", "surface1", ",", "curve2", ",", "surface2", ",", "0", ",", "ax", "=", "ax2", ")", "for", "ax", "in", "(", "ax1", ",", "ax2", ")", ":", "ax", ".", "set_xlim", "(", "-", "0.125", ",", "11.5", ")", "ax", ".", "set_ylim", "(", "-", "0.125", ",", "2.625", ")", "plt", ".", "setp", "(", "ax1", ".", "get_xticklabels", "(", ")", ",", "visible", "=", "False", ")", "figure", ".", "tight_layout", "(", "h_pad", "=", "-", "5.0", ")", "save_image", "(", "figure", ",", "\"classify_intersection7.png\"", ")" ]

[ "Image", "for", ":", "func", ":", ".", "_surface_helpers", ".", "classify_intersection", "docstring", "." ]

[ "def", "get_curvature", "(", "nodes", ",", "s", ",", "tangent_vec", ",", "curvature", ")", ":", "if", "NO_IMAGES", ":", "return", "curve", "=", "bezier", ".", "Curve", ".", "from_nodes", "(", "nodes", ")", "# Find the center of the circle along the direction", "# perpendicular to the tangent vector (90 degree left turn).", "radius_dir", "=", "np", ".", "asfortranarray", "(", "[", "[", "-", "tangent_vec", "[", "1", ",", "0", "]", "]", ",", "[", "tangent_vec", "[", "0", ",", "0", "]", "]", "]", ")", "radius_dir", "/=", "np", ".", "linalg", ".", "norm", "(", "radius_dir", ",", "ord", "=", "2", ")", "point", "=", "curve", ".", "evaluate", "(", "s", ")", "circle_center", "=", "point", "+", "radius_dir", "/", "curvature", "# Add the curve.", "ax", "=", "curve", ".", "plot", "(", "256", ")", "# Add the circle.", "circle_center", "=", "circle_center", ".", "ravel", "(", "order", "=", "\"F\"", ")", "circle", "=", "plt", ".", "Circle", "(", "circle_center", ",", "1.0", "/", "abs", "(", "curvature", ")", ",", "alpha", "=", "0.25", ")", "ax", ".", "add_artist", "(", "circle", ")", "# Add the point.", "ax", ".", "plot", "(", "point", "[", "0", ",", ":", "]", ",", "point", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "marker", "=", "\"o\"", ",", "linestyle", "=", "\"None\"", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "0.0625", ",", "1.0625", ")", "ax", ".", "set_ylim", "(", "-", "0.0625", ",", "0.625", ")", "save_image", "(", "ax", ".", "figure", ",", "\"get_curvature.png\"", ")" ]

[ "Image", "for", ":", "func", ":", "get_curvature", "docstring", "." ]

[ "def", "curve_locate", "(", "curve", ",", "point1", ",", "point2", ",", "point3", ")", ":", "if", "NO_IMAGES", ":", "return", "ax", "=", "curve", ".", "plot", "(", "256", ")", "points", "=", "np", ".", "hstack", "(", "[", "point1", ",", "point2", ",", "point3", "]", ")", "ax", ".", "plot", "(", "points", "[", "0", ",", ":", "]", ",", "points", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "0.8125", ",", "0.0625", ")", "ax", ".", "set_ylim", "(", "0.75", ",", "2.0625", ")", "save_image", "(", "ax", ".", "figure", ",", "\"curve_locate.png\"", ")" ]

[ "Image", "for", ":", "meth", ".", "Curve", ".", "locate", "docstring", "." ]

[ "def", "newton_refine_curve", "(", "curve", ",", "point", ",", "s", ",", "new_s", ")", ":", "if", "NO_IMAGES", ":", "return", "ax", "=", "curve", ".", "plot", "(", "256", ")", "ax", ".", "plot", "(", "point", "[", "0", ",", ":", "]", ",", "point", "[", "1", ",", ":", "]", ",", "marker", "=", "\"H\"", ")", "wrong_points", "=", "curve", ".", "evaluate_multi", "(", "np", ".", "asfortranarray", "(", "[", "s", ",", "new_s", "]", ")", ")", "ax", ".", "plot", "(", "wrong_points", "[", "0", ",", "[", "0", "]", "]", ",", "wrong_points", "[", "1", ",", "[", "0", "]", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ",", ")", "ax", ".", "plot", "(", "wrong_points", "[", "0", ",", "[", "1", "]", "]", ",", "wrong_points", "[", "1", ",", "[", "1", "]", "]", ",", "color", "=", "\"black\"", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ",", "markeredgewidth", "=", "1", ",", "markerfacecolor", "=", "\"None\"", ",", ")", "# Set the axis bounds / scaling.", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "0.125", ",", "3.125", ")", "ax", ".", "set_ylim", "(", "-", "0.125", ",", "1.375", ")", "save_image", "(", "ax", ".", "figure", ",", "\"newton_refine_curve.png\"", ")" ]

[ "Image", "for", ":", "func", ":", ".", "_curve_helpers", ".", "newton_refine", "docstring", "." ]

[ "def", "newton_refine_curve_cusp", "(", "curve", ",", "s_vals", ")", ":", "if", "NO_IMAGES", ":", "return", "ax", "=", "curve", ".", "plot", "(", "256", ")", "ax", ".", "lines", "[", "-", "1", "]", ".", "zorder", "=", "1", "points", "=", "curve", ".", "evaluate_multi", "(", "np", ".", "asfortranarray", "(", "s_vals", ")", ")", "colors", "=", "seaborn", ".", "dark_palette", "(", "\"blue\"", ",", "6", ")", "ax", ".", "scatter", "(", "points", "[", "0", ",", ":", "]", ",", "points", "[", "1", ",", ":", "]", ",", "c", "=", "colors", ",", "s", "=", "20", ",", "alpha", "=", "0.75", ",", "zorder", "=", "2", ")", "# Set the axis bounds / scaling.", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "0.125", ",", "6.125", ")", "ax", ".", "set_ylim", "(", "-", "3.125", ",", "3.125", ")", "save_image", "(", "ax", ".", "figure", ",", "\"newton_refine_curve_cusp.png\"", ")" ]

[ "Image", "for", ":", "func", ":", ".", "_curve_helpers", ".", "newton_refine", "docstring", "." ]

[ "def", "classify_intersection8", "(", "s", ",", "curve1", ",", "surface1", ",", "curve2", ",", "surface2", ")", ":", "if", "NO_IMAGES", ":", "return", "ax", "=", "classify_help", "(", "s", ",", "curve1", ",", "surface1", ",", "curve2", ",", "surface2", ",", "None", ")", "ax", ".", "set_xlim", "(", "-", "1.125", ",", "1.125", ")", "ax", ".", "set_ylim", "(", "-", "0.125", ",", "1.125", ")", "save_image", "(", "ax", ".", "figure", ",", "\"classify_intersection8.png\"", ")" ]

[ "Image", "for", ":", "func", ":", ".", "_surface_helpers", ".", "classify_intersection", "docstring", "." ]

[ "def", "_edges_classify_intersection9", "(", ")", ":", "edges1", "=", "(", "bezier", ".", "Curve", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "32.0", ",", "30.0", "]", ",", "[", "20.0", ",", "25.0", "]", "]", ")", ")", ",", "bezier", ".", "Curve", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "30.0", ",", "25.0", ",", "20.0", "]", ",", "[", "25.0", ",", "20.0", ",", "20.0", "]", "]", ")", ")", ",", "bezier", ".", "Curve", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "20.0", ",", "25.0", ",", "30.0", "]", ",", "[", "20.0", ",", "20.0", ",", "15.0", "]", "]", ")", ")", ",", "bezier", ".", "Curve", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "30.0", ",", "32.0", "]", ",", "[", "15.0", ",", "20.0", "]", "]", ")", ")", ",", ")", "edges2", "=", "(", "bezier", ".", "Curve", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "8.0", ",", "10.0", "]", ",", "[", "20.0", ",", "15.0", "]", "]", ")", ")", ",", "bezier", ".", "Curve", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "10.0", ",", "15.0", ",", "20.0", "]", ",", "[", "15.0", ",", "20.0", ",", "20.0", "]", "]", ")", ")", ",", "bezier", ".", "Curve", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "20.0", ",", "15.0", ",", "10.0", "]", ",", "[", "20.0", ",", "20.0", ",", "25.0", "]", "]", ")", ")", ",", "bezier", ".", "Curve", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "10.0", ",", "8.0", "]", ",", "[", "25.0", ",", "20.0", "]", "]", ")", ")", ",", ")", "return", "edges1", ",", "edges2" ]

[ "The", "edges", "for", "the", "curved", "polygon", "intersection", "used", "below", "." ]

[ "def", "classify_intersection9", "(", "s", ",", "curve1", ",", "curve2", ")", ":", "if", "NO_IMAGES", ":", "return", "surface1", "=", "bezier", ".", "Surface", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "0.0", ",", "20.0", ",", "40.0", ",", "10.0", ",", "30.0", ",", "20.0", "]", ",", "[", "0.0", ",", "40.0", ",", "0.0", ",", "25.0", ",", "25.0", ",", "50.0", "]", ",", "]", ")", ")", "surface2", "=", "bezier", ".", "Surface", ".", "from_nodes", "(", "np", ".", "asfortranarray", "(", "[", "[", "40.0", ",", "20.0", ",", "0.0", ",", "30.0", ",", "10.0", ",", "20.0", "]", ",", "[", "40.0", ",", "0.0", ",", "40.0", ",", "15.0", ",", "15.0", ",", "-", "10.0", "]", ",", "]", ")", ")", "figure", ",", "(", "ax1", ",", "ax2", ")", "=", "plt", ".", "subplots", "(", "1", ",", "2", ")", "classify_help", "(", "s", ",", "curve1", ",", "surface1", ",", "curve2", ",", "surface2", ",", "0", ",", "ax", "=", "ax1", ")", "classify_help", "(", "s", ",", "curve1", ",", "surface1", ",", "curve2", ",", "surface2", ",", "1", ",", "ax", "=", "ax2", ")", "# Remove the alpha from the color", "color1", "=", "ax1", ".", "patches", "[", "0", "]", ".", "get_facecolor", "(", ")", "[", ":", "3", "]", "color2", "=", "ax1", ".", "patches", "[", "1", "]", ".", "get_facecolor", "(", ")", "[", ":", "3", "]", "# Now add the \"degenerate\" intersection polygons.", "cp_edges1", ",", "cp_edges2", "=", "_edges_classify_intersection9", "(", ")", "curved_polygon1", "=", "bezier", ".", "CurvedPolygon", "(", "*", "cp_edges1", ")", "curved_polygon1", ".", "plot", "(", "256", ",", "ax", "=", "ax1", ")", "curved_polygon2", "=", "bezier", ".", "CurvedPolygon", "(", "*", "cp_edges2", ")", "curved_polygon2", ".", "plot", "(", "256", ",", "ax", "=", "ax2", ")", "(", "int_x", ",", ")", ",", "(", "int_y", ",", ")", "=", "curve1", ".", "evaluate", "(", "s", ")", "ax1", ".", "plot", "(", "[", "int_x", "]", ",", "[", "int_y", "]", ",", "color", "=", "color1", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ")", "ax2", ".", "plot", "(", "[", "int_x", "]", ",", "[", "int_y", "]", ",", "color", "=", "color2", ",", "linestyle", "=", "\"None\"", ",", "marker", "=", "\"o\"", ")", "for", "ax", "in", "(", "ax1", ",", "ax2", ")", ":", "ax", ".", "axis", "(", "\"scaled\"", ")", "ax", ".", "set_xlim", "(", "-", "2.0", ",", "42.0", ")", "ax", ".", "set_ylim", "(", "-", "12.0", ",", "52.0", ")", "plt", ".", "setp", "(", "ax2", ".", "get_yticklabels", "(", ")", ",", "visible", "=", "False", ")", "figure", ".", "tight_layout", "(", "w_pad", "=", "1.0", ")", "save_image", "(", "figure", ",", "\"classify_intersection9.png\"", ")" ]

[ "Image", "for", ":", "func", ":", ".", "_surface_helpers", ".", "classify_intersection", "docstring", "." ]

[ "def", "curve_elevate", "(", "curve", ",", "elevated", ")", ":", "if", "NO_IMAGES", ":", "return", "figure", ",", "(", "ax1", ",", "ax2", ")", "=", "plt", ".", "subplots", "(", "1", ",", "2", ")", "curve", ".", "plot", "(", "256", ",", "ax", "=", "ax1", ")", "color", "=", "ax1", ".", "lines", "[", "-", "1", "]", ".", "get_color", "(", ")", "add_patch", "(", "ax1", ",", "curve", ".", "_nodes", ",", "color", ")", "elevated", ".", "plot", "(", "256", ",", "ax", "=", "ax2", ")", "color", "=", "ax2", ".", "lines", "[", "-", "1", "]", ".", "get_color", "(", ")", "add_patch", "(", "ax2", ",", "elevated", ".", "_nodes", ",", "color", ")", "ax1", ".", "axis", "(", "\"scaled\"", ")", "ax2", ".", "axis", "(", "\"scaled\"", ")", "_plot_helpers", ".", "add_plot_boundary", "(", "ax1", ")", "ax2", ".", "set_xlim", "(", "*", "ax1", ".", "get_xlim", "(", ")", ")", "ax2", ".", "set_ylim", "(", "*", "ax1", ".", "get_ylim", "(", ")", ")", "save_image", "(", "figure", ",", "\"curve_elevate.png\"", ")" ]

[ "Image", "for", ":", "meth", ":", ".", "curve", ".", "Curve", ".", "elevate", "docstring", "." ]

[ "def", "unit_triangle", "(", ")", ":", "if", "NO_IMAGES", ":", "return", "nodes", "=", "np", ".", "asfortranarray", "(", "[", "[", "0.0", ",", "1.0", ",", "0.0", "]", ",", "[", "0.0", ",", "0.0", ",", "1.0", "]", "]", ")", "surface", "=", "bezier", ".", "Surface", "(", "nodes", ",", "degree", "=", "1", ")", "ax", "=", "surface", ".", "plot", "(", "256", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "_plot_helpers", ".", "add_plot_boundary", "(", "ax", ")", "save_image", "(", "ax", ".", "figure", ",", "\"unit_triangle.png\"", ")" ]

[ "Image", "for", ":", "class", ":", ".", "surface", ".", "Surface", "docstring", "." ]

[ "def", "curve_reduce", "(", "curve", ",", "reduced", ")", ":", "if", "NO_IMAGES", ":", "return", "figure", ",", "(", "ax1", ",", "ax2", ")", "=", "plt", ".", "subplots", "(", "1", ",", "2", ",", "sharex", "=", "True", ",", "sharey", "=", "True", ")", "curve", ".", "plot", "(", "256", ",", "ax", "=", "ax1", ")", "color", "=", "ax1", ".", "lines", "[", "-", "1", "]", ".", "get_color", "(", ")", "add_patch", "(", "ax1", ",", "curve", ".", "_nodes", ",", "color", ")", "reduced", ".", "plot", "(", "256", ",", "ax", "=", "ax2", ")", "color", "=", "ax2", ".", "lines", "[", "-", "1", "]", ".", "get_color", "(", ")", "add_patch", "(", "ax2", ",", "reduced", ".", "_nodes", ",", "color", ")", "ax1", ".", "axis", "(", "\"scaled\"", ")", "ax2", ".", "axis", "(", "\"scaled\"", ")", "_plot_helpers", ".", "add_plot_boundary", "(", "ax2", ")", "save_image", "(", "figure", ",", "\"curve_reduce.png\"", ")" ]

[ "Image", "for", ":", "meth", ":", ".", "curve", ".", "Curve", ".", "reduce", "docstring", "." ]

[ "def", "curve_reduce_approx", "(", "curve", ",", "reduced", ")", ":", "if", "NO_IMAGES", ":", "return", "ax", "=", "curve", ".", "plot", "(", "256", ")", "color", "=", "ax", ".", "lines", "[", "-", "1", "]", ".", "get_color", "(", ")", "add_patch", "(", "ax", ",", "curve", ".", "_nodes", ",", "color", ",", "alpha", "=", "0.25", ",", "node_color", "=", "color", ")", "reduced", ".", "plot", "(", "256", ",", "ax", "=", "ax", ")", "color", "=", "ax", ".", "lines", "[", "-", "1", "]", ".", "get_color", "(", ")", "add_patch", "(", "ax", ",", "reduced", ".", "_nodes", ",", "color", ",", "alpha", "=", "0.25", ",", "node_color", "=", "color", ")", "ax", ".", "axis", "(", "\"scaled\"", ")", "_plot_helpers", ".", "add_plot_boundary", "(", "ax", ")", "save_image", "(", "ax", ".", "figure", ",", "\"curve_reduce_approx.png\"", ")" ]

[ "Image", "for", ":", "meth", ":", ".", "curve", ".", "Curve", ".", "reduce", "docstring", "." ]

[ "def", "newton_refine_solve", "(", "jac_both", ",", "x_val", ",", "surf_x", ",", "y_val", ",", "surf_y", ")", ":", "a_val", ",", "b_val", ",", "c_val", ",", "d_val", "=", "jac_both", "[", ":", ",", "0", "]", "# and", "e_val", "=", "x_val", "-", "surf_x", "f_val", "=", "y_val", "-", "surf_y", "# Now solve:", "denom", "=", "a_val", "*", "d_val", "-", "b_val", "*", "c_val", "delta_s", "=", "(", "d_val", "*", "e_val", "-", "c_val", "*", "f_val", ")", "/", "denom", "delta_t", "=", "(", "a_val", "*", "f_val", "-", "b_val", "*", "e_val", ")", "/", "denom", "return", "delta_s", ",", "delta_t" ]

[ "r", "Helper", "for", ":", "func", ":", "newton_refine", "." ]

[ "def", "_newton_refine", "(", "nodes", ",", "degree", ",", "x_val", ",", "y_val", ",", "s", ",", "t", ")", ":", "lambda1", "=", "1.0", "-", "s", "-", "t", "(", "surf_x", ",", ")", ",", "(", "surf_y", ",", ")", "=", "_surface_helpers", ".", "evaluate_barycentric", "(", "nodes", ",", "degree", ",", "lambda1", ",", "s", ",", "t", ")", "if", "surf_x", "==", "x_val", "and", "surf_y", "==", "y_val", ":", "# No refinement is needed.", "return", "s", ",", "t", "# NOTE: This function assumes ``dimension==2`` (i.e. since ``x, y``).", "jac_nodes", "=", "_surface_helpers", ".", "jacobian_both", "(", "nodes", ",", "degree", ",", "2", ")", "# The degree of the jacobian is one less.", "jac_both", "=", "_surface_helpers", ".", "evaluate_barycentric", "(", "jac_nodes", ",", "degree", "-", "1", ",", "lambda1", ",", "s", ",", "t", ")", "# The first row of the jacobian matrix is B_s (i.e. the", "# top-most values in ``jac_both``).", "delta_s", ",", "delta_t", "=", "newton_refine_solve", "(", "jac_both", ",", "x_val", ",", "surf_x", ",", "y_val", ",", "surf_y", ")", "return", "s", "+", "delta_s", ",", "t", "+", "delta_t" ]

[ "r", "Refine", "a", "solution", "to", ":", "math", ":", "B", "(", "s", "t", ")", "=", "p", "using", "Newton", "s", "method", "." ]

[ "def", "update_locate_candidates", "(", "candidate", ",", "next_candidates", ",", "x_val", ",", "y_val", ",", "degree", ")", ":", "centroid_x", ",", "centroid_y", ",", "width", ",", "candidate_nodes", "=", "candidate", "point", "=", "np", ".", "asfortranarray", "(", "[", "x_val", ",", "y_val", "]", ")", "if", "not", "_helpers", ".", "contains_nd", "(", "candidate_nodes", ",", "point", ")", ":", "return", "nodes_a", ",", "nodes_b", ",", "nodes_c", ",", "nodes_d", "=", "_surface_helpers", ".", "subdivide_nodes", "(", "candidate_nodes", ",", "degree", ")", "half_width", "=", "0.5", "*", "width", "next_candidates", ".", "extend", "(", "(", "(", "centroid_x", "-", "half_width", ",", "centroid_y", "-", "half_width", ",", "half_width", ",", "nodes_a", ",", ")", ",", "(", "centroid_x", ",", "centroid_y", ",", "-", "half_width", ",", "nodes_b", ")", ",", "(", "centroid_x", "+", "width", ",", "centroid_y", "-", "half_width", ",", "half_width", ",", "nodes_c", ")", ",", "(", "centroid_x", "-", "half_width", ",", "centroid_y", "+", "width", ",", "half_width", ",", "nodes_d", ")", ",", ")", ")" ]

[ "Update", "list", "of", "candidate", "surfaces", "during", "geometric", "search", "for", "a", "point", "." ]

[ "def", "mean_centroid", "(", "candidates", ")", ":", "sum_x", "=", "0.0", "sum_y", "=", "0.0", "for", "centroid_x", ",", "centroid_y", ",", "_", ",", "_", "in", "candidates", ":", "sum_x", "+=", "centroid_x", "sum_y", "+=", "centroid_y", "denom", "=", "3.0", "*", "len", "(", "candidates", ")", "return", "sum_x", "/", "denom", ",", "sum_y", "/", "denom" ]

[ "Take", "the", "mean", "of", "all", "centroids", "in", "set", "of", "reference", "triangles", "." ]

[ "def", "_locate_point", "(", "nodes", ",", "degree", ",", "x_val", ",", "y_val", ")", ":", "# We track the centroid rather than base_x/base_y/width (by storing triple", "# the centroid -- to avoid division by three until needed). We also need", "# to track the width (or rather, just the sign of the width).", "candidates", "=", "[", "(", "1.0", ",", "1.0", ",", "1.0", ",", "nodes", ")", "]", "for", "_", "in", "six", ".", "moves", ".", "xrange", "(", "MAX_LOCATE_SUBDIVISIONS", "+", "1", ")", ":", "next_candidates", "=", "[", "]", "for", "candidate", "in", "candidates", ":", "update_locate_candidates", "(", "candidate", ",", "next_candidates", ",", "x_val", ",", "y_val", ",", "degree", ")", "candidates", "=", "next_candidates", "if", "not", "candidates", ":", "return", "None", "# We take the average of all centroids from the candidates", "# that may contain the point.", "s_approx", ",", "t_approx", "=", "mean_centroid", "(", "candidates", ")", "s", ",", "t", "=", "newton_refine", "(", "nodes", ",", "degree", ",", "x_val", ",", "y_val", ",", "s_approx", ",", "t_approx", ")", "actual", "=", "_surface_helpers", ".", "evaluate_barycentric", "(", "nodes", ",", "degree", ",", "1.0", "-", "s", "-", "t", ",", "s", ",", "t", ")", "expected", "=", "np", ".", "asfortranarray", "(", "[", "x_val", ",", "y_val", "]", ")", "if", "not", "_helpers", ".", "vector_close", "(", "actual", ".", "ravel", "(", "order", "=", "\"F\"", ")", ",", "expected", ",", "eps", "=", "LOCATE_EPS", ")", ":", "s", ",", "t", "=", "newton_refine", "(", "nodes", ",", "degree", ",", "x_val", ",", "y_val", ",", "s", ",", "t", ")", "return", "s", ",", "t" ]

[ "r", "Locate", "a", "point", "on", "a", "surface", "." ]

[ "def", "same_intersection", "(", "intersection1", ",", "intersection2", ",", "wiggle", "=", "0.5", "**", "40", ")", ":", "if", "intersection1", ".", "index_first", "!=", "intersection2", ".", "index_first", ":", "return", "False", "if", "intersection1", ".", "index_second", "!=", "intersection2", ".", "index_second", ":", "return", "False", "return", "np", ".", "allclose", "(", "[", "intersection1", ".", "s", ",", "intersection1", ".", "t", "]", ",", "[", "intersection2", ".", "s", ",", "intersection2", ".", "t", "]", ",", "atol", "=", "0.0", ",", "rtol", "=", "wiggle", ",", ")" ]

[ "Check", "if", "two", "intersections", "are", "close", "to", "machine", "precision", "." ]

[ "def", "verify_duplicates", "(", "duplicates", ",", "uniques", ")", ":", "for", "uniq1", ",", "uniq2", "in", "itertools", ".", "combinations", "(", "uniques", ",", "2", ")", ":", "if", "same_intersection", "(", "uniq1", ",", "uniq2", ")", ":", "raise", "ValueError", "(", "\"Non-unique intersection\"", ")", "counter", "=", "collections", ".", "Counter", "(", ")", "for", "dupe", "in", "duplicates", ":", "matches", "=", "[", "]", "for", "index", ",", "uniq", "in", "enumerate", "(", "uniques", ")", ":", "if", "same_intersection", "(", "dupe", ",", "uniq", ")", ":", "matches", ".", "append", "(", "index", ")", "if", "len", "(", "matches", ")", "!=", "1", ":", "raise", "ValueError", "(", "\"Duplicate not among uniques\"", ",", "dupe", ")", "matched", "=", "matches", "[", "0", "]", "counter", "[", "matched", "]", "+=", "1", "for", "index", ",", "count", "in", "six", ".", "iteritems", "(", "counter", ")", ":", "uniq", "=", "uniques", "[", "index", "]", "if", "count", "==", "1", ":", "if", "(", "uniq", ".", "s", ",", "uniq", ".", "t", ")", ".", "count", "(", "0.0", ")", "!=", "1", ":", "raise", "ValueError", "(", "\"Count == 1 should be a single corner\"", ",", "uniq", ")", "elif", "count", "==", "3", ":", "if", "(", "uniq", ".", "s", ",", "uniq", ".", "t", ")", "!=", "(", "0.0", ",", "0.0", ")", ":", "raise", "ValueError", "(", "\"Count == 3 should be a double corner\"", ",", "uniq", ")", "else", ":", "raise", "ValueError", "(", "\"Unexpected duplicate count\"", ",", "count", ")" ]

[ "Verify", "that", "a", "set", "of", "intersections", "had", "expected", "duplicates", "." ]

[ "def", "verify_edge_segments", "(", "edge_infos", ")", ":", "if", "edge_infos", "is", "None", ":", "return", "for", "edge_info", "in", "edge_infos", ":", "num_segments", "=", "len", "(", "edge_info", ")", "for", "index", "in", "six", ".", "moves", ".", "xrange", "(", "-", "1", ",", "num_segments", "-", "1", ")", ":", "index1", ",", "start1", ",", "end1", "=", "edge_info", "[", "index", "]", "# First, verify the start and end parameters for the current", "# segment.", "if", "not", "0.0", "<=", "start1", "<", "end1", "<=", "1.0", ":", "raise", "ValueError", "(", "BAD_SEGMENT_PARAMS", ",", "edge_info", "[", "index", "]", ")", "# Then, verify that the indices are not the same.", "index2", ",", "_", ",", "_", "=", "edge_info", "[", "index", "+", "1", "]", "if", "index1", "==", "index2", ":", "raise", "ValueError", "(", "SEGMENTS_SAME_EDGE", ",", "edge_info", "[", "index", "]", ",", "edge_info", "[", "index", "+", "1", "]", ")" ]

[ "Verify", "that", "the", "edge", "segments", "in", "an", "intersection", "are", "valid", "." ]

[ "def", "add_edge_end_unused", "(", "intersection", ",", "duplicates", ",", "intersections", ")", ":", "found", "=", "None", "for", "other", "in", "intersections", ":", "if", "(", "intersection", ".", "index_first", "==", "other", ".", "index_first", "and", "intersection", ".", "index_second", "==", "other", ".", "index_second", ")", ":", "if", "intersection", ".", "s", "==", "0.0", "and", "other", ".", "s", "==", "0.0", ":", "found", "=", "other", "break", "if", "intersection", ".", "t", "==", "0.0", "and", "other", ".", "t", "==", "0.0", ":", "found", "=", "other", "break", "if", "found", "is", "not", "None", ":", "intersections", ".", "remove", "(", "found", ")", "duplicates", ".", "append", "(", "found", ")", "intersections", ".", "append", "(", "intersection", ")" ]

[ "Add", "intersection", "that", "is", "COINCIDENT_UNUSED", "but", "on", "an", "edge", "end", "." ]

[ "def", "check_unused", "(", "intersection", ",", "duplicates", ",", "intersections", ")", ":", "for", "other", "in", "intersections", ":", "if", "(", "other", ".", "interior_curve", "==", "UNUSED_T", "and", "intersection", ".", "index_first", "==", "other", ".", "index_first", "and", "intersection", ".", "index_second", "==", "other", ".", "index_second", ")", ":", "if", "intersection", ".", "s", "==", "0.0", "and", "other", ".", "s", "==", "0.0", ":", "duplicates", ".", "append", "(", "intersection", ")", "return", "True", "if", "intersection", ".", "t", "==", "0.0", "and", "other", ".", "t", "==", "0.0", ":", "duplicates", ".", "append", "(", "intersection", ")", "return", "True", "return", "False" ]

[ "Check", "if", "a", "valid", "intersection", "is", "already", "in", "intersections", "." ]

[ "def", "add_intersection", "(", "# pylint: disable=too-many-arguments", "index1", ",", "s", ",", "index2", ",", "t", ",", "interior_curve", ",", "edge_nodes1", ",", "edge_nodes2", ",", "duplicates", ",", "intersections", ",", ")", ":", "# NOTE: There is no corresponding \"enable\", but the disable only applies", "# in this lexical scope.", "# pylint: disable=too-many-locals", "edge_end", ",", "is_corner", ",", "intersection_args", "=", "_surface_helpers", ".", "handle_ends", "(", "index1", ",", "s", ",", "index2", ",", "t", ")", "if", "edge_end", ":", "intersection", "=", "_intersection_helpers", ".", "Intersection", "(", "*", "intersection_args", ")", "intersection", ".", "interior_curve", "=", "interior_curve", "if", "interior_curve", "==", "UNUSED_T", ":", "add_edge_end_unused", "(", "intersection", ",", "duplicates", ",", "intersections", ")", "else", ":", "duplicates", ".", "append", "(", "intersection", ")", "else", ":", "intersection", "=", "_intersection_helpers", ".", "Intersection", "(", "index1", ",", "s", ",", "index2", ",", "t", ")", "if", "is_corner", ":", "is_duplicate", "=", "check_unused", "(", "intersection", ",", "duplicates", ",", "intersections", ")", "if", "is_duplicate", ":", "return", "# Classify the intersection.", "if", "interior_curve", "is", "None", ":", "interior_curve", "=", "_surface_helpers", ".", "classify_intersection", "(", "intersection", ",", "edge_nodes1", ",", "edge_nodes2", ")", "intersection", ".", "interior_curve", "=", "interior_curve", "intersections", ".", "append", "(", "intersection", ")" ]

[ "Create", "an", ":", "class", ":", "Intersection", "and", "append", "." ]

[ "def", "classify_coincident", "(", "st_vals", ",", "coincident", ")", ":", "if", "not", "coincident", ":", "return", "None", "if", "st_vals", "[", "0", ",", "0", "]", ">=", "st_vals", "[", "0", ",", "1", "]", "or", "st_vals", "[", "1", ",", "0", "]", ">=", "st_vals", "[", "1", ",", "1", "]", ":", "return", "UNUSED_T", "else", ":", "return", "CLASSIFICATION_T", ".", "COINCIDENT" ]

[ "r", "Determine", "if", "coincident", "parameters", "are", "unused", "." ]

[ "def", "should_use", "(", "intersection", ")", ":", "if", "intersection", ".", "interior_curve", "in", "ACCEPTABLE_CLASSIFICATIONS", ":", "return", "True", "if", "intersection", ".", "interior_curve", "in", "TANGENT_CLASSIFICATIONS", ":", "return", "intersection", ".", "s", "==", "0.0", "or", "intersection", ".", "t", "==", "0.0", "return", "False" ]

[ "Check", "if", "an", "intersection", "can", "be", "used", "as", "part", "of", "a", "curved", "polygon", "." ]

[ "def", "surface_intersections", "(", "edge_nodes1", ",", "edge_nodes2", ",", "all_intersections", ")", ":", "# NOTE: There is no corresponding \"enable\", but the disable only applies", "# in this lexical scope.", "# pylint: disable=too-many-locals", "intersections", "=", "[", "]", "duplicates", "=", "[", "]", "for", "index1", ",", "nodes1", "in", "enumerate", "(", "edge_nodes1", ")", ":", "for", "index2", ",", "nodes2", "in", "enumerate", "(", "edge_nodes2", ")", ":", "st_vals", ",", "coincident", "=", "all_intersections", "(", "nodes1", ",", "nodes2", ")", "interior_curve", "=", "classify_coincident", "(", "st_vals", ",", "coincident", ")", "for", "s", ",", "t", "in", "st_vals", ".", "T", ":", "add_intersection", "(", "index1", ",", "s", ",", "index2", ",", "t", ",", "interior_curve", ",", "edge_nodes1", ",", "edge_nodes2", ",", "duplicates", ",", "intersections", ",", ")", "all_types", "=", "set", "(", ")", "to_keep", "=", "[", "]", "unused", "=", "[", "]", "for", "intersection", "in", "intersections", ":", "all_types", ".", "add", "(", "intersection", ".", "interior_curve", ")", "# Only keep the intersections which are \"acceptable\".", "if", "should_use", "(", "intersection", ")", ":", "to_keep", ".", "append", "(", "intersection", ")", "else", ":", "unused", ".", "append", "(", "intersection", ")", "return", "to_keep", ",", "duplicates", ",", "unused", ",", "all_types" ]

[ "Find", "all", "intersections", "among", "edges", "of", "two", "surfaces", "." ]

[ "def", "generic_intersect", "(", "nodes1", ",", "degree1", ",", "nodes2", ",", "degree2", ",", "verify", ",", "all_intersections", ")", ":", "bbox_int", "=", "_geometric_intersection", ".", "bbox_intersect", "(", "nodes1", ",", "nodes2", ")", "if", "bbox_int", "!=", "INTERSECTION_T", ":", "return", "[", "]", ",", "None", ",", "(", ")", "# We need **all** edges (as nodes).", "edge_nodes1", "=", "_surface_helpers", ".", "compute_edge_nodes", "(", "nodes1", ",", "degree1", ")", "edge_nodes2", "=", "_surface_helpers", ".", "compute_edge_nodes", "(", "nodes2", ",", "degree2", ")", "# Run through **all** pairs of edges.", "intersections", ",", "duplicates", ",", "unused", ",", "all_types", "=", "surface_intersections", "(", "edge_nodes1", ",", "edge_nodes2", ",", "all_intersections", ")", "edge_infos", ",", "contained", "=", "_surface_helpers", ".", "combine_intersections", "(", "intersections", ",", "nodes1", ",", "degree1", ",", "nodes2", ",", "degree2", ",", "all_types", ")", "# Verify the duplicates and intersection if need be.", "if", "verify", ":", "verify_duplicates", "(", "duplicates", ",", "intersections", "+", "unused", ")", "verify_edge_segments", "(", "edge_infos", ")", "if", "edge_infos", "is", "None", "or", "edge_infos", "==", "[", "]", ":", "return", "edge_infos", ",", "contained", ",", "(", ")", "return", "edge_infos", ",", "contained", ",", "edge_nodes1", "+", "edge_nodes2" ]

[ "r", "Find", "all", "intersections", "among", "edges", "of", "two", "surfaces", "." ]

[ "def", "_geometric_intersect", "(", "nodes1", ",", "degree1", ",", "nodes2", ",", "degree2", ",", "verify", ")", ":", "all_intersections", "=", "_geometric_intersection", ".", "all_intersections", "return", "generic_intersect", "(", "nodes1", ",", "degree1", ",", "nodes2", ",", "degree2", ",", "verify", ",", "all_intersections", ")" ]

[ "r", "Find", "all", "intersections", "among", "edges", "of", "two", "surfaces", "." ]

[ "def", "algebraic_intersect", "(", "nodes1", ",", "degree1", ",", "nodes2", ",", "degree2", ",", "verify", ")", ":", "all_intersections", "=", "_algebraic_intersection", ".", "all_intersections", "return", "generic_intersect", "(", "nodes1", ",", "degree1", ",", "nodes2", ",", "degree2", ",", "verify", ",", "all_intersections", ")" ]

[ "r", "Find", "all", "intersections", "among", "edges", "of", "two", "surfaces", "." ]

[ "def", "modify_path", "(", ")", ":", "# Only modify path on Windows.", "if", "os", ".", "name", "!=", "\"nt\"", ":", "return", "path", "=", "os", ".", "environ", ".", "get", "(", "\"PATH\"", ")", "if", "path", "is", "None", ":", "return", "try", ":", "extra_dll_dir", "=", "pkg_resources", ".", "resource_filename", "(", "\"bezier\"", ",", "\"extra-dll\"", ")", "if", "os", ".", "path", ".", "isdir", "(", "extra_dll_dir", ")", ":", "os", ".", "environ", "[", "\"PATH\"", "]", "=", "path", "+", "os", ".", "pathsep", "+", "extra_dll_dir", "except", "ImportError", ":", "pass" ]

[ "Modify", "the", "module", "search", "path", "." ]

[ "def", "handle_import_error", "(", "caught_exc", ",", "name", ")", ":", "for", "template", "in", "TEMPLATES", ":", "expected_msg", "=", "template", ".", "format", "(", "name", ")", "if", "caught_exc", ".", "args", "==", "(", "expected_msg", ",", ")", ":", "return", "raise", "caught_exc" ]

[ "Allow", "or", "re", "-", "raise", "an", "import", "error", "." ]

[ "def", "is_macos_gfortran", "(", "f90_compiler", ")", ":", "# NOTE: NumPy may not be installed, but we don't want **this** module to", "# cause an import failure.", "from", "numpy", ".", "distutils", ".", "fcompiler", "import", "gnu", "# Only macOS.", "if", "sys", ".", "platform", "!=", "MAC_OS", ":", "return", "False", "# Only ``gfortran``.", "if", "not", "isinstance", "(", "f90_compiler", ",", "gnu", ".", "Gnu95FCompiler", ")", ":", "return", "False", "return", "True" ]

[ "Checks", "if", "the", "current", "build", "is", "gfortran", "on", "macOS", "." ]

[ "def", "patch_f90_compiler", "(", "f90_compiler", ")", ":", "if", "not", "is_macos_gfortran", "(", "f90_compiler", ")", ":", "return", "library_dirs", "=", "f90_compiler", ".", "library_dirs", "# ``library_dirs`` is a list (i.e. mutable), so we can update in place.", "library_dirs", "[", ":", "]", "=", "setup_helpers", ".", "gfortran_search_path", "(", "library_dirs", ")" ]

[ "Patch", "up", "f90_compiler", ".", "library_dirs", "." ]

[ "def", "_make_intersection", "(", "edge_info", ",", "all_edge_nodes", ")", ":", "edges", "=", "[", "]", "for", "index", ",", "start", ",", "end", "in", "edge_info", ":", "nodes", "=", "all_edge_nodes", "[", "index", "]", "new_nodes", "=", "_curve_helpers", ".", "specialize_curve", "(", "nodes", ",", "start", ",", "end", ")", "degree", "=", "new_nodes", ".", "shape", "[", "1", "]", "-", "1", "edge", "=", "_curve_mod", ".", "Curve", "(", "new_nodes", ",", "degree", ",", "_copy", "=", "False", ")", "edges", ".", "append", "(", "edge", ")", "return", "curved_polygon", ".", "CurvedPolygon", "(", "*", "edges", ",", "metadata", "=", "edge_info", ",", "_verify", "=", "False", ")" ]

[ "Convert", "a", "description", "of", "edges", "into", "a", "curved", "polygon", "." ]

[ "def", "from_nodes", "(", "cls", ",", "nodes", ",", "_copy", "=", "True", ")", ":", "_", ",", "num_nodes", "=", "nodes", ".", "shape", "degree", "=", "cls", ".", "_get_degree", "(", "num_nodes", ")", "return", "cls", "(", "nodes", ",", "degree", ",", "_copy", "=", "_copy", ")" ]

[ "Create", "a", ":", "class", ":", ".", "Surface", "from", "nodes", "." ]

[ "def", "_get_degree", "(", "num_nodes", ")", ":", "# 8 * num_nodes = 4(d + 1)(d + 2)", "# = 4d^2 + 12d + 8", "# = (2d + 3)^2 - 1", "d_float", "=", "0.5", "*", "(", "np", ".", "sqrt", "(", "8.0", "*", "num_nodes", "+", "1.0", ")", "-", "3.0", ")", "d_int", "=", "int", "(", "np", ".", "round", "(", "d_float", ")", ")", "if", "(", "d_int", "+", "1", ")", "*", "(", "d_int", "+", "2", ")", "==", "2", "*", "num_nodes", ":", "return", "d_int", "else", ":", "raise", "ValueError", "(", "num_nodes", ",", "\"not a triangular number\"", ")" ]

[ "Get", "the", "degree", "of", "the", "current", "surface", "." ]

[ "def", "area", "(", "self", ")", ":", "if", "self", ".", "_dimension", "!=", "2", ":", "raise", "NotImplementedError", "(", "\"2D is the only supported dimension\"", ",", "\"Current dimension\"", ",", "self", ".", "_dimension", ",", ")", "edge1", ",", "edge2", ",", "edge3", "=", "self", ".", "_get_edges", "(", ")", "return", "_surface_helpers", ".", "compute_area", "(", "(", "edge1", ".", "_nodes", ",", "edge2", ".", "_nodes", ",", "edge3", ".", "_nodes", ")", ")" ]

[ "r", "The", "area", "of", "the", "current", "surface", "." ]

[ "def", "_compute_edges", "(", "self", ")", ":", "nodes1", ",", "nodes2", ",", "nodes3", "=", "_surface_helpers", ".", "compute_edge_nodes", "(", "self", ".", "_nodes", ",", "self", ".", "_degree", ")", "edge1", "=", "_curve_mod", ".", "Curve", "(", "nodes1", ",", "self", ".", "_degree", ",", "_copy", "=", "False", ")", "edge2", "=", "_curve_mod", ".", "Curve", "(", "nodes2", ",", "self", ".", "_degree", ",", "_copy", "=", "False", ")", "edge3", "=", "_curve_mod", ".", "Curve", "(", "nodes3", ",", "self", ".", "_degree", ",", "_copy", "=", "False", ")", "return", "edge1", ",", "edge2", ",", "edge3" ]

[ "Compute", "the", "edges", "of", "the", "current", "surface", "." ]

[ "def", "_get_edges", "(", "self", ")", ":", "if", "self", ".", "_edges", "is", "None", ":", "self", ".", "_edges", "=", "self", ".", "_compute_edges", "(", ")", "return", "self", ".", "_edges" ]

[ "Get", "the", "edges", "for", "the", "current", "surface", "." ]

[ "def", "edges", "(", "self", ")", ":", "edge1", ",", "edge2", ",", "edge3", "=", "self", ".", "_get_edges", "(", ")", "# NOTE: It is crucial that we return copies here. Since the edges", "# are cached, if they were mutable, callers could", "# inadvertently mutate the cached value.", "edge1", "=", "edge1", ".", "_copy", "(", ")", "# pylint: disable=protected-access", "edge2", "=", "edge2", ".", "_copy", "(", ")", "# pylint: disable=protected-access", "edge3", "=", "edge3", ".", "_copy", "(", ")", "# pylint: disable=protected-access", "return", "edge1", ",", "edge2", ",", "edge3" ]

[ "The", "edges", "of", "the", "surface", "." ]

[ "def", "_verify_barycentric", "(", "lambda1", ",", "lambda2", ",", "lambda3", ")", ":", "weights_total", "=", "lambda1", "+", "lambda2", "+", "lambda3", "if", "not", "np", ".", "allclose", "(", "weights_total", ",", "1.0", ",", "atol", "=", "0.0", ")", ":", "raise", "ValueError", "(", "\"Weights do not sum to 1\"", ",", "lambda1", ",", "lambda2", ",", "lambda3", ")", "if", "lambda1", "<", "0.0", "or", "lambda2", "<", "0.0", "or", "lambda3", "<", "0.0", ":", "raise", "ValueError", "(", "\"Weights must be positive\"", ",", "lambda1", ",", "lambda2", ",", "lambda3", ")" ]

[ "Verifies", "that", "weights", "are", "barycentric", "and", "on", "the", "reference", "triangle", "." ]

[ "def", "evaluate_barycentric", "(", "self", ",", "lambda1", ",", "lambda2", ",", "lambda3", ",", "_verify", "=", "True", ")", ":", "if", "_verify", ":", "self", ".", "_verify_barycentric", "(", "lambda1", ",", "lambda2", ",", "lambda3", ")", "return", "_surface_helpers", ".", "evaluate_barycentric", "(", "self", ".", "_nodes", ",", "self", ".", "_degree", ",", "lambda1", ",", "lambda2", ",", "lambda3", ")" ]

[ "r", "Compute", "a", "point", "on", "the", "surface", "." ]

[ "def", "evaluate_barycentric_multi", "(", "self", ",", "param_vals", ",", "_verify", "=", "True", ")", ":", "if", "_verify", ":", "if", "param_vals", ".", "ndim", "!=", "2", ":", "raise", "ValueError", "(", "\"Parameter values must be 2D array\"", ")", "for", "lambda1", ",", "lambda2", ",", "lambda3", "in", "param_vals", ":", "self", ".", "_verify_barycentric", "(", "lambda1", ",", "lambda2", ",", "lambda3", ")", "return", "_surface_helpers", ".", "evaluate_barycentric_multi", "(", "self", ".", "_nodes", ",", "self", ".", "_degree", ",", "param_vals", ",", "self", ".", "_dimension", ")" ]

[ "r", "Compute", "multiple", "points", "on", "the", "surface", "." ]

[ "def", "_verify_cartesian", "(", "s", ",", "t", ")", ":", "if", "s", "<", "0.0", "or", "t", "<", "0.0", "or", "s", "+", "t", ">", "1.0", ":", "raise", "ValueError", "(", "\"Point lies outside reference triangle\"", ",", "s", ",", "t", ")" ]

[ "Verifies", "that", "a", "point", "is", "in", "the", "reference", "triangle", "." ]

[ "def", "evaluate_cartesian", "(", "self", ",", "s", ",", "t", ",", "_verify", "=", "True", ")", ":", "if", "_verify", ":", "self", ".", "_verify_cartesian", "(", "s", ",", "t", ")", "return", "_surface_helpers", ".", "evaluate_barycentric", "(", "self", ".", "_nodes", ",", "self", ".", "_degree", ",", "1.0", "-", "s", "-", "t", ",", "s", ",", "t", ")" ]

[ "r", "Compute", "a", "point", "on", "the", "surface", "." ]

[ "def", "evaluate_cartesian_multi", "(", "self", ",", "param_vals", ",", "_verify", "=", "True", ")", ":", "if", "_verify", ":", "if", "param_vals", ".", "ndim", "!=", "2", ":", "raise", "ValueError", "(", "\"Parameter values must be 2D array\"", ")", "for", "s", ",", "t", "in", "param_vals", ":", "self", ".", "_verify_cartesian", "(", "s", ",", "t", ")", "return", "_surface_helpers", ".", "evaluate_cartesian_multi", "(", "self", ".", "_nodes", ",", "self", ".", "_degree", ",", "param_vals", ",", "self", ".", "_dimension", ")" ]

[ "r", "Compute", "multiple", "points", "on", "the", "surface", "." ]

[ "def", "plot", "(", "self", ",", "pts_per_edge", ",", "color", "=", "None", ",", "ax", "=", "None", ",", "with_nodes", "=", "False", ")", ":", "if", "self", ".", "_dimension", "!=", "2", ":", "raise", "NotImplementedError", "(", "\"2D is the only supported dimension\"", ",", "\"Current dimension\"", ",", "self", ".", "_dimension", ",", ")", "if", "ax", "is", "None", ":", "ax", "=", "_plot_helpers", ".", "new_axis", "(", ")", "_plot_helpers", ".", "add_patch", "(", "ax", ",", "color", ",", "pts_per_edge", ",", "*", "self", ".", "_get_edges", "(", ")", ")", "if", "with_nodes", ":", "ax", ".", "plot", "(", "self", ".", "_nodes", "[", "0", ",", ":", "]", ",", "self", ".", "_nodes", "[", "1", ",", ":", "]", ",", "color", "=", "\"black\"", ",", "marker", "=", "\"o\"", ",", "linestyle", "=", "\"None\"", ",", ")", "return", "ax" ]

[ "Plot", "the", "current", "surface", "." ]

[ "def", "subdivide", "(", "self", ")", ":", "nodes_a", ",", "nodes_b", ",", "nodes_c", ",", "nodes_d", "=", "_surface_helpers", ".", "subdivide_nodes", "(", "self", ".", "_nodes", ",", "self", ".", "_degree", ")", "return", "(", "Surface", "(", "nodes_a", ",", "self", ".", "_degree", ",", "_copy", "=", "False", ")", ",", "Surface", "(", "nodes_b", ",", "self", ".", "_degree", ",", "_copy", "=", "False", ")", ",", "Surface", "(", "nodes_c", ",", "self", ".", "_degree", ",", "_copy", "=", "False", ")", ",", "Surface", "(", "nodes_d", ",", "self", ".", "_degree", ",", "_copy", "=", "False", ")", ",", ")" ]

[ "r", "Split", "the", "surface", "into", "four", "sub", "-", "surfaces", "." ]

[ "def", "_compute_valid", "(", "self", ")", ":", "if", "self", ".", "_dimension", "!=", "2", ":", "raise", "NotImplementedError", "(", "\"Validity check only implemented in R^2\"", ")", "poly_sign", "=", "None", "if", "self", ".", "_degree", "==", "1", ":", "# In the linear case, we are only invalid if the points", "# are collinear.", "first_deriv", "=", "self", ".", "_nodes", "[", ":", ",", "1", ":", "]", "-", "self", ".", "_nodes", "[", ":", ",", ":", "-", "1", "]", "poly_sign", "=", "_SIGN", "(", "np", ".", "linalg", ".", "det", "(", "first_deriv", ")", ")", "elif", "self", ".", "_degree", "==", "2", ":", "bernstein", "=", "_surface_helpers", ".", "quadratic_jacobian_polynomial", "(", "self", ".", "_nodes", ")", "poly_sign", "=", "_surface_helpers", ".", "polynomial_sign", "(", "bernstein", ",", "2", ")", "elif", "self", ".", "_degree", "==", "3", ":", "bernstein", "=", "_surface_helpers", ".", "cubic_jacobian_polynomial", "(", "self", ".", "_nodes", ")", "poly_sign", "=", "_surface_helpers", ".", "polynomial_sign", "(", "bernstein", ",", "4", ")", "else", ":", "raise", "_helpers", ".", "UnsupportedDegree", "(", "self", ".", "_degree", ",", "supported", "=", "(", "1", ",", "2", ",", "3", ")", ")", "return", "poly_sign", "==", "1" ]

[ "r", "Determines", "if", "the", "current", "surface", "is", "valid", "." ]

[ "def", "locate", "(", "self", ",", "point", ",", "_verify", "=", "True", ")", ":", "if", "_verify", ":", "if", "self", ".", "_dimension", "!=", "2", ":", "raise", "NotImplementedError", "(", "\"Only 2D surfaces supported.\"", ")", "if", "point", ".", "shape", "!=", "(", "self", ".", "_dimension", ",", "1", ")", ":", "point_dimensions", "=", "\" x \"", ".", "join", "(", "str", "(", "dimension", ")", "for", "dimension", "in", "point", ".", "shape", ")", "msg", "=", "_LOCATE_ERROR_TEMPLATE", ".", "format", "(", "self", ".", "_dimension", ",", "self", ".", "_dimension", ",", "point", ",", "point_dimensions", ")", "raise", "ValueError", "(", "msg", ")", "return", "_surface_intersection", ".", "locate_point", "(", "self", ".", "_nodes", ",", "self", ".", "_degree", ",", "point", "[", "0", ",", "0", "]", ",", "point", "[", "1", ",", "0", "]", ")" ]

[ "r", "Find", "a", "point", "on", "the", "current", "surface", "." ]

[ "def", "intersect", "(", "self", ",", "other", ",", "strategy", "=", "_STRATEGY", ".", "GEOMETRIC", ",", "_verify", "=", "True", ")", ":", "if", "_verify", ":", "if", "not", "isinstance", "(", "other", ",", "Surface", ")", ":", "raise", "TypeError", "(", "\"Can only intersect with another surface\"", ",", "\"Received\"", ",", "other", ",", ")", "if", "self", ".", "_dimension", "!=", "2", "or", "other", ".", "_dimension", "!=", "2", ":", "raise", "NotImplementedError", "(", "\"Intersection only implemented in 2D\"", ")", "if", "strategy", "==", "_STRATEGY", ".", "GEOMETRIC", ":", "do_intersect", "=", "_surface_intersection", ".", "geometric_intersect", "elif", "strategy", "==", "_STRATEGY", ".", "ALGEBRAIC", ":", "do_intersect", "=", "_surface_intersection", ".", "algebraic_intersect", "else", ":", "raise", "ValueError", "(", "\"Unexpected strategy.\"", ",", "strategy", ")", "edge_infos", ",", "contained", ",", "all_edge_nodes", "=", "do_intersect", "(", "self", ".", "_nodes", ",", "self", ".", "_degree", ",", "other", ".", "_nodes", ",", "other", ".", "_degree", ",", "_verify", ")", "if", "edge_infos", "is", "None", ":", "if", "contained", ":", "return", "[", "self", "]", "else", ":", "return", "[", "other", "]", "else", ":", "return", "[", "_make_intersection", "(", "edge_info", ",", "all_edge_nodes", ")", "for", "edge_info", "in", "edge_infos", "]" ]

[ "Find", "the", "common", "intersection", "with", "another", "surface", "." ]

[ "def", "elevate", "(", "self", ")", ":", "_", ",", "num_nodes", "=", "self", ".", "_nodes", ".", "shape", "# (d + 1)(d + 2)/2 --> (d + 2)(d + 3)/2", "num_new", "=", "num_nodes", "+", "self", ".", "_degree", "+", "2", "new_nodes", "=", "np", ".", "zeros", "(", "(", "self", ".", "_dimension", ",", "num_new", ")", ",", "order", "=", "\"F\"", ")", "# NOTE: We start from the index triples (i, j, k) for the current", "# nodes and map them onto (i + 1, j, k), etc. This index", "# tracking is also done in :func:`.de_casteljau_one_round`.", "index", "=", "0", "# parent_i1 = index + k", "# parent_i2 = index + k + 1", "# parent_i3 = index + degree + 2", "parent_i1", "=", "0", "parent_i2", "=", "1", "parent_i3", "=", "self", ".", "_degree", "+", "2", "for", "k", "in", "six", ".", "moves", ".", "xrange", "(", "self", ".", "_degree", "+", "1", ")", ":", "for", "j", "in", "six", ".", "moves", ".", "xrange", "(", "self", ".", "_degree", "+", "1", "-", "k", ")", ":", "i", "=", "self", ".", "_degree", "-", "j", "-", "k", "new_nodes", "[", ":", ",", "parent_i1", "]", "+=", "(", "i", "+", "1", ")", "*", "self", ".", "_nodes", "[", ":", ",", "index", "]", "new_nodes", "[", ":", ",", "parent_i2", "]", "+=", "(", "j", "+", "1", ")", "*", "self", ".", "_nodes", "[", ":", ",", "index", "]", "new_nodes", "[", ":", ",", "parent_i3", "]", "+=", "(", "k", "+", "1", ")", "*", "self", ".", "_nodes", "[", ":", ",", "index", "]", "# Update all the indices.", "parent_i1", "+=", "1", "parent_i2", "+=", "1", "parent_i3", "+=", "1", "index", "+=", "1", "# Update the indices that depend on k.", "parent_i1", "+=", "1", "parent_i2", "+=", "1", "# Hold off on division until the end, to (attempt to) avoid round-off.", "denominator", "=", "self", ".", "_degree", "+", "1.0", "new_nodes", "/=", "denominator", "return", "Surface", "(", "new_nodes", ",", "self", ".", "_degree", "+", "1", ",", "_copy", "=", "False", ")" ]

[ "r", "Return", "a", "degree", "-", "elevated", "version", "of", "the", "current", "surface", "." ]

[ "def", "_newton_refine", "(", "s", ",", "nodes1", ",", "t", ",", "nodes2", ")", ":", "# NOTE: We form -F(s, t) since we want to solve -DF^{-1} F(s, t).", "func_val", "=", "_curve_helpers", ".", "evaluate_multi", "(", "nodes2", ",", "np", ".", "asfortranarray", "(", "[", "t", "]", ")", ")", "-", "_curve_helpers", ".", "evaluate_multi", "(", "nodes1", ",", "np", ".", "asfortranarray", "(", "[", "s", "]", ")", ")", "if", "np", ".", "all", "(", "func_val", "==", "0.0", ")", ":", "# No refinement is needed.", "return", "s", ",", "t", "# NOTE: This assumes the curves are 2D.", "jac_mat", "=", "np", ".", "empty", "(", "(", "2", ",", "2", ")", ",", "order", "=", "\"F\"", ")", "jac_mat", "[", ":", ",", ":", "1", "]", "=", "_curve_helpers", ".", "evaluate_hodograph", "(", "s", ",", "nodes1", ")", "jac_mat", "[", ":", ",", "1", ":", "]", "=", "-", "_curve_helpers", ".", "evaluate_hodograph", "(", "t", ",", "nodes2", ")", "# Solve the system.", "singular", ",", "delta_s", ",", "delta_t", "=", "_helpers", ".", "solve2x2", "(", "jac_mat", ",", "func_val", "[", ":", ",", "0", "]", ")", "if", "singular", ":", "raise", "ValueError", "(", "\"Jacobian is singular.\"", ")", "else", ":", "return", "s", "+", "delta_s", ",", "t", "+", "delta_t" ]

[ "r", "Apply", "one", "step", "of", "2D", "Newton", "s", "method", "." ]

[ "def", "newton_iterate", "(", "evaluate_fn", ",", "s", ",", "t", ")", ":", "# Several quantities will be tracked throughout the iteration:", "# * norm_update_prev: ||p{n} - p{n-1}|| = ||dp{n-1}||", "# * norm_update : ||p{n+1} - p{n} || = ||dp{n} ||", "# * linear_updates : This is a count on the number of times that", "# ``dp{n}`` \"looks like\" ``dp{n-1}`` (i.e.", "# is within a constant factor of it).", "norm_update_prev", "=", "None", "norm_update", "=", "None", "linear_updates", "=", "0", "# Track the number of \"linear\" updates.", "current_s", "=", "s", "current_t", "=", "t", "for", "index", "in", "six", ".", "moves", ".", "xrange", "(", "MAX_NEWTON_ITERATIONS", ")", ":", "jacobian", ",", "func_val", "=", "evaluate_fn", "(", "current_s", ",", "current_t", ")", "if", "jacobian", "is", "None", ":", "return", "True", ",", "current_s", ",", "current_t", "singular", ",", "delta_s", ",", "delta_t", "=", "_helpers", ".", "solve2x2", "(", "jacobian", ",", "func_val", "[", ":", ",", "0", "]", ")", "if", "singular", ":", "break", "norm_update_prev", "=", "norm_update", "norm_update", "=", "np", ".", "linalg", ".", "norm", "(", "[", "delta_s", ",", "delta_t", "]", ",", "ord", "=", "2", ")", "# If ||p{n} - p{n-1}|| > 0.25 ||p{n-1} - p{n-2}||, then that means", "# our convergence is acting linear at the current step.", "if", "index", ">", "0", "and", "norm_update", ">", "0.25", "*", "norm_update_prev", ":", "linear_updates", "+=", "1", "# If ``>=2/3`` of the updates have been linear, we are near a", "# non-simple root. (Make sure at least 5 updates have occurred.)", "if", "index", ">=", "4", "and", "3", "*", "linear_updates", ">=", "2", "*", "index", ":", "break", "# Determine the norm of the \"old\" solution before updating.", "norm_soln", "=", "np", ".", "linalg", ".", "norm", "(", "[", "current_s", ",", "current_t", "]", ",", "ord", "=", "2", ")", "current_s", "-=", "delta_s", "current_t", "-=", "delta_t", "if", "norm_update", "<", "NEWTON_ERROR_RATIO", "*", "norm_soln", ":", "return", "True", ",", "current_s", ",", "current_t", "return", "False", ",", "current_s", ",", "current_t" ]

[ "r", "Perform", "a", "Newton", "iteration", "." ]

[ "def", "full_newton_nonzero", "(", "s", ",", "nodes1", ",", "t", ",", "nodes2", ")", ":", "# NOTE: We somewhat replicate code in ``evaluate_hodograph()``", "# here. This is so we don't re-compute the nodes for the first", "# (and possibly second) derivatives every time they are evaluated.", "_", ",", "num_nodes1", "=", "np", ".", "shape", "(", "nodes1", ")", "first_deriv1", "=", "(", "num_nodes1", "-", "1", ")", "*", "(", "nodes1", "[", ":", ",", "1", ":", "]", "-", "nodes1", "[", ":", ",", ":", "-", "1", "]", ")", "_", ",", "num_nodes2", "=", "np", ".", "shape", "(", "nodes2", ")", "first_deriv2", "=", "(", "num_nodes2", "-", "1", ")", "*", "(", "nodes2", "[", ":", ",", "1", ":", "]", "-", "nodes2", "[", ":", ",", ":", "-", "1", "]", ")", "evaluate_fn", "=", "NewtonSimpleRoot", "(", "nodes1", ",", "first_deriv1", ",", "nodes2", ",", "first_deriv2", ")", "converged", ",", "current_s", ",", "current_t", "=", "newton_iterate", "(", "evaluate_fn", ",", "s", ",", "t", ")", "if", "converged", ":", "return", "current_s", ",", "current_t", "# If Newton's method did not converge, then assume the root is not simple.", "second_deriv1", "=", "(", "num_nodes1", "-", "2", ")", "*", "(", "first_deriv1", "[", ":", ",", "1", ":", "]", "-", "first_deriv1", "[", ":", ",", ":", "-", "1", "]", ")", "second_deriv2", "=", "(", "num_nodes2", "-", "2", ")", "*", "(", "first_deriv2", "[", ":", ",", "1", ":", "]", "-", "first_deriv2", "[", ":", ",", ":", "-", "1", "]", ")", "evaluate_fn", "=", "NewtonDoubleRoot", "(", "nodes1", ",", "first_deriv1", ",", "second_deriv1", ",", "nodes2", ",", "first_deriv2", ",", "second_deriv2", ",", ")", "converged", ",", "current_s", ",", "current_t", "=", "newton_iterate", "(", "evaluate_fn", ",", "current_s", ",", "current_t", ")", "if", "converged", ":", "return", "current_s", ",", "current_t", "raise", "NotImplementedError", "(", "NEWTON_NO_CONVERGE", ")" ]

[ "r", "Perform", "a", "Newton", "iteration", "until", "convergence", "to", "a", "solution", "." ]

[ "def", "full_newton", "(", "s", ",", "nodes1", ",", "t", ",", "nodes2", ")", ":", "if", "s", "<", "ZERO_THRESHOLD", ":", "reversed1", "=", "np", ".", "asfortranarray", "(", "nodes1", "[", ":", ",", ":", ":", "-", "1", "]", ")", "if", "t", "<", "ZERO_THRESHOLD", ":", "reversed2", "=", "np", ".", "asfortranarray", "(", "nodes2", "[", ":", ",", ":", ":", "-", "1", "]", ")", "refined_s", ",", "refined_t", "=", "full_newton_nonzero", "(", "1.0", "-", "s", ",", "reversed1", ",", "1.0", "-", "t", ",", "reversed2", ")", "return", "1.0", "-", "refined_s", ",", "1.0", "-", "refined_t", "else", ":", "refined_s", ",", "refined_t", "=", "full_newton_nonzero", "(", "1.0", "-", "s", ",", "reversed1", ",", "t", ",", "nodes2", ")", "return", "1.0", "-", "refined_s", ",", "refined_t", "else", ":", "if", "t", "<", "ZERO_THRESHOLD", ":", "reversed2", "=", "np", ".", "asfortranarray", "(", "nodes2", "[", ":", ",", ":", ":", "-", "1", "]", ")", "refined_s", ",", "refined_t", "=", "full_newton_nonzero", "(", "s", ",", "nodes1", ",", "1.0", "-", "t", ",", "reversed2", ")", "return", "refined_s", ",", "1.0", "-", "refined_t", "else", ":", "return", "full_newton_nonzero", "(", "s", ",", "nodes1", ",", "t", ",", "nodes2", ")" ]

[ "r", "Perform", "a", "Newton", "iteration", "until", "convergence", "to", "a", "solution", "." ]

[ "def", "gfortran_search_path", "(", "library_dirs", ")", ":", "cmd", "=", "(", "\"gfortran\"", ",", "\"-print-search-dirs\"", ")", "process", "=", "subprocess", ".", "Popen", "(", "cmd", ",", "stdout", "=", "subprocess", ".", "PIPE", ")", "return_code", "=", "process", ".", "wait", "(", ")", "# Bail out if the command failed.", "if", "return_code", "!=", "0", ":", "return", "library_dirs", "cmd_output", "=", "process", ".", "stdout", ".", "read", "(", ")", ".", "decode", "(", "\"utf-8\"", ")", "# Find single line starting with ``libraries: ``.", "search_lines", "=", "cmd_output", ".", "strip", "(", ")", ".", "split", "(", "\"\\n\"", ")", "library_lines", "=", "[", "line", "[", "len", "(", "FORTRAN_LIBRARY_PREFIX", ")", ":", "]", "for", "line", "in", "search_lines", "if", "line", ".", "startswith", "(", "FORTRAN_LIBRARY_PREFIX", ")", "]", "if", "len", "(", "library_lines", ")", "!=", "1", ":", "msg", "=", "GFORTRAN_MISSING_LIBS", ".", "format", "(", "cmd_output", ")", "print", "(", "msg", ",", "file", "=", "sys", ".", "stderr", ")", "return", "library_dirs", "# Go through each library in the ``libraries: = ...`` line.", "library_line", "=", "library_lines", "[", "0", "]", "accepted", "=", "set", "(", "library_dirs", ")", "for", "part", "in", "library_line", ".", "split", "(", "os", ".", "pathsep", ")", ":", "full_path", "=", "os", ".", "path", ".", "abspath", "(", "part", ".", "strip", "(", ")", ")", "if", "os", ".", "path", ".", "isdir", "(", "full_path", ")", ":", "accepted", ".", "add", "(", "full_path", ")", "else", ":", "# Ignore anything that isn't a directory.", "msg", "=", "GFORTRAN_BAD_PATH", ".", "format", "(", "full_path", ")", "print", "(", "msg", ",", "file", "=", "sys", ".", "stderr", ")", "return", "sorted", "(", "accepted", ")" ]

[ "Get", "the", "library", "directory", "paths", "for", "gfortran", "." ]

[ "def", "_update_flags", "(", "compiler_flags", ",", "remove_flags", "=", "(", ")", ")", ":", "for", "flag", "in", "GFORTRAN_SHARED_FLAGS", ":", "if", "flag", "not", "in", "compiler_flags", ":", "compiler_flags", ".", "append", "(", "flag", ")", "if", "DEBUG_ENV", "in", "os", ".", "environ", ":", "to_add", "=", "GFORTRAN_DEBUG_FLAGS", "to_remove", "=", "GFORTRAN_OPTIMIZE_FLAGS", "else", ":", "to_add", "=", "GFORTRAN_OPTIMIZE_FLAGS", "if", "os", ".", "environ", ".", "get", "(", "WHEEL_ENV", ")", "is", "None", ":", "to_add", "+=", "(", "GFORTRAN_NATIVE_FLAG", ",", ")", "to_remove", "=", "GFORTRAN_DEBUG_FLAGS", "for", "flag", "in", "to_add", ":", "if", "flag", "not", "in", "compiler_flags", ":", "compiler_flags", ".", "append", "(", "flag", ")", "return", "[", "flag", "for", "flag", "in", "compiler_flags", "if", "not", "(", "flag", "in", "to_remove", "or", "flag", "in", "remove_flags", ")", "]" ]

[ "Update", "a", "given", "set", "of", "compiler", "flags", "." ]

[ "def", "patch_f90_compiler", "(", "f90_compiler", ")", ":", "# NOTE: NumPy may not be installed, but we don't want **this** module to", "# cause an import failure in ``setup.py``.", "from", "numpy", ".", "distutils", ".", "fcompiler", "import", "gnu", "# Only ``gfortran``.", "if", "not", "isinstance", "(", "f90_compiler", ",", "gnu", ".", "Gnu95FCompiler", ")", ":", "return", "False", "f90_compiler", ".", "compiler_f77", "[", ":", "]", "=", "_update_flags", "(", "f90_compiler", ".", "compiler_f77", ",", "remove_flags", "=", "(", "\"-Werror\"", ",", ")", ")", "f90_compiler", ".", "compiler_f90", "[", ":", "]", "=", "_update_flags", "(", "f90_compiler", ".", "compiler_f90", ")" ]

[ "Patch", "up", "f90_compiler", "." ]

[ "def", "start_journaling", "(", "self", ")", ":", "import", "numpy", ".", "distutils", ".", "ccompiler", "if", "self", ".", "journal_file", "is", "None", ":", "return", "def", "journaled_spawn", "(", "patched_self", ",", "cmd", ",", "display", "=", "None", ")", ":", "self", ".", "commands", ".", "append", "(", "cmd", ")", "return", "numpy", ".", "distutils", ".", "ccompiler", ".", "CCompiler_spawn", "(", "patched_self", ",", "cmd", ",", "display", "=", "None", ")", "numpy", ".", "distutils", ".", "ccompiler", ".", "replace_method", "(", "distutils", ".", "ccompiler", ".", "CCompiler", ",", "\"spawn\"", ",", "journaled_spawn", ")" ]

[ "Capture", "calls", "to", "the", "system", "by", "compilers", "." ]

[ "def", "save_journal", "(", "self", ")", ":", "if", "self", ".", "journal_file", "is", "None", ":", "return", "try", ":", "as_text", "=", "self", ".", "_commands_to_text", "(", ")", "with", "open", "(", "self", ".", "journal_file", ",", "\"w\"", ")", "as", "file_obj", ":", "file_obj", ".", "write", "(", "as_text", ")", "except", "Exception", "as", "exc", ":", "msg", "=", "BAD_JOURNAL", ".", "format", "(", "exc", ")", "print", "(", "msg", ",", "file", "=", "sys", ".", "stderr", ")" ]

[ "Save", "journaled", "commands", "to", "file", "." ]

[ "def", "_default_static_lib", "(", "self", ",", "obj_files", ")", ":", "c_compiler", "=", "self", ".", "F90_COMPILER", ".", "c_compiler", "static_lib_dir", "=", "os", ".", "path", ".", "join", "(", "self", ".", "build_lib", ",", "\"bezier\"", ",", "\"lib\"", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "static_lib_dir", ")", ":", "os", ".", "makedirs", "(", "static_lib_dir", ")", "c_compiler", ".", "create_static_lib", "(", "obj_files", ",", "\"bezier\"", ",", "output_dir", "=", "static_lib_dir", ")", "# NOTE: We must \"modify\" the paths for the ``extra_objects`` in", "# each extension since they were compiled with", "# ``output_dir=self.build_temp``.", "for", "extension", "in", "self", ".", "extensions", ":", "extension", ".", "extra_objects", "[", ":", "]", "=", "[", "os", ".", "path", ".", "join", "(", "self", ".", "build_temp", ",", "rel_path", ")", "for", "rel_path", "in", "extension", ".", "extra_objects", "]" ]

[ "Create", "a", "static", "library", "(", "i", ".", "e", ".", "a", ".", "a", "/", ".", "lib", "file", ")", "." ]

[ "def", "_default_cleanup", "(", "self", ")", ":", "if", "not", "self", ".", "inplace", ":", "return", "shutil", ".", "move", "(", "os", ".", "path", ".", "join", "(", "self", ".", "build_lib", ",", "\"bezier\"", ",", "\"lib\"", ")", ",", "os", ".", "path", ".", "join", "(", "\"src\"", ",", "\"bezier\"", ")", ",", ")" ]

[ "Default", "cleanup", "after", ":", "meth", ":", "run", "." ]

[ "def", "_verify_pair", "(", "prev", ",", "curr", ")", ":", "if", "prev", ".", "_dimension", "!=", "2", ":", "raise", "ValueError", "(", "\"Curve not in R^2\"", ",", "prev", ")", "end", "=", "prev", ".", "_nodes", "[", ":", ",", "-", "1", "]", "start", "=", "curr", ".", "_nodes", "[", ":", ",", "0", "]", "if", "not", "_helpers", ".", "vector_close", "(", "end", ",", "start", ")", ":", "raise", "ValueError", "(", "\"Not sufficiently close\"", ",", "\"Consecutive sides do not have common endpoint\"", ",", "prev", ",", "curr", ",", ")" ]

[ "Verify", "a", "pair", "of", "sides", "share", "an", "endpoint", "." ]

[ "def", "_verify", "(", "self", ")", ":", "if", "self", ".", "_num_sides", "<", "2", ":", "raise", "ValueError", "(", "\"At least two sides required.\"", ")", "for", "prev", ",", "curr", "in", "six", ".", "moves", ".", "zip", "(", "self", ".", "_edges", ",", "self", ".", "_edges", "[", "1", ":", "]", ")", ":", "self", ".", "_verify_pair", "(", "prev", ",", "curr", ")", "# Now we check that the final edge wraps around.", "prev", "=", "self", ".", "_edges", "[", "-", "1", "]", "curr", "=", "self", ".", "_edges", "[", "0", "]", "self", ".", "_verify_pair", "(", "prev", ",", "curr", ")" ]

[ "Verify", "that", "the", "edges", "define", "a", "curved", "polygon", "." ]

[ "def", "area", "(", "self", ")", ":", "edges", "=", "tuple", "(", "edge", ".", "_nodes", "for", "edge", "in", "self", ".", "_edges", ")", "return", "_surface_helpers", ".", "compute_area", "(", "edges", ")" ]

[ "r", "The", "area", "of", "the", "current", "curved", "polygon", "." ]

[ "def", "plot", "(", "self", ",", "pts_per_edge", ",", "color", "=", "None", ",", "ax", "=", "None", ")", ":", "if", "ax", "is", "None", ":", "ax", "=", "_plot_helpers", ".", "new_axis", "(", ")", "_plot_helpers", ".", "add_patch", "(", "ax", ",", "color", ",", "pts_per_edge", ",", "*", "self", ".", "_edges", ")", "return", "ax" ]

[ "Plot", "the", "current", "curved", "polygon", "." ]

[ "def", "compute_implicit_line", "(", "nodes", ")", ":", "delta", "=", "nodes", "[", ":", ",", "-", "1", "]", "-", "nodes", "[", ":", ",", "0", "]", "length", "=", "np", ".", "linalg", ".", "norm", "(", "delta", ",", "ord", "=", "2", ")", "# Normalize and rotate 90 degrees to the \"left\".", "coeff_a", "=", "-", "delta", "[", "1", "]", "/", "length", "coeff_b", "=", "delta", "[", "0", "]", "/", "length", "# c = - ax - by = (delta[1] x - delta[0] y) / L", "# NOTE: We divide by ``length`` at the end to \"put off\" rounding.", "coeff_c", "=", "(", "delta", "[", "1", "]", "*", "nodes", "[", "0", ",", "0", "]", "-", "delta", "[", "0", "]", "*", "nodes", "[", "1", ",", "0", "]", ")", "/", "length", "return", "coeff_a", ",", "coeff_b", ",", "coeff_c" ]

[ "Compute", "the", "implicit", "form", "of", "the", "line", "connecting", "curve", "endpoints", "." ]

[ "def", "compute_fat_line", "(", "nodes", ")", ":", "coeff_a", ",", "coeff_b", ",", "coeff_c", "=", "compute_implicit_line", "(", "nodes", ")", "# NOTE: This assumes, but does not check, that there are two rows.", "_", ",", "num_nodes", "=", "nodes", ".", "shape", "d_min", "=", "0.0", "d_max", "=", "0.0", "for", "index", "in", "six", ".", "moves", ".", "xrange", "(", "1", ",", "num_nodes", "-", "1", ")", ":", "# Only interior nodes.", "curr_dist", "=", "(", "coeff_a", "*", "nodes", "[", "0", ",", "index", "]", "+", "coeff_b", "*", "nodes", "[", "1", ",", "index", "]", "+", "coeff_c", ")", "if", "curr_dist", "<", "d_min", ":", "d_min", "=", "curr_dist", "elif", "curr_dist", ">", "d_max", ":", "d_max", "=", "curr_dist", "return", "coeff_a", ",", "coeff_b", ",", "coeff_c", ",", "d_min", ",", "d_max" ]

[ "Compute", "the", "fat", "line", "around", "a", "B", "|eacute|", "zier", "curve", "." ]

[ "def", "_update_parameters", "(", "s_min", ",", "s_max", ",", "start0", ",", "end0", ",", "start1", ",", "end1", ")", ":", "s", ",", "t", ",", "success", "=", "_geometric_intersection", ".", "segment_intersection", "(", "start0", ",", "end0", ",", "start1", ",", "end1", ")", "if", "not", "success", ":", "raise", "NotImplementedError", "(", "NO_PARALLEL", ")", "if", "_helpers", ".", "in_interval", "(", "t", ",", "0.0", ",", "1.0", ")", ":", "if", "_helpers", ".", "in_interval", "(", "s", ",", "0.0", ",", "s_min", ")", ":", "return", "s", ",", "s_max", "elif", "_helpers", ".", "in_interval", "(", "s", ",", "s_max", ",", "1.0", ")", ":", "return", "s_min", ",", "s", "return", "s_min", ",", "s_max" ]

[ "Update", "clipped", "parameter", "range", "." ]

[ "def", "_check_parameter_range", "(", "s_min", ",", "s_max", ")", ":", "if", "s_min", "==", "DEFAULT_S_MIN", ":", "# Based on the way ``_update_parameters`` works, we know", "# both parameters must be unset if ``s_min``.", "return", "0.0", ",", "1.0", "if", "s_max", "==", "DEFAULT_S_MAX", ":", "return", "s_min", ",", "s_min", "return", "s_min", ",", "s_max" ]

[ "r", "Performs", "a", "final", "check", "on", "a", "clipped", "parameter", "range", "." ]

[ "def", "clip_range", "(", "nodes1", ",", "nodes2", ")", ":", "# NOTE: There is no corresponding \"enable\", but the disable only applies", "# in this lexical scope.", "# pylint: disable=too-many-locals", "coeff_a", ",", "coeff_b", ",", "coeff_c", ",", "d_min", ",", "d_max", "=", "compute_fat_line", "(", "nodes1", ")", "# NOTE: This assumes, but does not check, that there are two rows.", "_", ",", "num_nodes2", "=", "nodes2", ".", "shape", "polynomial", "=", "np", ".", "empty", "(", "(", "2", ",", "num_nodes2", ")", ",", "order", "=", "\"F\"", ")", "denominator", "=", "float", "(", "num_nodes2", "-", "1", ")", "for", "index", "in", "six", ".", "moves", ".", "xrange", "(", "num_nodes2", ")", ":", "polynomial", "[", "0", ",", "index", "]", "=", "index", "/", "denominator", "polynomial", "[", "1", ",", "index", "]", "=", "(", "coeff_a", "*", "nodes2", "[", "0", ",", "index", "]", "+", "coeff_b", "*", "nodes2", "[", "1", ",", "index", "]", "+", "coeff_c", ")", "# Define segments for the top and the bottom of the region", "# bounded by the fat line.", "start_bottom", "=", "np", ".", "asfortranarray", "(", "[", "0.0", ",", "d_min", "]", ")", "end_bottom", "=", "np", ".", "asfortranarray", "(", "[", "1.0", ",", "d_min", "]", ")", "start_top", "=", "np", ".", "asfortranarray", "(", "[", "0.0", ",", "d_max", "]", ")", "end_top", "=", "np", ".", "asfortranarray", "(", "[", "1.0", ",", "d_max", "]", ")", "s_min", "=", "DEFAULT_S_MIN", "s_max", "=", "DEFAULT_S_MAX", "# NOTE: We avoid computing the convex hull and just compute where", "# all segments connecting two control points intersect the", "# fat lines.", "for", "start_index", "in", "six", ".", "moves", ".", "xrange", "(", "num_nodes2", "-", "1", ")", ":", "for", "end_index", "in", "six", ".", "moves", ".", "xrange", "(", "start_index", "+", "1", ",", "num_nodes2", ")", ":", "s_min", ",", "s_max", "=", "_update_parameters", "(", "s_min", ",", "s_max", ",", "start_bottom", ",", "end_bottom", ",", "polynomial", "[", ":", ",", "start_index", "]", ",", "polynomial", "[", ":", ",", "end_index", "]", ",", ")", "s_min", ",", "s_max", "=", "_update_parameters", "(", "s_min", ",", "s_max", ",", "start_top", ",", "end_top", ",", "polynomial", "[", ":", ",", "start_index", "]", ",", "polynomial", "[", ":", ",", "end_index", "]", ",", ")", "return", "_check_parameter_range", "(", "s_min", ",", "s_max", ")" ]

[ "r", "Reduce", "the", "parameter", "range", "where", "two", "curves", "can", "intersect", "." ]

[ "def", "post_process_travis_macos", "(", "journal_filename", ")", ":", "travis_build_dir", "=", "os", ".", "environ", ".", "get", "(", "\"TRAVIS_BUILD_DIR\"", ",", "\"\"", ")", "with", "open", "(", "journal_filename", ",", "\"r\"", ")", "as", "file_obj", ":", "content", "=", "file_obj", ".", "read", "(", ")", "processed", "=", "content", ".", "replace", "(", "travis_build_dir", ",", "\"${TRAVIS_BUILD_DIR}\"", ")", "with", "open", "(", "journal_filename", ",", "\"w\"", ")", "as", "file_obj", ":", "file_obj", ".", "write", "(", "processed", ")" ]

[ "Post", "-", "process", "a", "generated", "journal", "file", "on", "Travis", "macOS", "." ]

[ "def", "mod_replace", "(", "match", ",", "sphinx_modules", ")", ":", "sphinx_modules", ".", "append", "(", "match", ".", "group", "(", "\"module\"", ")", ")", "return", "\"`{}`_\"", ".", "format", "(", "match", ".", "group", "(", "\"value\"", ")", ")" ]

[ "Convert", "Sphinx", ":", "mod", ":", "to", "plain", "reST", "link", "." ]

[ "def", "doc_replace", "(", "match", ",", "sphinx_docs", ")", ":", "sphinx_docs", ".", "append", "(", "match", ".", "group", "(", "\"path\"", ")", ")", "return", "\"`{}`_\"", ".", "format", "(", "match", ".", "group", "(", "\"value\"", ")", ")" ]

[ "Convert", "Sphinx", ":", "doc", ":", "to", "plain", "reST", "link", "." ]

[ "def", "get_diff", "(", "value1", ",", "value2", ",", "name1", ",", "name2", ")", ":", "lines1", "=", "[", "line", "+", "\"\\n\"", "for", "line", "in", "value1", ".", "splitlines", "(", ")", "]", "lines2", "=", "[", "line", "+", "\"\\n\"", "for", "line", "in", "value2", ".", "splitlines", "(", ")", "]", "diff_lines", "=", "difflib", ".", "context_diff", "(", "lines1", ",", "lines2", ",", "fromfile", "=", "name1", ",", "tofile", "=", "name2", ")", "return", "\"\"", ".", "join", "(", "diff_lines", ")" ]

[ "Get", "a", "diff", "between", "two", "strings", "." ]

[ "def", "populate_readme", "(", "revision", ",", "rtd_version", ",", "*", "*", "extra_kwargs", ")", ":", "with", "open", "(", "TEMPLATE_FILE", ",", "\"r\"", ")", "as", "file_obj", ":", "template", "=", "file_obj", ".", "read", "(", ")", "img_prefix", "=", "IMG_PREFIX", ".", "format", "(", "revision", "=", "revision", ")", "extra_links", "=", "EXTRA_LINKS", ".", "format", "(", "rtd_version", "=", "rtd_version", ",", "revision", "=", "revision", ")", "docs_img", "=", "DOCS_IMG", ".", "format", "(", "rtd_version", "=", "rtd_version", ")", "bernstein_basis", "=", "BERNSTEIN_BASIS_PLAIN", ".", "format", "(", "img_prefix", "=", "img_prefix", ")", "bezier_defn", "=", "BEZIER_DEFN_PLAIN", ".", "format", "(", "img_prefix", "=", "img_prefix", ")", "sum_to_unity", "=", "SUM_TO_UNITY_PLAIN", ".", "format", "(", "img_prefix", "=", "img_prefix", ")", "template_kwargs", "=", "{", "\"code_block1\"", ":", "PLAIN_CODE_BLOCK", ",", "\"code_block2\"", ":", "PLAIN_CODE_BLOCK", ",", "\"code_block3\"", ":", "PLAIN_CODE_BLOCK", ",", "\"testcleanup\"", ":", "\"\"", ",", "\"toctree\"", ":", "\"\"", ",", "\"bernstein_basis\"", ":", "bernstein_basis", ",", "\"bezier_defn\"", ":", "bezier_defn", ",", "\"sum_to_unity\"", ":", "sum_to_unity", ",", "\"img_prefix\"", ":", "img_prefix", ",", "\"extra_links\"", ":", "extra_links", ",", "\"docs\"", ":", "\"|docs| \"", ",", "\"docs_img\"", ":", "docs_img", ",", "\"pypi\"", ":", "\"\\n\\n|pypi| \"", ",", "\"pypi_img\"", ":", "PYPI_IMG", ",", "\"versions\"", ":", "\"|versions|\\n\\n\"", ",", "\"versions_img\"", ":", "VERSIONS_IMG", ",", "\"rtd_version\"", ":", "rtd_version", ",", "\"revision\"", ":", "revision", ",", "\"circleci_badge\"", ":", "CIRCLECI_BADGE", ",", "\"circleci_path\"", ":", "\"\"", ",", "\"travis_badge\"", ":", "TRAVIS_BADGE", ",", "\"travis_path\"", ":", "\"\"", ",", "\"appveyor_badge\"", ":", "APPVEYOR_BADGE", ",", "\"appveyor_path\"", ":", "\"\"", ",", "\"coveralls_badge\"", ":", "COVERALLS_BADGE", ",", "\"coveralls_path\"", ":", "COVERALLS_PATH", ",", "\"zenodo\"", ":", "\"|zenodo|\"", ",", "\"zenodo_img\"", ":", "ZENODO_IMG", ",", "\"joss\"", ":", "\" |JOSS|\"", ",", "\"joss_img\"", ":", "JOSS_IMG", ",", "}", "template_kwargs", ".", "update", "(", "*", "*", "extra_kwargs", ")", "readme_contents", "=", "template", ".", "format", "(", "*", "*", "template_kwargs", ")", "# Apply regular expressions to convert Sphinx \"roles\" to plain reST.", "readme_contents", "=", "INLINE_MATH_EXPR", ".", "sub", "(", "inline_math", ",", "readme_contents", ")", "sphinx_modules", "=", "[", "]", "to_replace", "=", "functools", ".", "partial", "(", "mod_replace", ",", "sphinx_modules", "=", "sphinx_modules", ")", "readme_contents", "=", "MOD_EXPR", ".", "sub", "(", "to_replace", ",", "readme_contents", ")", "if", "sphinx_modules", "!=", "[", "\"bezier.curve\"", ",", "\"bezier.surface\"", "]", ":", "raise", "ValueError", "(", "\"Unexpected sphinx_modules\"", ",", "sphinx_modules", ")", "sphinx_docs", "=", "[", "]", "to_replace", "=", "functools", ".", "partial", "(", "doc_replace", ",", "sphinx_docs", "=", "sphinx_docs", ")", "readme_contents", "=", "DOC_EXPR", ".", "sub", "(", "to_replace", ",", "readme_contents", ")", "if", "sphinx_docs", "!=", "[", "\"python/reference/bezier\"", ",", "\"development\"", "]", ":", "raise", "ValueError", "(", "\"Unexpected sphinx_docs\"", ",", "sphinx_docs", ")", "return", "readme_contents" ]

[ "Populate", "README", "template", "with", "values", "." ]

[ "def", "readme_verify", "(", ")", ":", "expected", "=", "populate_readme", "(", "REVISION", ",", "RTD_VERSION", ")", "# Actually get the stored contents.", "with", "open", "(", "README_FILE", ",", "\"r\"", ")", "as", "file_obj", ":", "contents", "=", "file_obj", ".", "read", "(", ")", "if", "contents", "!=", "expected", ":", "err_msg", "=", "\"\\n\"", "+", "get_diff", "(", "contents", ",", "expected", ",", "\"README.rst.actual\"", ",", "\"README.rst.expected\"", ")", "raise", "ValueError", "(", "err_msg", ")", "else", ":", "print", "(", "\"README contents are as expected.\"", ")" ]

[ "Populate", "the", "template", "and", "compare", "to", "README", "." ]

[ "def", "release_readme_verify", "(", ")", ":", "version", "=", "\"{version}\"", "expected", "=", "populate_readme", "(", "version", ",", "version", ",", "pypi", "=", "\"\"", ",", "pypi_img", "=", "\"\"", ",", "versions", "=", "\"\\n\\n\"", ",", "versions_img", "=", "\"\"", ",", "circleci_badge", "=", "CIRCLECI_BADGE_RELEASE", ",", "circleci_path", "=", "\"/{circleci_build}\"", ",", "travis_badge", "=", "TRAVIS_BADGE_RELEASE", ",", "travis_path", "=", "\"/builds/{travis_build}\"", ",", "appveyor_badge", "=", "APPVEYOR_BADGE_RELEASE", ",", "appveyor_path", "=", "\"/build/{appveyor_build}\"", ",", "coveralls_badge", "=", "COVERALLS_BADGE_RELEASE", ",", "coveralls_path", "=", "\"builds/{coveralls_build}\"", ",", ")", "with", "open", "(", "RELEASE_README_FILE", ",", "\"r\"", ")", "as", "file_obj", ":", "contents", "=", "file_obj", ".", "read", "(", ")", "if", "contents", "!=", "expected", ":", "err_msg", "=", "\"\\n\"", "+", "get_diff", "(", "contents", ",", "expected", ",", "\"README.rst.release.actual\"", ",", "\"README.rst.release.expected\"", ",", ")", "raise", "ValueError", "(", "err_msg", ")", "else", ":", "print", "(", "\"README.rst.release.template contents are as expected.\"", ")" ]

[ "Specialize", "the", "template", "to", "a", "PyPI", "release", "template", "." ]

[ "def", "_index_verify", "(", "index_file", ",", "*", "*", "extra_kwargs", ")", ":", "side_effect", "=", "extra_kwargs", ".", "pop", "(", "\"side_effect\"", ",", "None", ")", "with", "open", "(", "TEMPLATE_FILE", ",", "\"r\"", ")", "as", "file_obj", ":", "template", "=", "file_obj", ".", "read", "(", ")", "template_kwargs", "=", "{", "\"code_block1\"", ":", "SPHINX_CODE_BLOCK1", ",", "\"code_block2\"", ":", "SPHINX_CODE_BLOCK2", ",", "\"code_block3\"", ":", "SPHINX_CODE_BLOCK3", ",", "\"testcleanup\"", ":", "TEST_CLEANUP", ",", "\"toctree\"", ":", "TOCTREE", ",", "\"bernstein_basis\"", ":", "BERNSTEIN_BASIS_SPHINX", ",", "\"bezier_defn\"", ":", "BEZIER_DEFN_SPHINX", ",", "\"sum_to_unity\"", ":", "SUM_TO_UNITY_SPHINX", ",", "\"img_prefix\"", ":", "\"\"", ",", "\"extra_links\"", ":", "\"\"", ",", "\"docs\"", ":", "\"\"", ",", "\"docs_img\"", ":", "\"\"", ",", "\"pypi\"", ":", "\"\\n\\n|pypi| \"", ",", "\"pypi_img\"", ":", "PYPI_IMG", ",", "\"versions\"", ":", "\"|versions|\\n\\n\"", ",", "\"versions_img\"", ":", "VERSIONS_IMG", ",", "\"rtd_version\"", ":", "RTD_VERSION", ",", "\"revision\"", ":", "REVISION", ",", "\"circleci_badge\"", ":", "CIRCLECI_BADGE", ",", "\"circleci_path\"", ":", "\"\"", ",", "\"travis_badge\"", ":", "TRAVIS_BADGE", ",", "\"travis_path\"", ":", "\"\"", ",", "\"appveyor_badge\"", ":", "APPVEYOR_BADGE", ",", "\"appveyor_path\"", ":", "\"\"", ",", "\"coveralls_badge\"", ":", "COVERALLS_BADGE", ",", "\"coveralls_path\"", ":", "COVERALLS_PATH", ",", "\"zenodo\"", ":", "\"|zenodo|\"", ",", "\"zenodo_img\"", ":", "ZENODO_IMG", ",", "\"joss\"", ":", "\" |JOSS|\"", ",", "\"joss_img\"", ":", "JOSS_IMG", ",", "}", "template_kwargs", ".", "update", "(", "*", "*", "extra_kwargs", ")", "expected", "=", "template", ".", "format", "(", "*", "*", "template_kwargs", ")", "if", "side_effect", "is", "not", "None", ":", "expected", "=", "side_effect", "(", "expected", ")", "with", "open", "(", "index_file", ",", "\"r\"", ")", "as", "file_obj", ":", "contents", "=", "file_obj", ".", "read", "(", ")", "if", "contents", "!=", "expected", ":", "err_msg", "=", "\"\\n\"", "+", "get_diff", "(", "contents", ",", "expected", ",", "index_file", "+", "\".actual\"", ",", "index_file", "+", "\".expected\"", ",", ")", "raise", "ValueError", "(", "err_msg", ")", "else", ":", "rel_name", "=", "os", ".", "path", ".", "relpath", "(", "index_file", ",", "_ROOT_DIR", ")", "msg", "=", "\"{} contents are as expected.\"", ".", "format", "(", "rel_name", ")", "print", "(", "msg", ")" ]

[ "Populate", "the", "template", "and", "compare", "to", "documentation", "index", "file", "." ]

[ "def", "release_docs_side_effect", "(", "content", ")", ":", "# First replace **all** curly braces.", "result", "=", "content", ".", "replace", "(", "\"{\"", ",", "\"{{\"", ")", ".", "replace", "(", "\"}\"", ",", "\"}}\"", ")", "# Then reset the actual template arguments.", "result", "=", "result", ".", "replace", "(", "\"{{version}}\"", ",", "\"{version}\"", ")", "result", "=", "result", ".", "replace", "(", "\"{{circleci_build}}\"", ",", "\"{circleci_build}\"", ")", "result", "=", "result", ".", "replace", "(", "\"{{travis_build}}\"", ",", "\"{travis_build}\"", ")", "result", "=", "result", ".", "replace", "(", "\"{{appveyor_build}}\"", ",", "\"{appveyor_build}\"", ")", "result", "=", "result", ".", "replace", "(", "\"{{coveralls_build}}\"", ",", "\"{coveralls_build}\"", ")", "return", "result" ]

[ "Updates", "the", "template", "so", "that", "curly", "braces", "are", "escaped", "correctly", "." ]

[ "def", "release_docs_index_verify", "(", ")", ":", "version", "=", "\"{version}\"", "_index_verify", "(", "RELEASE_INDEX_FILE", ",", "side_effect", "=", "release_docs_side_effect", ",", "pypi", "=", "\"\"", ",", "pypi_img", "=", "\"\"", ",", "versions", "=", "\"\\n\\n\"", ",", "versions_img", "=", "\"\"", ",", "rtd_version", "=", "version", ",", "revision", "=", "version", ",", "circleci_badge", "=", "CIRCLECI_BADGE_RELEASE", ",", "circleci_path", "=", "\"/{circleci_build}\"", ",", "travis_badge", "=", "TRAVIS_BADGE_RELEASE", ",", "travis_path", "=", "\"/builds/{travis_build}\"", ",", "appveyor_badge", "=", "APPVEYOR_BADGE_RELEASE", ",", "appveyor_path", "=", "\"/build/{appveyor_build}\"", ",", "coveralls_badge", "=", "COVERALLS_BADGE_RELEASE", ",", "coveralls_path", "=", "\"builds/{coveralls_build}\"", ",", ")" ]

[ "Populate", "template", "and", "compare", "to", "docs", "/", "index", ".", "rst", ".", "release", ".", "template", "." ]

[ "def", "development_verify", "(", ")", ":", "with", "open", "(", "DEVELOPMENT_TEMPLATE", ",", "\"r\"", ")", "as", "file_obj", ":", "template", "=", "file_obj", ".", "read", "(", ")", "expected", "=", "template", ".", "format", "(", "revision", "=", "REVISION", ",", "rtd_version", "=", "RTD_VERSION", ")", "with", "open", "(", "DEVELOPMENT_FILE", ",", "\"r\"", ")", "as", "file_obj", ":", "contents", "=", "file_obj", ".", "read", "(", ")", "if", "contents", "!=", "expected", ":", "err_msg", "=", "\"\\n\"", "+", "get_diff", "(", "contents", ",", "expected", ",", "\"DEVELOPMENT.rst.actual\"", ",", "\"DEVELOPMENT.rst.expected\"", ",", ")", "raise", "ValueError", "(", "err_msg", ")", "else", ":", "print", "(", "\"DEVELOPMENT.rst contents are as expected.\"", ")" ]

[ "Populate", "template", "and", "compare", "to", "DEVELOPMENT", ".", "rst" ]

[ "def", "native_libraries_verify", "(", ")", ":", "with", "open", "(", "BINARY_EXT_TEMPLATE", ",", "\"r\"", ")", "as", "file_obj", ":", "template", "=", "file_obj", ".", "read", "(", ")", "expected", "=", "template", ".", "format", "(", "revision", "=", "REVISION", ")", "with", "open", "(", "BINARY_EXT_FILE", ",", "\"r\"", ")", "as", "file_obj", ":", "contents", "=", "file_obj", ".", "read", "(", ")", "if", "contents", "!=", "expected", ":", "err_msg", "=", "\"\\n\"", "+", "get_diff", "(", "contents", ",", "expected", ",", "\"docs/python/binary-extension.rst.actual\"", ",", "\"docs/python/binary-extension.rst.expected\"", ",", ")", "raise", "ValueError", "(", "err_msg", ")", "else", ":", "print", "(", "\"docs/python/binary-extension.rst contents are as expected.\"", ")" ]

[ "Populate", "the", "template", "and", "compare", "to", "binary", "-", "extension", ".", "rst", "." ]

[ "def", "_evaluate3", "(", "nodes", ",", "x_val", ",", "y_val", ")", ":", "# NOTE: This may be (a) slower and (b) less precise than", "# hard-coding the determinant.", "sylvester_mat", "=", "np", ".", "zeros", "(", "(", "6", ",", "6", ")", ",", "order", "=", "\"F\"", ")", "delta", "=", "nodes", "-", "np", ".", "asfortranarray", "(", "[", "[", "x_val", "]", ",", "[", "y_val", "]", "]", ")", "delta", "[", ":", ",", "1", ":", "3", "]", "*=", "3.0", "# Swap rows/columns so that x-y are right next to each other.", "# This will only change the determinant up to a sign.", "sylvester_mat", "[", ":", "2", ",", ":", "4", "]", "=", "delta", "sylvester_mat", "[", "2", ":", "4", ",", "1", ":", "5", "]", "=", "delta", "sylvester_mat", "[", "4", ":", ",", "2", ":", "]", "=", "delta", "return", "np", ".", "linalg", ".", "det", "(", "sylvester_mat", ")" ]

[ "Helper", "for", ":", "func", ":", "evaluate", "when", "nodes", "is", "degree", "3", "." ]

[ "def", "evaluate", "(", "nodes", ",", "x_val", ",", "y_val", ")", ":", "_", ",", "num_nodes", "=", "nodes", ".", "shape", "if", "num_nodes", "==", "1", ":", "raise", "ValueError", "(", "\"A point cannot be implicitized\"", ")", "elif", "num_nodes", "==", "2", ":", "# x(s) - x = (x0 - x) (1 - s) + (x1 - x) s", "# y(s) - y = (y0 - y) (1 - s) + (y1 - y) s", "# Modified Sylvester: [x0 - x, x1 - x]", "# [y0 - y, y1 - y]", "return", "(", "nodes", "[", "0", ",", "0", "]", "-", "x_val", ")", "*", "(", "nodes", "[", "1", ",", "1", "]", "-", "y_val", ")", "-", "(", "nodes", "[", "0", ",", "1", "]", "-", "x_val", ")", "*", "(", "nodes", "[", "1", ",", "0", "]", "-", "y_val", ")", "elif", "num_nodes", "==", "3", ":", "# x(s) - x = (x0 - x) (1 - s)^2 + 2 (x1 - x) s(1 - s) + (x2 - x) s^2", "# y(s) - y = (y0 - y) (1 - s)^2 + 2 (y1 - y) s(1 - s) + (y2 - y) s^2", "# Modified Sylvester: [x0 - x, 2(x1 - x), x2 - x, 0] = A|B|C|0", "# [ 0, x0 - x, 2(x1 - x), x2 - x] 0|A|B|C", "# [y0 - y, 2(y1 - y), y2 - y, 0] D|E|F|0", "# [ 0, y0 - y, 2(y1 - y), y2 - y] 0|D|E|F", "val_a", ",", "val_b", ",", "val_c", "=", "nodes", "[", "0", ",", ":", "]", "-", "x_val", "val_b", "*=", "2", "val_d", ",", "val_e", ",", "val_f", "=", "nodes", "[", "1", ",", ":", "]", "-", "y_val", "val_e", "*=", "2", "# [A, B, C] [E, F, 0]", "# det [E, F, 0] = - det [A, B, C] = -E (BF - CE) + F(AF - CD)", "# [D, E, F] [D, E, F]", "sub1", "=", "val_b", "*", "val_f", "-", "val_c", "*", "val_e", "sub2", "=", "val_a", "*", "val_f", "-", "val_c", "*", "val_d", "sub_det_a", "=", "-", "val_e", "*", "sub1", "+", "val_f", "*", "sub2", "# [B, C, 0]", "# det [A, B, C] = B (BF - CE) - C (AF - CD)", "# [D, E, F]", "sub_det_d", "=", "val_b", "*", "sub1", "-", "val_c", "*", "sub2", "return", "val_a", "*", "sub_det_a", "+", "val_d", "*", "sub_det_d", "elif", "num_nodes", "==", "4", ":", "return", "_evaluate3", "(", "nodes", ",", "x_val", ",", "y_val", ")", "else", ":", "raise", "_helpers", ".", "UnsupportedDegree", "(", "num_nodes", "-", "1", ",", "supported", "=", "(", "1", ",", "2", ",", "3", ")", ")" ]

[ "r", "Evaluate", "the", "implicitized", "bivariate", "polynomial", "containing", "the", "curve", "." ]

[ "def", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "t", ")", ":", "(", "x_val", ",", ")", ",", "(", "y_val", ",", ")", "=", "_curve_helpers", ".", "evaluate_multi", "(", "nodes2", ",", "np", ".", "asfortranarray", "(", "[", "t", "]", ")", ")", "return", "evaluate", "(", "nodes1", ",", "x_val", ",", "y_val", ")" ]

[ "r", "Evaluates", "a", "parametric", "curve", "**", "on", "**", "an", "implicitized", "algebraic", "curve", "." ]

[ "def", "_to_power_basis11", "(", "nodes1", ",", "nodes2", ")", ":", "# We manually invert the Vandermonde matrix:", "# [1 0][c0] = [n0]", "# [1 1][c1] [n1]", "val0", "=", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "0.0", ")", "val1", "=", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "1.0", ")", "# [c0] = [ 1 0][n0]", "# [c1] = [-1 1][n1]", "return", "np", ".", "asfortranarray", "(", "[", "val0", ",", "-", "val0", "+", "val1", "]", ")" ]

[ "r", "Compute", "the", "coefficients", "of", "an", "**", "intersection", "polynomial", "**", "." ]

[ "def", "_to_power_basis12", "(", "nodes1", ",", "nodes2", ")", ":", "# We manually invert the Vandermonde matrix:", "# [1 0 0 ][c0] = [n0]", "# [1 1/2 1/4][c1] [n1]", "# [1 1 1 ][c2] [n2]", "val0", "=", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "0.0", ")", "val1", "=", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "0.5", ")", "val2", "=", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "1.0", ")", "# [c0] = [ 1 0 0][n0]", "# [c1] = [-3 4 -1][n1]", "# [c2] = [ 2 -4 2][n2]", "return", "np", ".", "asfortranarray", "(", "[", "val0", ",", "-", "3.0", "*", "val0", "+", "4.0", "*", "val1", "-", "val2", ",", "2.0", "*", "val0", "-", "4.0", "*", "val1", "+", "2.0", "*", "val2", ",", "]", ")" ]

[ "r", "Compute", "the", "coefficients", "of", "an", "**", "intersection", "polynomial", "**", "." ]

[ "def", "_to_power_basis13", "(", "nodes1", ",", "nodes2", ")", ":", "# We manually invert the Vandermonde matrix:", "# Use exact f.p. numbers to avoid round-off wherever possible.", "# [1 0 0 0 ][c0] = [n0]", "# [1 1/4 1/16 1/64 ][c1] [n1]", "# [1 3/4 9/16 27/64][c2] [n2]", "# [1 1 1 1 ][c3] [n3]", "val0", "=", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "0.0", ")", "val1", "=", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "0.25", ")", "val2", "=", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "0.75", ")", "val3", "=", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "1.0", ")", "# [c0] = [ 3 0 0 0][n0]", "# [c1] = 1 / 3 [-19 24 -8 3][n1]", "# [c2] = [ 32 -56 40 -16][n2]", "# [c3] = [-16 32 -32 16][n3]", "# Since polynomial coefficients, we don't need to divide by 3", "# to get the same polynomial. Avoid the division to avoid round-off.", "return", "np", ".", "asfortranarray", "(", "[", "3.0", "*", "val0", ",", "-", "19.0", "*", "val0", "+", "24.0", "*", "val1", "-", "8.0", "*", "val2", "+", "3.0", "*", "val3", ",", "32.0", "*", "val0", "-", "56.0", "*", "val1", "+", "40.0", "*", "val2", "-", "16.0", "*", "val3", ",", "-", "16.0", "*", "val0", "+", "32.0", "*", "val1", "-", "32.0", "*", "val2", "+", "16.0", "*", "val3", ",", "]", ")" ]

[ "r", "Compute", "the", "coefficients", "of", "an", "**", "intersection", "polynomial", "**", "." ]

[ "def", "_to_power_basis_degree4", "(", "nodes1", ",", "nodes2", ")", ":", "# We manually invert the Vandermonde matrix:", "# [1 0 0 0 0 ][c0] = [n0]", "# [1 1/4 1/16 1/64 1/256 ][c1] [n1]", "# [1 1/2 1/4 1/8 1/16 ][c2] [n2]", "# [1 3/4 9/16 27/64 81/256][c3] [n3]", "# [1 1 1 1 1 ][c4] [n4]", "val0", "=", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "0.0", ")", "val1", "=", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "0.25", ")", "val2", "=", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "0.5", ")", "val3", "=", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "0.75", ")", "val4", "=", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "1.0", ")", "# [c0] = [ 3 0 0 0 0 ][n0]", "# [c1] = 1 / 3 [-25 48 -36 16 -3 ][n1]", "# [c2] = [ 70 -208 228 -112 22][n2]", "# [c3] = [-80 288 -384 224 -48][n3]", "# [c4] = [ 32 -128 192 -128 32][n4]", "# Since polynomial coefficients, we don't need to divide by 3", "# to get the same polynomial. Avoid the division to avoid round-off.", "return", "np", ".", "asfortranarray", "(", "[", "3.0", "*", "val0", ",", "-", "25.0", "*", "val0", "+", "48.0", "*", "val1", "-", "36.0", "*", "val2", "+", "16.0", "*", "val3", "-", "3.0", "*", "val4", ",", "70.0", "*", "val0", "-", "208.0", "*", "val1", "+", "228.0", "*", "val2", "-", "112.0", "*", "val3", "+", "22.0", "*", "val4", ",", "(", "-", "80.0", "*", "val0", "+", "288.0", "*", "val1", "-", "384.0", "*", "val2", "+", "224.0", "*", "val3", "-", "48.0", "*", "val4", ")", ",", "32.0", "*", "val0", "-", "128.0", "*", "val1", "+", "192.0", "*", "val2", "-", "128.0", "*", "val3", "+", "32.0", "*", "val4", ",", "]", ")" ]

[ "r", "Compute", "the", "coefficients", "of", "an", "**", "intersection", "polynomial", "**", "." ]

[ "def", "_to_power_basis23", "(", "nodes1", ",", "nodes2", ")", ":", "evaluated", "=", "[", "eval_intersection_polynomial", "(", "nodes1", ",", "nodes2", ",", "t_val", ")", "for", "t_val", "in", "_CHEB7", "]", "return", "polynomial", ".", "polyfit", "(", "_CHEB7", ",", "evaluated", ",", "6", ")" ]

[ "r", "Compute", "the", "coefficients", "of", "an", "**", "intersection", "polynomial", "**", "." ]