tolerance_comparison.h

Go to the documentation of this file.

//
// Copyright (c) 2014 Limit Point Systems, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//


#ifndef TOLERANCE_COMPARISON_H
#define TOLERANCE_COMPARISON_H

#ifndef SHEAF_DLL_SPEC_H
#include "SheafSystem/sheaf_dll_spec.h"
#endif

#ifndef STD_LIMITS_H
#include "SheafSystem/std_limits.h"
#endif
 
#ifndef STD_MATH_H
#include "SheafSystem/std_cmath.h"
#endif
 
namespace sheaf
{

  // ===========================================================
  // FLOAT COMPARISION
  // ===========================================================

  const float float_tolerance = sqrt(std::numeric_limits<float>::epsilon());
  
  SHEAF_DLL_SPEC inline bool a_eql_0(float xf0)
  {
    return std::abs(xf0) <= float_tolerance;
  };
  
  SHEAF_DLL_SPEC inline bool a_eql_0(float xf0, float xtolerance)
  {
    return std::abs(xf0) <= xtolerance;
  };
  
  SHEAF_DLL_SPEC inline bool a_eql_1(float xf0)
  {
    return std::abs(xf0 - 1.0f) <= float_tolerance;
  };
  
  SHEAF_DLL_SPEC inline bool a_eql_1(float xf0, float xtolerance)
  {
    return std::abs(xf0 - 1.0f) <= xtolerance;
  };
  
  SHEAF_DLL_SPEC inline bool a_eql(float xf0, float xf1)
  {
    return std::abs(xf0 - xf1) <= float_tolerance;
  };
  
  SHEAF_DLL_SPEC inline bool a_eql(float xf0, float xf1, float xtolerance)
  {
    return std::abs(xf0 - xf1) <= xtolerance;
  };

  SHEAF_DLL_SPEC inline bool r_eql(float xf0, float xf1)
  {
    return std::abs(xf0 - xf1) <= float_tolerance*(std::abs(xf0) + std::abs(xf1));
  };
  
  SHEAF_DLL_SPEC inline bool r_eql(float xf0, float xf1, float xtolerance)
  {
    return std::abs(xf0 - xf1) <= xtolerance*(std::abs(xf0) + std::abs(xf1));
  };
  
  SHEAF_DLL_SPEC inline bool c_eql(float xf0, float xf1)
  {
    return std::abs(xf0 - xf1) <= float_tolerance*(std::abs(xf0) + std::abs(xf1) + 1.0f);
  };
  
  SHEAF_DLL_SPEC inline bool c_eql(float xf0, float xf1, float xtolerance)
  {
    return std::abs(xf0 - xf1) <= xtolerance*(std::abs(xf0) + std::abs(xf1) + 1.0f);
  };
  

  // ===========================================================
  // DOUBLE EQUALITY COMPARISION
  // ===========================================================

  const double double_tolerance = sqrt(std::numeric_limits<double>::epsilon());
  
  SHEAF_DLL_SPEC inline bool a_eql_0(double xd0)
  {
    return std::abs(xd0) <= double_tolerance;
  };
  
  SHEAF_DLL_SPEC inline bool a_eql_0(double xd0, double xtolerance)
  {
    return std::abs(xd0) <= xtolerance;
  };
  
  SHEAF_DLL_SPEC inline bool a_eql_1(double xd0)
  {
    return std::abs(xd0 - 1.0) <= double_tolerance;
  };
  
  SHEAF_DLL_SPEC inline bool a_eql_1(double xd0, double xtolerance)
  {
    return std::abs(xd0 - 1.0) <= xtolerance;
  };
  
  SHEAF_DLL_SPEC inline bool a_eql(double xd0, double xd1)
  {
    return std::abs(xd0 - xd1) <= double_tolerance;
  };
  
  SHEAF_DLL_SPEC inline bool a_eql(double xd0, double xd1, double xtolerance)
  {
    return std::abs(xd0 - xd1) <= xtolerance;
  };

  SHEAF_DLL_SPEC inline bool r_eql(double xd0, double xd1)
  {
    return std::abs(xd0 - xd1) <= double_tolerance*(std::abs(xd0) + std::abs(xd1));
  };
  
  SHEAF_DLL_SPEC inline bool r_eql(double xd0, double xd1, double xtolerance)
  {
    return std::abs(xd0 - xd1) <= xtolerance*(std::abs(xd0) + std::abs(xd1));
  };
  
  SHEAF_DLL_SPEC inline bool c_eql(double xd0, double xd1)
  {
    return std::abs(xd0 - xd1) <= double_tolerance*(std::abs(xd0) + std::abs(xd1) + 1.0);
  };
  
  SHEAF_DLL_SPEC inline bool c_eql(double xd0, double xd1, double xtolerance)
  {
    return std::abs(xd0 - xd1) <= xtolerance*(std::abs(xd0) + std::abs(xd1) + 1.0);
  };
  

  // ===========================================================
  // DOUBLE LESS THAN OR EQUAL COMPARISION
  // ===========================================================
  
  SHEAF_DLL_SPEC inline bool c_lte(double xd0, double xd1)
  {
    return xd0 <= (xd1 + double_tolerance*(std::abs(xd0) + std::abs(xd1) + 1.0));
  };
  
  SHEAF_DLL_SPEC inline bool c_lte(double xd0, double xd1, double xtolerance)
  {
    return xd0 <= (xd1 + xtolerance*(std::abs(xd0) + std::abs(xd1) + 1.0));
  };
  

  // ===========================================================
  // DOUBLE LESS THAN COMPARISION
  // ===========================================================
  
  SHEAF_DLL_SPEC inline bool c_lt(double xd0, double xd1)
  {
    return xd0 < (xd1 - double_tolerance*(std::abs(xd0) + std::abs(xd1) + 1.0));
  };
  
  SHEAF_DLL_SPEC inline bool c_lt(double xd0, double xd1, double xtolerance)
  {
    return xd0 < (xd1 - xtolerance*(std::abs(xd0) + std::abs(xd1) + 1.0));
  };
  

  // ===========================================================
  // DOUBLE GREATER THAN OR EQUAL COMPARISION
  // ===========================================================
  
  SHEAF_DLL_SPEC inline bool c_gte(double xd0, double xd1)
  {
    return xd0 >= (xd1 - double_tolerance*(std::abs(xd0) + std::abs(xd1) + 1.0));
  };
  
  SHEAF_DLL_SPEC inline bool c_gte(double xd0, double xd1, double xtolerance)
  {
    return xd0 >= (xd1 - xtolerance*(std::abs(xd0) + std::abs(xd1) + 1.0));
  };
  

  // ===========================================================
  // DOUBLE GREATER THAN COMPARISION
  // ===========================================================
  
  SHEAF_DLL_SPEC inline bool c_gt(double xd0, double xd1)
  {
    return xd0 > (xd1 + double_tolerance*(std::abs(xd0) + std::abs(xd1) + 1.0));
  };
  
  SHEAF_DLL_SPEC inline bool c_gt(double xd0, double xd1, double xtolerance)
  {
    return xd0 > (xd1 + xtolerance*(std::abs(xd0) + std::abs(xd1) + 1.0));
  };
  

  
  
} // end namespace sheaf

#endif // ifndef TOLERANCE_COMPARISON_H