double_plus.h

Go to the documentation of this file.

#ifndef DOUBLE_PLUS_CLASS
#define DOUBLE_PLUS_CLASS
 
/*****************************************************************************\
*                                                                             *
*  Name   : double_plus (an extension for double floating point numbers)      *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1993-$now By Author.  This program 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 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/
 
#include "math_ops.h"
 
#include <basis/contracts.h>
#include <basis/enhance_cpp.h>
#include <basis/functions.h>
 
#include <stdio.h>//temp
 
 
namespace mathematics {
 
class double_plus : public basis::orderable
{
public:
  #define DEFAULT_DELTA 0.0001
  double_plus(double init = 0.0, double delta = DEFAULT_DELTA) : c_value(init), c_delta(delta) {}
 
  double_plus(const double_plus &to_copy) : c_value(to_copy.c_value), c_delta(to_copy.c_delta) {}
 
  virtual ~double_plus() {}
 
  DEFINE_CLASS_NAME("double_plus");
 
  double_plus &operator = (const double_plus &cp)
      { c_value = cp.c_value; c_delta = cp.c_delta; return *this; }
 
  double value() const { return truncate(); }
  operator double () const { return truncate(); }
 
  double delta() const { return c_delta; }
  void delta(double new_delta) { c_delta = new_delta; }
 
  double truncate() const { return math_ops::round_it(c_value / c_delta) * c_delta; }
 
  virtual bool equal_to(const basis::equalizable &f2) const {
     const double_plus *cast = dynamic_cast<const double_plus *>(&f2);
     if (!cast) return false;
     return this->d_eq(*cast);
  }
 
  virtual bool less_than(const basis::orderable &f2) const
  {
     const double_plus *cast = dynamic_cast<const double_plus *>(&f2);
     if (!cast) return false;
     return !this->d_eq(*cast) && (c_value < cast->c_value);
  }
 
private:
  double c_value;  
  double c_delta;  
 
  bool d_eq(const double_plus &to_compare) const {
    double diff = basis::absolute_value(c_value - to_compare.value());
    return diff < basis::absolute_value(c_delta); 
  }
};
 
} //namespace.
 
#endif