matrq.h

Go to the documentation of this file.

/* This file is part of the Tomographer project, which is distributed under the
 * terms of the MIT license.
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 ETH Zurich, Institute for Theoretical Physics, Philippe Faist
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef _MATRQ_H
#define _MATRQ_H

#include <cstddef> // std::size_t
#include <complex>

#include <Eigen/Core>


namespace Tomographer {



template<int FixedDim_ = Eigen::Dynamic, int FixedMaxParamList_ = Eigen::Dynamic,
         typename RealScalar_ = double, typename IntFreqType_ = int> struct MatrQ;

namespace tomo_internal
{
  template<typename Derived>
  struct matrq_traits { };

  template<int FixedDim_, int FixedMaxParamList_,
           typename RealScalar_, typename IntFreqType_>
  struct matrq_traits<MatrQ<FixedDim_, FixedMaxParamList_, RealScalar_, IntFreqType_> >
  {
    enum {
      FixedDim = FixedDim_,
      FixedMaxParamList = FixedMaxParamList_
    };
    typedef RealScalar_ RealScalar;
    typedef std::complex<RealScalar> ComplexScalar;
    typedef IntFreqType_ IntFreqType;
  };

};


template<typename Derived>
struct MatrQBase
{
  enum {
    FixedDim = tomo_internal::matrq_traits<Derived>::FixedDim,
    FixedDim2 = ((FixedDim!=Eigen::Dynamic) ? FixedDim*FixedDim : Eigen::Dynamic),
    FixedNdof = ((FixedDim2!=Eigen::Dynamic) ? FixedDim2-1 : Eigen::Dynamic),
    FixedMaxParamList = tomo_internal::matrq_traits<Derived>::FixedMaxParamList
  };
  typedef typename tomo_internal::matrq_traits<Derived>::RealScalar RealScalar;
  typedef typename tomo_internal::matrq_traits<Derived>::ComplexScalar ComplexScalar;
  typedef typename tomo_internal::matrq_traits<Derived>::IntFreqType IntFreqType;

  typedef Eigen::Matrix<std::complex<RealScalar>, FixedDim, FixedDim> MatrixType;
  
  typedef Eigen::Matrix<RealScalar, FixedDim2, 1> VectorParamType;

  typedef Eigen::Matrix<RealScalar, FixedNdof, 1> VectorParamNdofType;
  
  typedef Eigen::Matrix<RealScalar, Eigen::Dynamic, FixedDim2, Eigen::RowMajor,
                        FixedMaxParamList, FixedDim2> VectorParamListType;

  typedef Eigen::Array<IntFreqType, Eigen::Dynamic, 1, 0 /*Options*/,
                       FixedMaxParamList, 1> FreqListType;

};


template<typename Derived, bool has_fixed_dim>
struct MatrQBaseDimStore : public MatrQBase<Derived>
{
  inline std::size_t dim() const { return MatrQBase<Derived>::FixedDim; }
  inline std::size_t dim2() const { return MatrQBase<Derived>::FixedDim2; }
  inline std::size_t ndof() const { return MatrQBase<Derived>::FixedNdof; }

  MatrQBaseDimStore(std::size_t dim_)
  {
    (void)dim_; // don't warn of unused variable if eigen_assert() gets optimized out

    // use eigen_assert() here for our test suite to check this without abort()ing.
    eigen_assert(MatrQBase<Derived>::FixedDim != Eigen::Dynamic);
    eigen_assert(dim_ == MatrQBase<Derived>::FixedDim);
  }

  inline typename MatrQBase<Derived>::MatrixType::ConstantReturnType
  initMatrixType() const
  {
    return MatrQBase<Derived>::MatrixType::Zero();
  }

  inline typename MatrQBase<Derived>::VectorParamType::ConstantReturnType
  initVectorParamType() const
  {
    return MatrQBase<Derived>::VectorParamType::Zero();
  }

  inline typename MatrQBase<Derived>::VectorParamNdofType::ConstantReturnType
  initVectorParamNdofType() const
  {
    return MatrQBase<Derived>::VectorParamNdofType::Zero();
  }

  inline typename MatrQBase<Derived>::VectorParamListType::ConstantReturnType
  initVectorParamListType(std::size_t len) const
  {
    return MatrQBase<Derived>::VectorParamListType::Zero(len,
                                                         MatrQBase<Derived>::FixedDim*MatrQBase<Derived>::FixedDim);
  }

  inline typename MatrQBase<Derived>::FreqListType::ConstantReturnType
  initFreqListType(std::size_t len) const
  {
    return MatrQBase<Derived>::FreqListType::Zero(len);
  }
};

template<typename Derived>
struct MatrQBaseDimStore<Derived, false> : public MatrQBase<Derived>
{
private:
  const std::size_t _dim;
public:

  inline std::size_t dim() const { return _dim; }
  inline std::size_t dim2() const { return _dim*_dim; }
  inline std::size_t ndof() const { return _dim*_dim - 1; }

  MatrQBaseDimStore(std::size_t dim_)
    : _dim(dim_)
  {
    eigen_assert(MatrQBase<Derived>::FixedDim == Eigen::Dynamic);
  }

  inline typename MatrQBase<Derived>::MatrixType::ConstantReturnType initMatrixType() const
  {
    return MatrQBase<Derived>::MatrixType::Zero(_dim, _dim);
  }
  inline typename MatrQBase<Derived>::VectorParamType::ConstantReturnType initVectorParamType() const
  {
    return MatrQBase<Derived>::VectorParamType::Zero(_dim*_dim);
  }
  inline typename MatrQBase<Derived>::VectorParamNdofType::ConstantReturnType initVectorParamNdofType() const
  {
    return MatrQBase<Derived>::VectorParamNdofType::Zero(_dim*_dim-1);
  }
  inline typename MatrQBase<Derived>::VectorParamListType::ConstantReturnType
  initVectorParamListType(std::size_t len) const
  {
    return MatrQBase<Derived>::VectorParamListType::Zero(len, _dim*_dim);
  }
  inline typename MatrQBase<Derived>::FreqListType::ConstantReturnType initFreqListType(std::size_t len) const
  {
    return MatrQBase<Derived>::FreqListType::Zero(len);
  }
};



template<int FixedDim_, int FixedMaxParamList_, typename RealScalar_, typename IntFreqType_>
struct MatrQ
  : public MatrQBaseDimStore<MatrQ<FixedDim_, FixedMaxParamList_, RealScalar_, IntFreqType_>,
                             FixedDim_ != Eigen::Dynamic>
{
  MatrQ(std::size_t dim_)
    : MatrQBaseDimStore<MatrQ<FixedDim_, FixedMaxParamList_, RealScalar_, IntFreqType_>,
                        FixedDim_ != Eigen::Dynamic>(dim_)
  {
  }
};



typedef MatrQ<Eigen::Dynamic, Eigen::Dynamic, double, int> DefaultMatrQ;

typedef MatrQ<2,6,double,int> QubitPaulisMatrQ;



} // namespace Tomographer


#endif