Misc. typos

Found via `codespell -q 3` via downstream VTK

CMake/FindTBB.cmake

@@ -174,7 +174,7 @@ endif ()
 # will never adequately match the user's setup, so there is no feasible way
 # to detect the "best" version to use. The user will have to manually
 # select the right files. (Chances are the distributions are shipping their
-# custom version of tbb, anyway, so the problem is probably nonexistant.)
+# custom version of tbb, anyway, so the problem is probably nonexistent.)
 if (WIN32 AND MSVC)
   set(COMPILER_PREFIX "vc7.1")
   if (MSVC_VERSION EQUAL 1400)

CMake/VTKmCheckPyexpander.cmake

@@ -70,7 +70,7 @@ if(${diff_result})
   # If diff returned non-zero, it failed and the two files are different.
   get_filename_component(filename ${SOURCE_FILE} NAME)
   message(SEND_ERROR
-    "The source file ${filename} does not match the generated file. If you have modified this file directly, then you have messed up. Modify the ${filename}.in file instead and then copy the pyexpander result to ${filename}. If you modified ${filename}.in, then you might just need to copy the pyresult back to the source directory. If you have not modifed either, then you have likely checked out an inappropriate change. Check the git logs to see what changes were made.
+    "The source file ${filename} does not match the generated file. If you have modified this file directly, then you have messed up. Modify the ${filename}.in file instead and then copy the pyexpander result to ${filename}. If you modified ${filename}.in, then you might just need to copy the pyresult back to the source directory. If you have not modified either, then you have likely checked out an inappropriate change. Check the git logs to see what changes were made.
 If the changes have resulted from modifying ${filename}.in, then you can finish by moving ${GENERATED_FILE}.save over ${SOURCE_FILE}")
 else()
   # Now that we have done the comparison, remove the generated file so there is

CMake/VTKmConfigureComponents.cmake

@@ -111,7 +111,7 @@ macro(vtkm_configure_component_Base)
     endif()
   endif()
 
-  # Check for the existance of the base vtkm target
+  # Check for the existence of the base vtkm target
   if (TARGET vtkm)
     set(VTKm_base_vtkm_target_FOUND True)
   endif()
@@ -179,7 +179,7 @@ macro(vtkm_configure_component_OpenGL)
 
   #setting VTKm_OPENGL_INCLUDE_DIRS when both mesa and
   #opengl are not present causes cmake to fail to configure
-  #becase of a percieved dependency in the rendering lib
+  #because of a perceived dependency in the rendering lib
   if(VTKm_OSMesa_FOUND OR OPENGL_FOUND)
     set(VTKm_OPENGL_INCLUDE_DIRS ${vtkm_opengl_includes})
     set(VTKm_OPENGL_LIBRARIES  ${vtkm_opengl_libraries})
@@ -350,7 +350,7 @@ macro(vtkm_configure_component_CUDA)
     set(VTKm_CUDA_Architecture "native" CACHE STRING "Which GPU Architecture(s) to compile for")
     set_property(CACHE VTKm_CUDA_Architecture PROPERTY STRINGS native fermi kepler maxwell pascal volta all)
 
-    #detect what the propery is set too
+    #detect what the property is set too
     if(VTKm_CUDA_Architecture STREQUAL "native")
 
       if(VTKM_CUDA_NATIVE_EXE_PROCESS_RAN_OUTPUT)

CMake/VTKmMacros.cmake

@@ -186,7 +186,7 @@ function(vtkm_add_header_build_test name dir_prefix use_cuda)
   vtkm_setup_msvc_properties(TestBuild_${name})
 
   # Send the libraries created for test builds to their own directory so as to
-  # not polute the directory with useful libraries.
+  # not pollute the directory with useful libraries.
   set_target_properties(TestBuild_${name} PROPERTIES
     ARCHIVE_OUTPUT_DIRECTORY ${VTKm_LIBRARY_OUTPUT_PATH}/testbuilds
     LIBRARY_OUTPUT_DIRECTORY ${VTKm_LIBRARY_OUTPUT_PATH}/testbuilds

CMakeLists.txt

@@ -94,7 +94,7 @@ if(NOT VTKm_Base_FOUND)
 endif()
 
 #-----------------------------------------------------------------------------
-# When using C++11 suport make sure you use the standard C++ extensions rather
+# When using C++11 support make sure you use the standard C++ extensions rather
 # than compiler-specific versions of the extensions (to preserve portability).
 set(CMAKE_CXX_EXTENSIONS False)
 

CONTRIBUTING.md

@@ -436,7 +436,7 @@ authorized developers may add a comment with a single *trailing* line:
     Do: merge
 
 to ask that the change be merged into the upstream repository. By
-convention, only merge if you have recieved `+1` . Do not request a merge
+convention, only merge if you have received `+1` . Do not request a merge
 if any `-1` review comments have not been resolved.
 
 ### Merge Success ###

vtkm/Bounds.h

@@ -142,7 +142,7 @@ struct Bounds
   /// \b Expand bounds to include other bounds.
   ///
   /// This version of \c Include expands these bounds just enough to include
-  /// that of another bounds. Esentially it is the union of the two bounds.
+  /// that of another bounds. Essentially it is the union of the two bounds.
   ///
   VTKM_EXEC_CONT
   void Include(const vtkm::Bounds& bounds)

vtkm/Matrix.h

@@ -329,7 +329,7 @@ VTKM_EXEC_CONT void MatrixLUPFactorFindUpperTriangleElements(vtkm::Matrix<T, Siz
 /// LU-factorization takes a matrix A and decomposes it into a lower triangular
 /// matrix L and upper triangular matrix U such that A = LU. The
 /// LUP-factorization also allows permutation of A, which makes the
-/// decomposition always posible so long as A is not singular. In addition to
+/// decomposition always possible so long as A is not singular. In addition to
 /// matrices L and U, LUP also finds permutation matrix P containing all zeros
 /// except one 1 per row and column such that PA = LU.
 ///

vtkm/Range.h

@@ -139,7 +139,7 @@ struct Range
   /// \b Expand range to include other range.
   ///
   /// This version of \c Include expands this range just enough to include that
-  /// of another range. Esentially it is the union of the two ranges.
+  /// of another range. Essentially it is the union of the two ranges.
   ///
   VTKM_EXEC_CONT
   void Include(const vtkm::Range& range)

vtkm/RangeId.h

@@ -102,7 +102,7 @@ struct RangeId
   /// \b Expand range to include other range.
   ///
   /// This version of \c Include expands this range just enough to include that
-  /// of another range. Esentially it is the union of the two ranges.
+  /// of another range. Essentially it is the union of the two ranges.
   ///
   VTKM_EXEC_CONT
   void Include(const vtkm::RangeId& range)

vtkm/RangeId3.h

@@ -131,7 +131,7 @@ struct RangeId3
   /// \b Expand range to include other range.
   ///
   /// This version of \c Include expands the range just enough to include
-  /// the other range. Esentially it is the union of the two ranges.
+  /// the other range. Essentially it is the union of the two ranges.
   ///
   VTKM_EXEC_CONT
   void Include(const vtkm::RangeId3& range)

vtkm/Transform3D.h

@@ -58,7 +58,7 @@ VTKM_EXEC_CONT vtkm::Vec<T, 3> Transform3DPoint(const vtkm::Matrix<T, 4, 4>& mat
 /// transformed by the given matrix in homogeneous coordinates.
 ///
 /// Unlike Transform3DPoint, this method honors the fourth component of the
-/// transformed homogeneous coordiante. This makes it applicable for perspective
+/// transformed homogeneous coordinate. This makes it applicable for perspective
 /// transformations, but requires some more computations.
 ///
 template <typename T>

vtkm/TypeTraits.h

@@ -63,7 +63,7 @@ struct TypeTraitsVectorTag
 };
 
 /// The TypeTraits class provides helpful compile-time information about the
-/// basic types used in VTKm (and a few others for convienience). The majority
+/// basic types used in VTKm (and a few others for convenience). The majority
 /// of TypeTraits contents are typedefs to tags that can be used to easily
 /// override behavior of called functions.
 ///
@@ -71,7 +71,7 @@ template <typename T>
 class TypeTraits
 {
 public:
-  /// \brief A tag to determing whether the type is integer or real.
+  /// \brief A tag to determine whether the type is integer or real.
   ///
   /// This tag is either TypeTraitsRealTag or TypeTraitsIntegerTag.
   using NumericTag = vtkm::TypeTraitsUnknownTag;

vtkm/Types.h

@@ -48,7 +48,7 @@
  * \brief Transportation controls for Control Environment Objects.
  *
  * vtkm::cont::arg includes the classes that allows the vtkm::worklet::Dispatchers
- * to request Control Environment Objects to be transfered to the Execution Environment.
+ * to request Control Environment Objects to be transferred to the Execution Environment.
  *
  * \namespace vtkm::cont::cuda
  * \brief CUDA implementation for Control Environment.
@@ -790,7 +790,7 @@ protected:
 /// The \c Vec class is most often used to represent vectors in the
 /// mathematical sense as a quantity with a magnitude and direction. Vectors
 /// are, of course, used extensively in computational geometry as well as
-/// phyiscal simulations. The \c Vec class can be (and is) repurposed for more
+/// physical simulations. The \c Vec class can be (and is) repurposed for more
 /// general usage of holding a fixed-length sequence of objects.
 ///
 /// There is no real limit to the size of the sequence (other than the largest

vtkm/VecTraits.h

@@ -367,7 +367,7 @@ struct VecTraitsBasic
 
 /// \brief VecTraits for Pair types
 ///
-/// Although a pair woudl seem better as a size-2 vector, we treat it as a
+/// Although a pair would seem better as a size-2 vector, we treat it as a
 /// scalar. This is because a \c Vec is assumed to have the same type for
 /// every component, and a pair in general has a different type for each
 /// component. Thus we treat a pair as a "scalar" unit.

vtkm/VectorAnalysis.h

@@ -22,7 +22,7 @@
 #ifndef vtk_m_VectorAnalysis_h
 #define vtk_m_VectorAnalysis_h
 
-// This header file defines math functions that deal with linear albegra funcitons
+// This header file defines math functions that deal with linear albegra functions
 
 #include <vtkm/Math.h>
 #include <vtkm/TypeTraits.h>

vtkm/benchmarking/BenchmarkDeviceAdapter.cxx

@@ -418,7 +418,7 @@ private:
     typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
 
     ValueArrayHandle InputHandle;
-    // We don't actually use this, but we need it to prevent sufficently
+    // We don't actually use this, but we need it to prevent sufficiently
     // smart compilers from optimizing the Reduce call out.
     Value Result;
 

vtkm/cont/ArrayHandleTransform.h

@@ -436,7 +436,7 @@ public:
   {
     throw vtkm::cont::ErrorInternal(
       "ArrayHandleTransform read only. "
-      "There should be no occurance of the ArrayHandle trying to pull "
+      "There should be no occurrence of the ArrayHandle trying to pull "
       "data from the execution environment.");
   }
 

vtkm/cont/ArrayPortalToIterators.h

@@ -75,7 +75,7 @@ private:
   PortalType Portal;
 };
 
-/// Convienience function for converting an ArrayPortal to a begin iterator.
+/// Convenience function for converting an ArrayPortal to a begin iterator.
 ///
 VTKM_SUPPRESS_EXEC_WARNINGS
 template <typename PortalType>
@@ -86,7 +86,7 @@ ArrayPortalToIteratorBegin(const PortalType& portal)
   return iterators.GetBegin();
 }
 
-/// Convienience function for converting an ArrayPortal to an end iterator.
+/// Convenience function for converting an ArrayPortal to an end iterator.
 ///
 VTKM_SUPPRESS_EXEC_WARNINGS
 template <typename PortalType>

vtkm/cont/DeviceAdapterAlgorithm.h

@@ -631,7 +631,7 @@ class DeviceAdapterAtomicArrayImplementation;
 /// \brief Class providing a device-specific support for selecting the optimal
 /// Task type for a given worklet.
 ///
-/// When worklets are launched inside the execution enviornment we need to
+/// When worklets are launched inside the execution environment we need to
 /// ask the device adapter what is the preferred execution style, be it
 /// a tiled iteration pattern, or strided. This class
 ///

vtkm/cont/DynamicArrayHandle.h

@@ -67,7 +67,7 @@ struct VTKM_CONT_EXPORT PolymorphicArrayHandleContainerBase
 ///
 /// The \c PolymorphicArrayHandleContainer is similar to the
 /// \c SimplePolymorphicContainer in that it can contain an object of an
-/// unkown type. However, this class specifically holds ArrayHandle objects
+/// unknown type. However, this class specifically holds ArrayHandle objects
 /// (with different template parameters) so that it can polymorphically answer
 /// simple questions about the object.
 ///
@@ -289,7 +289,7 @@ public:
     return this->CastToTypeStorage<ValueType, StorageTag>();
   }
 
-  /// Given a refernce to an ArrayHandle object, casts this array to the
+  /// Given a references to an ArrayHandle object, casts this array to the
   /// ArrayHandle's type and sets the given ArrayHandle to this array. Throws
   /// \c ErrorBadType if the cast does not work. Use \c
   /// ArrayHandleType to check if the cast can happen.

vtkm/cont/Field.h

@@ -308,7 +308,7 @@ void CastAndCall(const vtkm::cont::Field& field, Functor&& f, Args&&... args)
 }
 
 //@{
