Line data    Source code

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