PyPI - warp-lang - Versions diffs - 1.7.0__py3-none-manylinux_2_34_aarch64.whl → 1.7.2rc1__py3-none-manylinux_2_34_aarch64.whl - Mend

warp-lang 1.7.0__py3-none-manylinux_2_34_aarch64.whl → 1.7.2rc1__py3-none-manylinux_2_34_aarch64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of warp-lang might be problematic. Click here for more details.

Files changed (60) hide show

warp/autograd.py +12 -2
warp/bin/warp-clang.so +0 -0
warp/bin/warp.so +0 -0
warp/build.py +1 -1
warp/builtins.py +103 -66
warp/codegen.py +48 -27
warp/config.py +1 -1
warp/context.py +112 -49
warp/examples/benchmarks/benchmark_cloth.py +1 -1
warp/examples/distributed/example_jacobi_mpi.py +507 -0
warp/fem/cache.py +1 -1
warp/fem/field/field.py +11 -1
warp/fem/field/nodal_field.py +36 -22
warp/fem/geometry/adaptive_nanogrid.py +7 -3
warp/fem/geometry/trimesh.py +4 -12
warp/jax_experimental/custom_call.py +14 -2
warp/jax_experimental/ffi.py +100 -67
warp/native/builtin.h +91 -65
warp/native/svd.h +59 -49
warp/native/tile.h +55 -26
warp/native/volume.cpp +2 -2
warp/native/volume_builder.cu +33 -22
warp/native/warp.cu +1 -1
warp/render/render_opengl.py +41 -34
warp/render/render_usd.py +96 -6
warp/sim/collide.py +11 -9
warp/sim/inertia.py +189 -156
warp/sim/integrator_euler.py +3 -0
warp/sim/integrator_xpbd.py +3 -0
warp/sim/model.py +56 -31
warp/sim/render.py +4 -0
warp/sparse.py +1 -1
warp/stubs.py +73 -25
warp/tests/assets/torus.usda +1 -1
warp/tests/cuda/test_streams.py +1 -1
warp/tests/sim/test_collision.py +237 -206
warp/tests/sim/test_inertia.py +161 -0
warp/tests/sim/test_model.py +5 -3
warp/tests/sim/{flaky_test_sim_grad.py → test_sim_grad.py} +1 -4
warp/tests/sim/test_xpbd.py +399 -0
warp/tests/test_array.py +8 -7
warp/tests/test_atomic.py +181 -2
warp/tests/test_builtins_resolution.py +38 -38
warp/tests/test_codegen.py +24 -3
warp/tests/test_examples.py +16 -6
warp/tests/test_fem.py +93 -14
warp/tests/test_func.py +1 -1
warp/tests/test_mat.py +416 -119
warp/tests/test_quat.py +321 -137
warp/tests/test_struct.py +116 -0
warp/tests/test_vec.py +320 -174
warp/tests/tile/test_tile.py +27 -0
warp/tests/tile/test_tile_load.py +124 -0
warp/tests/unittest_suites.py +2 -5
warp/types.py +107 -9
{warp_lang-1.7.0.dist-info → warp_lang-1.7.2rc1.dist-info}/METADATA +41 -19
{warp_lang-1.7.0.dist-info → warp_lang-1.7.2rc1.dist-info}/RECORD +60 -57
{warp_lang-1.7.0.dist-info → warp_lang-1.7.2rc1.dist-info}/WHEEL +1 -1
{warp_lang-1.7.0.dist-info → warp_lang-1.7.2rc1.dist-info}/licenses/LICENSE.md +0 -26
{warp_lang-1.7.0.dist-info → warp_lang-1.7.2rc1.dist-info}/top_level.txt +0 -0

warp/stubs.py CHANGED Viewed

@@ -713,7 +713,7 @@ def quaternion(dtype: Float) -> Quaternion[Float]:
 @over
-def quaternion(x: Float, y: Float, z: Float, w: Float) -> Quaternion[Float]:
+def quaternion(x: Float, y: Float, z: Float, w: Float, dtype: Scalar) -> Quaternion[Float]:
     """Create a quaternion using the supplied components (type inferred from component type)."""
     ...
@@ -2248,145 +2248,193 @@ def where(arr: Array[Any], value_if_true: Any, value_if_false: Any) -> Any:
 @over
 def atomic_add(arr: Array[Any], i: Int, value: Any) -> Any:
-    """Atomically add ``value`` onto ``arr[i]`` and return the old value."""
+    """Atomically adds ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+    This function is automatically invoked when using the syntax ``arr[i] += value``.
+    """
     ...
 @over
 def atomic_add(arr: Array[Any], i: Int, j: Int, value: Any) -> Any:
