QuCoSi/Vector

Go to the documentation of this file.

// QuCoSi - Quantum Computer Simulation
// Copyright © 2009 Frank S. Thomas <frank@blue-dwarf.de>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef QUCOSI_VECTOR_H
#define QUCOSI_VECTOR_H

#include <Eigen/Array>

#include "Aux"

namespace QuCoSi {

/** \class Vector
  *
  * \brief Dynamic size vector of complex numbers
  *
  * The Vector class is the base for all vectors and qubits used in QuCoSi. It
  * is of dynamic size and uses complex numbers. Besides the standard methods
  * that are inherited from the Eigen base class it offers some convenient
  * methods like isNormalized() and randomize(). The most important feature of
  * this class is the tensor product tensorDot() and tensorDotSet().
  *
  * \sa Qubit
  */
class Vector : public VectorXc
{
  public:
    /** \brief Constructs the two-dimensional vector (1 0)<sup>T</sup>
      */
    inline Vector() : VectorXc(2)
    {
      *this << 1, 0;
    }

    /** \brief Constructs the null vector of dimension \p dim
      *
      * \param dim the dimension of this vector
      */
    inline Vector(const int dim) : VectorXc(dim) {}

    /** \brief Constructs the two-dimensional vector (\p c0 \p c1)<sup>T</sup>
      *
      * \param c0 the first component of this vector
      * \param c1 the second component of this vector
      */
    inline Vector(const field& c0, const field& c1) : VectorXc(2)
    {
      *this << c0, c1;
    }

    inline Vector& operator=(const VectorXc& v)
    {
      VectorXc::operator=(v);
      return *this;
    }

    /** \brief Checks if this vector is an unit vector
      *
      * \return true if this vector is an unit vector
      */
    inline bool isNormalized() const
    {
      return is_one(norm());
    }

    /** \brief Sets all coefficients of this vector to random values
      *
      * \return a reference to \c *this
      */
    inline Vector& randomize()
    {
      do setRandom().normalize(); while (isZero() == true);
      return *this;
    }

    /** \brief Computes the tensor product of this vector with \p v
      *
      * The tensor product \f$x \otimes y\f$ of the vectors \f$x \in K^n\f$
      * and \f$y \in K^m\f$ is defined as:
      * \f[
      *   \left(\begin{array}{c}
      *     x_1 \\ x_2 \\ \vdots \\ x_n
      *   \end{array}\right)
      *   \otimes
      *   \left(\begin{array}{c}
      *     y_1 \\ y_2 \\ \vdots \\ y_m
      *   \end{array}\right)
      *   =
      *   \left(\begin{array}{c}
      *     x_1 y_1 \\ \vdots \\ x_1 y_m \\
      *     x_2 y_1 \\ \vdots \\ x_2 y_m \\
      *     \vdots \\ x_n y_m
      *   \end{array}\right) \in K^{nm} \ .
      * \f]
      *
      * \param v the right hand side operand of the tensor product
      * \return the tensor product of this vector with Vector \p v
      */
    inline Vector tensorDot(const Vector& v) const
    {
      Vector w(size()*v.size());
      for (int i = 0, k = 0; i < size(); ++i) {
        for (int j = 0; j < v.size(); ++j, ++k) {
          w(k) = (*this)(i)*v(j);
        }
      }
      return w;
    }

    /** \brief Sets the tensor product of this vector and \p v as this vector
      *
      * This method computes the tensor product of this vector and Vector
      * \p v and sets the result as this vector. For two vectors \c x and \c y
      * \code x.tensorDotSet(y) \endcode is practically identical to
      * \code x = x.tensorDot(y) \endcode
      *
      * \param v the right hand side operand of the tensor product
      * \return a reference to \c *this
      * \sa tensorDot()
      */
    inline Vector& tensorDotSet(const Vector& v)
    {
      *this = tensorDot(v);
      return *this;
    }
};

} // namespace QuCoSi

#endif // QUCOSI_VECTOR_H

// vim: filetype=cpp shiftwidth=2 textwidth=78