Fixed documentation examples

Author: stephenchouca

docs/data_analytics/index.html

@@ -170,8 +170,72 @@
 <p>
 <script type="math/tex; mode=display">A_{ij} = B_{ikl} \cdot D_{lj} \cdot C_{kj}.</script>
 </p>
-<p>You can use the TACO Python library to easily and efficiently compute MTTKRP,
-as shown here:</p>
+<p>You can use the TACO C++ library to easily and efficiently compute the MTTKRP,
+as shown here:
+<pre class="highlight"><code class="language-c++">// On Linux and MacOS, you can compile and run this program like so:
+//   g++ -std=c++11 -O3 -DNDEBUG -DTACO -I ../../include -L../../build/lib mttkrp.cpp -o mttkrp -ltaco
+//   LD_LIBRARY_PATH=../../build/lib ./mttkrp
+#include &lt;random&gt;
+#include "taco.h"
+using namespace taco;
+int main(int argc, char* argv[]) {
+  std::default_random_engine gen(0);
+  std::uniform_real_distribution&lt;double&gt; unif(0.0, 1.0);
+  // Predeclare the storage formats that the inputs and output will be stored as.
+  // To define a format, you must specify whether each dimension is dense or 
+  // sparse and (optionally) the order in which dimensions should be stored. The 
+  // formats declared below correspond to compressed sparse fiber (csf) and 
+  // row-major dense (rm).
+  Format csf({Sparse,Sparse,Sparse});
+  Format  rm({Dense,Dense});
+
+  // Load a sparse order-3 tensor from file (stored in the FROSTT format) and 
+  // store it as a compressed sparse fiber tensor. The tensor in this example 
+  // can be download from: http://frostt.io/tensors/nell-2/
+  Tensor&lt;double&gt; B = read("nell-2.tns", csf);
+  // Generate a random dense matrix and store it in row-major (dense) format. 
+  // Matrices correspond to order-2 tensors in taco.
+  Tensor&lt;double&gt; C({B.getDimension(1), 25}, rm);
+  for (int i = 0; i &lt; C.getDimension(0); ++i) {
+    for (int j = 0; j &lt; C.getDimension(1); ++j) {
+      C.insert({i,j}, unif(gen));
+    }
+  }
+  C.pack();
+
+
+  // Generate another random dense matrix and store it in row-major format.
+  Tensor&lt;double&gt; D({B.getDimension(2), 25}, rm);
+  for (int i = 0; i &lt; D.getDimension(0); ++i) {
+    for (int j = 0; j &lt; D.getDimension(1); ++j) {
+      D.insert({i,j}, unif(gen));
+    }
+  }
+  D.pack();
+
+    // Declare the output matrix to be a dense matrix with 25 columns and the same
+  // number of rows as the number of slices along the first dimension of input
+  // tensor B, to be also stored as a row-major dense matrix.
+  Tensor&lt;double&gt; A({B.getDimension(0), 25}, rm);
+
+
+  // Define the MTTKRP computation using index notation.
+  IndexVar i, j, k, l;
+  A(i,j) = B(i,k,l) * D(l,j) * C(k,j);
+  // At this point, we have defined how entries in the output matrix should be
+  // computed from entries in the input tensor and matrices but have not actually
+  // performed the computation yet. To do so, we must first tell taco to generate
+  // code that can be executed to compute the MTTKRP operation.
+  A.compile();
+  // We can now call the functions taco generated to assemble the indices of the
+  // output matrix and then actually compute the MTTKRP.
+  A.assemble();
+  A.compute();
+  // Write the output of the computation to file (stored in the FROSTT format).
+  write("A.tns", A);
+}</code></pre></p>
+<p>You can also use the TACO Python library to perform the same computation, as
+demonstrated here:</p>
 <pre class="highlight"><code class="language-python">import pytaco as pt
 import numpy as np
 from pytaco import compressed, dense

docs/index.html

@@ -227,5 +227,5 @@ <h1 id="getting-help">Getting Help</h1>
 
 <!--
 MkDocs version : 0.17.2
-Build Date UTC : 2020-06-21 19:11:02
+Build Date UTC : 2020-07-26 01:30:52
 -->

docs/machine_learning/index.html

