dmtypes.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) 2016 ETH Zurich, Institute for Theoretical Physics, Philippe Faist
 * Copyright (c) 2017 Caltech, Institute for Quantum Information and Matter, 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 TOMOGRAPHER_DENSEDM_DMTYPES_H
#define TOMOGRAPHER_DENSEDM_DMTYPES_H

#include <cstddef>
#include <cassert>

#include <Eigen/Eigen>

#include <tomographer/tools/cxxutil.h> // StaticOrDynamic, TOMOGRAPHER_ENABLED_IF

namespace Tomographer {
namespace DenseDM {


template<int FixedDim_, typename RealScalar_ = double, int MaxFixedDim_ = FixedDim_>
struct DMTypes {

  // assert: either FixedDim_ is dynamic (in which case MaxFixedDim_ can be anything, or
  // FixedDim_ is static, and has to be equal to MaxFixedDim_ (or less than is also ok but
  // no idea why you'd do it).
  TOMO_STATIC_ASSERT_EXPR((FixedDim_ == Eigen::Dynamic) ||
                          (FixedDim_ <= MaxFixedDim_)) ;

  static constexpr bool IsDynamicDim = (FixedDim_ == Eigen::Dynamic);
  static constexpr int FixedDim = FixedDim_;
  static constexpr int FixedDim2 = ((FixedDim!=Eigen::Dynamic) ? FixedDim*FixedDim : Eigen::Dynamic);
  static constexpr int FixedNdof = ((FixedDim2!=Eigen::Dynamic) ? FixedDim2-1 : Eigen::Dynamic);

  typedef RealScalar_ RealScalar;
  typedef std::complex<RealScalar> ComplexScalar;

  static inline ComplexScalar cplx(RealScalar a, RealScalar b)
  {
    return ComplexScalar(a, b);
  }

  typedef Eigen::Matrix<ComplexScalar, FixedDim, FixedDim,
                        Eigen::Matrix<ComplexScalar,FixedDim,FixedDim>::Options, // the default options
                        MaxFixedDim_, MaxFixedDim_>  MatrixType;
  typedef const Eigen::Ref<const MatrixType> &  MatrixTypeConstRef;

  typedef Eigen::Matrix<RealScalar, FixedDim2, 1> VectorParamType;
  typedef const Eigen::Ref<const VectorParamType> &  VectorParamTypeConstRef;

  typedef Eigen::Matrix<RealScalar, FixedNdof, 1> VectorParamNdofType;
  typedef const Eigen::Ref<const VectorParamNdofType> &  VectorParamNdofTypeConstRef;
  


  TOMOGRAPHER_ENABLED_IF(!IsDynamicDim)
  inline DMTypes()
  : _dim()
  {
  }

  inline DMTypes(std::size_t d)
    : _dim(d)
  {
  }

  inline std::size_t dim() const { return _dim.value(); }

  inline std::size_t dim2() const { return _dim.value()*_dim.value(); }

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


  TOMOGRAPHER_ENABLED_IF(!IsDynamicDim)
  inline typename MatrixType::ConstantReturnType initMatrixType() const
  {
    return MatrixType::Zero();
  }
  TOMOGRAPHER_ENABLED_IF(IsDynamicDim)
  inline typename MatrixType::ConstantReturnType initMatrixType() const
  {
    return MatrixType::Zero(_dim.value(), _dim.value());
  }

  TOMOGRAPHER_ENABLED_IF(!IsDynamicDim)
  inline typename VectorParamType::ConstantReturnType initVectorParamType() const
  {
    return VectorParamType::Zero();
  }
  TOMOGRAPHER_ENABLED_IF(IsDynamicDim)
  inline typename VectorParamType::ConstantReturnType initVectorParamType() const
  {
    return VectorParamType::Zero(dim2());
  }

  TOMOGRAPHER_ENABLED_IF(!IsDynamicDim)
  inline typename VectorParamNdofType::ConstantReturnType initVectorParamNdofType() const
  {
    return VectorParamNdofType::Zero();
  }
  TOMOGRAPHER_ENABLED_IF(IsDynamicDim)
  inline typename VectorParamNdofType::ConstantReturnType initVectorParamNdofType() const
  {
    return VectorParamNdofType::Zero(ndof());
  }


private:
  const Tools::StaticOrDynamic<std::size_t, IsDynamicDim, (std::size_t)FixedDim> _dim;
};





} // namespace DenseDM
} // namespace Tomographer








#endif