From 6d0fd919059c40c10710f90634fc6ff08cbebdaf Mon Sep 17 00:00:00 2001
From: Sebastian Kraemer <basti.kr@gmail.com>
Date: Wed, 19 Apr 2017 17:11:21 +0200
Subject: [PATCH] Fix a few errors in docstrings.

* Spelling mistakes.
* Mistakes in latex formulas.
---
 src/bases.jl                 |  6 +++---
 src/fock.jl                  |  2 +-
 src/manybody.jl              |  9 +++------
 src/mcwf.jl                  |  4 ++--
 src/nlevel.jl                |  2 +-
 src/operators.jl             | 18 +++++++++---------
 src/operators_dense.jl       |  1 +
 src/operators_lazyproduct.jl |  8 ++++----
 src/operators_lazysum.jl     |  5 +++--
 src/operators_lazytensor.jl  |  8 ++++----
 src/spin.jl                  |  2 +-
 src/states.jl                |  6 +++---
 src/superoperators.jl        |  7 ++++---
 13 files changed, 39 insertions(+), 39 deletions(-)

diff --git a/src/bases.jl b/src/bases.jl
index 6c8fb9db..be3178f7 100644
--- a/src/bases.jl
+++ b/src/bases.jl
@@ -16,7 +16,7 @@ The Basis class is meant to specify a basis of the Hilbert space of the
 studied system. Besides basis specific information all subclasses must
 implement a shape variable which indicates the dimension of the used
 Hilbert space. For a spin-1/2 Hilbert space this would be the
-vector `Int[2]`. A system composed of 2 spins would then have a
+vector `Int[2]`. A system composed of two spins would then have a
 shape vector `Int[2 2]`.
 
 Composite systems can be defined with help of the [`CompositeBasis`](@ref)
@@ -247,8 +247,8 @@ ptrace(a, index::Int) = ptrace(a, Int[index])
 
 Change the ordering of the subsystems of the given object.
 
-For a permutation vector [2,1,3] and a given object with basis [b1, b2, b3]
-this function results in [b2, b1, b3].
+For a permutation vector `[2,1,3]` and a given object with basis `[b1, b2, b3]`
+this function results in `[b2, b1, b3]`.
 """
 function permutesystems(b::CompositeBasis, perm::Vector{Int})
     @assert length(b.bases) == length(perm)
diff --git a/src/fock.jl b/src/fock.jl
index 33b54c79..f7d31a45 100644
--- a/src/fock.jl
+++ b/src/fock.jl
@@ -80,7 +80,7 @@ end
 """
     coherentstate(b::FockBasis, alpha)
 
-Coherent state `|α⟩` for the specified Fock space.
+Coherent state ``|α⟩`` for the specified Fock space.
 """
 function coherentstate(b::FockBasis, alpha::Number, result=Ket(b, Vector{Complex128}(length(b))))
     alpha = complex(alpha)
diff --git a/src/manybody.jl b/src/manybody.jl
index 7f92df64..1a317d7e 100644
--- a/src/manybody.jl
+++ b/src/manybody.jl
@@ -214,20 +214,17 @@ moment not implemented.
 The mathematical formalism for the one-body case is described by
 
 ```math
-X = \\sum_{ij} a_i^† a_j \\left⟨u_i \right| x \\left| u_j \\right⟩
+X = \\sum_{ij} a_i^† a_j ⟨u_i| x | u_j⟩
 ```
 
 and for the interaction case by
 
 ```math
-X = \\sum_{ijkl} a_i^† a_j^† a_k a_l
-            \\left⟨ u_i \\right| \\left⟨ u_j \\right|
-            x
-            \\left| u_k \\right⟩ \\left| u_l \\right⟩
+X = \\sum_{ijkl} a_i^† a_j^† a_k a_l ⟨u_i|⟨u_j| x |u_k⟩|u_l⟩
 ```
 
 where ``X`` is the N-particle operator, ``x`` is the one-body operator and
-``\\left| u \\right⟩`` are the one-body states associated to the
+``|u⟩`` are the one-body states associated to the
 different modes of the N-particle basis.
 """
 function manybodyoperator{T<:Operator}(basis::ManyBodyBasis, op::T)::T
diff --git a/src/mcwf.jl b/src/mcwf.jl
index bd285ae9..298b976f 100644
--- a/src/mcwf.jl
+++ b/src/mcwf.jl
@@ -166,8 +166,8 @@ Integrate the master equation using the MCWF method.
 There are two implementations for integrating the non-hermitian
 schroedinger equation:
 
