amp_criteria.hpp

Go to the documentation of this file.

//This file is part of Bertini 2.
//
//amp_criteria.hpp 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.
//
//amp_criteria.hpp 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 amp_criteria.hpp.  If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) Bertini2 Development Team
//
// See <http://www.gnu.org/licenses/> for a copy of the license,
// as well as COPYING.  Bertini2 is provided with permitted
// additional terms in the b2/licenses/ directory.
 
#ifndef BERTINI_AMP_CRITERIA_HPP
#define BERTINI_AMP_CRITERIA_HPP

 
#include "bertini2/trackers/config.hpp"
 
namespace bertini{
    namespace tracking{
        namespace amp{
 
 

            inline
            double CriterionARHS(double const& norm_J, double const& norm_J_inverse, AdaptiveMultiplePrecisionConfig const& AMP_config)
            {
                return AMP_config.safety_digits_1 + log10(norm_J_inverse * AMP_config.linear_solve_error_bound * (norm_J + AMP_config.jacobian_eval_error_bound ));
            }

            template<typename NumT>
            bool CriterionA(double const& norm_J, double const& norm_J_inverse, AdaptiveMultiplePrecisionConfig const& AMP_config)
            {
                return NumTraits<NumT>::NumDigits()  >  CriterionARHS(norm_J, norm_J_inverse, AMP_config);
            }
 
 

            inline
            double D(double const& norm_J, double const& norm_J_inverse, AdaptiveMultiplePrecisionConfig const& AMP_config)
            {
                return log10(norm_J_inverse*( (2+AMP_config.linear_solve_error_bound)*norm_J+AMP_config.linear_solve_error_bound*AMP_config.jacobian_eval_error_bound)+1);
            }

            inline
            double CriterionBRHS(double const& norm_J, double const& norm_J_inverse, unsigned num_newton_iterations_remaining, NumErrorT const& tracking_tolerance, double const& norm_of_latest_newton_residual, AdaptiveMultiplePrecisionConfig const& AMP_config)
            {
                return AMP_config.safety_digits_1 + D(norm_J, norm_J_inverse, AMP_config) + (-log10(tracking_tolerance) + log10(norm_of_latest_newton_residual)) / (num_newton_iterations_remaining);
            }
 

            template<typename NumT>
            bool CriterionB(double const& norm_J,
                            double const& norm_J_inverse,
                            unsigned num_newton_iterations_remaining,
                            NumErrorT const& tracking_tolerance,
                            double const& norm_of_latest_newton_residual,
                            AdaptiveMultiplePrecisionConfig const& AMP_config)
            {
                return NumTraits<NumT>::NumDigits() > CriterionBRHS(norm_J, norm_J_inverse, num_newton_iterations_remaining, tracking_tolerance,  norm_of_latest_newton_residual, AMP_config);
            }
 
 
 
 

            inline
            double CriterionCRHS(double const& norm_J_inverse,
                                 double const& norm_z,
                                 NumErrorT const& tracking_tolerance,
                                 AdaptiveMultiplePrecisionConfig const& AMP_config)
            {
                return AMP_config.safety_digits_2 + -log10(tracking_tolerance) + log10(norm_J_inverse*AMP_config.function_eval_error_bound + norm_z);
            }
 
 

            template<typename Derived>
            double CriterionCRHS(double const& norm_J_inverse,
                                const Eigen::MatrixBase<Derived>& z,
                                NumErrorT tracking_tolerance,
                                AdaptiveMultiplePrecisionConfig const& AMP_config)
            {
                return CriterionCRHS(norm_J_inverse, double(z.norm()), tracking_tolerance, AMP_config);
            }
 

            template<typename NumT, typename Derived>
            bool CriterionC(double const& norm_J_inverse, const Eigen::MatrixBase<Derived>& z, NumErrorT tracking_tolerance, AdaptiveMultiplePrecisionConfig const& AMP_config)
            {
                return NumTraits<NumT>::NumDigits() > CriterionCRHS(norm_J_inverse, z, tracking_tolerance, AMP_config);
            }
        }
    }
 
}
 
 
#endif