Line data    Source code

       1             : #include "SplittingProblem.h"
       2             : 
       3             : namespace elsa
       4             : {
       5             :     template <typename data_t>
       6           0 :     SplittingProblem<data_t>::SplittingProblem(const Functional<data_t>& f,
       7             :                                                const std::vector<RegularizationTerm<data_t>>& g,
       8             :                                                const Constraint<data_t>& constraint)
       9           0 :         : Problem<data_t>(f, g), _f{f.clone()}, _g{g}, _constraint{constraint.clone()}
      10             :     {
      11           0 :     }
      12             : 
      13             :     template <typename data_t>
      14           0 :     SplittingProblem<data_t>::SplittingProblem(const Functional<data_t>& f,
      15             :                                                const RegularizationTerm<data_t>& g,
      16             :                                                const Constraint<data_t>& constraint)
      17           0 :         : Problem<data_t>(f, g), _f{f.clone()}, _g{g}, _constraint{constraint.clone()}
      18             :     {
      19           0 :     }
      20             : 
      21             :     template <typename data_t>
      22           0 :     auto SplittingProblem<data_t>::getConstraint() const -> const Constraint<data_t>&
      23             :     {
      24           0 :         return *_constraint;
      25             :     }
      26             : 
      27             :     template <typename data_t>
      28           0 :     auto SplittingProblem<data_t>::cloneImpl() const -> SplittingProblem<data_t>*
      29             :     {
      30           0 :         return new SplittingProblem<data_t>(*_f, _g, *_constraint);
      31             :     }
      32             : 
      33             :     template <typename data_t>
      34           0 :     auto SplittingProblem<data_t>::evaluateImpl() -> data_t
      35             :     {
      36           0 :         throw std::runtime_error("SplittingProblem::evaluateImpl: currently unsupported operation");
      37             :     }
      38             : 
      39             :     template <typename data_t>
      40           0 :     void SplittingProblem<data_t>::getGradientImpl(DataContainer<data_t>&)
      41             :     {
      42           0 :         throw std::runtime_error(
      43             :             "SplittingProblem::getGradientImpl: currently unsupported operation");
      44             :     }
      45             : 
      46             :     template <typename data_t>
      47           0 :     auto SplittingProblem<data_t>::getHessianImpl() const -> LinearOperator<data_t>
      48             :     {
      49           0 :         throw std::runtime_error(
      50             :             "SplittingProblem::getHessianImpl: currently unsupported operation");
      51             :     }
      52             : 
      53             :     template <typename data_t>
      54           0 :     auto SplittingProblem<data_t>::getLipschitzConstantImpl(index_t) const -> data_t
      55             :     {
      56           0 :         throw std::runtime_error(
      57             :             "SplittingProblem::getLipschitzConstantImpl: currently unsupported operation");
      58             :     }
      59             : 
      60             :     template <typename data_t>
      61           0 :     auto SplittingProblem<data_t>::getF() const -> const Functional<data_t>&
      62             :     {
      63           0 :         return *_f;
      64             :     }
      65             : 
      66             :     template <typename data_t>
      67           0 :     auto SplittingProblem<data_t>::getG() const -> const std::vector<RegularizationTerm<data_t>>&
      68             :     {
      69           0 :         return _g;
      70             :     }
      71             : 
      72             :     // ------------------------------------------
      73             :     // explicit template instantiation
      74             :     template class SplittingProblem<float>;
      75             :     template class SplittingProblem<complex<float>>;
      76             :     template class SplittingProblem<double>;
      77             :     template class SplittingProblem<complex<double>>;
      78             : } // namespace elsa