Merge pull request #36 from facebookresearch/regen-docs

Regenerate docs with fixes

Author: prigoyal

docs/source/introduction.rst

@@ -23,13 +23,13 @@ Let's start with a simple example is a matrix vector product:
 
 .. code::
 
-    def mv(float(R,C) A, float(C) x) -> (o) {
-      o(i) += A(i,j) * x(j)
+    def mv(float(R,C) A, float(C) B) -> (o) {
+      o(i) += A(i,j) * B(j)
     }
 
-:code:`A` and :code:`x` are input tensors. :code:`o` is an output tensor.
-The statement :code:`o(i) += A(i,j)*x(j)` introduces two index variables :code:`i` and :code:`j`.
-Their range is inferred by their use indexing :code:`A` and :code:`x`. :code:`i = [0,R)`, :code:`j = [0,C)`.
+:code:`A` and :code:`B` are input tensors. :code:`o` is an output tensor.
+The statement :code:`o(i) += A(i,j) * B(j)` introduces two index variables :code:`i` and :code:`j`.
+Their range is inferred by their use indexing :code:`A` and :code:`B`. :code:`i = [0,R)`, :code:`j = [0,C)`.
 Because :code:`j` only appears on the right side,
 stores into :code:`o` will reduce over :code:`j` with the reduction specified for the loop.
 Reductions can occur across multiple variables, but they all share the same kind of associative reduction (e.g. :code:`+=`)
@@ -40,7 +40,7 @@ to maintain invariant (3). :code:`mv` computes the same thing as this C++ loop:
     for(int i = 0; i < R; i++) {
       o(i) = 0.0f;
       for(int j = 0; j < C; j++) {
-        o(i) += A(i,j) * x(j);
+        o(i) += A(i,j) * B(j);
       }
     }
 
@@ -56,8 +56,8 @@ Simple matrix-vector
 
 .. code::
 
-    def mv(float(R,C) A, float(C) x) -> (o) {
-      o(i) += A(i,j) * x(j)
+    def mv(float(R,C) A, float(C) B) -> (o) {
+      o(i) += A(i,j) * B(j)
     }
 
 Simple matrix-multiply

docs/source/semantics.rst

@@ -32,19 +32,21 @@ Each index variable has an associated range :code:`[b,e)` over which it operates
 That range is inferred by its use, as described below.
 Index variables go out of scope after the statement, allowing the reuse of short variable names like :code:`i`.
 
-Implied Reductions
-------------------
+Implied Reductions and operators
+--------------------------------
 
 If an index variable appears on the right but not on the left of a statement,
 it is a reduction index for the statement.
 If a statement has one or more reduction variables then it must specify a :code:`reduction`
 operator such as :code:`+` or :code:`max`.
 There is only one reduction operator for the entire statement because
 combinations like :code:`max/+` on different dimensions have different mathematical meanings depending on loop order.
-All reduction operators are considered to be associative and commutative to
-allow for arbitrary order of evaluation.
-Reduction operators may be suffixed with :code:`!` to indicate that the tensor to which values are accumulated should first be initialized with the identity of the reduction operator (e.g., zero for :code:`+`).
-Otherwise, values are accumulated directly to the output or temporary tensor passed to the kernel.
+All reduction operators are considered to be associative and commutative to allow for arbitrary order of evaluation.
+
+Reduction operators may be suffixed with :code:`!` (for example :code:`+=!`) to indicate that the
+tensor to which values are accumulated should first be initialized with the identity of the reduction
+operator (e.g., :code:`0` for :code:`+`). Otherwise, values are accumulated directly to the output or
+temporary tensor passed to the kernel.
 
 Size Expressions
 ----------------