-* ``mcwf_h``: Usual formulation with Hamiltonian + jump operators separately.
-* ``mcwf_nh``: Variant with non-hermitian Hamiltonian.
+* [`mcwf_h`](@ref): Usual formulation with Hamiltonian + jump operators separately.
+* [`mcwf_nh`](@ref): Variant with non-hermitian Hamiltonian.
 
 The ``mcwf`` function takes a normal Hamiltonian, calculates the
 non-hermitian Hamiltonian and then calls mcwf_nh which is slightly faster.
diff --git a/src/nlevel.jl b/src/nlevel.jl
index 5257b9b7..ff60d611 100644
--- a/src/nlevel.jl
+++ b/src/nlevel.jl
@@ -28,7 +28,7 @@ end
 """
     transition(b::NLevelBasis, to::Int, from::Int)
 
-Transition operator ``|to><from|``.
+Transition operator ``|\\mathrm{to}⟩⟨\\mathrm{from}|``.
 """
 function transition(b::NLevelBasis, to::Int, from::Int)
     if to < 1 || b.N < to
diff --git a/src/operators.jl b/src/operators.jl
index 2703ba6f..1c3db33c 100644
--- a/src/operators.jl
+++ b/src/operators.jl
@@ -16,10 +16,10 @@ export Operator,
 Abstract base class for all operators.
 
 All deriving operator classes have to define the fields
-basis_l and basis_r defining the left and right side bases.
+`basis_l` and `basis_r` defining the left and right side bases.
 
 For fast time evolution also at least the function
-gemv!(alpha, op::Operator, x::Ket, beta, result::Ket) should be
+`gemv!(alpha, op::Operator, x::Ket, beta, result::Ket)` should be
 implemented. Many other generic multiplication functions can be defined in
 terms of this function and are provided automatically.
 """
@@ -71,14 +71,14 @@ ptrace(a::Operator, index::Vector{Int}) = arithmetic_unary_error("Partial trace"
 """
     normalize(op)
 
-Return the normalized operator so that its trace is one.
+Return the normalized operator so that its `trace(op)` is one.
 """
 normalize(op::Operator) = op/trace(op)
 
 """
     normalize!(op)
 
-In-place normalization of the given operator so that its trace is one.
+In-place normalization of the given operator so that its `trace(x)` is one.
 """
 normalize!(op::Operator) = throw(ArgumentError("normalize! is not defined for this type of operator: $(typeof(op)).\n You may have to fall back to the non-inplace version 'normalize()'."))
 
@@ -105,7 +105,7 @@ end
 """
     expect(index, op, state)
 
-If `index` is given, it assumes that
+If an `index` is given, it assumes that `op` is defined in the subsystem specified by this number.
 """
 expect(index::Int, op::Operator, state) = expect([index], op, state)
 expect(op::Operator, states::Vector) = [expect(op, state) for state=states]
@@ -203,8 +203,8 @@ embed{T<:Operator}(basis::CompositeBasis, operators::Dict{Vector{Int}, T}; kwarg
 
 Fast in-place multiplication of operators with state vectors. It
 implements the relation `result = beta*result + alpha*a*b`.
-`alpha` and `beta` are complex numbers. `result` and either `a` or `b`
-are state vectors while the other one can be of any operator type.
+Here, `alpha` and `beta` are complex numbers, while `result` and either `a`
+or `b` are state vectors while the other one can be of any operator type.
 """
 gemv!() = error("Not Implemented.")
 
@@ -213,8 +213,8 @@ gemv!() = error("Not Implemented.")
 
 Fast in-place multiplication of of operators with DenseOperators. It
 implements the relation `result = beta*result + alpha*a*b`.
-`alpha` and `beta` are complex numbers. `result` and either `a` or `b`
-are dense operators while the other one can be of any operator type.
+Here, `alpha` and `beta` are complex numbers, while `result` and either `a`
+or `b` are dense operators while the other one can be of any operator type.
 """
 gemm!() = error("Not Implemented.")
 
diff --git a/src/operators_dense.jl b/src/operators_dense.jl
index b9e42318..b78de562 100644
--- a/src/operators_dense.jl
+++ b/src/operators_dense.jl
@@ -37,6 +37,7 @@ Base.copy(x::DenseOperator) = deepcopy(x)
 
 Convert an arbitrary Operator into a [`DenseOperator`](@ref).
 """
+Base.full(x::Operator) = throw(ArgumentError("Conversion from $(typeof(a)) to a DenseOperator not implemented."))
 Base.full(x::DenseOperator) = deepcopy(x)
 
 ==(x::DenseOperator, y::DenseOperator) = (x.basis_l == y.basis_l) && (x.basis_r == y.basis_r) && (x.data == y.data)
