zero.hh

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                             */
/*   This file is part of the C++-library RFFGen.                              */
/*   Copyright 2015 Lars Lubkoll                                               */
/*                                                                             */
/*   RFFGen 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.                                       */
/*                                                                             */
/*   RFFGen 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 RFFGen.  If not, see <http://www.gnu.org/licenses/>.           */
/*                                                                             */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#ifndef RFFGEN_UTIL_ZERO_HH
#define RFFGEN_UTIL_ZERO_HH

#include <utility>

#include "staticChecks.hh"

namespace RFFGen
{
  namespace Checks
  {
    template <class Matrix>
    using TryCallToZeroes = decltype(std::declval<Matrix>().zeros());

    template <class Matrix>
    using TryCallToFill   = decltype(std::declval<Matrix>().fill(0));
  }
  template <class Matrix, class = void>
  struct Zero
  {
    Matrix operator()() const
    {
      return Matrix(0.);
    }
  };

  template <class Matrix>
  struct Zero< Matrix , void_t<Checks::TryCallToFill<Matrix> > >
  {
    Matrix operator()() const
    {
      Matrix m;
      m.fill(0);
      return m;
    }

    Matrix& operator()(Matrix& m) const
    {
      m.fill(0);
      return m;
    }
  };

  template <class Matrix, class = std::enable_if_t<Checks::isConstantSizeMatrix<Matrix>()> >
  Matrix zero()
  {
    return Zero<Matrix>()();
  }

  template <class Matrix, class = std::enable_if_t<!Checks::isConstantSizeMatrix<Matrix>()> >
  constexpr Matrix zero(int rows, int cols)
  {
    Matrix m(rows,cols);
    return Zero<Matrix>()(m);
  }

}

#endif // RFFGEN_UTIL_ZERO_HH