approx.h

// -*-c++-*-
#ifndef STORMM_APPROX_H
#define STORMM_APPROX_H
 
#include <cmath>
#include <string>
#include <vector>
#include "copyright.h"
#include "Constants/scaling.h"
#include "DataTypes/common_types.h"
#include "DataTypes/stormm_vector_types.h"
#include "Reporting/error_format.h"
#include "unit_test_enumerators.h"
 
namespace stormm {
namespace testing {
 
using data_types::isScalarType;

class Approx {
public:

  template <typename T> Approx(const std::vector<T> &values_in,
                               ComparisonType style_in = ComparisonType::ABSOLUTE,
                               double tol_in = 1.0e-6);

  Approx(double value_in, ComparisonType style_in = ComparisonType::ABSOLUTE,
         double tol_in = 1.0e-6);
  Approx(double value_in, double tol_in, ComparisonType style_in = ComparisonType::ABSOLUTE);

  ~Approx() = default;

  int size() const;

  double getValue() const;

  std::vector<double> getValues() const;

  ComparisonType getStyle() const;

  double getMargin() const;
  double getTolerance() const;
  double getTol() const;

  void setValue(double value_in);
  void setValues(const std::vector<double> &values_in);
  void setValue(double value_in, size_t index);

  void setMargin(double dtol_in);
  void setTolerance(double dtol_in);
  void setTol(double dtol_in);

  Approx margin(double dtol_in) const;
  Approx tolerance(double dtol_in) const;
  Approx tol(double dtol_in) const;

  bool test(const double test_value) const;

  template <typename T> bool test(const std::vector<T> &test_values) const;
 
private:
  std::vector<double> values;  
  ComparisonType style;        
  double dtol;                 
};

template <typename T> bool verifyVectorApproxCompatibility(const std::vector<T> &test_values,
                                                           const Approx &cr);

bool operator==(const double d, const Approx &cr);
bool operator==(const Approx &cr, const double d);
bool operator!=(const double d, const Approx &cr);
bool operator!=(const Approx &cr, const double d);
bool operator>(const double d, const Approx &cr);
bool operator>(const Approx &cr, const double d);
bool operator<(const double d, const Approx &cr);
bool operator<(const Approx &cr, const double d);
bool operator>=(const double d, const Approx &cr);
bool operator>=(const Approx &cr, const double d);
bool operator<=(const double d, const Approx &cr);
bool operator<=(const Approx &cr, const double d);

template <typename T> bool operator==(const std::vector<T> &tvec, const Approx &cr);
template <typename T> bool operator==(const Approx &cr, const std::vector<T> &tvec);
template <typename T> bool operator!=(const std::vector<T> &tvec, const Approx &cr);
template <typename T> bool operator!=(const Approx &cr, const std::vector<T> &tvec);
template <typename T> bool operator>(const std::vector<T> &tvec, const Approx &cr);
template <typename T> bool operator>(const Approx &cr, const std::vector<T> &tvec);
template <typename T> bool operator<(const std::vector<T> &tvec, const Approx &cr);
template <typename T> bool operator<(const Approx &cr, const std::vector<T> &tvec);
template <typename T> bool operator>=(const std::vector<T> &tvec, const Approx &cr);
template <typename T> bool operator>=(const Approx &cr, const std::vector<T> &tvec);
template <typename T> bool operator<=(const std::vector<T> &tvec, const Approx &cr);
template <typename T> bool operator<=(const Approx &cr, const std::vector<T> &tvec);
 
 
} // namespace testing
} // namespace stormm
 
#include "approx.tpp"
 
#endif