-/// Convinience functions to build fields from C style arrays and std::vector
+/// Convenience functions to build fields from C style arrays and std::vector
 template <typename T>
 vtkm::cont::Field make_Field(std::string name,
                              Field::AssociationEnum association,

vtkm/cont/MultiBlock.h

@@ -36,16 +36,16 @@ namespace cont
 class VTKM_CONT_EXPORT MultiBlock
 {
 public:
-  /// creat a new MultiBlcok containng a single DataSet "ds"
+  /// create a new MultiBlock containng a single DataSet "ds"
   VTKM_CONT
   MultiBlock(const vtkm::cont::DataSet& ds);
-  /// creat a new MultiBlcok with the exisiting one "src"
+  /// create a new MultiBlock with the existing one "src"
   VTKM_CONT
   MultiBlock(const vtkm::cont::MultiBlock& src);
-  /// creat a new MultiBlcok with a DataSet vector "mblocks"
+  /// create a new MultiBlock with a DataSet vector "mblocks"
   VTKM_CONT
   MultiBlock(const std::vector<vtkm::cont::DataSet>& mblocks);
-  /// creat a new MultiBlcok with the capacity set to be "size"
+  /// create a new MultiBlock with the capacity set to be "size"
   VTKM_CONT
   MultiBlock(vtkm::Id size);
 
@@ -57,7 +57,7 @@ public:
 
   VTKM_CONT
   ~MultiBlock();
-  /// get the field "field_name" from blcok "block_index"
+  /// get the field "field_name" from block "block_index"
   VTKM_CONT
   vtkm::cont::Field GetField(const std::string& field_name, const int& block_index);
 

vtkm/cont/RuntimeDeviceTracker.h

@@ -131,7 +131,7 @@ public:
   ///
   /// If you want a \c RuntimeDeviceTracker with independent state, just create
   /// one independently. If you want to start with the state of a source
-  /// \c RuntimeDeviceTracker but update the state indepenently, you can use
+  /// \c RuntimeDeviceTracker but update the state independently, you can use
   /// \c DeepCopy method to get the initial state. Further changes will
   /// not be shared.
   ///
@@ -152,7 +152,7 @@ public:
   ///
   /// If you want a \c RuntimeDeviceTracker with independent state, just create
   /// one independently. If you want to start with the state of a source
-  /// \c RuntimeDeviceTracker but update the state indepenently, you can use
+  /// \c RuntimeDeviceTracker but update the state independently, you can use
   /// \c DeepCopy method to get the initial state. Further changes will
   /// not be shared.
   ///

vtkm/cont/Storage.h

@@ -132,7 +132,7 @@ public:
   VTKM_CONT
   PortalConstType GetPortalConst() const;
 
-  /// Retuns the number of entries allocated in the array.
+  /// Returns the number of entries allocated in the array.
   VTKM_CONT
   vtkm::Id GetNumberOfValues() const;
 

vtkm/cont/Timer.h

@@ -27,7 +27,7 @@ namespace vtkm
 namespace cont
 {
 
-/// A class that can be used to time operations in VTK-m that might be occuring
+/// A class that can be used to time operations in VTK-m that might be occurring
 /// in parallel. You should make sure that the device adapter for the timer
 /// matches that being used to execute algorithms to ensure that the thread
 /// synchronization is correct.

vtkm/cont/cuda/internal/CudaAllocator.h

@@ -42,7 +42,7 @@ struct VTKM_CONT_EXPORT CudaAllocator
   /// that can be accessed concurrently by the CPU and GPUs.
   static VTKM_CONT bool UsingManagedMemory();
 
-  /// Returns true if the pointer is accessable from a CUDA device.
+  /// Returns true if the pointer is accessible from a CUDA device.
   static VTKM_CONT bool IsDevicePointer(const void* ptr);
 
   /// Returns true if the pointer is a CUDA pointer allocated with

vtkm/cont/cuda/internal/DeviceAdapterAlgorithmThrust.h

@@ -356,7 +356,7 @@ private:
                                       BinaryFunctor binary_functor,
                                       std::false_type)
   {
-    //The portal type and the initial value ARENT the same type so we have
+    //The portal type and the initial value AREN'T the same type so we have
     //to a slower approach, where we wrap the input portal inside a cast
     //portal
     using CastFunctor = vtkm::cont::internal::Cast<typename InputPortal::ValueType, T>;

vtkm/cont/internal/ArrayManagerExecution.h

@@ -40,7 +40,7 @@ namespace internal
 /// any resources in its destructor.
 ///
 /// This class typically takes on one of two forms. If the control and
-/// execution environments have seperate memory spaces, then this class
+/// execution environments have separate memory spaces, then this class
 /// behaves how you would expect. It allocates/deallocates arrays and copies
 /// data. However, if the control and execution environments share the same
 /// memory space, this class should delegate all its operations to the

vtkm/cont/internal/DeviceAdapterAlgorithmGeneral.h

@@ -1007,7 +1007,7 @@ private:
 /// \brief Class providing a device-specific support for selecting the optimal
 /// Task type for a given worklet.
 ///
-/// When worklets are launched inside the execution enviornment we need to
+/// When worklets are launched inside the execution environment we need to
 /// ask the device adapter what is the preferred execution style, be it
 /// a tiled iteration pattern, or strided. This class
 ///

vtkm/cont/internal/testing/UnitTestArrayPortalFromIterators.cxx

@@ -119,7 +119,7 @@ struct TemplatedTests
     VTKM_TEST_ASSERT(const_portal.GetNumberOfValues() == ARRAY_SIZE,
                      "Const portal array size wrong.");
 
-    std::cout << "  Check inital value." << std::endl;
+    std::cout << "  Check initial value." << std::endl;
     VTKM_TEST_ASSERT(CheckPortal(portal, ORIGINAL_VALUE), "Portal iterator has bad value.");
     VTKM_TEST_ASSERT(CheckPortal(const_portal, ORIGINAL_VALUE),
                      "Const portal iterator has bad value.");

vtkm/cont/testing/TestingCellLocatorTwoLevelUniformGrid.h

@@ -128,7 +128,7 @@ vtkm::cont::DataSet MakeTestDataSet(const vtkm::Vec<vtkm::Id, DIMENSIONS>& dims,
       VTKM_ASSERT(false);
   }
 
-  // It is posible that the warping will result in invalid cells. So use a
+  // It is possible that the warping will result in invalid cells. So use a
   // local random generator with a known seed that does not create invalid cells.
   std::default_random_engine rgen;
 

vtkm/exec/CellFace.h

@@ -265,7 +265,7 @@ static inline VTKM_EXEC vtkm::VecCConst<vtkm::IdComponent> CellFaceLocalIndices(
                          numPointsInFace);
 }
 
-/// \brief Returns a canonical identifer for a cell face
+/// \brief Returns a canonical identifier for a cell face
 ///
 /// Given information about a cell face and the global point indices for that cell, returns a
 /// vtkm::Id3 that contains values that are unique to that face. The values for two faces will be

vtkm/exec/CellInterpolate.h

@@ -67,8 +67,8 @@ VTKM_EXEC typename WorldCoordVector::ComponentType ReverseInterpolateTriangle(
   //
   // In this diagram, the distance between p0 and the point marked x divided by
   // the length of the edge it is on is equal, by proportionality, to the u
-  // parametric coordiante. (The v coordinate follows the other edge
-  // accordingly.) Thus, if we can find the interesection at x (or more
+  // parametric coordinate. (The v coordinate follows the other edge
+  // accordingly.) Thus, if we can find the intersection at x (or more
   // specifically the distance between p0 and x), then we can find that
   // parametric coordinate.
   //
@@ -94,13 +94,13 @@ VTKM_EXEC typename WorldCoordVector::ComponentType ReverseInterpolateTriangle(
   // compute it, we are done. We can skip the part about finding the actual
   // coordinates of the intersection.
   //
-  // Solving for the interesection is as simple as substituting the line's
+  // Solving for the intersection is as simple as substituting the line's
   // definition of p(d) into p for the plane equation. With some basic algebra
   // you get:
   //
   // d = dot((wcoords - p0), planeNormal)/dot((p1-p0), planeNormal)
   //
-  // From here, the u coordiante is simply d. The v coordinate follows
+  // From here, the u coordinate is simply d. The v coordinate follows
   // similarly.
   //
 

vtkm/exec/ParametricCoordinates.h

@@ -786,7 +786,7 @@ WorldCoordinatesToParametricCoordinates(const WorldCoordVector& pointWCoords,
   VTKM_ASSERT(pointWCoords.GetNumberOfComponents() == 2);
   success = true;
 
-  // Because this is a line, there is only one vaild parametric coordinate. Let
+  // Because this is a line, there is only one valid parametric coordinate. Let
   // vec be the vector from the first point to the second point
   // (pointWCoords[1] - pointWCoords[0]), which is the direction of the line.
   // dot(vec,wcoords-pointWCoords[0])/mag(vec) is the orthoginal projection of

vtkm/exec/arg/Fetch.h

@@ -47,7 +47,7 @@ namespace arg
 /// object associated where the fetch (nominally) gets its data from. This
 /// execution object is the data provided by the transport.
 ///
-/// There is no generic implementaiton of \c Fetch. There are partial
+/// There is no generic implementation of \c Fetch. There are partial
 /// specializations of \c Fetch for each mechanism (fetch-aspect tag
 /// combination) supported. If you get a compiler error about an incomplete
 /// type for \c Fetch, it means you used an invalid \c FetchTag - \c AspectTag

vtkm/exec/arg/FetchTagArrayDirectIn.h

@@ -32,7 +32,7 @@ namespace arg
 
 /// \brief \c Fetch tag for getting array values with direct indexing.
 ///
-/// \c FetchTagArrayDirectIn is a tag used with the \c Fetch class to retreive
+/// \c FetchTagArrayDirectIn is a tag used with the \c Fetch class to retrieve
 /// values from an array portal. The fetch uses direct indexing, so the thread
 /// index given to \c Load is used as the index into the array.
 ///

vtkm/exec/arg/FetchTagArrayTopologyMapIn.h

@@ -43,7 +43,7 @@ namespace arg
 /// \brief \c Fetch tag for getting array values determined by topology connections.
 ///
 /// \c FetchTagArrayTopologyMapIn is a tag used with the \c Fetch class to
-/// retreive values from an array portal. The fetch uses indexing based on
+/// retrieve values from an array portal. The fetch uses indexing based on
 /// the topology structure used for the input domain.
 ///
 struct FetchTagArrayTopologyMapIn

vtkm/exec/arg/FetchTagCellSetIn.h

@@ -33,7 +33,7 @@ namespace arg
 
 /// \brief \c Fetch tag for getting topology information.
 ///
-/// \c FetchTagCellSetIn is a tag used with the \c Fetch class to retreive
+/// \c FetchTagCellSetIn is a tag used with the \c Fetch class to retrieve
 /// values from a topology object.  This default parameter returns
 /// the basis topology type, i.e. cell type in a \c WorkletCellMap.
 ///

vtkm/exec/arg/FetchTagExecObject.h

@@ -36,7 +36,7 @@ namespace arg
 
 /// \brief \c Fetch tag for execution objects.
 ///
-/// \c FetchTagExecObject is a tag used with the \c Fetch class to retreive
+/// \c FetchTagExecObject is a tag used with the \c Fetch class to retrieve
 /// execution objects. For safety, execution objects are read-only. \c
 /// FetchTagExecObject is almost always used in conjunction with \c
 /// TransportTagExecObject and vice versa.

vtkm/exec/arg/ThreadIndicesPointNeighborhood.h

@@ -198,21 +198,21 @@ struct BoundaryState
 
 namespace detail
 {
-/// Given a \c Vec of (semi) aribtrary size, inflate it to a vtkm::Id3 by padding with zeros.
+/// Given a \c Vec of (semi) arbitrary size, inflate it to a vtkm::Id3 by padding with zeros.
 ///
 inline VTKM_EXEC vtkm::Id3 To3D(vtkm::Id3 index)
 {
   return index;
 }
 
-/// Given a \c Vec of (semi) aribtrary size, inflate it to a vtkm::Id3 by padding with zeros.
+/// Given a \c Vec of (semi) arbitrary size, inflate it to a vtkm::Id3 by padding with zeros.
 /// \overload
 inline VTKM_EXEC vtkm::Id3 To3D(vtkm::Id2 index)
 {
   return vtkm::Id3(index[0], index[1], 1);
 }
 
-/// Given a \c Vec of (semi) aribtrary size, inflate it to a vtkm::Id3 by padding with zeros.
+/// Given a \c Vec of (semi) arbitrary size, inflate it to a vtkm::Id3 by padding with zeros.
 /// \overload
 inline VTKM_EXEC vtkm::Id3 To3D(vtkm::Vec<vtkm::Id, 1> index)
 {

vtkm/exec/arg/ThreadIndicesTopologyMap.h

@@ -36,7 +36,7 @@ namespace detail
 {
 
 /// Most cell shape tags have a default constructor, but the generic cell shape
-/// tag does not to prevent accidently losing the Id, which, unlike the other
+/// tag does not to prevent accidentally losing the Id, which, unlike the other
 /// cell shapes, can vary.
 ///
 template <typename CellShapeTag>
@@ -158,42 +158,42 @@ private:
 namespace detail
 {
 
-/// Given a \c Vec of (semi) aribtrary size, inflate it to a vtkm::Id3 by padding with zeros.
+/// Given a \c Vec of (semi) arbitrary size, inflate it to a vtkm::Id3 by padding with zeros.
 ///
 static inline VTKM_EXEC vtkm::Id3 InflateTo3D(vtkm::Id3 index)
 {
   return index;
 }
 
-/// Given a \c Vec of (semi) aribtrary size, inflate it to a vtkm::Id3 by padding with zeros.
+/// Given a \c Vec of (semi) arbitrary size, inflate it to a vtkm::Id3 by padding with zeros.
 /// \overload
 static inline VTKM_EXEC vtkm::Id3 InflateTo3D(vtkm::Id2 index)
 {
   return vtkm::Id3(index[0], index[1], 0);
 }
 
-/// Given a \c Vec of (semi) aribtrary size, inflate it to a vtkm::Id3 by padding with zeros.
+/// Given a \c Vec of (semi) arbitrary size, inflate it to a vtkm::Id3 by padding with zeros.
 /// \overload
 static inline VTKM_EXEC vtkm::Id3 InflateTo3D(vtkm::Vec<vtkm::Id, 1> index)
 {
   return vtkm::Id3(index[0], 0, 0);
 }
 
-/// Given a \c Vec of (semi) aribtrary size, inflate it to a vtkm::Id3 by padding with zeros.
+/// Given a \c Vec of (semi) arbitrary size, inflate it to a vtkm::Id3 by padding with zeros.
 /// \overload
 static inline VTKM_EXEC vtkm::Id3 InflateTo3D(vtkm::Id index)
 {
   return vtkm::Id3(index, 0, 0);
 }
 
-/// Given a vtkm::Id3, reduce down to an identifer of choice.
+/// Given a vtkm::Id3, reduce down to an identifier of choice.
 ///
 static inline VTKM_EXEC vtkm::Id3 Deflate(const vtkm::Id3& index, vtkm::Id3)
 {
   return index;
 }
 
-/// Given a vtkm::Id3, reduce down to an identifer of choice.
+/// Given a vtkm::Id3, reduce down to an identifier of choice.
 /// \overload
 static inline VTKM_EXEC vtkm::Id2 Deflate(const vtkm::Id3& index, vtkm::Id2)
 {

vtkm/exec/testing/UnitTestCellDerivative.cxx

@@ -50,7 +50,7 @@ vtkm::Vec<T, 3> WorldToParametric(const vtkm::Vec<T, 3>& wcoord)
   return T(0.5) * (wcoord + vtkm::Vec<T, 3>(0.25f));
 }
 
-/// Simple structure describing a linear field.  Has a convienience class
+/// Simple structure describing a linear field.  Has a convenience class
 /// for getting values.
 template <typename FieldType>
 struct LinearField

vtkm/filter/testing/UnitTestExternalFacesFilter.cxx

@@ -93,8 +93,8 @@ void TestExternalFacesExplicitGrid(const vtkm::cont::DataSet& ds,
   VTKM_TEST_ASSERT(numOutputExtFaces == numExpectedExtFaces, "Number of External Faces mismatch");
 
   // verify fields
-  VTKM_TEST_ASSERT(resultds.HasField("pointvar"), "Point field not mapped succesfully");
-  VTKM_TEST_ASSERT(resultds.HasField("cellvar"), "Cell field not mapped succesfully");
+  VTKM_TEST_ASSERT(resultds.HasField("pointvar"), "Point field not mapped successfully");
+  VTKM_TEST_ASSERT(resultds.HasField("cellvar"), "Cell field not mapped successfully");
 
   // verify CompactPoints
   if (compactPoints)

vtkm/filter/testing/UnitTestGradient.cxx

@@ -37,8 +37,8 @@ void TestCellGradientUniform3D()
   vtkm::filter::Gradient gradient;
   gradient.SetOutputFieldName("Gradient");
 
-  gradient.SetComputeVorticity(true);  //this wont work as we have a scalar field
-  gradient.SetComputeQCriterion(true); //this wont work as we have a scalar field
+  gradient.SetComputeVorticity(true);  //this won't work as we have a scalar field
+  gradient.SetComputeQCriterion(true); //this won't work as we have a scalar field
 
   result = gradient.Execute(dataSet, dataSet.GetField("pointvar"));
 

vtkm/internal/ArrayPortalValueReference.h

@@ -32,7 +32,7 @@ namespace internal
 /// \brief A value class for returning setable values of an ArrayPortal
 ///
 /// \c ArrayPortal classes have a pair of \c Get and \c Set methods that
-/// retreive and store values in the array. This is to make it easy to
+/// retrieve and store values in the array. This is to make it easy to
 /// implement the \c ArrayPortal even it is not really an array. However, there
 /// are some cases where the code structure expects a reference to a value that
 /// can be set. For example, the \c IteratorFromArrayPortal class must return

vtkm/internal/Configure.h.in

@@ -307,7 +307,7 @@
 
 #ifdef VTKM_MSVC
 //With MSVC the types that we generate cause warning C4503 (long symbol names)
-//this doesn't affect the resulting binary so we just supress that warning
+//this doesn't affect the resulting binary so we just suppress that warning
 //
 #pragma warning(disable:4503)
 
@@ -317,7 +317,7 @@
 //a valid use is MSVC-specific. Even less fortunate is the fact that if
 //another header violates the warning, it is impossible to suppress it
 //because it happens in a system header file (xutility), which was included
-//far before the actual offending code occured. Even less fortunate than
+//far before the actual offending code occurred. Even less fortunate than
 //that, a boost header we (indirectly) use sets off this warning, cannot
 //be suppressed, and is not going to be fixed
 //(https://svn.boost.org/trac/boost/ticket/11426). The best solution is to

vtkm/internal/FunctionInterface.h

@@ -102,7 +102,7 @@ class FunctionInterfaceDynamicTransformContContinue;
 /// series of transformations and operations can occur.
 ///
 /// Supporting arbitrary function and template arguments is difficult and
-/// really requires seperate implementations for ANSI and C++11 versions of
+/// really requires separate implementations for ANSI and C++11 versions of
 /// compilers. Thus, variatic template arguments are, at this point in time,
 /// something to be avoided when possible. The intention of \c
 /// FunctionInterface is to collect most of the variatic template code into one

vtkm/internal/testing/UnitTestFunctionInterface.cxx

@@ -500,7 +500,7 @@ void TestInvokeTime()
   vtkm::Float64 invokeCallTime = timer.GetElapsedTime();
   std::cout << "Time for invoking function interface: " << invokeCallTime << " seconds"
             << std::endl;
-  std::cout << "Pointless result (makeing sure compiler computes it) " << f.Field << std::endl;
+  std::cout << "Pointless result (making sure compiler computes it) " << f.Field << std::endl;
 
 #if !defined(NDEBUG) && defined(VTKM_MSVC)
   // We expect function calls through the FunctionInterface class to take

vtkm/interop/internal/TransferToOpenGL.h

@@ -214,7 +214,7 @@ public:
     //to openGL this works for all storage types.
     //
     //Second option is to call PrepareForInput and get a PortalConst in the
-    //exection environment.
+    //execution environment.
     //if we are StorageTagBasic this would allow us the ability to grab
     //the raw memory value and copy those, which we know are valid and remove
     //a unneeded copy.

vtkm/interop/testing/UnitTestFancyTransferGLUT.cxx

@@ -40,7 +40,7 @@
 // 1. Some Linux distributions default linker implicitly enables the as-needed
 // linking flag. This means that your shared library or executable will only
 // link to libraries from which they use symbols. So if you explicitly link to
-// pthread but don't use any symbols you wont have a 'DT_NEEDED' entry for
+// pthread but don't use any symbols you won't have a 'DT_NEEDED' entry for
 // pthread.
 //
 // 2. NVidia libGL (driver version 352 ) uses pthread but doesn't have

vtkm/interop/testing/UnitTestTransferGLUT.cxx

@@ -42,7 +42,7 @@
 // 1. Some Linux distributions default linker implicitly enables the as-needed
 // linking flag. This means that your shared library or executable will only
 // link to libraries from which they use symbols. So if you explicitly link to
-// pthread but don't use any symbols you wont have a 'DT_NEEDED' entry for
+// pthread but don't use any symbols you won't have a 'DT_NEEDED' entry for
 // pthread.
 //
 // 2. NVidia libGL (driver version 352 ) uses pthread but doesn't have

vtkm/io/reader/BOVDataSetReader.h

@@ -98,7 +98,7 @@ private:
 
       std::stringstream strStream(options);
 
-      //Format supports both space and "_" seperated tokens...
+      //Format supports both space and "_" separated tokens...
       if (token.find("DATA") != std::string::npos && token.find("FILE") != std::string::npos)
       {
         strStream >> bovFile >> std::ws;

vtkm/rendering/CMakeLists.txt

@@ -172,7 +172,7 @@ vtkm_library(
   WRAP_FOR_CUDA ${device_sources}
   )
 
-# EGL Libs are added here to ensure propper linking when statically compiling.
+# EGL Libs are added here to ensure proper linking when statically compiling.
 # This is safe to do even when not using EGL as the values will then be empty.
 target_link_libraries(vtkm_rendering
                       PUBLIC vtkm_cont
@@ -181,7 +181,7 @@ target_link_libraries(vtkm_rendering
                               ${EGL_LIBRARIES}
                       )
 
-# EGL Dirs are added here to ensure propper linking when statically compiling.
+# EGL Dirs are added here to ensure proper linking when statically compiling.
 # This is safe to do even when not using EGL as the values will then be empty.
 target_include_directories(vtkm_rendering
                           PRIVATE ${VTKm_OPENGL_INCLUDE_DIRS}

vtkm/rendering/Camera.h

@@ -438,7 +438,7 @@ public:
   /// \brief Rotate the camera about the view up vector centered at the focal point.
   ///
   /// Note that the view up vector is whatever was set via SetViewUp, and is
-  /// not necesarily perpendicular to the direction of projection. The angle is
+  /// not necessarily perpendicular to the direction of projection. The angle is
   /// given in degrees.
   ///
   /// Azimuth only makes sense for 3D cameras, so the camera mode will be set

vtkm/rendering/CanvasRayTracer.cxx

@@ -102,7 +102,7 @@ public:
     {
       color[i] = vtkm::Min(1.f, vtkm::Max(color[i], 0.f));
     }
-    // The existng depth should already been feed into thge ray mapper
+    // The existing depth should already been feed into the ray mapper
     // so no color contribution will exist past the existing depth.
 
     depthBuffer.Set(pixelIndex, depth);

vtkm/rendering/ColorTable.h

@@ -41,7 +41,7 @@ struct ColorTableInternals;
 ///
 /// This class provides the basic representation of a color table. This class was
 /// Ported from EAVL. Originally created by Jeremy Meredith, Dave Pugmire,
-/// and Sean Ahern. This class uses seperate RGB and alpha control points and can
+/// and Sean Ahern. This class uses separate RGB and alpha control points and can
 /// be used as a transfer function.
 ///
 class VTKM_RENDERING_EXPORT ColorTable

vtkm/rendering/DecodePNG.cxx

@@ -59,13 +59,13 @@ in_size: size of the input PNG file in bytes.
 convert_to_rgba32: optional parameter, true by default.
   Set to true to get the output in RGBA 32-bit (8 bit per channel) color format
   no matter what color type the original PNG image had. This gives predictable,
-  useable data from any random input PNG.
+  usable data from any random input PNG.
   Set to false to do no color conversion at all. The result then has the same data
   type as the PNG image, which can range from 1 bit to 64 bits per pixel.
   Information about the color type or palette colors are not provided. You need
   to know this information yourself to be able to use the data so this only
   works for trusted PNG files. Use LodePNG instead of picoPNG if you need this information.
-return: 0 if success, not 0 if some error occured.
+return: 0 if success, not 0 if some error occurred.
 */
 int DecodePNG(std::vector<unsigned char>& out_image,
               unsigned long& image_width,

vtkm/rendering/Triangulator.h

@@ -293,7 +293,7 @@ public:
     {
       if (index == 0)
         return;
-      //if we are a shared face, mark ourself and neighbor for desctruction
+      //if we are a shared face, mark ourself and neighbor for destruction
       if (IsTwin(indices.Get(index), indices.Get(index - 1)))
       {
         outputFlags.Set(index, 0);

vtkm/rendering/raytracing/ChannelBuffer.h

@@ -40,8 +40,8 @@ namespace raytracing
 ///  \c The ChannelBuffer class is meant to handle a buffer of values with potentially many
 ///  channels. While RGBA values could be placed in a Vec<T,4>, data with a large number of
 ///  channels (e.g., 100+ energy bins) are better handled by a raw array. Rays can have color,
-///  absorption, absorption + emmision, or even track additional scalar values to support
-///  standards such as Cinema. This class allows us to treat all of these differnt use cases
+///  absorption, absorption + emission, or even track additional scalar values to support
+///  standards such as Cinema. This class allows us to treat all of these different use cases
 ///  with the same type.
 ///
 ///  This class has methods that can be utilized by other VTK-m classes that already have a

vtkm/rendering/raytracing/ConnectivityTracer.h

@@ -48,7 +48,7 @@ struct RenderFunctor;
 
 //
 //  Ray tracker manages memory and pointer
-//  swaping for current cell intersection data
+//  swapping for current cell intersection data
 //
 template <typename FloatType>
 class RayTracking

vtkm/rendering/raytracing/ConnectivityTracer.hxx

@@ -559,7 +559,7 @@ public:
 
       //
       // Traditionally, we would only keep track of a single intensity value per ray
-      // per bin and we would integrate from the begining to end of the ray. In a
+      // per bin and we would integrate from the beginning to end of the ray. In a
       // distributed memory setting, we would move cell data around so that the
       // entire ray could be traced, but in situ, moving that much cell data around
       // could blow memory. Here we are keeping track of two values. Total absorption
@@ -1181,7 +1181,7 @@ void ConnectivityTracer<CellType, ConnectivityType>::RenderOnDevice(Ray<FloatTyp
     {
       vtkm::cont::Timer<Device> entryTimer;
       //
-      // if ray misses the exteral face it will be marked RAY_EXITED_MESH
+      // if ray misses the external face it will be marked RAY_EXITED_MESH
       //
       MeshConn.FindEntry(rays, Device());
       MeshEntryTime += entryTimer.GetElapsedTime();
@@ -1238,7 +1238,7 @@ void ConnectivityTracer<CellType, ConnectivityType>::RenderOnDevice(Ray<FloatTyp
     workRemaining = RayOperations::RaysProcessed(rays, Device()) != rays.NumRays;
     //
     // Ensure that we move the current distance forward some
-    // epsilon so we dont re-enter the cell we just left.
+    // epsilon so we don't re-enter the cell we just left.
     //
     if (workRemaining)
     {

vtkm/rendering/raytracing/ConnectivityTracerBase.cxx

@@ -86,7 +86,7 @@ void ConnectivityTracerBase::SetEnergyData(const vtkm::cont::Field& absorption,
     throw vtkm::cont::ErrorBadValue("Absorption Field '" + absorption.GetName() +
                                     "' not accociated with cells");
   ScalarField = absorption;
-  // Check for emmision
+  // Check for emission
   HasEmission = false;
 
   if (emission.GetAssociation() != vtkm::cont::Field::ASSOC_ANY)

vtkm/rendering/raytracing/MeshConnectivityBuilder.h

@@ -234,7 +234,7 @@ public:
       currentIndex--;
     }
 
-    //this means that this cell is resposible for both itself and the other cell
+    //this means that this cell is responsible for both itself and the other cell
     //set the connecttion for the other cell
     if (isInternal)
     {
@@ -720,13 +720,13 @@ protected:
 
     // We are creating a spatial hash based on morton codes calculated
     // from the centriod (point average)  of each face. Each centroid is
-    // calculated in way (consistant order of floating point calcs) that
+    // calculated in way (consistent order of floating point calcs) that
     // ensures that each face maps to the same morton code. It is possbilbe
     // that two non-connecting faces map to the same morton code,  but if
     // if a face has a matching face from another cell, it will be mapped
     // to the same morton code. We check for this.
 
-    // set up everyting we need to gen morton codes
+    // set up everything we need to gen morton codes
     vtkm::Vec<vtkm::Float32, 3> inverseExtent;
     inverseExtent[0] = 1.f / (BoundingBox[1] - BoundingBox[0]);
     inverseExtent[1] = 1.f / (BoundingBox[3] - BoundingBox[2]);

vtkm/rendering/raytracing/MeshConnectivityStructures.h

@@ -65,7 +65,7 @@ public:
   IdHandle CellConn;
   IdHandle CellOffsets;
   UCharHandle Shapes;
-  // Mesh Boundry
+  // Mesh Boundary
   Id4Handle ExternalTriangles;
   LinearBVH Bvh;
 
@@ -304,7 +304,7 @@ public:
   IdHandle FaceConnectivity;
   CountingHandle CellOffsets;
   IdHandle CellConnectivity;
-  // Mesh Boundry
+  // Mesh Boundary
   LinearBVH Bvh;
   Id4Handle ExternalTriangles;
 
@@ -547,7 +547,7 @@ public:
   vtkm::Bounds CoordinateBounds;
   vtkm::cont::CoordinateSystem Coords;
   vtkm::cont::CellSetStructured<3> Cellset;
-  // Mesh Boundry
+  // Mesh Boundary
   LinearBVH Bvh;
   Id4Handle ExternalTriangles;
 

vtkm/rendering/raytracing/MortonCodes.h

@@ -207,7 +207,7 @@ public:
       vtkm::Vec<vtkm::Id, 3> cellFace;
       cellFace[0] = cellId;
 
-      // We must be sure that this calulation is the same for all faces. If we didn't
+      // We must be sure that this calculation is the same for all faces. If we didn't
       // then it is possible for the same face to end up in multiple morton "buckets" due to
       // the wonders of floating point math. This is bad. If we calculate in the same order
       // for all faces, then at worst, two different faces can enter the same bucket, which

vtkm/rendering/raytracing/RayOperations.h

@@ -210,7 +210,7 @@ public:
       .Invoke(rays.Status, masks);
 
     //
-    // Make empty composite vectors so we dont use up extra storage
+    // Make empty composite vectors so we don't use up extra storage
     //
     vtkm::IdComponent inComp[3];
     inComp[0] = 0;

vtkm/rendering/raytracing/VolumeRendererStructured.cxx

@@ -134,7 +134,7 @@ public:
     {
       //
       // When searching for points, we consider the max value of the cell
-      // to be apart of the next cell. If the point falls on the boundry of the
+      // to be apart of the next cell. If the point falls on the boundary of the
       // data set, then it is technically inside a cell. This checks for that case
       //
       if (point[dim] == MaxPoint[dim])

vtkm/testing/OptionParser.h

@@ -1466,7 +1466,7 @@ struct Parser::Action
    * options if they have a Descriptor whose Descriptor::check_arg does not return
    * @ref ARG_ILLEGAL.
    *
-   * Returns @c false iff a fatal error has occured and the parse should be aborted.
+   * Returns @c false iff a fatal error has occurred and the parse should be aborted.
    */
   virtual bool perform(Option&) { return true; }
 

vtkm/testing/Testing.h

@@ -398,7 +398,7 @@ static inline VTKM_EXEC_CONT bool test_equal_impl(ScalarType1 scalar1,
                                        vtkm::TypeTraitsScalarTag>::type::value),
                          "Trying to compare a scalar with a vector.");
 
-  // Do all comparisions using 64-bit floats.
+  // Do all comparisons using 64-bit floats.
   vtkm::Float64 value1 = vtkm::Float64(scalar1);
   vtkm::Float64 value2 = vtkm::Float64(scalar2);
 

vtkm/testing/UnitTestMatrix.cxx

@@ -74,18 +74,18 @@ struct MatrixTest
     FOR_ROW_COL(matrix) { matrix[row][col] = ComponentType(value(row, col) * 2); }
     FOR_ROW_COL(matrix)
     {
-      VTKM_TEST_ASSERT(test_equal(matrix(row, col), value(row, col) * 2), "Bad set or retreive.");
+      VTKM_TEST_ASSERT(test_equal(matrix(row, col), value(row, col) * 2), "Bad set or retrieve.");
       const MatrixType const_matrix = matrix;
       VTKM_TEST_ASSERT(test_equal(const_matrix(row, col), value(row, col) * 2),
-                       "Bad set or retreive.");
+                       "Bad set or retrieve.");
     }
 
     FOR_ROW_COL(matrix) { matrix(row, col) = value(row, col); }
     const MatrixType const_matrix = matrix;
     FOR_ROW_COL(matrix)
     {
-      VTKM_TEST_ASSERT(test_equal(matrix[row][col], value(row, col)), "Bad set or retreive.");
-      VTKM_TEST_ASSERT(test_equal(const_matrix[row][col], value(row, col)), "Bad set or retreive.");
+      VTKM_TEST_ASSERT(test_equal(matrix[row][col], value(row, col)), "Bad set or retrieve.");
+      VTKM_TEST_ASSERT(test_equal(const_matrix[row][col], value(row, col)), "Bad set or retrieve.");
     }
     VTKM_TEST_ASSERT(matrix == const_matrix, "Equal test operator not working.");
     VTKM_TEST_ASSERT(!(matrix != const_matrix), "Not-Equal test operator not working.");

vtkm/testing/UnitTestTransform3D.cxx

@@ -73,7 +73,7 @@ struct TransformTests
     VTKM_TEST_ASSERT(test_equal(translated2, startPoint + T(2) * translateAmount),
                      "Bad translation.");
 
-    // Vectors should be invarient to translation.
+    // Vectors should be invariant to translation.
     translated1 = vtkm::Transform3DVector(translate, startPoint);
     std::cout << " Translated vector: " << translated1 << std::endl;
     VTKM_TEST_ASSERT(test_equal(translated1, startPoint), "Bad translation.");

vtkm/thirdparty/diy/vtkmdiy/include/vtkmdiy/io/block.hpp

@@ -41,7 +41,7 @@ namespace io
   }
 }
 
-// Serialize GidOffsetCount explicitly, to avoid alignment and unitialized data issues
+// Serialize GidOffsetCount explicitly, to avoid alignment and uninitialized data issues
 // (to get identical output files given the same block input)
 template<>
 struct Serialization<io::detail::GidOffsetCount>

vtkm/thirdparty/diy/vtkmdiy/include/vtkmdiy/mpi/communicator.hpp

@@ -33,7 +33,7 @@ namespace mpi
       request   isend(int dest, int tag, const T& x) const  { return detail::isend<T>()(comm_, dest, tag, x); }
 
       //! Non-blocking version of `recv()`.
-      //! If `T` is an `std::vector<...>`, its size must be big enough to accomodate the sent values.
+      //! If `T` is an `std::vector<...>`, its size must be big enough to accommodate the sent values.
       template<class T>
       request   irecv(int source, int tag, T& x) const      { return detail::irecv<T>()(comm_, source, tag, x); }
 

vtkm/worklet/Clip.h

@@ -317,7 +317,7 @@ public:
           {
             connectivityExplicit.SetConnectivity(connectivityIdx++, indices[entry - 100]);
           }
-          else // edge, new point to be generated by cutting the egde
+          else // edge, new point to be generated by cutting the edge
           {
             internal::ClipTables::EdgeVec edge = this->ClipTables.GetEdge(shape.Id, entry);
             // Sanity check to make sure the edge is valid.

vtkm/worklet/MarchingCubes.h

@@ -309,7 +309,7 @@ public:
       const FieldType ivalue = isovalues[i];
       // Compute the Marching Cubes case number for this cell. We need to iterate
       // the isovalues until the sum >= our visit index. But we need to make
-      // sure the caseNumber is correct before stoping
+      // sure the caseNumber is correct before stopping
       caseNumber =
         ((fieldIn[0] > ivalue) | (fieldIn[1] > ivalue) << 1 | (fieldIn[2] > ivalue) << 2 |
          (fieldIn[3] > ivalue) << 3 | (fieldIn[4] > ivalue) << 4 | (fieldIn[5] > ivalue) << 5 |

vtkm/worklet/NDimsHistMarginalization.h

@@ -172,7 +172,7 @@ public:
 
     vtkm::cont::ArrayHandle<vtkm::Id> freqs;
     DeviceAlgorithms::Copy(freqsIn, freqs);
-    vtkm::Id numMarginalVariables = 0; //count num of marginal varaibles
+    vtkm::Id numMarginalVariables = 0; //count num of marginal variables
     for (vtkm::Id i = 0; i < numOfVariable; i++)
     {
       if (marginalVariables.GetPortalConstControl().Get(i) == true)

vtkm/worklet/RemoveUnusedPoints.h

@@ -202,7 +202,7 @@ public:
   /// \brief Maps a point field from the original points to the new reduced points
   ///
   /// Given an array handle that holds the values for a point field of the
-  /// orignal data set, returns a new array handle containing field values
+  /// original data set, returns a new array handle containing field values
   /// rearranged to the new indices of the reduced point set.
   ///
   /// This version of point mapping performs a shallow copy by using a
@@ -221,7 +221,7 @@ public:
   /// \brief Maps a point field from the original points to the new reduced points
   ///
   /// Given an array handle that holds the values for a point field of the
-  /// orignal data set, returns a new array handle containing field values
+  /// original data set, returns a new array handle containing field values
   /// rearranged to the new indices of the reduced point set.
   ///
   /// This version of point mapping performs a deep copy into the destination
@@ -244,7 +244,7 @@ public:
   /// \brief Maps a point field from the original points to the new reduced points
   ///
   /// Given an array handle that holds the values for a point field of the
-  /// orignal data set, returns a new array handle containing field values
+  /// original data set, returns a new array handle containing field values
   /// rearranged to the new indices of the reduced point set.
   ///
   /// This version of point mapping performs a deep copy into an array that is

vtkm/worklet/internal/DispatcherBase.h

@@ -124,7 +124,7 @@ struct DetermineHasCorrectParameters
     // control signature as ControlSignature(CellSetIn, ...) and the first argument passed
     // to Invoke is an ArrayHandle, you will get an error here because you cannot use an
     // ArrayHandle in place of a CellSetIn argument. (You need to use a CellSet.) See a few
-    // lines later for some diagnostics to help you trace where the error occured.
+    // lines later for some diagnostics to help you trace where the error occurred.
     VTKM_READ_THE_SOURCE_CODE_FOR_HELP(isCorrect);
 
     // If you are getting the error described above, the following lines will give you some

vtkm/worklet/splatkernels/Gaussian.h

@@ -24,7 +24,7 @@
 
 //
 // Gaussian kernel.
-// Compact support is achived by truncating the kernel beyond the cutoff radius
+// Compact support is achieved by truncating the kernel beyond the cutoff radius
 // This implementation uses a factor of 5 between smoothing length and cutoff
 //
 

vtkm/worklet/testing/UnitTestCrossProduct.cxx

@@ -88,7 +88,7 @@ void TestCrossProduct()
   VTKM_TEST_ASSERT(outputArray.GetNumberOfValues() == inputArray1.GetNumberOfValues(),
                    "Wrong number of results for CrossProduct worklet");
 
-  //Test the cannonical cases.
+  //Test the canonical cases.
   VTKM_TEST_ASSERT(
     test_equal(outputArray.GetPortalConstControl().Get(0), vtkm::make_Vec(0, 0, 1)) &&
       test_equal(outputArray.GetPortalConstControl().Get(1), vtkm::make_Vec(1, 0, 0)) &&

vtkm/worklet/testing/UnitTestNDimsHistMarginalization.cxx

@@ -192,7 +192,7 @@ vtkm::cont::DataSet MakeTestDataSet()
 // marginal histogram
 // In this example, we have three variable var0, var1, var2
 // the condition is P(Var0, Var2 | 1<Var1<4)
-// because var0 and var2 are the marginal varaible, we do not care the case var==0 or var==2
+// because var0 and var2 are the marginal variable, we do not care the case var==0 or var==2
 // it supposes that we do not have input as var ==0 or 2
 struct VariableCondition
 {

vtkm/worklet/wavelets/WaveletDWT.h

@@ -150,7 +150,7 @@ public:
     else if (!pretendSigPaddedZero && padZeroAtExt2)
     { // This case is not exactly padding a zero at the end of Ext2.
       // Rather, it is to increase extension length by one and fill it
-      //         to be whatever mirrorred.
+      //         to be whatever mirrored.
       extDimX = addLen + 1;
       ext2.PrepareForOutput(extDimX * extDimY * extDimZ, DeviceTag());
       ExtensionWorklet worklet(extDimX,
@@ -315,7 +315,7 @@ public:
     else if (!pretendSigPaddedZero && padZeroAtExt2)
     { // This case is not exactly padding a zero at the end of Ext2.
       // Rather, it is to increase extension length by one and fill it
-      //         to be whatever mirrorred.
+      //         to be whatever mirrored.
       extDimY = addLen + 1;
       ext2.PrepareForOutput(extDimX * extDimY * extDimZ, DeviceTag());
       ExtensionWorklet worklet(extDimX,
@@ -480,7 +480,7 @@ public:
     else if (!pretendSigPaddedZero && padZeroAtExt2)
     { // This case is not exactly padding a zero at the end of Ext2.
       // Rather, it is to increase extension length by one and fill it
-      //         to be whatever mirrorred.
+      //         to be whatever mirrored.
       extDimZ = addLen + 1;
       ext2.PrepareForOutput(extDimX * extDimY * extDimZ, DeviceTag());
       ExtensionWorklet worklet(extDimX,

vtkm/worklet/wavelets/WaveletTransforms.h

@@ -3677,7 +3677,7 @@ private:
                                 // each becomes a wild card if negative
 };
 
-// Worklet: Copys a small rectangle to become a part of a big rectangle
+// Worklet: Copies a small rectangle to become a part of a big rectangle
 class RectangleCopyTo : public vtkm::worklet::WorkletMapField
 {
 public:
@@ -3731,7 +3731,7 @@ private:
   vtkm::Id outXStart, outYStart;
 };
 
-// Worklet: Copys a small cube to become a part of a big cube
+// Worklet: Copies a small cube to become a part of a big cube
 class CubeCopyTo : public vtkm::worklet::WorkletMapField
 {
 public: