warp-lang 1.6.2__py3-none-macosx_10_13_universal2.whl → 1.7.1__py3-none-macosx_10_13_universal2.whl

warp/fem/geometry/grid_2d.py

@@ -173,7 +173,7 @@ class Grid2D(Geometry):
             return Grid2D.Side(axis, origin)
 
         axis_side_index = side_index - 2 * arg.cell_count
-        axis = wp.select(axis_side_index < arg.axis_offsets[1], 1, 0)
+        axis = wp.where(axis_side_index < arg.axis_offsets[1], 0, 1)
 
         altitude = arg.cell_arg.res[Grid2D.ROTATION[axis, 0]]
         longitude = axis_side_index - arg.axis_offsets[axis]
@@ -273,7 +273,7 @@ class Grid2D(Geometry):
     def side_position(args: SideArg, s: Sample):
         side = Grid2D.get_side(args, s.element_index)
 
-        coord = wp.select((side.origin[0] == 0) == (side.axis == 0), 1.0 - s.element_coords[0], s.element_coords[0])
+        coord = wp.where((side.origin[0] == 0) == (side.axis == 0), s.element_coords[0], 1.0 - s.element_coords[0])
 
         local_pos = wp.vec2(
             float(side.origin[0]),
@@ -288,7 +288,7 @@ class Grid2D(Geometry):
     def side_deformation_gradient(args: SideArg, s: Sample):
         side = Grid2D.get_side(args, s.element_index)
 
-        sign = wp.select((side.origin[0] == 0) == (side.axis == 0), -1.0, 1.0)
+        sign = wp.where((side.origin[0] == 0) == (side.axis == 0), 1.0, -1.0)
 
         return wp.cw_mul(Grid2D._rotate(side.axis, wp.vec2(0.0, sign)), args.cell_arg.cell_size)
 
@@ -316,7 +316,7 @@ class Grid2D(Geometry):
     def side_normal(args: SideArg, s: Sample):
         side = Grid2D.get_side(args, s.element_index)
 
-        sign = wp.select(side.origin[0] == 0, 1.0, -1.0)
+        sign = wp.where(side.origin[0] == 0, -1.0, 1.0)
 
         local_n = wp.vec2(sign, 0.0)
         return Grid2D._rotate(side.axis, local_n)
@@ -325,7 +325,7 @@ class Grid2D(Geometry):
     def side_inner_cell_index(arg: SideArg, side_index: ElementIndex):
         side = Grid2D.get_side(arg, side_index)
 
-        inner_alt = wp.select(side.origin[0] == 0, side.origin[0] - 1, 0)
+        inner_alt = wp.where(side.origin[0] == 0, 0, side.origin[0] - 1)
 
         inner_origin = wp.vec2i(inner_alt, side.origin[1])
 
@@ -337,8 +337,8 @@ class Grid2D(Geometry):
         side = Grid2D.get_side(arg, side_index)
 
         alt_axis = Grid2D.ROTATION[side.axis, 0]
-        outer_alt = wp.select(
-            side.origin[0] == arg.cell_arg.res[alt_axis], side.origin[0], arg.cell_arg.res[alt_axis] - 1
+        outer_alt = wp.where(
+            side.origin[0] == arg.cell_arg.res[alt_axis], arg.cell_arg.res[alt_axis] - 1, side.origin[0]
         )
 
         outer_origin = wp.vec2i(outer_alt, side.origin[1])
@@ -350,9 +350,9 @@ class Grid2D(Geometry):
     def side_inner_cell_coords(args: SideArg, side_index: ElementIndex, side_coords: Coords):
         side = Grid2D.get_side(args, side_index)
 
-        inner_alt = wp.select(side.origin[0] == 0, 1.0, 0.0)
+        inner_alt = wp.where(side.origin[0] == 0, 0.0, 1.0)
 
-        side_coord = wp.select((side.origin[0] == 0) == (side.axis == 0), 1.0 - side_coords[0], side_coords[0])
+        side_coord = wp.where((side.origin[0] == 0) == (side.axis == 0), side_coords[0], 1.0 - side_coords[0])
 
         coords = Grid2D._rotate(side.axis, wp.vec2(inner_alt, side_coord))
         return Coords(coords[0], coords[1], 0.0)
@@ -362,9 +362,9 @@ class Grid2D(Geometry):
         side = Grid2D.get_side(args, side_index)
 
         alt_axis = Grid2D.ROTATION[side.axis, 0]
-        outer_alt = wp.select(side.origin[0] == args.cell_arg.res[alt_axis], 0.0, 1.0)
+        outer_alt = wp.where(side.origin[0] == args.cell_arg.res[alt_axis], 1.0, 0.0)
 
-        side_coord = wp.select((side.origin[0] == 0) == (side.axis == 0), 1.0 - side_coords[0], side_coords[0])
+        side_coord = wp.where((side.origin[0] == 0) == (side.axis == 0), side_coords[0], 1.0 - side_coords[0])
 
         coords = Grid2D._rotate(side.axis, wp.vec2(outer_alt, side_coord))
         return Coords(coords[0], coords[1], 0.0)
@@ -382,7 +382,7 @@ class Grid2D(Geometry):
         if float(side.origin[0] - cell[side.axis]) == element_coords[side.axis]:
             long_axis = Grid2D.ROTATION[side.axis, 1]
             axis_coord = element_coords[long_axis]
-            side_coord = wp.select((side.origin[0] == 0) == (side.axis == 0), 1.0 - axis_coord, axis_coord)
+            side_coord = wp.where((side.origin[0] == 0) == (side.axis == 0), axis_coord, 1.0 - axis_coord)
             return Coords(side_coord, 0.0, 0.0)
 
         return Coords(OUTSIDE)

warp/fem/geometry/grid_3d.py

@@ -30,9 +30,6 @@ class Grid3DCellArg:
     origin: wp.vec3
 
 
-_mat32 = wp.mat(shape=(3, 2), dtype=float)
-
-
 class Grid3D(Geometry):
     """Three-dimensional regular grid geometry"""
 
@@ -331,7 +328,7 @@ class Grid3D(Geometry):
     def side_position(args: SideArg, s: Sample):
         side = Grid3D.get_side(args, s.element_index)
 
-        coord0 = wp.select(side.origin[0] == 0, s.element_coords[0], 1.0 - s.element_coords[0])
+        coord0 = wp.where(side.origin[0] == 0, 1.0 - s.element_coords[0], s.element_coords[0])
 
         local_pos = wp.vec3(
             float(side.origin[0]),
@@ -347,9 +344,9 @@ class Grid3D(Geometry):
     def side_deformation_gradient(args: SideArg, s: Sample):
         side = Grid3D.get_side(args, s.element_index)
 
-        sign = wp.select(side.origin[0] == 0, 1.0, -1.0)
+        sign = wp.where(side.origin[0] == 0, -1.0, 1.0)
 
-        return _mat32(
+        return wp.matrix_from_cols(
             wp.cw_mul(Grid3D._local_to_world(side.axis, wp.vec3(0.0, sign, 0.0)), args.cell_arg.cell_size),
             wp.cw_mul(Grid3D._local_to_world(side.axis, wp.vec3(0.0, 0.0, 1.0)), args.cell_arg.cell_size),
         )
@@ -379,7 +376,7 @@ class Grid3D(Geometry):
     def side_normal(args: SideArg, s: Sample):
         side = Grid3D.get_side(args, s.element_index)
 
-        sign = wp.select(side.origin[0] == 0, 1.0, -1.0)
+        sign = wp.where(side.origin[0] == 0, -1.0, 1.0)
 
         local_n = wp.vec3(sign, 0.0, 0.0)
         return Grid3D._local_to_world(side.axis, local_n)
@@ -388,7 +385,7 @@ class Grid3D(Geometry):
     def side_inner_cell_index(arg: SideArg, side_index: ElementIndex):
         side = Grid3D.get_side(arg, side_index)
 
-        inner_alt = wp.select(side.origin[0] == 0, side.origin[0] - 1, 0)
+        inner_alt = wp.where(side.origin[0] == 0, 0, side.origin[0] - 1)
 
         inner_origin = wp.vec3i(inner_alt, side.origin[1], side.origin[2])
 
@@ -401,8 +398,8 @@ class Grid3D(Geometry):
 
         alt_axis = Grid3D._local_to_world_axis(side.axis, 0)
 
-        outer_alt = wp.select(
-            side.origin[0] == arg.cell_arg.res[alt_axis], side.origin[0], arg.cell_arg.res[alt_axis] - 1
+        outer_alt = wp.where(
+            side.origin[0] == arg.cell_arg.res[alt_axis], arg.cell_arg.res[alt_axis] - 1, side.origin[0]
         )
 
         outer_origin = wp.vec3i(outer_alt, side.origin[1], side.origin[2])
@@ -414,9 +411,9 @@ class Grid3D(Geometry):
     def side_inner_cell_coords(args: SideArg, side_index: ElementIndex, side_coords: Coords):
         side = Grid3D.get_side(args, side_index)
 
-        inner_alt = wp.select(side.origin[0] == 0, 1.0, 0.0)
+        inner_alt = wp.where(side.origin[0] == 0, 0.0, 1.0)
 
-        side_coord0 = wp.select(side.origin[0] == 0, side_coords[0], 1.0 - side_coords[0])
+        side_coord0 = wp.where(side.origin[0] == 0, 1.0 - side_coords[0], side_coords[0])
 
         return Grid3D._local_to_world(side.axis, wp.vec3(inner_alt, side_coord0, side_coords[1]))
 
@@ -425,9 +422,9 @@ class Grid3D(Geometry):
         side = Grid3D.get_side(args, side_index)
 
         alt_axis = Grid3D._local_to_world_axis(side.axis, 0)
-        outer_alt = wp.select(side.origin[0] == args.cell_arg.res[alt_axis], 0.0, 1.0)
+        outer_alt = wp.where(side.origin[0] == args.cell_arg.res[alt_axis], 1.0, 0.0)
 
-        side_coord0 = wp.select(side.origin[0] == 0, side_coords[0], 1.0 - side_coords[0])
+        side_coord0 = wp.where(side.origin[0] == 0, 1.0 - side_coords[0], side_coords[0])
 
         return Grid3D._local_to_world(side.axis, wp.vec3(outer_alt, side_coord0, side_coords[1]))
 
@@ -445,7 +442,7 @@ class Grid3D(Geometry):
             long_axis = Grid3D._local_to_world_axis(side.axis, 1)
             lat_axis = Grid3D._local_to_world_axis(side.axis, 2)
             long_coord = element_coords[long_axis]
-            long_coord = wp.select(side.origin[0] == 0, long_coord, 1.0 - long_coord)
+            long_coord = wp.where(side.origin[0] == 0, 1.0 - long_coord, long_coord)
             return Coords(long_coord, element_coords[lat_axis], 0.0)
 
         return Coords(OUTSIDE)

warp/fem/geometry/hexmesh.py

@@ -46,8 +46,6 @@ class HexmeshSideArg:
     face_hex_face_orientation: wp.array(dtype=wp.vec4i)
 
 
-_mat32 = wp.mat(shape=(3, 2), dtype=float)
-
 FACE_VERTEX_INDICES = wp.constant(
     wp.mat(shape=(6, 4), dtype=int)(
         [
@@ -322,7 +320,7 @@ class Hexmesh(Geometry):
     def side_deformation_gradient(args: SideArg, s: Sample):
         """Transposed side deformation gradient at `coords`"""
         v1, v2 = Hexmesh._side_deformation_vecs(args, s.element_index, s.element_coords)
-        return _mat32(v1, v2)
+        return wp.matrix_from_cols(v1, v2)
 
     @wp.func
     def side_inner_cell_index(arg: SideArg, side_index: ElementIndex):
@@ -342,7 +340,7 @@ class Hexmesh(Geometry):
         )
 
         normal_coord = hex_coords[_FACE_COORD_INDICES[face_index, 2]]
-        normal_coord = wp.select(_FACE_COORD_INDICES[face_index, 3] == 0, normal_coord - 1.0, -normal_coord)
+        normal_coord = wp.where(_FACE_COORD_INDICES[face_index, 3] == 0, -normal_coord, normal_coord - 1.0)
 
         return face_coords, normal_coord
 
@@ -353,7 +351,7 @@ class Hexmesh(Geometry):
         hex_coords = Coords()
         hex_coords[_FACE_COORD_INDICES[face_index, 0]] = face_coords[0]
         hex_coords[_FACE_COORD_INDICES[face_index, 1]] = face_coords[1]
-        hex_coords[_FACE_COORD_INDICES[face_index, 2]] = wp.select(_FACE_COORD_INDICES[face_index, 3] == 0, 1.0, 0.0)
+        hex_coords[_FACE_COORD_INDICES[face_index, 2]] = wp.where(_FACE_COORD_INDICES[face_index, 3] == 0, 0.0, 1.0)
 
         return hex_coords
 
@@ -402,8 +400,8 @@ class Hexmesh(Geometry):
             face_orientation = args.face_hex_face_orientation[side_index][3]
 
         face_coords, normal_coord = Hexmesh._hex_local_face_coords(hex_coords, local_face_index)
-        return wp.select(
-            normal_coord == 0.0, Coords(OUTSIDE), Hexmesh._local_to_oriented_face_coords(face_orientation, face_coords)
+        return wp.where(
+            normal_coord == 0.0, Hexmesh._local_to_oriented_face_coords(face_orientation, face_coords), Coords(OUTSIDE)
         )
 
     @wp.func

warp/fem/geometry/nanogrid.py

@@ -33,13 +33,11 @@ FACE_AXIS_MASK = wp.constant(wp.uint8((1 << 2) - 1))
 FACE_INNER_OFFSET_BIT = wp.constant(wp.uint8(2))
 FACE_OUTER_OFFSET_BIT = wp.constant(wp.uint8(3))
 
-_mat32 = wp.mat(shape=(3, 2), dtype=float)
-
 
 @wp.func
 def _add_axis_flag(ijk: wp.vec3i, axis: int):
     coord = ijk[axis]
-    ijk[axis] = wp.select(coord < 0, coord | GRID_AXIS_FLAG, coord & (~GRID_AXIS_FLAG))
+    ijk[axis] = wp.where(coord < 0, coord & (~GRID_AXIS_FLAG), coord | GRID_AXIS_FLAG)
     return ijk
 
 
@@ -191,9 +189,9 @@ class Nanogrid(Geometry):
         coords = uvw - wp.vec3(ijk)
         if cell_index == -1:
             if wp.min(coords) == 0.0 or wp.max(coords) == 1.0:
-                il = wp.select(coords[0] > 0.5, -1, 0)
-                jl = wp.select(coords[1] > 0.5, -1, 0)
-                kl = wp.select(coords[2] > 0.5, -1, 0)
+                il = wp.where(coords[0] > 0.5, 0, -1)
+                jl = wp.where(coords[1] > 0.5, 0, -1)
+                kl = wp.where(coords[2] > 0.5, 0, -1)
 
                 for n in range(8):
                     ni = n >> 2
@@ -327,7 +325,7 @@ class Nanogrid(Geometry):
         axis = Nanogrid._get_face_axis(flags)
         flip = Nanogrid._get_face_inner_offset(flags)
         v1, v2 = Nanogrid._face_tangent_vecs(args.cell_arg.cell_grid, axis, flip)
-        return _mat32(v1, v2)
+        return wp.matrix_from_cols(v1, v2)
 
     @wp.func
     def side_inner_inverse_deformation_gradient(args: SideArg, s: Sample):
@@ -409,8 +407,8 @@ class Nanogrid(Geometry):
 
         on_side = float(side_ijk[axis] - cell_ijk[axis]) == element_coords[axis]
 
-        return wp.select(
-            on_side, Coords(OUTSIDE), Coords(element_coords[(axis + 1) % 3], element_coords[(axis + 2) % 3], 0.0)
+        return wp.where(
+            on_side, Coords(element_coords[(axis + 1) % 3], element_coords[(axis + 2) % 3], 0.0), Coords(OUTSIDE)
         )
 
     @wp.func
@@ -538,8 +536,8 @@ def _build_edge_grid(cell_ijk, grid: wp.Volume, temporary_store: cache.Temporary
 
 @wp.func
 def _make_face_flags(axis: int, plus_cell_index: int, minus_cell_index: int):
-    plus_boundary = wp.uint8(wp.select(plus_cell_index == -1, 0, 1)) << FACE_OUTER_OFFSET_BIT
-    minus_boundary = wp.uint8(wp.select(minus_cell_index == -1, 0, 1)) << FACE_INNER_OFFSET_BIT
+    plus_boundary = wp.uint8(wp.where(plus_cell_index == -1, 1, 0)) << FACE_OUTER_OFFSET_BIT
+    minus_boundary = wp.uint8(wp.where(minus_cell_index == -1, 1, 0)) << FACE_INNER_OFFSET_BIT
 
     return wp.uint8(axis) | plus_boundary | minus_boundary
 

warp/fem/geometry/quadmesh.py

@@ -165,13 +165,13 @@ class Quadmesh(Geometry):
         s = side_coords[0]
 
         if vs == quad_vidx[0]:
-            return wp.select(ve == quad_vidx[1], Coords(0.0, s, 0.0), Coords(s, 0.0, 0.0))
+            return wp.where(ve == quad_vidx[1], Coords(s, 0.0, 0.0), Coords(0.0, s, 0.0))
         elif vs == quad_vidx[1]:
-            return wp.select(ve == quad_vidx[2], Coords(1.0 - s, 0.0, 0.0), Coords(1.0, s, 0.0))
+            return wp.where(ve == quad_vidx[2], Coords(1.0, s, 0.0), Coords(1.0 - s, 0.0, 0.0))
         elif vs == quad_vidx[2]:
-            return wp.select(ve == quad_vidx[3], Coords(1.0, 1.0 - s, 0.0), Coords(1.0 - s, 1.0, 0.0))
+            return wp.where(ve == quad_vidx[3], Coords(1.0 - s, 1.0, 0.0), Coords(1.0, 1.0 - s, 0.0))
 
-        return wp.select(ve == quad_vidx[0], Coords(s, 1.0, 0.0), Coords(0.0, 1.0 - s, 0.0))
+        return wp.where(ve == quad_vidx[0], Coords(0.0, 1.0 - s, 0.0), Coords(s, 1.0, 0.0))
 
     @wp.func
     def _quad_to_edge_coords(
@@ -190,18 +190,18 @@ class Quadmesh(Geometry):
         cy = quad_coords[1]
 
         if vs == quad_vidx[0]:
-            oc = wp.select(ve == quad_vidx[1], cx, cy)
-            ec = wp.select(ve == quad_vidx[1], cy, cx)
+            oc = wp.where(ve == quad_vidx[1], cy, cx)
+            ec = wp.where(ve == quad_vidx[1], cx, cy)
         elif vs == quad_vidx[1]:
-            oc = wp.select(ve == quad_vidx[2], cy, 1.0 - cx)
-            ec = wp.select(ve == quad_vidx[2], 1.0 - cx, cy)
+            oc = wp.where(ve == quad_vidx[2], 1.0 - cx, cy)
+            ec = wp.where(ve == quad_vidx[2], cy, 1.0 - cx)
         elif vs == quad_vidx[2]:
-            oc = wp.select(ve == quad_vidx[3], 1.0 - cx, 1.0 - cy)
-            ec = wp.select(ve == quad_vidx[3], 1.0 - cy, 1.0 - cx)
+            oc = wp.where(ve == quad_vidx[3], 1.0 - cy, 1.0 - cx)
+            ec = wp.where(ve == quad_vidx[3], 1.0 - cx, 1.0 - cy)
         else:
-            oc = wp.select(ve == quad_vidx[0], 1.0 - cy, cx)
-            ec = wp.select(ve == quad_vidx[0], cx, 1.0 - cy)
-        return wp.select(oc == 0.0, Coords(OUTSIDE), Coords(ec, 0.0, 0.0))
+            oc = wp.where(ve == quad_vidx[0], cx, 1.0 - cy)
+            ec = wp.where(ve == quad_vidx[0], 1.0 - cy, cx)
+        return wp.where(oc == 0.0, Coords(ec, 0.0, 0.0), Coords(OUTSIDE))
 
     @wp.func
     def boundary_side_index(args: SideIndexArg, boundary_side_index: int):

warp/fem/geometry/tetmesh.py

@@ -56,7 +56,6 @@ class TetmeshSideArg:
     face_tet_indices: wp.array(dtype=wp.vec2i)
 
 
-_mat32 = wp.mat(shape=(3, 2), dtype=float)
 _NULL_BVH = wp.constant(wp.uint64(-1))
 
 
@@ -203,7 +202,7 @@ class Tetmesh(Geometry):
         p1 = args.positions[args.tet_vertex_indices[s.element_index, 1]]
         p2 = args.positions[args.tet_vertex_indices[s.element_index, 2]]
         p3 = args.positions[args.tet_vertex_indices[s.element_index, 3]]
-        return wp.mat33(p1 - p0, p2 - p0, p3 - p0)
+        return wp.matrix_from_cols(p1 - p0, p2 - p0, p3 - p0)
 
     @wp.func
     def cell_inverse_deformation_gradient(args: CellArg, s: Sample):
@@ -312,7 +311,7 @@ class Tetmesh(Geometry):
     @wp.func
     def side_deformation_gradient(args: SideArg, s: Sample):
         e1, e2 = Tetmesh._side_vecs(args, s.element_index)
-        return _mat32(e1, e2)
+        return wp.matrix_from_cols(e1, e2)
 
     @wp.func
     def side_inner_cell_index(arg: SideArg, side_index: ElementIndex):
@@ -389,7 +388,7 @@ class Tetmesh(Geometry):
         else:
             c2 = 1.0 - tet_coords[0] - tet_coords[1] - tet_coords[2]
 
-        return wp.select(c0 + c1 + c2 > 0.999, Coords(OUTSIDE), Coords(c0, c1, c2))
+        return wp.where(c0 + c1 + c2 > 0.999, Coords(c0, c1, c2), Coords(OUTSIDE))
 
     @wp.func
     def side_to_cell_arg(side_arg: SideArg):

warp/fem/geometry/trimesh.py

@@ -190,7 +190,7 @@ class Trimesh(Geometry):
         return args
 
     def _bvh_id(self, device):
-        if self._tri_bvh is None or self._tri_bvh.device != device:
+        if self._tri_bvh is None or self._tri_bvh.device != wp.get_device(device):
             return _NULL_BVH
         return self._tri_bvh.id
 
@@ -325,9 +325,7 @@ class Trimesh(Geometry):
             elif edge_vidx[0] == v:
                 start = k
 
-        return wp.select(
-            tri_coords[start] + tri_coords[end] > 0.999, Coords(OUTSIDE), Coords(tri_coords[end], 0.0, 0.0)
-        )
+        return wp.where(tri_coords[start] + tri_coords[end] > 0.999, Coords(tri_coords[end], 0.0, 0.0), Coords(OUTSIDE))
 
     def _build_topology(self, temporary_store: TemporaryStore):
         from warp.fem.utils import compress_node_indices, host_read_at_index, masked_indices
@@ -521,7 +519,7 @@ class Trimesh(Geometry):
     @wp.kernel
     def _compute_tri_bounds(
         tri_vertex_indices: wp.array2d(dtype=int),
-        positions: wp.array(dtype=wp.vec2),
+        positions: wp.array(dtype=Any),
         lowers: wp.array(dtype=wp.vec3),
         uppers: wp.array(dtype=wp.vec3),
     ):
@@ -530,16 +528,8 @@ class Trimesh(Geometry):
         p1 = _bvh_vec(positions[tri_vertex_indices[t, 1]])
         p2 = _bvh_vec(positions[tri_vertex_indices[t, 2]])
 
-        lowers[t] = wp.vec3(
-            wp.min(wp.min(p0[0], p1[0]), p2[0]),
-            wp.min(wp.min(p0[1], p1[1]), p2[1]),
-            wp.min(wp.min(p0[2], p1[2]), p2[2]),
-        )
-        uppers[t] = wp.vec3(
-            wp.max(wp.max(p0[0], p1[0]), p2[0]),
-            wp.max(wp.max(p0[1], p1[1]), p2[1]),
-            wp.max(wp.max(p0[2], p1[2]), p2[2]),
-        )
+        lowers[t] = wp.min(wp.min(p0, p1), p2)
+        uppers[t] = wp.max(wp.max(p0, p1), p2)
 
 
 @wp.struct
@@ -576,7 +566,7 @@ class Trimesh2D(Trimesh):
         p0 = args.positions[tri_idx[0]]
         p1 = args.positions[tri_idx[1]]
         p2 = args.positions[tri_idx[2]]
-        return wp.mat22(p1 - p0, p2 - p0)
+        return wp.matrix_from_cols(p1 - p0, p2 - p0)
 
     @wp.func
     def cell_lookup(args: CellArg, pos: wp.vec2):
@@ -689,9 +679,6 @@ class Trimesh3DSideArg:
     positions: wp.array(dtype=wp.vec3)
 
 
-_mat32 = wp.mat(shape=(3, 2), dtype=float)
-
-
 class Trimesh3D(Trimesh):
     """3D Triangular mesh geometry"""
 
@@ -714,7 +701,7 @@ class Trimesh3D(Trimesh):
         p0 = args.positions[tri_idx[0]]
         p1 = args.positions[tri_idx[1]]
         p2 = args.positions[tri_idx[2]]
-        return _mat32(p1 - p0, p2 - p0)
+        return wp.matrix_from_cols(p1 - p0, p2 - p0)
 
     @wp.func
     def cell_lookup(args: CellArg, pos: wp.vec3):