scale.h

Go to the documentation of this file.

#pragma once
#ifndef SYDEVS_SCALE_H_
#define SYDEVS_SCALE_H_

#include <sydevs/core/number_types.h>
#include <iosfwd>

namespace sydevs {


class scale
{
public:
    using level_type = int8;  

    constexpr scale();

    explicit constexpr scale(int64 level);

    constexpr scale(const scale&)  = default;  
    scale& operator=(const scale&) = default;  
    scale(scale&&)                 = default;  
    scale& operator=(scale&&)      = default;  
    ~scale()                       = default;  

    constexpr int64 level() const;     
    constexpr float64 approx() const;  

    scale& operator++();           
    scale  operator++(int);        
    scale& operator--();           
    scale  operator--(int);        
    scale& operator+=(int64 rhs);  
    scale& operator-=(int64 rhs);  

    constexpr const scale operator+() const;  
    constexpr const scale operator-() const;  

    constexpr const scale operator+(int64 rhs) const;  
    constexpr const scale operator-(int64 rhs) const;  
    constexpr int64 operator-(scale rhs) const;        
    constexpr float64 operator/(scale rhs) const;      

    constexpr bool operator==(scale rhs) const;  
    constexpr bool operator!=(scale rhs) const;  
    constexpr bool operator< (scale rhs) const;  
    constexpr bool operator> (scale rhs) const;  
    constexpr bool operator<=(scale rhs) const;  
    constexpr bool operator>=(scale rhs) const;  

    char symbol() const;

private:
    level_type level_;

};


constexpr scale::scale()
    : level_(0)
{
}


constexpr scale::scale(int64 level)
    : level_(level_type(level))
{
}

    
constexpr scale no_scale = scale(std::numeric_limits<scale::level_type>::max());

constexpr scale yocto = scale(-8);
constexpr scale zepto = scale(-7);
constexpr scale atto  = scale(-6);
constexpr scale femto = scale(-5);
constexpr scale pico  = scale(-4);
constexpr scale nano  = scale(-3);
constexpr scale micro = scale(-2);
constexpr scale milli = scale(-1);
constexpr scale unit  = scale(0);
constexpr scale kilo  = scale(1);
constexpr scale mega  = scale(2);
constexpr scale giga  = scale(3);
constexpr scale tera  = scale(4);
constexpr scale peta  = scale(5);
constexpr scale exa   = scale(6);
constexpr scale zetta = scale(7);
constexpr scale yotta = scale(8);


constexpr int64 scale::level() const
{
    return level_;
}


constexpr float64 scale::approx() const
{ 
    return level_ == 0 ? 1.0 : 
           level_ < 0  ? 0.001*scale(level_ + 1).approx() : 
                         1000.0*scale(level_ - 1).approx();
}


constexpr const scale scale::operator+() const
{
    return scale(level_);
}


constexpr const scale scale::operator-() const
{
    return scale(-level_);
}


constexpr const scale scale::operator+(int64 rhs) const
{
    return scale(level_ + rhs);
}


constexpr const scale scale::operator-(int64 rhs) const
{
    return scale(level_ - rhs);
}


constexpr int64 scale::operator-(scale rhs) const
{
    return level_ - rhs.level_;
}


constexpr float64 scale::operator/(scale rhs) const
{ 
    return level_ == rhs.level_ ? 1.0 : 
           level_ < rhs.level_  ? 0.001*(scale(level_ + 1)/rhs) : 
                                  1000.0*(scale(level_ - 1)/rhs);
}


constexpr bool scale::operator==(scale rhs) const
{
    return level_ == rhs.level_;
}


constexpr bool scale::operator!=(scale rhs) const
{
    return level_ != rhs.level_;
}


constexpr bool scale::operator<(scale rhs) const
{
    return level_ < rhs.level_;
}


constexpr bool scale::operator>(scale rhs) const
{
    return level_ > rhs.level_;
}


constexpr bool scale::operator<=(scale rhs) const
{
    return level_ <= rhs.level_;
}


constexpr bool scale::operator>=(scale rhs) const
{
    return level_ >= rhs.level_;
}


constexpr const scale operator+(int64 lhs, scale rhs)
{
    return rhs + lhs;
}


std::ostream& operator<<(std::ostream& os, const scale& rhs);
  

}  // namespace

#endif