Catch2/include/internal/catch_approx.hpp

/*
 *  catch_approx.hpp
 *  Catch
 *
 *  Created by Phil on 28/04/2011.
 *  Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
 *
 *  Distributed under the Boost Software License, Version 1.0. (See accompanying
 *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 *
 */
#ifndef TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED

#include "catch_capture.hpp"

#include <cmath>
#include <limits>

namespace Catch
{
    namespace Detail
    {
        class Approx
        {
        public:
            ///////////////////////////////////////////////////////////////////////////
            explicit Approx
            (
                double value
            )
            :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
                m_scale( 1.0 ),
                m_value( value )
            {
            }
            
            ///////////////////////////////////////////////////////////////////////////
            Approx
            (
                const Approx& other
            )
            :   m_epsilon( other.m_epsilon ),
                m_scale( other.m_scale ),
                m_value( other.m_value )
            {
            }

            ///////////////////////////////////////////////////////////////////////////
            static Approx custom
            ()
            {
                return Approx( 0 );
            }
            
            ///////////////////////////////////////////////////////////////////////////
            Approx operator()
            (
                double value
            )
            {
                Approx approx( value );
                approx.epsilon( m_epsilon );
                approx.scale( m_scale );
                return approx;
            }
            
            ///////////////////////////////////////////////////////////////////////////
            friend bool operator == 
            (
                double lhs,
                const Approx& rhs
            )
            {
                // Thanks to Richard Harris for his help refining this formula
                return fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( fabs(lhs), fabs(rhs.m_value) ) );
            }
            
            ///////////////////////////////////////////////////////////////////////////
            friend bool operator == 
            (
                const Approx& lhs,
                double rhs
            )
            {
                return operator==( rhs, lhs );
            }
            
            ///////////////////////////////////////////////////////////////////////////
            friend bool operator != 
            (
                double lhs, 
                const Approx& rhs
            )
            {
                return !operator==( lhs, rhs );
            }

            ///////////////////////////////////////////////////////////////////////////
            friend bool operator != 
            (
                const Approx& lhs,
                double rhs
            )
            {
                return !operator==( rhs, lhs );
            }
            
            
            ///////////////////////////////////////////////////////////////////////////
            Approx& epsilon
            (
                double newEpsilon
            )
            {
                m_epsilon = newEpsilon;
                return *this;
            }
            
            ///////////////////////////////////////////////////////////////////////////
            Approx& scale
            (
                double newScale
            )
            {
                m_scale = newScale;
                return *this;
            }
            
            ///////////////////////////////////////////////////////////////////////////
            std::string toString() const
            {
                std::ostringstream oss;
                oss << "Approx( " << m_value << ")";
                return oss.str();
            }
            
        private:
            double m_epsilon;
            double m_scale;
            double m_value;
        };
    }
  
    ///////////////////////////////////////////////////////////////////////////////
    template<>
    inline std::string toString<Detail::Approx>
    (
        const Detail::Approx& value
    )
    {
        return value.toString();
    }
    
} // end namespace Catch

#endif // TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED