sparse_solver.hh

Go to the documentation of this file.

/* -*- mia-c++  -*-
 *
 * This file is part of MIA - a toolbox for medical image analysis 
 * Copyright (c) Leipzig, Madrid 1999-2017 Gert Wollny
 *
 * MIA 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.
 *
 * This program 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 MIA; if not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef mia_core_sparse_solver_hh
#define mia_core_sparse_solver_hh


#include <mia/core/product_base.hh>
#include <mia/core/traits.hh>

NS_MIA_BEGIN

template <typename F> 
class TSparseSolver : public CProductBase{
public: 
        typedef F Field;
        
        typedef F plugin_data; 
        
        typedef typename dim_traits<F>::dimsize_type dimsize_type; 

        typedef TSparseSolver<F> plugin_type; 
        
        static const char * const type_descr; 

        typedef typename Field::iterator field_iterator;  
        
        typedef typename Field::const_iterator const_field_iterator;  
        
        typedef typename Field::value_type value_type; 
        
        class A_mult_x: public CProductBase {
        public: 
                typedef F plugin_data; 
                
                typedef A_mult_x plugin_type; 
                
                static const char * const type_descr; 
                
                A_mult_x():m_size(dimsize_type()){}; 

                A_mult_x(const dimsize_type& size):m_size(size){};

                virtual ~A_mult_x() {}; 

                virtual value_type operator () (const_field_iterator ix) const = 0;

                virtual int get_boundary_size() const = 0; 
                
                dimsize_type get_size() const {
                        return m_size; 
                }
        private: 
                dimsize_type m_size; 
                
        }; 

        virtual ~TSparseSolver() {}; 


        virtual int solve(const Field& rhs, Field& x, const A_mult_x& mult) const = 0; 
}; 

template <typename F> 
const char * const TSparseSolver<F>::type_descr = "sparsesolver"; 


template <typename F> 
const char * const TSparseSolver<F>::A_mult_x::type_descr = "amultx"; 


template <typename F>
struct multiply {
        static void apply(F& MIA_PARAM_UNUSED(result), 
                          const typename TSparseSolver<F>::A_mult_x& MIA_PARAM_UNUSED(A), const F& MIA_PARAM_UNUSED(x)) {
                static_assert(sizeof(F)==0, "This operation needs to be specialized");  
        }
}; 


template <typename F>
F operator * (const typename TSparseSolver<F>::A_mult_x& A, const F& x)
{
        F result(x.get_size()); 
        multiply<F>::apply(result, A, x); 
        return result;
}


NS_MIA_END

#endif