ProjectedGradient.hpp

/*
 * This file is part of bogus, a C++ sparse block matrix library.
 *
 * Copyright 2013 Gilles Daviet <gdaviet@gmail.com>
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/


#ifndef BOGUS_BLOCK_PROJECTED_GRADIENT_HPP
#define BOGUS_BLOCK_PROJECTED_GRADIENT_HPP

#include "ConstrainedSolverBase.hpp"

#include <vector>

namespace bogus
{

namespace projected_gradient {
    enum Variant {
        Standard,
        Descent,
        Conjugated,
        APGD,
        SPG
    } ;
}

template < typename BlockMatrixType >
class ProjectedGradient : public ConstrainedSolverBase< ProjectedGradient<BlockMatrixType >, BlockMatrixType >
{
public:
    typedef ConstrainedSolverBase< ProjectedGradient, BlockMatrixType > Base ;
    typedef typename Base::Scalar Scalar ;

    ProjectedGradient( ) : Base() { init() ; }
    explicit ProjectedGradient( const BlockObjectBase< BlockMatrixType > & matrix ) : Base()
    { init() ; Base::setMatrix( matrix ) ; }

    template < typename NSLaw, typename RhsT, typename ResT >
    Scalar solve( const NSLaw &law, const RhsT &b, ResT &x ) const ;


    template < projected_gradient::Variant variant, typename NSLaw, typename RhsT, typename ResT >
    Scalar solve( const NSLaw &law, const RhsT &b, ResT &x ) const ;


    ProjectedGradient& setMatrix( const BlockObjectBase< BlockMatrixType > & matrix )
    {
        m_matrix = &matrix ;
        Base::updateScalings() ;
        return *this ;
    }

    void setLineSearchIterations( const unsigned lsIterations )
    { m_lsIters = lsIterations ; }

    void setLineSearchOptimisticFactor( const Scalar lsOptimisticFactor )
    { m_lsOptimisticFactor = lsOptimisticFactor ; }

    void setLineSearchPessimisticFactor( const Scalar lsPessimisticFactor )
    { m_lsPessimisticFactor = lsPessimisticFactor ; }

    void setLineSearchArmijoCoefficient( const Scalar lsArmijoCoefficient )
    { m_lsArmijoCoefficient = lsArmijoCoefficient ; }

    void setDefaultVariant( projected_gradient::Variant variant )
    { m_defaultVariant = variant ; }

    unsigned lineSearchIterations() const { return m_lsIters ; }
    Scalar lineSearchOptimisticFactor() const { return m_lsOptimisticFactor ; }
    Scalar lineSearchPessimisticFactor() const { return m_lsPessimisticFactor ; }
    Scalar lineSearchArmijoCoefficient() const { return m_lsArmijoCoefficient ; }

protected:

    typedef typename Base::Index Index ;

    void init()
    {
        m_tol = 1.e-6 ;
        m_maxIters = 300 ;
        m_lsIters = 8 ;
        m_lsOptimisticFactor = 1.25 ;
        m_lsPessimisticFactor = .5 ;
        m_lsArmijoCoefficient = .5 ;
        m_defaultVariant = projected_gradient::APGD ;
    }

    using Base::m_matrix ;
    using Base::m_maxIters ;
    using Base::m_tol ;

    unsigned m_lsIters ;
    Scalar m_lsOptimisticFactor ;
    Scalar m_lsPessimisticFactor ;
    Scalar m_lsArmijoCoefficient ;

    projected_gradient::Variant m_defaultVariant ;

} ;

} //namespace bogus


#endif