IterativeSolverIterator.h

Go to the documentation of this file.

/*
 * This program 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.
 * 
 * Written (W) 2013 Soumyajit De
 */

#ifndef ITERATIVE_SOLVER_ITERATOR_H_
#define ITERATIVE_SOLVER_ITERATOR_H_

#include <shogun/lib/config.h>

#ifdef HAVE_EIGEN3
#include <shogun/mathematics/eigen3.h>

using namespace Eigen;

namespace shogun
{

typedef struct _IterInfo
{
    float64_t residual_norm;

    index_t iteration_count;
} IterInfo;

template<class T> class IterativeSolverIterator
{

typedef Matrix<T, Dynamic, 1> VectorXt;

public:
    IterativeSolverIterator(const VectorXt& b,
        index_t max_iteration_limit=1000,
        float64_t relative_tolerence=1E-5,
        float64_t absolute_tolerence=1E-5)
    : m_max_iteration_limit(max_iteration_limit),
        m_tolerence(absolute_tolerence+relative_tolerence*b.norm()),
        m_success(false)
    {
        m_iter_info.residual_norm=std::numeric_limits<float64_t>::max();
        m_iter_info.iteration_count=0;
    }

    void begin(const VectorXt& residual)
    {
        m_iter_info.residual_norm=residual.norm();
        m_iter_info.iteration_count=0;
    }

    const bool end(const VectorXt& residual)
    {
        m_iter_info.residual_norm=residual.norm();

        m_success=m_iter_info.residual_norm < m_tolerence;
        return m_success || m_iter_info.iteration_count >= m_max_iteration_limit;
    }

    const IterInfo get_iter_info() const
    {
        return m_iter_info;
    }

    const bool succeeded(const VectorXt& residual)
    {
        m_iter_info.residual_norm=residual.norm();

        m_success=m_iter_info.residual_norm < m_tolerence;
        return m_success;
    }

    void operator++()
    {
        m_iter_info.iteration_count++;
    }

private:
    IterInfo m_iter_info;

    const index_t m_max_iteration_limit;

    const float64_t m_tolerence;

    bool m_success;
};

}

#endif // HAVE_EIGEN3
#endif // ITERATIVE_SOLVER_ITERATOR_H_