ocd

Author: gnzlbg

text/0000-ppv.md

@@ -174,10 +174,11 @@ Operations on vector types can be either:
   `false` for each of the vector lanes. Most vertical operations are binary operations (they take two input vectors). These operations are typically very fast on most architectures and they are the most widely used in practice.
 
 * **horizontal**: that is, along a single vector - they are unary operations.
-  For example, `a.sum()` adds the elements of a vector together while `a.hmax()`
-  returns the largest element in a vector. These operations (typically)
-  translate to a sequence of multiple SIMD instructions on most architectures
-  and are therefore slower. In many cases, they are, however, necessary. 
+  For example, `a.sum()` adds the elements of a vector together while
+  `a.hmax()` returns the largest element in a vector. These operations
+  (typically) translate to a sequence of multiple SIMD instructions on most
+  architectures and are therefore slower. In many cases, they are, however,
+  necessary.
 
 ## Example: Average
 
@@ -403,7 +404,6 @@ implement the following methods:
 
 ```rust
 impl {element_type}{lane_width}x{number_of_lanes} {
-
 /// Creates a new instance of the vector from `number_of_lanes` 
 /// values.
 pub const fn new(args...: element_type) -> Self;
@@ -448,7 +448,6 @@ All portable vector types implement the following methods:
 
 ```rust
 impl {element_type}{lane_width}x{number_of_lanes} {
-
 /// Writes the values of the vector to the `slice`.
 ///
 /// # Panics
@@ -595,7 +594,6 @@ methods:
 
 ```rust
 impl {element_type}{lane_width}x{number_of_lanes} {
-
 /// Horizontal wrapping sum of the vector elements.
 ///
 /// The intrinsic performs a tree-reduction of the vector elements.
@@ -626,7 +624,6 @@ All portable floating-point vector types implement the following methods:
 
 ```rust
 impl {element_type}{lane_width}x{number_of_lanes} {
-
 /// Horizontal sum of the vector elements.
 ///
 /// The intrinsic performs a tree-reduction of the vector elements.
@@ -996,7 +993,7 @@ implemented on top of the architecture specific types.
 ## Zero-overhead requirement for backends
 
 A future architecture might have an instruction that performs multiple
-operations exposed by this API in one go, like `(a + b).sum()` on an
+operations exposed by this API in one go, like `(a + b).wrapping_sum()` on an
 `f32x4` vector. The zero-overhead requirement makes it a bug if Rust does not
 generate optimal code for this situation.