-    """Atomically add ``value`` onto ``arr[i,j]`` and return the old value."""
+    """Atomically adds ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+    This function is automatically invoked when using the syntax ``arr[i,j] += value``.
+    """
     ...
 @over
 def atomic_add(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
-    """Atomically add ``value`` onto ``arr[i,j,k]`` and return the old value."""
+    """Atomically adds ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k] += value``.
+    """
     ...
 @over
 def atomic_add(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
-    """Atomically add ``value`` onto ``arr[i,j,k,l]`` and return the old value."""
+    """Atomically adds ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] += value``.
+    """
     ...
 @over
 def atomic_add(arr: FabricArray[Any], i: Int, value: Any) -> Any:
-    """Atomically add ``value`` onto ``arr[i]`` and return the old value."""
+    """Atomically adds ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+    This function is automatically invoked when using the syntax ``arr[i] += value``.
+    """
     ...
 @over
 def atomic_add(arr: FabricArray[Any], i: Int, j: Int, value: Any) -> Any:
-    """Atomically add ``value`` onto ``arr[i,j]`` and return the old value."""
+    """Atomically adds ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+    This function is automatically invoked when using the syntax ``arr[i,j] += value``.
+    """
     ...
 @over
 def atomic_add(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
-    """Atomically add ``value`` onto ``arr[i,j,k]`` and return the old value."""
+    """Atomically adds ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k] += value``.
+    """
     ...
 @over
 def atomic_add(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
-    """Atomically add ``value`` onto ``arr[i,j,k,l]`` and return the old value."""
+    """Atomically adds ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] += value``.
+    """
     ...
 @over
 def atomic_add(arr: IndexedFabricArray[Any], i: Int, value: Any) -> Any:
-    """Atomically add ``value`` onto ``arr[i]`` and return the old value."""
+    """Atomically adds ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+    This function is automatically invoked when using the syntax ``arr[i] += value``.
+    """
     ...
 @over
 def atomic_add(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) -> Any:
-    """Atomically add ``value`` onto ``arr[i,j]`` and return the old value."""
+    """Atomically adds ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+    This function is automatically invoked when using the syntax ``arr[i,j] += value``.
+    """
     ...
 @over
 def atomic_add(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
-    """Atomically add ``value`` onto ``arr[i,j,k]`` and return the old value."""
+    """Atomically adds ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k] += value``.
+    """
     ...
 @over
 def atomic_add(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
-    """Atomically add ``value`` onto ``arr[i,j,k,l]`` and return the old value."""
+    """Atomically adds ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] += value``.
+    """
     ...
 @over
 def atomic_sub(arr: Array[Any], i: Int, value: Any) -> Any:
-    """Atomically subtract ``value`` onto ``arr[i]`` and return the old value."""
+    """Atomically subtracts ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+    This function is automatically invoked when using the syntax ``arr[i] -= value``.
+    """
     ...
 @over
 def atomic_sub(arr: Array[Any], i: Int, j: Int, value: Any) -> Any:
-    """Atomically subtract ``value`` onto ``arr[i,j]`` and return the old value."""
+    """Atomically subtracts ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+    This function is automatically invoked when using the syntax ``arr[i,j] -= value``.
+    """
     ...
 @over
 def atomic_sub(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
-    """Atomically subtract ``value`` onto ``arr[i,j,k]`` and return the old value."""
+    """Atomically subtracts ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k] -= value``.
+    """
     ...
 @over
 def atomic_sub(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
-    """Atomically subtract ``value`` onto ``arr[i,j,k,l]`` and return the old value."""
+    """Atomically subtracts ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] -= value``.
+    """
     ...
 @over
 def atomic_sub(arr: FabricArray[Any], i: Int, value: Any) -> Any:
-    """Atomically subtract ``value`` onto ``arr[i]`` and return the old value."""
+    """Atomically subtracts ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+    This function is automatically invoked when using the syntax ``arr[i] -= value``.
+    """
     ...
 @over
 def atomic_sub(arr: FabricArray[Any], i: Int, j: Int, value: Any) -> Any:
-    """Atomically subtract ``value`` onto ``arr[i,j]`` and return the old value."""
+    """Atomically subtracts ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+    This function is automatically invoked when using the syntax ``arr[i,j] -= value``.
+    """
     ...
 @over
 def atomic_sub(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
-    """Atomically subtract ``value`` onto ``arr[i,j,k]`` and return the old value."""
+    """Atomically subtracts ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k] -= value``.
+    """
     ...
 @over
 def atomic_sub(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
-    """Atomically subtract ``value`` onto ``arr[i,j,k,l]`` and return the old value."""
+    """Atomically subtracts ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] -= value``.
+    """
     ...
 @over
 def atomic_sub(arr: IndexedFabricArray[Any], i: Int, value: Any) -> Any:
-    """Atomically subtract ``value`` onto ``arr[i]`` and return the old value."""
+    """Atomically subtracts ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+    This function is automatically invoked when using the syntax ``arr[i] -= value``.
+    """
     ...
 @over
 def atomic_sub(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) -> Any:
-    """Atomically subtract ``value`` onto ``arr[i,j]`` and return the old value."""
+    """Atomically subtracts ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+    This function is automatically invoked when using the syntax ``arr[i,j] -= value``.
+    """
     ...
 @over
 def atomic_sub(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
-    """Atomically subtract ``value`` onto ``arr[i,j,k]`` and return the old value."""
+    """Atomically subtracts ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k] -= value``.
+    """
     ...
 @over
 def atomic_sub(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
-    """Atomically subtract ``value`` onto ``arr[i,j,k,l]`` and return the old value."""
+    """Atomically subtracts ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] -= value``.
+    """
     ...

warp/tests/assets/torus.usda CHANGED Viewed

@@ -59,9 +59,9 @@
     }
     defaultPrim = "World"
     endTimeCode = 100
+    framesPerSecond = 24
     metersPerUnit = 0.01
     startTimeCode = 0
-    timeCodesPerSecond = 24
     upAxis = "Y"
 )

warp/tests/cuda/test_streams.py CHANGED Viewed

@@ -442,7 +442,7 @@ def test_stream_event_is_complete(test, device):
         a = wp.zeros(1, dtype=wp.uint64)
-        threads = 1024 * 1024 * 8
+        threads = 1024 * 1024 * 64
         with wp.ScopedStream(stream):
             # Launch some work on the stream and reuse the event