Corrected typo in exception text

antonwolfy · antonwolfy · commit ee715628d10f · 2023-08-16T08:51:06.000-05:00
diff --git a/dpctl/tensor/_usmarray.pyx b/dpctl/tensor/_usmarray.pyx
@@ -325,7 +325,7 @@ cdef class usm_ndarray:
         if (_offset + ary_min_displacement < 0 or
            (_offset + ary_max_displacement + 1) * itemsize > _buffer.nbytes):
             self._cleanup()
-            raise ValueError(("buffer='{}' can not accomodate "
+            raise ValueError(("buffer='{}' can not accommodate "
                               "the requested array.").format(buffer))
         is_fp64 = (typenum == UAR_DOUBLE or typenum == UAR_CDOUBLE)
         is_fp16 = (typenum == UAR_HALF)
diff --git a/dpctl/tensor/libtensor/source/boolean_advanced_indexing.cpp b/dpctl/tensor/libtensor/source/boolean_advanced_indexing.cpp
@@ -387,14 +387,14 @@ py_extract(dpctl::tensor::usm_ndarray src,
 
     // ensure that dst is sufficiently ample
     auto dst_offsets = dst.get_minmax_offsets();
-    // destination must be ample enough to accomodate all elements
+    // destination must be ample enough to accommodate all elements
     {
         size_t range =
             static_cast<size_t>(dst_offsets.second - dst_offsets.first);
         if (range + 1 < static_cast<size_t>(ortho_nelems * masked_dst_nelems)) {
             throw py::value_error(
                 "Memory addressed by the destination array can not "
-                "accomodate all the "
+                "accommodate all the "
                 "array elements.");
         }
     }
@@ -716,14 +716,14 @@ py_place(dpctl::tensor::usm_ndarray dst,
 
     // ensure that dst is sufficiently ample
     auto dst_offsets = dst.get_minmax_offsets();
-    // destination must be ample enough to accomodate all elements
+    // destination must be ample enough to accommodate all elements
     {
         size_t range =
             static_cast<size_t>(dst_offsets.second - dst_offsets.first);
         if (range + 1 < static_cast<size_t>(ortho_nelems * masked_dst_nelems)) {
             throw py::value_error(
                 "Memory addressed by the destination array can not "
-                "accomodate all the "
+                "accommodate all the "
                 "array elements.");
         }
     }
@@ -999,14 +999,14 @@ py_nonzero(dpctl::tensor::usm_ndarray
 
     // ensure that dst is sufficiently ample
     auto indexes_offsets = indexes.get_minmax_offsets();
-    // destination must be ample enough to accomodate all elements
+    // destination must be ample enough to accommodate all elements
     {
         size_t range =
             static_cast<size_t>(indexes_offsets.second - indexes_offsets.first);
         if (range + 1 < static_cast<size_t>(nz_elems * _ndim)) {
             throw py::value_error(
                 "Memory addressed by the destination array can not "
-                "accomodate all the array elements.");
+                "accommodate all the array elements.");
         }
     }
 
diff --git a/dpctl/tensor/libtensor/source/boolean_reductions.hpp b/dpctl/tensor/libtensor/source/boolean_reductions.hpp
@@ -102,14 +102,14 @@ py_boolean_reduction(dpctl::tensor::usm_ndarray src,
 
     // ensure that dst is sufficiently ample
     auto dst_offsets = dst.get_minmax_offsets();
-    // destination must be ample enough to accomodate all elements
+    // destination must be ample enough to accommodate all elements
     {
         size_t range =
             static_cast<size_t>(dst_offsets.second - dst_offsets.first);
         if (range + 1 < static_cast<size_t>(dst_nelems)) {
             throw py::value_error(
                 "Memory addressed by the destination array can not "
-                "accomodate all the array elements.");
+                "accommodate all the array elements.");
         }
     }
 
diff --git a/dpctl/tensor/libtensor/source/copy_and_cast_usm_to_usm.cpp b/dpctl/tensor/libtensor/source/copy_and_cast_usm_to_usm.cpp
@@ -100,14 +100,14 @@ copy_usm_ndarray_into_usm_ndarray(dpctl::tensor::usm_ndarray src,
         return std::make_pair(sycl::event(), sycl::event());
     }
 
-    // destination must be ample enough to accomodate all elements
+    // destination must be ample enough to accommodate all elements
     {
         auto dst_offsets = dst.get_minmax_offsets();
         size_t range =
             static_cast<size_t>(dst_offsets.second - dst_offsets.first);
         if (range + 1 < src_nelems) {
             throw py::value_error(
-                "Destination array can not accomodate all the "
+                "Destination array can not accommodate all the "
                 "elements of source array.");
         }
     }
diff --git a/dpctl/tensor/libtensor/source/copy_for_reshape.cpp b/dpctl/tensor/libtensor/source/copy_for_reshape.cpp
@@ -88,14 +88,14 @@ copy_usm_ndarray_for_reshape(dpctl::tensor::usm_ndarray src,
         return std::make_pair(sycl::event(), sycl::event());
     }
 
-    // destination must be ample enough to accomodate all elements
+    // destination must be ample enough to accommodate all elements
     {
         auto dst_offsets = dst.get_minmax_offsets();
         py::ssize_t range =
             static_cast<py::ssize_t>(dst_offsets.second - dst_offsets.first);
         if (range + 1 < src_nelems) {
             throw py::value_error(
-                "Destination array can not accomodate all the "
+                "Destination array can not accommodate all the "
                 "elements of source array.");
         }
     }
diff --git a/dpctl/tensor/libtensor/source/copy_numpy_ndarray_into_usm_ndarray.cpp b/dpctl/tensor/libtensor/source/copy_numpy_ndarray_into_usm_ndarray.cpp
@@ -89,14 +89,14 @@ void copy_numpy_ndarray_into_usm_ndarray(
     }
 
     auto dst_offsets = dst.get_minmax_offsets();
-    // destination must be ample enough to accomodate all elements of source
+    // destination must be ample enough to accommodate all elements of source
     // array
     {
         size_t range =
             static_cast<size_t>(dst_offsets.second - dst_offsets.first);
         if (range + 1 < src_nelems) {
             throw py::value_error(
-                "Destination array can not accomodate all the "
+                "Destination array can not accommodate all the "
                 "elements of source array.");
         }
     }
diff --git a/dpctl/tensor/libtensor/source/elementwise_functions.hpp b/dpctl/tensor/libtensor/source/elementwise_functions.hpp
@@ -113,15 +113,15 @@ py_unary_ufunc(dpctl::tensor::usm_ndarray src,
         return std::make_pair(sycl::event(), sycl::event());
     }
 
-    // ensure that output is ample enough to accomodate all elements
+    // ensure that output is ample enough to accommodate all elements
     auto dst_offsets = dst.get_minmax_offsets();
-    // destination must be ample enough to accomodate all elements
+    // destination must be ample enough to accommodate all elements
     {
         size_t range =
             static_cast<size_t>(dst_offsets.second - dst_offsets.first);
         if (range + 1 < src_nelems) {
             throw py::value_error(
-                "Destination array can not accomodate all the "
+                "Destination array can not accommodate all the "
                 "elements of source array.");
         }
     }
@@ -366,15 +366,15 @@ std::pair<sycl::event, sycl::event> py_binary_ufunc(
         return std::make_pair(sycl::event(), sycl::event());
     }
 
-    // ensure that output is ample enough to accomodate all elements
+    // ensure that output is ample enough to accommodate all elements
     auto dst_offsets = dst.get_minmax_offsets();
-    // destination must be ample enough to accomodate all elements
+    // destination must be ample enough to accommodate all elements
     {
         size_t range =
             static_cast<size_t>(dst_offsets.second - dst_offsets.first);
         if (range + 1 < src_nelems) {
             throw py::value_error(
-                "Destination array can not accomodate all the "
+                "Destination array can not accommodate all the "
                 "elements of source array.");
         }
     }
@@ -664,15 +664,15 @@ py_binary_inplace_ufunc(dpctl::tensor::usm_ndarray lhs,
         return std::make_pair(sycl::event(), sycl::event());
     }
 
-    // ensure that output is ample enough to accomodate all elements
+    // ensure that output is ample enough to accommodate all elements
     auto lhs_offsets = lhs.get_minmax_offsets();
-    // destination must be ample enough to accomodate all elements
+    // destination must be ample enough to accommodate all elements
     {
         size_t range =
             static_cast<size_t>(lhs_offsets.second - lhs_offsets.first);
         if (range + 1 < rhs_nelems) {
             throw py::value_error(
-                "Destination array can not accomodate all the "
+                "Destination array can not accommodate all the "
                 "elements of source array.");
         }
     }
diff --git a/dpctl/tensor/libtensor/source/sum_reductions.cpp b/dpctl/tensor/libtensor/source/sum_reductions.cpp
@@ -142,14 +142,14 @@ std::pair<sycl::event, sycl::event> py_sum_over_axis(
         throw py::value_error("Arrays index overlapping segments of memory");
     }
 
-    // destination must be ample enough to accomodate all elements
+    // destination must be ample enough to accommodate all elements
     {
         auto dst_offsets = dst.get_minmax_offsets();
         size_t range =
             static_cast<size_t>(dst_offsets.second - dst_offsets.first);
         if (range + 1 < dst_nelems) {
             throw py::value_error(
-                "Destination array can not accomodate all the "
+                "Destination array can not accommodate all the "
                 "elements of source array.");
         }
     }
diff --git a/dpctl/tensor/libtensor/source/where.cpp b/dpctl/tensor/libtensor/source/where.cpp
@@ -132,14 +132,14 @@ py_where(dpctl::tensor::usm_ndarray condition,
 
     // ensure that dst is sufficiently ample
     auto dst_offsets = dst.get_minmax_offsets();
-    // destination must be ample enough to accomodate all elements
+    // destination must be ample enough to accommodate all elements
     {
         size_t range =
             static_cast<size_t>(dst_offsets.second - dst_offsets.first);
         if (range + 1 < static_cast<size_t>(nelems)) {
             throw py::value_error(
                 "Memory addressed by the destination array can not "
-                "accomodate all the "
+                "accommodate all the "
                 "array elements.");
         }
     }
diff --git a/dpctl/tests/test_usm_ndarray_ctor.py b/dpctl/tests/test_usm_ndarray_ctor.py
@@ -1602,7 +1602,7 @@ def test_arange(dt):
     elif np.issubdtype(dt, np.complexfloating):
         assert complex(X[47]) == 47.0 + 0.0j
 
-    # choose size larger than maximal value that u1/u2 can accomodate
+    # choose size larger than maximal value that u1/u2 can accommodate
     sz = int(dpt.iinfo(dpt.int8).max)
     X1 = dpt.arange(sz + 1, dtype=dt, sycl_queue=q)
     assert X1.shape == (sz + 1,)

Original file line number	Diff line number	Diff line change
`@@ -387,14 +387,14 @@ py_extract(dpctl::tensor::usm_ndarray src,`
`387`	`387`
`388`	`388`	`// ensure that dst is sufficiently ample`
`389`	`389`	`auto dst_offsets = dst.get_minmax_offsets();`
`390`		`- // destination must be ample enough to accomodate all elements`
	`390`	`+ // destination must be ample enough to accommodate all elements`
`391`	`391`	`{`
`392`	`392`	`size_t range =`
`393`	`393`	`static_cast<size_t>(dst_offsets.second - dst_offsets.first);`
`394`	`394`	`if (range + 1 < static_cast<size_t>(ortho_nelems * masked_dst_nelems)) {`
`395`	`395`	`throw py::value_error(`
`396`	`396`	`"Memory addressed by the destination array can not "`
`397`		`- "accomodate all the "`
	`397`	`+ "accommodate all the "`
`398`	`398`	`"array elements.");`
`399`	`399`	`}`
`400`	`400`	`}`
`@@ -716,14 +716,14 @@ py_place(dpctl::tensor::usm_ndarray dst,`
`716`	`716`
`717`	`717`	`// ensure that dst is sufficiently ample`
`718`	`718`	`auto dst_offsets = dst.get_minmax_offsets();`
`719`		`- // destination must be ample enough to accomodate all elements`
	`719`	`+ // destination must be ample enough to accommodate all elements`
`720`	`720`	`{`
`721`	`721`	`size_t range =`
`722`	`722`	`static_cast<size_t>(dst_offsets.second - dst_offsets.first);`
`723`	`723`	`if (range + 1 < static_cast<size_t>(ortho_nelems * masked_dst_nelems)) {`
`724`	`724`	`throw py::value_error(`
`725`	`725`	`"Memory addressed by the destination array can not "`
`726`		`- "accomodate all the "`
	`726`	`+ "accommodate all the "`
`727`	`727`	`"array elements.");`
`728`	`728`	`}`
`729`	`729`	`}`
`@@ -999,14 +999,14 @@ py_nonzero(dpctl::tensor::usm_ndarray`
`999`	`999`
`1000`	`1000`	`// ensure that dst is sufficiently ample`
`1001`	`1001`	`auto indexes_offsets = indexes.get_minmax_offsets();`
`1002`		`- // destination must be ample enough to accomodate all elements`
	`1002`	`+ // destination must be ample enough to accommodate all elements`
`1003`	`1003`	`{`
`1004`	`1004`	`size_t range =`
`1005`	`1005`	`static_cast<size_t>(indexes_offsets.second - indexes_offsets.first);`
`1006`	`1006`	`if (range + 1 < static_cast<size_t>(nz_elems * _ndim)) {`
`1007`	`1007`	`throw py::value_error(`
`1008`	`1008`	`"Memory addressed by the destination array can not "`
`1009`		`- "accomodate all the array elements.");`
	`1009`	`+ "accommodate all the array elements.");`
`1010`	`1010`	`}`
`1011`	`1011`	`}`
`1012`	`1012`
Original file line number	Diff line number	Diff line change
`@@ -102,14 +102,14 @@ py_boolean_reduction(dpctl::tensor::usm_ndarray src,`
`102`	`102`
`103`	`103`	`// ensure that dst is sufficiently ample`
`104`	`104`	`auto dst_offsets = dst.get_minmax_offsets();`
`105`		`- // destination must be ample enough to accomodate all elements`
	`105`	`+ // destination must be ample enough to accommodate all elements`
`106`	`106`	`{`
`107`	`107`	`size_t range =`
`108`	`108`	`static_cast<size_t>(dst_offsets.second - dst_offsets.first);`
`109`	`109`	`if (range + 1 < static_cast<size_t>(dst_nelems)) {`
`110`	`110`	`throw py::value_error(`
`111`	`111`	`"Memory addressed by the destination array can not "`
`112`		`- "accomodate all the array elements.");`
	`112`	`+ "accommodate all the array elements.");`
`113`	`113`	`}`
`114`	`114`	`}`
`115`	`115`
Original file line number	Diff line number	Diff line change
`@@ -100,14 +100,14 @@ copy_usm_ndarray_into_usm_ndarray(dpctl::tensor::usm_ndarray src,`
`100`	`100`	`return std::make_pair(sycl::event(), sycl::event());`
`101`	`101`	`}`
`102`	`102`
`103`		`- // destination must be ample enough to accomodate all elements`
	`103`	`+ // destination must be ample enough to accommodate all elements`
`104`	`104`	`{`
`105`	`105`	`auto dst_offsets = dst.get_minmax_offsets();`
`106`	`106`	`size_t range =`
`107`	`107`	`static_cast<size_t>(dst_offsets.second - dst_offsets.first);`
`108`	`108`	`if (range + 1 < src_nelems) {`
`109`	`109`	`throw py::value_error(`
`110`		`- "Destination array can not accomodate all the "`
	`110`	`+ "Destination array can not accommodate all the "`
`111`	`111`	`"elements of source array.");`
`112`	`112`	`}`
`113`	`113`	`}`
Original file line number	Diff line number	Diff line change
`@@ -88,14 +88,14 @@ copy_usm_ndarray_for_reshape(dpctl::tensor::usm_ndarray src,`
`88`	`88`	`return std::make_pair(sycl::event(), sycl::event());`
`89`	`89`	`}`
`90`	`90`
`91`		`- // destination must be ample enough to accomodate all elements`
	`91`	`+ // destination must be ample enough to accommodate all elements`
`92`	`92`	`{`
`93`	`93`	`auto dst_offsets = dst.get_minmax_offsets();`
`94`	`94`	`py::ssize_t range =`
`95`	`95`	`static_cast<py::ssize_t>(dst_offsets.second - dst_offsets.first);`
`96`	`96`	`if (range + 1 < src_nelems) {`
`97`	`97`	`throw py::value_error(`
`98`		`- "Destination array can not accomodate all the "`
	`98`	`+ "Destination array can not accommodate all the "`
`99`	`99`	`"elements of source array.");`
`100`	`100`	`}`
`101`	`101`	`}`
Original file line number	Diff line number	Diff line change
`@@ -89,14 +89,14 @@ void copy_numpy_ndarray_into_usm_ndarray(`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`auto dst_offsets = dst.get_minmax_offsets();`
`92`		`- // destination must be ample enough to accomodate all elements of source`
	`92`	`+ // destination must be ample enough to accommodate all elements of source`
`93`	`93`	`// array`
`94`	`94`	`{`
`95`	`95`	`size_t range =`
`96`	`96`	`static_cast<size_t>(dst_offsets.second - dst_offsets.first);`
`97`	`97`	`if (range + 1 < src_nelems) {`
`98`	`98`	`throw py::value_error(`
`99`		`- "Destination array can not accomodate all the "`
	`99`	`+ "Destination array can not accommodate all the "`
`100`	`100`	`"elements of source array.");`
`101`	`101`	`}`
`102`	`102`	`}`
Original file line number	Diff line number	Diff line change
`@@ -113,15 +113,15 @@ py_unary_ufunc(dpctl::tensor::usm_ndarray src,`
`113`	`113`	`return std::make_pair(sycl::event(), sycl::event());`
`114`	`114`	`}`
`115`	`115`
`116`		`- // ensure that output is ample enough to accomodate all elements`
	`116`	`+ // ensure that output is ample enough to accommodate all elements`
`117`	`117`	`auto dst_offsets = dst.get_minmax_offsets();`
`118`		`- // destination must be ample enough to accomodate all elements`
	`118`	`+ // destination must be ample enough to accommodate all elements`
`119`	`119`	`{`
`120`	`120`	`size_t range =`
`121`	`121`	`static_cast<size_t>(dst_offsets.second - dst_offsets.first);`
`122`	`122`	`if (range + 1 < src_nelems) {`
`123`	`123`	`throw py::value_error(`
`124`		`- "Destination array can not accomodate all the "`
	`124`	`+ "Destination array can not accommodate all the "`
`125`	`125`	`"elements of source array.");`
`126`	`126`	`}`
`127`	`127`	`}`
`@@ -366,15 +366,15 @@ std::pair<sycl::event, sycl::event> py_binary_ufunc(`
`366`	`366`	`return std::make_pair(sycl::event(), sycl::event());`
`367`	`367`	`}`
`368`	`368`
`369`		`- // ensure that output is ample enough to accomodate all elements`
	`369`	`+ // ensure that output is ample enough to accommodate all elements`
`370`	`370`	`auto dst_offsets = dst.get_minmax_offsets();`
`371`		`- // destination must be ample enough to accomodate all elements`
	`371`	`+ // destination must be ample enough to accommodate all elements`
`372`	`372`	`{`
`373`	`373`	`size_t range =`
`374`	`374`	`static_cast<size_t>(dst_offsets.second - dst_offsets.first);`
`375`	`375`	`if (range + 1 < src_nelems) {`
`376`	`376`	`throw py::value_error(`
`377`		`- "Destination array can not accomodate all the "`
	`377`	`+ "Destination array can not accommodate all the "`
`378`	`378`	`"elements of source array.");`
`379`	`379`	`}`
`380`	`380`	`}`
`@@ -664,15 +664,15 @@ py_binary_inplace_ufunc(dpctl::tensor::usm_ndarray lhs,`
`664`	`664`	`return std::make_pair(sycl::event(), sycl::event());`
`665`	`665`	`}`
`666`	`666`
`667`		`- // ensure that output is ample enough to accomodate all elements`
	`667`	`+ // ensure that output is ample enough to accommodate all elements`
`668`	`668`	`auto lhs_offsets = lhs.get_minmax_offsets();`
`669`		`- // destination must be ample enough to accomodate all elements`
	`669`	`+ // destination must be ample enough to accommodate all elements`
`670`	`670`	`{`
`671`	`671`	`size_t range =`
`672`	`672`	`static_cast<size_t>(lhs_offsets.second - lhs_offsets.first);`
`673`	`673`	`if (range + 1 < rhs_nelems) {`
`674`	`674`	`throw py::value_error(`
`675`		`- "Destination array can not accomodate all the "`
	`675`	`+ "Destination array can not accommodate all the "`
`676`	`676`	`"elements of source array.");`
`677`	`677`	`}`
`678`	`678`	`}`
Original file line number	Diff line number	Diff line change
`@@ -142,14 +142,14 @@ std::pair<sycl::event, sycl::event> py_sum_over_axis(`
`142`	`142`	`throw py::value_error("Arrays index overlapping segments of memory");`
`143`	`143`	`}`
`144`	`144`
`145`		`- // destination must be ample enough to accomodate all elements`
	`145`	`+ // destination must be ample enough to accommodate all elements`
`146`	`146`	`{`
`147`	`147`	`auto dst_offsets = dst.get_minmax_offsets();`
`148`	`148`	`size_t range =`
`149`	`149`	`static_cast<size_t>(dst_offsets.second - dst_offsets.first);`
`150`	`150`	`if (range + 1 < dst_nelems) {`
`151`	`151`	`throw py::value_error(`
`152`		`- "Destination array can not accomodate all the "`
	`152`	`+ "Destination array can not accommodate all the "`
`153`	`153`	`"elements of source array.");`
`154`	`154`	`}`
`155`	`155`	`}`
Original file line number	Diff line number	Diff line change
`@@ -132,14 +132,14 @@ py_where(dpctl::tensor::usm_ndarray condition,`
`132`	`132`
`133`	`133`	`// ensure that dst is sufficiently ample`
`134`	`134`	`auto dst_offsets = dst.get_minmax_offsets();`
`135`		`- // destination must be ample enough to accomodate all elements`
	`135`	`+ // destination must be ample enough to accommodate all elements`
`136`	`136`	`{`
`137`	`137`	`size_t range =`
`138`	`138`	`static_cast<size_t>(dst_offsets.second - dst_offsets.first);`
`139`	`139`	`if (range + 1 < static_cast<size_t>(nelems)) {`
`140`	`140`	`throw py::value_error(`
`141`	`141`	`"Memory addressed by the destination array can not "`
`142`		`- "accomodate all the "`
	`142`	`+ "accommodate all the "`
`143`	`143`	`"array elements.");`
`144`	`144`	`}`
`145`	`145`	`}`