add a code quoting to a word and remove double quotes

Author: KristofferC

README.md

@@ -39,7 +39,7 @@ This package also provides optimized functions to compute column-wise and pairwi
 * Bray-Curtis dissimilarity
 * Bregman divergence
 
-For ``Euclidean distance``, ``Squared Euclidean distance``, ``Cityblock distance``, ``Minkowski distance``, and ``Hamming distance``, a weighted version is also provided.
+For `Euclidean distance`, `Squared Euclidean distance`, `Cityblock distance`, `Minkowski distance`, and `Hamming distance`, a weighted version is also provided.
 
 
 ## Basic use
@@ -55,7 +55,7 @@ r = evaluate(dist, x, y)
 r = dist(x, y)
 ```
 
-Here, dist is an instance of a distance type. For example, the type for Euclidean distance is ``Euclidean`` (more distance types will be introduced in the next section), then you can compute the Euclidean distance between ``x`` and ``y`` as
+Here, `dist` is an instance of a distance type. For example, the type for Euclidean distance is `Euclidean` (more distance types will be introduced in the next section), then you can compute the Euclidean distance between `x` and `y` as
 
 ```julia
 r = evaluate(Euclidean(), x, y)
@@ -70,57 +70,57 @@ r = euclidean(x, y)
 
 #### Computing distances between corresponding columns
 
-Suppose you have two ``m-by-n`` matrix ``X`` and ``Y``, then you can compute all distances between corresponding columns of ``X`` and ``Y`` in one batch, using the ``colwise`` function, as
+Suppose you have two `m-by-n` matrix `X` and `Y`, then you can compute all distances between corresponding columns of `X` and `Y` in one batch, using the `colwise` function, as
 
 ```julia
 r = colwise(dist, X, Y)
 ```
 
-The output ``r`` is a vector of length ``n``. In particular, ``r[i]`` is the distance between ``X[:,i]`` and ``Y[:,i]``. The batch computation typically runs considerably faster than calling ``evaluate`` column-by-column.
+The output `r` is a vector of length `n`. In particular, `r[i]` is the distance between `X[:,i]` and `Y[:,i]`. The batch computation typically runs considerably faster than calling `evaluate` column-by-column.
 
-Note that either of ``X`` and ``Y`` can be just a single vector -- then the ``colwise`` function will compute the distance between this vector and each column of the other parameter.
+Note that either of `X` and `Y` can be just a single vector -- then the `colwise` function will compute the distance between this vector and each column of the other parameter.
 
 #### Computing pairwise distances
 
-Let ``X`` and ``Y`` respectively have ``m`` and ``n`` columns. Then the ``pairwise`` function with the ``dims=2`` argument computes distances between each pair of columns in ``X`` and ``Y``:
+Let `X` and `Y` respectively have `m` and `n` columns. Then the `pairwise` function with the `dims=2` argument computes distances between each pair of columns in `X` and `Y`:
 
 ```julia
 R = pairwise(dist, X, Y, dims=2)
 ```
 
-In the output, ``R`` is a matrix of size ``(m, n)``, such that ``R[i,j]`` is the distance between ``X[:,i]`` and ``Y[:,j]``. Computing distances for all pairs using ``pairwise`` function is often remarkably faster than evaluting for each pair individually.
+In the output, `R` is a matrix of size `(m, n)`, such that `R[i,j]` is the distance between `X[:,i]` and `Y[:,j]`. Computing distances for all pairs using `pairwise` function is often remarkably faster than evaluting for each pair individually.
 
-If you just want to just compute distances between columns of a matrix ``X``, you can write
+If you just want to just compute distances between columns of a matrix `X`, you can write
 
 ```julia
 R = pairwise(dist, X, dims=2)
 ```
 
-This statement will result in an ``m-by-m`` matrix, where ``R[i,j]`` is the distance between ``X[:,i]`` and ``X[:,j]``.
-``pairwise(dist, X)`` is typically more efficient than ``pairwise(dist, X, X)``, as the former will take advantage of the symmetry when ``dist`` is a semi-metric (including metric).
+This statement will result in an `m-by-m` matrix, where `R[i,j]` is the distance between `X[:,i]` and `X[:,j]`.
+`pairwise(dist, X)` is typically more efficient than `pairwise(dist, X, X)`, as the former will take advantage of the symmetry when `dist` is a semi-metric (including metric).
 
 For performance reasons, it is recommended to use matrices with observations in columns (as shown above). Indeed,
-the ``Array`` type in Julia is column-major, making it more efficient to access memory column by column. However,
-matrices with observations stored in rows are also supported via the argument ``dims=1``.
+the `Array` type in Julia is column-major, making it more efficient to access memory column by column. However,
+matrices with observations stored in rows are also supported via the argument `dims=1`.
 
 #### Computing column-wise and pairwise distances inplace
 