diff --git a/src/operators_lazyproduct.jl b/src/operators_lazyproduct.jl
index 9e74a736..f3583525 100644
--- a/src/operators_lazyproduct.jl
+++ b/src/operators_lazyproduct.jl
@@ -12,11 +12,11 @@ export LazyProduct
     LazyProduct(operators[, factor=1])
     LazyProduct(op1, op2...)
 
-Lazy evaluation of product of operators.
+Lazy evaluation of products of operators.
 
-The factors of the product are stored in the "operators" field. Additionally a
-complex factor is stored in the "factor" field which allows for fast
-multiplication with a number.
+The factors of the product are stored in the `operators` field. Additionally a
+complex factor is stored in the `factor` field which allows for fast
+multiplication with numbers.
 """
 type LazyProduct <: Operator
     basis_l::Basis
diff --git a/src/operators_lazysum.jl b/src/operators_lazysum.jl
index 9dcad2aa..c2e26b37 100644
--- a/src/operators_lazysum.jl
+++ b/src/operators_lazysum.jl
@@ -11,10 +11,11 @@ export LazySum
 """
     LazySum([factors,] operators)
 
-Lazy evaluation of sum of operators.
+Lazy evaluation of sums of operators.
 
 All operators have to be given in respect to the same bases. The field
-factors accounts for an additional multiplicative factor for each operator.
+`factors` accounts for an additional multiplicative factor for each operator
+stored in the `operators` field.
 """
 type LazySum <: Operator
     basis_l::Basis
diff --git a/src/operators_lazytensor.jl b/src/operators_lazytensor.jl
index fc41e1d4..d7db4dac 100644
--- a/src/operators_lazytensor.jl
+++ b/src/operators_lazytensor.jl
@@ -14,10 +14,10 @@ export LazyTensor
 
 Lazy implementation of a tensor product of operators.
 
-The suboperators are stored in the "operators" field. The "indices" field
-specifies to which subsystem the corresponding operator lives. Additionally,
-a complex factor is stored in the "factor" field which allows for fast
-multiplication with a number.
+The suboperators are stored in the `operators` field. The `indices` field
+specifies in which subsystem the corresponding operator lives. Additionally,
+a complex factor is stored in the `factor` field which allows for fast
+multiplication with numbers.
 """
 type LazyTensor <: Operator
     basis_l::CompositeBasis
diff --git a/src/spin.jl b/src/spin.jl
index 271b6015..0455dccf 100644
--- a/src/spin.jl
+++ b/src/spin.jl
@@ -14,7 +14,7 @@ Basis for spin-n particles.
 
 The basis can be created for arbitrary spinnumbers by using a rational number,
 e.g. `SpinBasis(3//2)`. The Pauli operators are defined for all possible
-spinnumbers.
+spin numbers.
 """
 type SpinBasis <: Basis
     shape::Vector{Int}
diff --git a/src/states.jl b/src/states.jl
index b5c1de06..24523b9f 100644
--- a/src/states.jl
+++ b/src/states.jl
@@ -10,7 +10,7 @@ export StateVector, Bra, Ket,
 
 
 """
-Abstract base class for Bra and Ket states.
+Abstract base class for [`Bra`](@ref) and [`Ket`](@ref) states.
 
 The state vector class stores the coefficients of an abstract state
 in respect to a certain basis. These coefficients are stored in the
@@ -22,7 +22,7 @@ abstract StateVector
 """
     Bra(b::Basis[, data])
 
-Bra state defined by coefficients in respect to a basis.
+Bra state defined by coefficients in respect to the basis.
 """
 type Bra <: StateVector
     basis::Basis
@@ -33,7 +33,7 @@ end
 """
     Ket(b::Basis[, data])
 
-Ket state defined by coefficients in respect to a basis.
+Ket state defined by coefficients in respect to the given basis.
 """
 type Ket <: StateVector
     basis::Basis
diff --git a/src/superoperators.jl b/src/superoperators.jl
index b802e2db..636ea897 100644
--- a/src/superoperators.jl
+++ b/src/superoperators.jl
@@ -18,10 +18,11 @@ left hand basis `basis_l` and a right hand basis `basis_r` where each of
 them again consists of a left and right hand basis.
 
 ```math
-    A_{bl_1,bl_2} &= S_{(bl_1,bl_2)<->(br_1,br_2)} B_{br_1,br_2}
-    \\
-    A_{br_1,br_2} &= B_{bl_1,bl_2} S_{(bl_1,bl_2)<->(br_1,br_2)}
+A_{bl_1,bl_2} = S_{(bl_1,bl_2) ↔ (br_1,br_2)} B_{br_1,br_2}
+\\\\
+A_{br_1,br_2} = B_{bl_1,bl_2} S_{(bl_1,bl_2) ↔ (br_1,br_2)}
 ```
+
 """
 abstract SuperOperator