warp-lang 1.7.2__py3-none-macosx_10_13_universal2.whl → 1.8.0__py3-none-macosx_10_13_universal2.whl

warp/native/exports.h

@@ -953,10 +953,25 @@ WP_API void builtin_cw_div_mat22d_mat22d(mat22d& a, mat22d& b, mat22d* ret) { *r
 WP_API void builtin_cw_div_mat33d_mat33d(mat33d& a, mat33d& b, mat33d* ret) { *ret = wp::cw_div(a, b); }
 WP_API void builtin_cw_div_mat44d_mat44d(mat44d& a, mat44d& b, mat44d* ret) { *ret = wp::cw_div(a, b); }
 WP_API void builtin_cw_div_spatial_matrixd_spatial_matrixd(spatial_matrixd& a, spatial_matrixd& b, spatial_matrixd* ret) { *ret = wp::cw_div(a, b); }
+WP_API void builtin_svd3_mat33h(mat33h& A, mat33h& ret_0, vec3h& ret_1, mat33h& ret_2) { wp::svd3(A, ret_0, ret_1, ret_2); }
+WP_API void builtin_svd3_mat33f(mat33f& A, mat33f& ret_0, vec3f& ret_1, mat33f& ret_2) { wp::svd3(A, ret_0, ret_1, ret_2); }
+WP_API void builtin_svd3_mat33d(mat33d& A, mat33d& ret_0, vec3d& ret_1, mat33d& ret_2) { wp::svd3(A, ret_0, ret_1, ret_2); }
+WP_API void builtin_svd2_mat22h(mat22h& A, mat22h& ret_0, vec2h& ret_1, mat22h& ret_2) { wp::svd2(A, ret_0, ret_1, ret_2); }
+WP_API void builtin_svd2_mat22f(mat22f& A, mat22f& ret_0, vec2f& ret_1, mat22f& ret_2) { wp::svd2(A, ret_0, ret_1, ret_2); }
+WP_API void builtin_svd2_mat22d(mat22d& A, mat22d& ret_0, vec2d& ret_1, mat22d& ret_2) { wp::svd2(A, ret_0, ret_1, ret_2); }
+WP_API void builtin_qr3_mat33h(mat33h& A, mat33h& ret_0, mat33h& ret_1) { wp::qr3(A, ret_0, ret_1); }
+WP_API void builtin_qr3_mat33f(mat33f& A, mat33f& ret_0, mat33f& ret_1) { wp::qr3(A, ret_0, ret_1); }
+WP_API void builtin_qr3_mat33d(mat33d& A, mat33d& ret_0, mat33d& ret_1) { wp::qr3(A, ret_0, ret_1); }
+WP_API void builtin_eig3_mat33h(mat33h& A, mat33h& ret_0, vec3h& ret_1) { wp::eig3(A, ret_0, ret_1); }
+WP_API void builtin_eig3_mat33f(mat33f& A, mat33f& ret_0, vec3f& ret_1) { wp::eig3(A, ret_0, ret_1); }
+WP_API void builtin_eig3_mat33d(mat33d& A, mat33d& ret_0, vec3d& ret_1) { wp::eig3(A, ret_0, ret_1); }
 WP_API void builtin_quat_identity(quatf* ret) { *ret = wp::quat_identity(); }
 WP_API void builtin_quat_from_axis_angle_vec3h_float16(vec3h& axis, float16 angle, quath* ret) { *ret = wp::quat_from_axis_angle(axis, angle); }
 WP_API void builtin_quat_from_axis_angle_vec3f_float32(vec3f& axis, float32 angle, quatf* ret) { *ret = wp::quat_from_axis_angle(axis, angle); }
 WP_API void builtin_quat_from_axis_angle_vec3d_float64(vec3d& axis, float64 angle, quatd* ret) { *ret = wp::quat_from_axis_angle(axis, angle); }
+WP_API void builtin_quat_to_axis_angle_quath(quath& quat, vec3h& ret_0, float16& ret_1) { wp::quat_to_axis_angle(quat, ret_0, ret_1); }
+WP_API void builtin_quat_to_axis_angle_quatf(quatf& quat, vec3f& ret_0, float32& ret_1) { wp::quat_to_axis_angle(quat, ret_0, ret_1); }
+WP_API void builtin_quat_to_axis_angle_quatd(quatd& quat, vec3d& ret_0, float64& ret_1) { wp::quat_to_axis_angle(quat, ret_0, ret_1); }
 WP_API void builtin_quat_from_matrix_mat33h(mat33h& mat, quath* ret) { *ret = wp::quat_from_matrix(mat); }
 WP_API void builtin_quat_from_matrix_mat33f(mat33f& mat, quatf* ret) { *ret = wp::quat_from_matrix(mat); }
 WP_API void builtin_quat_from_matrix_mat33d(mat33d& mat, quatd* ret) { *ret = wp::quat_from_matrix(mat); }
@@ -988,6 +1003,12 @@ WP_API void builtin_transform_get_translation_transformd(transformd& xform, vec3
 WP_API void builtin_transform_get_rotation_transformh(transformh& xform, quath* ret) { *ret = wp::transform_get_rotation(xform); }
 WP_API void builtin_transform_get_rotation_transformf(transformf& xform, quatf* ret) { *ret = wp::transform_get_rotation(xform); }
 WP_API void builtin_transform_get_rotation_transformd(transformd& xform, quatd* ret) { *ret = wp::transform_get_rotation(xform); }
+WP_API void builtin_transform_set_translation_transformh_vec3h(transformh& xform, vec3h& p) { wp::transform_set_translation(xform, p); }
+WP_API void builtin_transform_set_translation_transformf_vec3f(transformf& xform, vec3f& p) { wp::transform_set_translation(xform, p); }
+WP_API void builtin_transform_set_translation_transformd_vec3d(transformd& xform, vec3d& p) { wp::transform_set_translation(xform, p); }
+WP_API void builtin_transform_set_rotation_transformh_quath(transformh& xform, quath& q) { wp::transform_set_rotation(xform, q); }
+WP_API void builtin_transform_set_rotation_transformf_quatf(transformf& xform, quatf& q) { wp::transform_set_rotation(xform, q); }
+WP_API void builtin_transform_set_rotation_transformd_quatd(transformd& xform, quatd& q) { wp::transform_set_rotation(xform, q); }
 WP_API void builtin_transform_multiply_transformh_transformh(transformh& a, transformh& b, transformh* ret) { *ret = wp::transform_multiply(a, b); }
 WP_API void builtin_transform_multiply_transformf_transformf(transformf& a, transformf& b, transformf* ret) { *ret = wp::transform_multiply(a, b); }
 WP_API void builtin_transform_multiply_transformd_transformd(transformd& a, transformd& b, transformd* ret) { *ret = wp::transform_multiply(a, b); }
@@ -1063,6 +1084,7 @@ WP_API void builtin_pnoise_uint32_vec4f_int32_int32_int32_int32(uint32 state, ve
 WP_API void builtin_curlnoise_uint32_vec2f_uint32_float32_float32(uint32 state, vec2f& xy, uint32 octaves, float32 lacunarity, float32 gain, vec2f* ret) { *ret = wp::curlnoise(state, xy, octaves, lacunarity, gain); }
 WP_API void builtin_curlnoise_uint32_vec3f_uint32_float32_float32(uint32 state, vec3f& xyz, uint32 octaves, float32 lacunarity, float32 gain, vec3f* ret) { *ret = wp::curlnoise(state, xyz, octaves, lacunarity, gain); }
 WP_API void builtin_curlnoise_uint32_vec4f_uint32_float32_float32(uint32 state, vec4f& xyzt, uint32 octaves, float32 lacunarity, float32 gain, vec3f* ret) { *ret = wp::curlnoise(state, xyzt, octaves, lacunarity, gain); }
+WP_API void builtin_block_dim(int* ret) { *ret = wp::block_dim(); }
 WP_API void builtin_extract_vec2h_int32(vec2h& a, int32 i, float16* ret) { *ret = wp::extract(a, i); }
 WP_API void builtin_extract_vec3h_int32(vec3h& a, int32 i, float16* ret) { *ret = wp::extract(a, i); }
 WP_API void builtin_extract_vec4h_int32(vec4h& a, int32 i, float16* ret) { *ret = wp::extract(a, i); }
@@ -1130,69 +1152,72 @@ WP_API void builtin_extract_transformh_int32(transformh& a, int32 i, float16* re
 WP_API void builtin_extract_transformf_int32(transformf& a, int32 i, float32* ret) { *ret = wp::extract(a, i); }
 WP_API void builtin_extract_transformd_int32(transformd& a, int32 i, float64* ret) { *ret = wp::extract(a, i); }
 WP_API void builtin_extract_shape_t_int32(shape_t s, int32 i, int* ret) { *ret = wp::extract(s, i); }
-WP_API void builtin_assign_copy_vec2h_int32_float16(vec2h& a, int32 i, float16 value, vec2h* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3h_int32_float16(vec3h& a, int32 i, float16 value, vec3h* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4h_int32_float16(vec4h& a, int32 i, float16 value, vec4h* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_spatial_vectorh_int32_float16(spatial_vectorh& a, int32 i, float16 value, spatial_vectorh* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2f_int32_float32(vec2f& a, int32 i, float32 value, vec2f* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3f_int32_float32(vec3f& a, int32 i, float32 value, vec3f* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4f_int32_float32(vec4f& a, int32 i, float32 value, vec4f* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_spatial_vectorf_int32_float32(spatial_vectorf& a, int32 i, float32 value, spatial_vectorf* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2d_int32_float64(vec2d& a, int32 i, float64 value, vec2d* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3d_int32_float64(vec3d& a, int32 i, float64 value, vec3d* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4d_int32_float64(vec4d& a, int32 i, float64 value, vec4d* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_spatial_vectord_int32_float64(spatial_vectord& a, int32 i, float64 value, spatial_vectord* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2s_int32_int16(vec2s& a, int32 i, int16 value, vec2s* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3s_int32_int16(vec3s& a, int32 i, int16 value, vec3s* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4s_int32_int16(vec4s& a, int32 i, int16 value, vec4s* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2i_int32_int32(vec2i& a, int32 i, int32 value, vec2i* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3i_int32_int32(vec3i& a, int32 i, int32 value, vec3i* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4i_int32_int32(vec4i& a, int32 i, int32 value, vec4i* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2l_int32_int64(vec2l& a, int32 i, int64 value, vec2l* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3l_int32_int64(vec3l& a, int32 i, int64 value, vec3l* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4l_int32_int64(vec4l& a, int32 i, int64 value, vec4l* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2b_int32_int8(vec2b& a, int32 i, int8 value, vec2b* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3b_int32_int8(vec3b& a, int32 i, int8 value, vec3b* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4b_int32_int8(vec4b& a, int32 i, int8 value, vec4b* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2us_int32_uint16(vec2us& a, int32 i, uint16 value, vec2us* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3us_int32_uint16(vec3us& a, int32 i, uint16 value, vec3us* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4us_int32_uint16(vec4us& a, int32 i, uint16 value, vec4us* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2ui_int32_uint32(vec2ui& a, int32 i, uint32 value, vec2ui* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3ui_int32_uint32(vec3ui& a, int32 i, uint32 value, vec3ui* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4ui_int32_uint32(vec4ui& a, int32 i, uint32 value, vec4ui* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2ul_int32_uint64(vec2ul& a, int32 i, uint64 value, vec2ul* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3ul_int32_uint64(vec3ul& a, int32 i, uint64 value, vec3ul* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4ul_int32_uint64(vec4ul& a, int32 i, uint64 value, vec4ul* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec2ub_int32_uint8(vec2ub& a, int32 i, uint8 value, vec2ub* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec3ub_int32_uint8(vec3ub& a, int32 i, uint8 value, vec3ub* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_vec4ub_int32_uint8(vec4ub& a, int32 i, uint8 value, vec4ub* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_quath_int32_float16(quath& a, int32 i, float16 value, quath* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_quatf_int32_float32(quatf& a, int32 i, float32 value, quatf* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_quatd_int32_float64(quatd& a, int32 i, float64 value, quatd* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat22h_int32_int32_float16(mat22h& a, int32 i, int32 j, float16 value, mat22h* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat33h_int32_int32_float16(mat33h& a, int32 i, int32 j, float16 value, mat33h* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat44h_int32_int32_float16(mat44h& a, int32 i, int32 j, float16 value, mat44h* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_spatial_matrixh_int32_int32_float16(spatial_matrixh& a, int32 i, int32 j, float16 value, spatial_matrixh* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat22f_int32_int32_float32(mat22f& a, int32 i, int32 j, float32 value, mat22f* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat33f_int32_int32_float32(mat33f& a, int32 i, int32 j, float32 value, mat33f* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat44f_int32_int32_float32(mat44f& a, int32 i, int32 j, float32 value, mat44f* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_spatial_matrixf_int32_int32_float32(spatial_matrixf& a, int32 i, int32 j, float32 value, spatial_matrixf* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat22d_int32_int32_float64(mat22d& a, int32 i, int32 j, float64 value, mat22d* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat33d_int32_int32_float64(mat33d& a, int32 i, int32 j, float64 value, mat33d* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat44d_int32_int32_float64(mat44d& a, int32 i, int32 j, float64 value, mat44d* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_spatial_matrixd_int32_int32_float64(spatial_matrixd& a, int32 i, int32 j, float64 value, spatial_matrixd* ret) { *ret = wp::assign_copy(a, i, j, value); }
-WP_API void builtin_assign_copy_mat22h_int32_vec2h(mat22h& a, int32 i, vec2h& value, mat22h* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat33h_int32_vec3h(mat33h& a, int32 i, vec3h& value, mat33h* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat44h_int32_vec4h(mat44h& a, int32 i, vec4h& value, mat44h* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_spatial_matrixh_int32_spatial_vectorh(spatial_matrixh& a, int32 i, spatial_vectorh& value, spatial_matrixh* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat22f_int32_vec2f(mat22f& a, int32 i, vec2f& value, mat22f* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat33f_int32_vec3f(mat33f& a, int32 i, vec3f& value, mat33f* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat44f_int32_vec4f(mat44f& a, int32 i, vec4f& value, mat44f* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_spatial_matrixf_int32_spatial_vectorf(spatial_matrixf& a, int32 i, spatial_vectorf& value, spatial_matrixf* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat22d_int32_vec2d(mat22d& a, int32 i, vec2d& value, mat22d* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat33d_int32_vec3d(mat33d& a, int32 i, vec3d& value, mat33d* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_mat44d_int32_vec4d(mat44d& a, int32 i, vec4d& value, mat44d* ret) { *ret = wp::assign_copy(a, i, value); }
-WP_API void builtin_assign_copy_spatial_matrixd_int32_spatial_vectord(spatial_matrixd& a, int32 i, spatial_vectord& value, spatial_matrixd* ret) { *ret = wp::assign_copy(a, i, value); }
+WP_API void builtin_expect_eq_int8_int8(int8 a, int8 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_uint8_uint8(uint8 a, uint8 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_int16_int16(int16 a, int16 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_uint16_uint16(uint16 a, uint16 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_int32_int32(int32 a, int32 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_uint32_uint32(uint32 a, uint32 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_int64_int64(int64 a, int64 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_uint64_uint64(uint64 a, uint64 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_float16_float16(float16 a, float16 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_float32_float32(float32 a, float32 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_float64_float64(float64 a, float64 b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_quath_quath(quath& a, quath& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_quatf_quatf(quatf& a, quatf& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_quatd_quatd(quatd& a, quatd& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_transformh_transformh(transformh& a, transformh& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_transformf_transformf(transformf& a, transformf& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_transformd_transformd(transformd& a, transformd& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_bool_bool(bool a, bool b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2h_vec2h(vec2h& a, vec2h& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3h_vec3h(vec3h& a, vec3h& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4h_vec4h(vec4h& a, vec4h& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_spatial_vectorh_spatial_vectorh(spatial_vectorh& a, spatial_vectorh& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2f_vec2f(vec2f& a, vec2f& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3f_vec3f(vec3f& a, vec3f& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4f_vec4f(vec4f& a, vec4f& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_spatial_vectorf_spatial_vectorf(spatial_vectorf& a, spatial_vectorf& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2d_vec2d(vec2d& a, vec2d& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3d_vec3d(vec3d& a, vec3d& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4d_vec4d(vec4d& a, vec4d& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_spatial_vectord_spatial_vectord(spatial_vectord& a, spatial_vectord& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2s_vec2s(vec2s& a, vec2s& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3s_vec3s(vec3s& a, vec3s& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4s_vec4s(vec4s& a, vec4s& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2i_vec2i(vec2i& a, vec2i& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3i_vec3i(vec3i& a, vec3i& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4i_vec4i(vec4i& a, vec4i& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2l_vec2l(vec2l& a, vec2l& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3l_vec3l(vec3l& a, vec3l& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4l_vec4l(vec4l& a, vec4l& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2b_vec2b(vec2b& a, vec2b& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3b_vec3b(vec3b& a, vec3b& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4b_vec4b(vec4b& a, vec4b& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2us_vec2us(vec2us& a, vec2us& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3us_vec3us(vec3us& a, vec3us& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4us_vec4us(vec4us& a, vec4us& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2ui_vec2ui(vec2ui& a, vec2ui& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3ui_vec3ui(vec3ui& a, vec3ui& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4ui_vec4ui(vec4ui& a, vec4ui& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2ul_vec2ul(vec2ul& a, vec2ul& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3ul_vec3ul(vec3ul& a, vec3ul& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4ul_vec4ul(vec4ul& a, vec4ul& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec2ub_vec2ub(vec2ub& a, vec2ub& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec3ub_vec3ub(vec3ub& a, vec3ub& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_vec4ub_vec4ub(vec4ub& a, vec4ub& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat22h_mat22h(mat22h& a, mat22h& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat33h_mat33h(mat33h& a, mat33h& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat44h_mat44h(mat44h& a, mat44h& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_spatial_matrixh_spatial_matrixh(spatial_matrixh& a, spatial_matrixh& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat22f_mat22f(mat22f& a, mat22f& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat33f_mat33f(mat33f& a, mat33f& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat44f_mat44f(mat44f& a, mat44f& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_spatial_matrixf_spatial_matrixf(spatial_matrixf& a, spatial_matrixf& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat22d_mat22d(mat22d& a, mat22d& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat33d_mat33d(mat33d& a, mat33d& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_mat44d_mat44d(mat44d& a, mat44d& b) { wp::expect_eq(a, b); }
+WP_API void builtin_expect_eq_spatial_matrixd_spatial_matrixd(spatial_matrixd& a, spatial_matrixd& b) { wp::expect_eq(a, b); }
 WP_API void builtin_lerp_float16_float16_float16(float16 a, float16 b, float16 t, float16* ret) { *ret = wp::lerp(a, b, t); }
 WP_API void builtin_lerp_float32_float32_float32(float32 a, float32 b, float32 t, float32* ret) { *ret = wp::lerp(a, b, t); }
 WP_API void builtin_lerp_float64_float64_float64(float64 a, float64 b, float64 t, float64* ret) { *ret = wp::lerp(a, b, t); }
@@ -1229,6 +1254,36 @@ WP_API void builtin_lerp_transformd_transformd_float64(transformd& a, transformd
 WP_API void builtin_smoothstep_float16_float16_float16(float16 a, float16 b, float16 x, float16* ret) { *ret = wp::smoothstep(a, b, x); }
 WP_API void builtin_smoothstep_float32_float32_float32(float32 a, float32 b, float32 x, float32* ret) { *ret = wp::smoothstep(a, b, x); }
 WP_API void builtin_smoothstep_float64_float64_float64(float64 a, float64 b, float64 x, float64* ret) { *ret = wp::smoothstep(a, b, x); }
+WP_API void builtin_expect_near_float16_float16_float16(float16 a, float16 b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_float32_float32_float32(float32 a, float32 b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_float64_float64_float64(float64 a, float64 b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec2h_vec2h_float16(vec2h& a, vec2h& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec3h_vec3h_float16(vec3h& a, vec3h& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec4h_vec4h_float16(vec4h& a, vec4h& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_spatial_vectorh_spatial_vectorh_float16(spatial_vectorh& a, spatial_vectorh& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec2f_vec2f_float32(vec2f& a, vec2f& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec3f_vec3f_float32(vec3f& a, vec3f& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec4f_vec4f_float32(vec4f& a, vec4f& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_spatial_vectorf_spatial_vectorf_float32(spatial_vectorf& a, spatial_vectorf& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec2d_vec2d_float64(vec2d& a, vec2d& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec3d_vec3d_float64(vec3d& a, vec3d& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_vec4d_vec4d_float64(vec4d& a, vec4d& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_spatial_vectord_spatial_vectord_float64(spatial_vectord& a, spatial_vectord& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_quath_quath_float16(quath& a, quath& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_quatf_quatf_float32(quatf& a, quatf& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_quatd_quatd_float64(quatd& a, quatd& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat22h_mat22h_float16(mat22h& a, mat22h& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat33h_mat33h_float16(mat33h& a, mat33h& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat44h_mat44h_float16(mat44h& a, mat44h& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_spatial_matrixh_spatial_matrixh_float16(spatial_matrixh& a, spatial_matrixh& b, float16 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat22f_mat22f_float32(mat22f& a, mat22f& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat33f_mat33f_float32(mat33f& a, mat33f& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat44f_mat44f_float32(mat44f& a, mat44f& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_spatial_matrixf_spatial_matrixf_float32(spatial_matrixf& a, spatial_matrixf& b, float32 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat22d_mat22d_float64(mat22d& a, mat22d& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat33d_mat33d_float64(mat33d& a, mat33d& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_mat44d_mat44d_float64(mat44d& a, mat44d& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
+WP_API void builtin_expect_near_spatial_matrixd_spatial_matrixd_float64(spatial_matrixd& a, spatial_matrixd& b, float64 tolerance) { wp::expect_near(a, b, tolerance); }
 WP_API void builtin_add_float16_float16(float16 a, float16 b, float16* ret) { *ret = wp::add(a, b); }
 WP_API void builtin_add_float32_float32(float32 a, float32 b, float32* ret) { *ret = wp::add(a, b); }
 WP_API void builtin_add_float64_float64(float64 a, float64 b, float64* ret) { *ret = wp::add(a, b); }

warp/native/intersect.h

@@ -665,7 +665,7 @@ CUDA_CALLABLE inline void adj_closest_point_to_triangle(
     bool var_25;
     bool var_26;
     bool var_27;
-    float32 var_28;
+    float32 var_28 = 0.0;
     vec2 var_29;
     vec2 var_30;
     vec3 var_31;
@@ -685,7 +685,7 @@ CUDA_CALLABLE inline void adj_closest_point_to_triangle(
     bool var_45;
     bool var_46;
     bool var_47;
-    float32 var_48;
+    float32 var_48 = 0.0;
     vec2 var_49;
     vec2 var_50;
     float32 var_51;
@@ -702,7 +702,7 @@ CUDA_CALLABLE inline void adj_closest_point_to_triangle(
     float32 var_62;
     bool var_63;
     bool var_64;
-    float32 var_65;
+    float32 var_65 = 0.0;
     vec2 var_66;
     // vec2 var_67;
     float32 var_68;

warp/native/mat.h

@@ -389,23 +389,17 @@ inline CUDA_CALLABLE bool operator==(const mat_t<Rows,Cols,Type>& a, const mat_t
     return true;
 }
 
-
-// negation:
 template<unsigned Rows, unsigned Cols, typename Type>
-inline CUDA_CALLABLE mat_t<Rows,Cols,Type> operator - (mat_t<Rows,Cols,Type> a)
+inline CUDA_CALLABLE mat_t<Rows,Cols,Type> operator - (const mat_t<Rows,Cols,Type>& x)
 {
-    // NB: this constructor will initialize all ret's components to 0, which is
-    // unnecessary... 
     mat_t<Rows,Cols,Type> ret;
     for (unsigned i=0; i < Rows; ++i)
         for (unsigned j=0; j < Cols; ++j)
-            ret.data[i][j] = -a.data[i][j];
+            ret.data[i][j] = -x.data[i][j];
 
-    // Wonder if this does a load of copying when it returns... hopefully not as it's inlined?
     return ret;
 }
 
-
 template<unsigned Rows, unsigned Cols, typename Type>
 CUDA_CALLABLE inline mat_t<Rows,Cols,Type> pos(const mat_t<Rows,Cols,Type>& x)
 {
@@ -2206,8 +2200,9 @@ inline CUDA_CALLABLE void expect_near(const mat_t<Rows,Cols,Type>& actual, const
     if (diff > tolerance)
     {
         printf("Error, expect_near() failed with tolerance "); print(tolerance);
-        printf("\t Expected: "); print(expected);
-        printf("\t Actual: "); print(actual);
+        printf("    Expected: "); print(expected);
+        printf("    Actual: "); print(actual);
+        printf("    Max absolute difference: "); print(diff);
     }
 }
 

warp/native/mathdx.cpp

@@ -26,7 +26,8 @@ extern "C"
 WP_API
 bool cuda_compile_fft(
                       const char* ltoir_output_path,
-                      const char* symbol_name, int num_include_dirs,
+                      const char* symbol_name,
+                      int num_include_dirs,
                       const char** include_dirs,
                       const char* mathdx_include_dir,
                       int arch,
@@ -41,7 +42,6 @@ bool cuda_compile_fft(
 }
 
 WP_API bool cuda_compile_dot(
-                             const char* fatbin_output_path,
                              const char* ltoir_output_path,
                              const char* symbol_name,
                              int num_include_dirs,
@@ -55,9 +55,9 @@ WP_API bool cuda_compile_dot(
                              int precision_B,
                              int precision_C,
                              int type,
-                             int a_arrangement,
-                             int b_arrangement,
-                             int c_arrangement,
+                             int arrangement_A,
+                             int arrangement_B,
+                             int arrangement_C,
                              int num_threads)
 {
     printf("CUDA is disabled and/or Warp was not compiled with MathDx support.\n");
@@ -65,6 +65,7 @@ WP_API bool cuda_compile_dot(
 }
 
 WP_API bool cuda_compile_solver(
+                                const char* fatbin_output_path,
                                 const char* ltoir_output_path,
                                 const char* symbol_name,
                                 int num_include_dirs,
@@ -73,8 +74,13 @@ WP_API bool cuda_compile_solver(
                                 int arch,
                                 int M,
                                 int N,
+                                int NRHS,
                                 int function,
+                                int side,
+                                int diag,
                                 int precision,
+                                int arrangement_A,
+                                int arrangement_B,
                                 int fill_mode,
                                 int num_threads)
 {

warp/native/matnn.h

@@ -218,126 +218,4 @@ CUDA_CALLABLE inline void adj_dense_solve(int n,
     }
 }
 
-
-template <typename F>
-CUDA_CALLABLE inline void mlp(const array_t<float>& weights, const array_t<float>& bias, F activation, int index, const array_t<float>& x, array_t<float>& out)
-{
-    const int m = weights.shape[0];
-    const int n = weights.shape[1];
-    const int b = x.shape[1];
-
-    for (int i=0; i < m; ++i)
-    {
-        float tmp = bias.data[i];
-
-        for(int j=0; j < n; ++j)
-        {
-            tmp += weights.data[i*n + j]*x.data[index + b*j];
-        }
-
-        out.data[index + b*i] = activation(tmp);
-    }
-}
-
-template <typename F, typename AdjF>
-CUDA_CALLABLE inline void adj_mlp(const array_t<float>& weights, const array_t<float>& bias, F activation, int index, const array_t<float>& x, array_t<float>& out,
-                                  array_t<float>& adj_weights, array_t<float>& adj_bias, AdjF adj_activation, int adj_index, array_t<float>& adj_x, array_t<float>& adj_out)
-{
-    const int m = weights.shape[0];
-    const int n = weights.shape[1];
-    const int b = x.shape[1];
-
-    for (int i=0; i < m; ++i)
-    {
-        // recompute forward pass so we don't have to store pre-activation outputs
-        float tmp = bias.data[i];
-
-        for(int j=0; j < n; ++j)
-        {
-            tmp += weights.data[i*n + j]*x.data[index + b*j];
-        }
-
-        // adjoint w.r.t to activation
-        float adj_f = 0.0f;
-    
-        if (adj_out.data)
-            adj_activation(tmp, adj_f, adj_out.data[index + b*i]);
-
-        for (int j=0; j < n; ++j)
-        {
-            // adjoint w.r.t M_i
-            if (adj_weights.data)
-                atomic_add(&adj_weights.data[i*n + j], x.data[index + b*j]*adj_f);    // todo: reduce these atomic stores using warp/block level reductions
-
-            // adjoint w.r.t x
-            if (adj_x.data)
-                atomic_add(&adj_x.data[index + b*j], weights.data[i*n + j]*adj_f);
-        }
-
-        // adjoint w.r.t b
-        if (adj_bias.data)
-            atomic_add(&adj_bias.data[i], adj_f);
-
-    }
-}
-
-
-// template <typename F>
-// CUDA_CALLABLE inline void mlp(const array_t<float>& weights, const array_t<float>& bias, F activation, int m, int n, int b, int index, const array_t<float>& x, array_t<float>& out)
-// {
-//     x += index*n;
-//     out += index*m;
-
-
-//     for (int i=0; i < m; ++i)
-//     {
-//         float tmp = bias[i];
-
-//         for(int j=0; j < n; ++j)
-//         {
-//             tmp += weights[i*n + j]*x[j];
-//         }
-
-//         out[i] = activation(tmp);
-//     }
-// }
-
-// template <typename F, typename AdjF>
-// CUDA_CALLABLE inline void adj_mlp(const array_t<float>& weights, const array_t<float>& bias, F activation, int m, int n, int b, int index, const array_t<float>& x, const array_t<float>& out,
-//                                   array_t<float>& adj_weights, array_t<float>& adj_bias, AdjF adj_activation, int adj_m, int adj_n, int adj_b, int adj_index, array_t<float>& adj_x, array_t<float>& adj_out)
-// {
-//     x += index*n;
-//     out += index*m;
-
-//     adj_x += index*n;
-//     adj_out += index*m;
-
-//     for (int i=0; i < m; ++i)
-//     {
-//         // recompute forward pass so we don't have to store pre-activation outputs
-//         float tmp = bias[i];
-
-//         for(int j=0; j < n; ++j)
-//         {
-//             tmp += weights[i*n + j]*x[index + b*j];            
-//         }
-
-//         // adjoint w.r.t to activation
-//         float adj_f = 0.0f;
-//         adj_activation(tmp, adj_f, adj_out[index + b*i]);
-
-//         for (int j=0; j < n; ++j)
-//         {
-//             // adjoint w.r.t M_i
-//             adj_weights[i*n + j] += x[j]*adj_f;
-
-//             // adjoint w.r.t x
-//             adj_x[index + b*j] += weights[i*n + j]*adj_f;
-//         }
-
-//         // adjoint w.r.t b
-//         adj_bias[i] += adj_f;
-//     }
-// }
-
-} // namespace wp
+} // namespace wp

warp/native/quat.h

@@ -274,8 +274,32 @@ inline CUDA_CALLABLE quat_t<Type> add(const quat_t<Type>& a, const quat_t<Type>&
 template<typename Type>
 inline CUDA_CALLABLE quat_t<Type> sub(const quat_t<Type>& a, const quat_t<Type>& b)
 {
-    return quat_t<Type>(a.x-b.x, a.y-b.y, a.z-b.z, a.w-b.w);}
+    return quat_t<Type>(a.x-b.x, a.y-b.y, a.z-b.z, a.w-b.w);
+}
+
+template<typename Type>
+inline CUDA_CALLABLE quat_t<Type> operator - (const quat_t<Type>& q)
+{
+    return quat_t<Type>(-q.x, -q.y, -q.z, -q.w);
+}
+
+template<typename Type>
+CUDA_CALLABLE inline quat_t<Type> pos(const quat_t<Type>& q)
+{
+    return q;
+}
+
+template<typename Type>
+CUDA_CALLABLE inline quat_t<Type> neg(const quat_t<Type>& q)
+{
+    return -q;
+}
 
+template<typename Type>
+CUDA_CALLABLE inline void adj_neg(const quat_t<Type>& q, quat_t<Type>& adj_q, const quat_t<Type>& adj_ret)
+{
+    adj_q -= adj_ret;
+}
 
 template<typename Type>
 inline CUDA_CALLABLE quat_t<Type> mul(const quat_t<Type>& a, const quat_t<Type>& b)
@@ -298,7 +322,6 @@ inline CUDA_CALLABLE quat_t<Type> mul(Type s, const quat_t<Type>& a)
     return mul(a, s);
 }
 
-// division
 template<typename Type>
 inline CUDA_CALLABLE quat_t<Type> div(quat_t<Type> q, Type s)
 {
@@ -1357,8 +1380,9 @@ inline CUDA_CALLABLE void expect_near(const quat_t<Type>& actual, const quat_t<T
     if (diff > tolerance)
     {
         printf("Error, expect_near() failed with tolerance "); print(tolerance);
-        printf("\t Expected: "); print(expected);
-        printf("\t Actual: "); print(actual);
+        printf("    Expected: "); print(expected);
+        printf("    Actual: "); print(actual);
+        printf("    Max absolute difference: "); print(diff);
     }
 }