@@ -169,8 +169,72 @@
 <p>
 <script type="math/tex; mode=display">A_{ij} = B_{ij} \cdot C_{ik} \cdot C_{kj}.</script>
 </p>
-<p>You can use the TACO Python library to easily and efficiently compute SDDMM, as
+<p>You can use the taco C++ library to easily and efficiently compute the SDDMM, as
 shown here:</p>
+<pre class="highlight"><code class="language-c++">// On Linux and MacOS, you can compile and run this program like so:
+//   g++ -std=c++11 -O3 -DNDEBUG -DTACO -I ../../include -L../../build/lib sddmm.cpp -o sddmm -ltaco
+//   LD_LIBRARY_PATH=../../build/lib ./sddmm
+#include &lt;random&gt;
+#include "taco.h"
+using namespace taco;
+int main(int argc, char* argv[]) {
+  std::default_random_engine gen(0);
+  std::uniform_real_distribution&lt;double&gt; unif(0.0, 1.0);
+  // Predeclare the storage formats that the inputs and output will be stored as.
+  // To define a format, you must specify whether each dimension is dense or sparse
+  // and (optionally) the order in which dimensions should be stored. The formats
+  // declared below correspond to doubly compressed sparse row (dcsr), row-major
+  // dense (rm), and column-major dense (dm).
+  Format dcsr({Sparse,Sparse});
+  Format   rm({Dense,Dense});
+  Format   cm({Dense,Dense}, {1,0});
+
+  // Load a sparse matrix from file (stored in the Matrix Market format) and
+  // store it as a doubly compressed sparse row matrix. Matrices correspond to
+  // order-2 tensors in taco. The matrix in this example can be download from:
+  // https://www.cise.ufl.edu/research/sparse/MM/Williams/webbase-1M.tar.gz
+  Tensor&lt;double&gt; B = read("webbase-1M.mtx", dcsr);
+  // Generate a random dense matrix and store it in row-major (dense) format.
+  Tensor&lt;double&gt; C({B.getDimension(0), 1000}, rm);
+  for (int i = 0; i &lt; C.getDimension(0); ++i) {
+    for (int j = 0; j &lt; C.getDimension(1); ++j) {
+      C.insert({i,j}, unif(gen));
+    }
+  }
+  C.pack();
+
+  // Generate another random dense matrix and store it in column-major format.
+  Tensor&lt;double&gt; D({1000, B.getDimension(1)}, cm);
+  for (int i = 0; i &lt; D.getDimension(0); ++i) {
+    for (int j = 0; j &lt; D.getDimension(1); ++j) {
+      D.insert({i,j}, unif(gen));
+    }
+  }
+  D.pack();
+
+  // Declare the output matrix to be a sparse matrix with the same dimensions as
+  // input matrix B, to be also stored as a doubly compressed sparse row matrix.
+  Tensor&lt;double&gt; A(B.getDimensions(), dcsr);
+
+  // Define the SDDMM computation using index notation.
+  IndexVar i, j, k;
+  A(i,j) = B(i,j) * C(i,k) * D(k,j);
+
+  // At this point, we have defined how entries in the output matrix should be
+  // computed from entries in the input matrices but have not actually performed
+  // the computation yet. To do so, we must first tell taco to generate code that
+  // can be executed to compute the SDDMM operation.
+  A.compile();
+  // We can now call the functions taco generated to assemble the indices of the
+  // output matrix and then actually compute the SDDMM.
+  A.assemble();
+  A.compute();
+  // Write the output of the computation to file (stored in the Matrix Market format).
+  write("A.mtx", A);
+}</code></pre>
+
+<p>You can also use the TACO Python library to perform the same computation, as
+demonstrated here:</p>
 <pre class="highlight"><code class="language-python">import pytaco as pt
 from pytaco import dense, compressed
 import numpy as np

docs/scientific_computing/index.html

@@ -161,14 +161,77 @@
 <p>
 <script type="math/tex; mode=display">y = Ax + z,</script>
 </p>