-If the vector/matrix to store the results are pre-allocated, you may use the storage (without creating a new array) using the following syntax (``i`` being either ``1`` or ``2``):
+If the vector/matrix to store the results are pre-allocated, you may use the storage (without creating a new array) using the following syntax (`i` being either `1` or `2`):
 
 ```julia
 colwise!(r, dist, X, Y)
 pairwise!(R, dist, X, Y, dims=i)
 pairwise!(R, dist, X, dims=i)
 ```
 
-Please pay attention to the difference, the functions for inplace computation are ``colwise!`` and ``pairwise!`` (instead of ``colwise`` and ``pairwise``).
+Please pay attention to the difference, the functions for inplace computation are `colwise!` and `pairwise!` (instead of `colwise` and `pairwise`).
 
 
 ## Distance type hierarchy
 
 The distances are organized into a type hierarchy.
 
-At the top of this hierarchy is an abstract class **PreMetric**, which is defined to be a function ``d`` that satisfies
+At the top of this hierarchy is an abstract class **PreMetric**, which is defined to be a function `d` that satisfies
 
 	d(x, x) == 0  for all x
 	d(x, y) >= 0  for all x, y
@@ -214,7 +214,7 @@ The tables below can be replicated using the script in `benchmark/print_table.jl
 
 #### Column-wise benchmark
 
-The table below compares the performance (measured in terms of average elapsed time of each iteration) of a straightforward loop implementation and an optimized implementation provided in *Distances.jl*. The task in each iteration is to compute a specific distance between corresponding columns in two ``200-by-10000`` matrices.
+The table below compares the performance (measured in terms of average elapsed time of each iteration) of a straightforward loop implementation and an optimized implementation provided in *Distances.jl*. The task in each iteration is to compute a specific distance between corresponding columns in two `200-by-10000` matrices.
 
 |  distance  |  loop  |  colwise  |  gain  |
 |----------- | -------| ----------| -------|
@@ -244,11 +244,11 @@ The table below compares the performance (measured in terms of average elapsed t
 | Mahalanobis | 0.082180s |  0.019618s |  4.1891 |
 | BrayCurtis | 0.004464s |  0.001121s |  3.9809 |
 
-We can see that using ``colwise`` instead of a simple loop yields considerable gain (2x - 4x), especially when the internal computation of each distance is simple. Nonetheless, when the computation of a single distance is heavy enough (e.g. *KLDivergence*,  *RenyiDivergence*), the gain is not as significant.
+We can see that using `colwise` instead of a simple loop yields considerable gain (2x - 4x), especially when the internal computation of each distance is simple. Nonetheless, when the computation of a single distance is heavy enough (e.g. *KLDivergence*,  *RenyiDivergence*), the gain is not as significant.
 
 #### Pairwise benchmark
 
-The table below compares the performance (measured in terms of average elapsed time of each iteration) of a straightforward loop implementation and an optimized implementation provided in *Distances.jl*. The task in each iteration is to compute a specific distance in a pairwise manner between columns in a ``100-by-200`` and ``100-by-250`` matrices, which will result in a ``200-by-250`` distance matrix.
+The table below compares the performance (measured in terms of average elapsed time of each iteration) of a straightforward loop implementation and an optimized implementation provided in *Distances.jl*. The task in each iteration is to compute a specific distance in a pairwise manner between columns in a `100-by-200` and `100-by-250` matrices, which will result in a `200-by-250` distance matrix.
 
 |  distance  |  loop  |  pairwise  |  gain  |
 |----------- | -------| ----------| -------|
@@ -278,4 +278,4 @@ The table below compares the performance (measured in terms of average elapsed t
 | Mahalanobis | 0.197294s |  0.000420s | **470.2354** |
 | BrayCurtis | 0.012872s |  0.001489s |  8.6456 |
 
-For distances of which a major part of the computation is a quadratic form (e.g. *Euclidean*, *CosineDist*, *Mahalanobis*), the performance can be drastically improved by restructuring the computation and delegating the core part to ``GEMM`` in *BLAS*. The use of this strategy can easily lead to 100x performance gain over simple loops (see the highlighted part of the table above).
+For distances of which a major part of the computation is a quadratic form (e.g. *Euclidean*, *CosineDist*, *Mahalanobis*), the performance can be drastically improved by restructuring the computation and delegating the core part to `GEMM` in *BLAS*. The use of this strategy can easily lead to 100x performance gain over simple loops (see the highlighted part of the table above).