ls-standard-library/source/ls-std/boxing/Double.cppm

export module ls.std.boxing.double;

/*
 * Author:          Patrick-Christopher Mattulat
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2020-08-14
 * Changed:         2025-12-25
 *
 * */

#include <cmath>
#include <ls-std/core/Class.hpp>
#include <ls-std/core/interface/IBoxing.hpp>
#include <ls-std/core/exception/IllegalArgumentException.hpp>
#include <ls-std/os/dynamic-goal.hpp>

/*
 * @doc: class(name: 'Double', package: 'boxing')
 * @doc: boxing.Double.description('This class represents the primitive datatype double and provides functionalities for arithmetic operations, accuracy and string representation.')
 * */

using ls::std::core::Class;
using ls::std::core::IllegalArgumentException;
using ls::std::core::interface_type::IBoxing;
using std::fabs;
using std::stod;
using std::string;
using std::to_string;

export namespace ls::std::boxing
{
  class LS_STD_DYNAMIC_GOAL Double : public Class, public IBoxing
  {
    public:

      Double() : Class(_fetchClassName())
      {
        this->_assignEpsilon(0.00000001);
      }

      explicit Double(const double _value) : Class(_fetchClassName()), value(_value)
      {
        this->_assignEpsilon(0.00000001);
      }

      ~Double() noexcept override = default;

      Double &operator=(const double _value)
      {
        this->value = _value;
        return *this;
      }

      double operator-() const
      {
        return -this->value;
      }

      double operator+(const Double &_double) const
      {
        return this->value + _double.getValue();
      }

      double operator+(const double _value) const
      {
        return this->value + _value;
      }

      double operator*(const Double &_double) const
      {
        return this->value * _double.getValue();
      }

      double operator*(const double _value) const
      {
        return this->value * _value;
      }

      double operator-(const Double &_double) const
      {
        return this->value - _double.getValue();
      }

      double operator-(const double _value) const
      {
        return this->value - _value;
      }

      double operator/(const Double &_double) const
      {
        return this->value / _double.getValue();
      }

      double operator/(const double _value) const
      {
        return this->value / _value;
      }

      Double &operator+=(const Double &_double)
      {
        this->value += _double.getValue();
        return *this;
      }

      Double &operator+=(const double _value)
      {
        this->value += _value;
        return *this;
      }

      Double &operator-=(const Double &_double)
      {
        this->value -= _double.getValue();
        return *this;
      }

      Double &operator-=(const double _value)
      {
        this->value -= _value;
        return *this;
      }

      Double &operator*=(const Double &_double)
      {
        this->value *= _double.getValue();
        return *this;
      }

      Double &operator*=(const double _value)
      {
        this->value *= _value;
        return *this;
      }

      Double &operator/=(const Double &_double)
      {
        this->value /= _double.getValue();
        return *this;
      }

      Double &operator/=(const double _value)
      {
        this->value /= _value;
        return *this;
      }

      bool operator==(const Double &_double) const
      {
        return fabs(this->value - _double.getValue()) < this->epsilon;
      }

      bool operator==(const double _value) const
      {
        return fabs(this->value - _value) < this->epsilon;
      }

      bool operator!=(const Double &_double) const
      {
        return fabs(this->value - _double.getValue()) >= this->epsilon;
      }

      bool operator!=(const double _value) const
      {
        return fabs(this->value - _value) >= this->epsilon;
      }

      bool operator>(const Double &_double) const
      {
        return this->value > _double.getValue();
      }

      bool operator>(const double _value) const
      {
        return this->value > _value;
      }

      bool operator>=(const Double &_double) const
      {
        return this->value >= _double.getValue();
      }

      bool operator>=(const double _value) const
      {
        return this->value >= _value;
      }

      bool operator<(const Double &_double) const
      {
        return this->value < _double.getValue();
      }

      bool operator<(const double _value) const
      {
        return this->value < _value;
      }

      bool operator<=(const Double &_double) const
      {
        return this->value <= _double.getValue();
      }

      bool operator<=(const double _value) const
      {
        return this->value <= _value;
      }

      void operator++()
      {
        this->value += 1.0;
      }

      void operator--()
      {
        this->value -= 1.0;
      }

      void parse(const string &_parseText) override
      {
        this->value = stod(_parseText);
      }

      [[nodiscard]] string toString() override
      {
        return to_string(this->value);
      }

      [[nodiscard]] double getEpsilon() const
      {
        return this->epsilon;
      }

      [[nodiscard]] double getValue() const
      {
        return this->value;
      }

      void setEpsilon(const double _epsilon)
      {
        this->_assignEpsilon(_epsilon);
      }

    private:

      double epsilon{};
      double value{};

      void _assignEpsilon(const double _epsilon)
      {
        if (_epsilon <= 0.0)
        {
          throw IllegalArgumentException{"_epsilon is less than or equal zero"};
        }

        this->epsilon = _epsilon;
      }

      [[nodiscard]] static string _fetchClassName()
      {
        static const string className = "Double";
        return className;
      }
  };
}