-<p>where <script type="math/tex">A</script> is a sparse matrix and <script type="math/tex">x</script>, <script type="math/tex">y</script>, and <script type="math/tex">z</script>
-are dense vectors. The computation can also be expressed in <a href="../pycomputations/index.html#specifying-tensor-algebra-computations">index
+<p>where <script type="math/tex">A</script> is a sparse matrix and <script type="math/tex">x</script>, <script type="math/tex">y</script>, and <script type="math/tex">z</script> are dense vectors.
+The computation can also be expressed in <a href="../pycomputations/index.html#specifying-tensor-algebra-computations">index
 notation</a> as </p>
 <p>
 <script type="math/tex; mode=display">y_i = A_{ij} \cdot x_j + z_i.</script>
 </p>
-<p>You can use the TACO Python library to easily and efficiently compute SpMV, as
+<p>You can use the TACO C++ library to easily and efficiently compute SpMV, as
 shown here:</p>
+<pre class="highlight"><code class="language-c++">// On Linux and MacOS, you can compile and run this program like so:
+//   g++ -std=c++11 -O3 -DNDEBUG -DTACO -I ../../include -L../../build/lib spmv.cpp -o spmv -ltaco
+//   LD_LIBRARY_PATH=../../build/lib ./spmv
+#include &lt;random&gt;
+#include "taco.h"
+using namespace taco;
+int main(int argc, char* argv[]) {
+  std::default_random_engine gen(0);
+  std::uniform_real_distribution&lt;double&gt; unif(0.0, 1.0);
+  // Predeclare the storage formats that the inputs and output will be stored as.
+  // To define a format, you must specify whether each dimension is dense or sparse 
+  // and (optionally) the order in which dimensions should be stored. The formats 
+  // declared below correspond to compressed sparse row (csr) and dense vector (dv). 
+  Format csr({Dense,Sparse});
+  Format  dv({Dense});
+
+  // Load a sparse matrix from file (stored in the Matrix Market format) and 
+  // store it as a compressed sparse row matrix. Matrices correspond to order-2 
+  // tensors in taco. The matrix in this example can be downloaded from:
+  // https://www.cise.ufl.edu/research/sparse/MM/Boeing/pwtk.tar.gz
+  Tensor&lt;double&gt; A = read("pwtk.mtx", csr);
+
+  // Generate a random dense vector and store it in the dense vector format. 
+  // Vectors correspond to order-1 tensors in taco.
+  Tensor&lt;double&gt; x({A.getDimension(1)}, dv);
+  for (int i = 0; i &lt; x.getDimension(0); ++i) {
+    x.insert({i}, unif(gen));
+  }
+  x.pack();
+
+  // Generate another random dense vetor and store it in the dense vector format..
+  Tensor&lt;double&gt; z({A.getDimension(0)}, dv);
+  for (int i = 0; i &lt; z.getDimension(0); ++i) {
+    z.insert({i}, unif(gen));
+  }
+  z.pack();
+
+  // Declare and initializing the scaling factors in the SpMV computation. 
+  // Scalars correspond to order-0 tensors in taco.
+  Tensor&lt;double&gt; alpha(42.0);
+  Tensor&lt;double&gt; beta(33.0);
+
+  // Declare the output matrix to be a sparse matrix with the same dimensions as 
+  // input matrix B, to be also stored as a doubly compressed sparse row matrix.
+  Tensor&lt;double&gt; y({A.getDimension(0)}, dv);
+  // Define the SpMV computation using index notation.
+  IndexVar i, j;
+  y(i) = alpha() * (A(i,j) * x(j)) + beta() * z(i);
+  // At this point, we have defined how entries in the output vector should be 
+  // computed from entries in the input matrice and vectorsbut have not actually 
+  // performed the computation yet. To do so, we must first tell taco to generate 
+  // code that can be executed to compute the SpMV operation.
+  y.compile();
+  // We can now call the functions taco generated to assemble the indices of the 
+  // output vector and then actually compute the SpMV.
+  y.assemble();
+  y.compute();
+  // Write the output of the computation to file (stored in the FROSTT format).
+  write("y.tns", y);
+}</code></pre>
+
+<p>You can also use the TACO Python library to perform the same computation, as
+demonstrated here:</p>
 <pre class="highlight"><code class="language-python">import pytaco as pt
 from pytaco import compressed, dense
 import numpy as np