length.cc

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2019 Lawrence Livermore National Laboratory
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Mathew Bielejeski <bielejeski1@llnl.gov>
 */

#include "length.h"

#include "ns3/log.h"

#include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <functional>
#include <limits>
#include <map>
#include <ratio>
#include <sstream>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <vector>

namespace {
template<class R>
double ScaleValue (double value)
{
  return (value * R::num) / static_cast<double> (R::den);
}

double FootToMeter (double value)
{
  return value * 0.3048;
}

double MeterToFoot (double value)
{
  return value * 3.28084;
}

template<class R>
double USToMeter (double value)
{
  return FootToMeter ( ScaleValue<R> (value) );
}

template<class R>
double MeterToUS (double value)
{
  return ScaleValue<R> ( MeterToFoot (value) );
}

double Convert (double value, ns3::Length::Unit fromUnit, ns3::Length::Unit toUnit)
{
  using Unit = ns3::Length::Unit;
  using Key = std::pair<Unit, Unit>;
  using Conversion = std::function<double (double)>;

  struct KeyHash
  {
    std::size_t operator () (const Key& key) const noexcept
    {
      static_assert (sizeof(Unit) < sizeof(std::size_t),
                     "sizeof(Length::Unit) changed, it must be less than "
                     "sizeof(std::size_t)");

      int shift = sizeof(Unit) * 8;
      return static_cast<std::size_t> (key.first) << shift |
             static_cast<std::size_t> (key.second);
    }

  };

  using ConversionTable = std::unordered_map<Key, Conversion, KeyHash>;

  static ConversionTable CONVERSIONS {
    { {Unit::Nanometer, Unit::Meter}, ScaleValue<std::nano> },
    { {Unit::Meter, Unit::Nanometer}, ScaleValue<std::giga> },
    { {Unit::Micrometer, Unit::Meter}, ScaleValue<std::micro> },
    { {Unit::Meter, Unit::Micrometer}, ScaleValue<std::mega> },
    { {Unit::Millimeter, Unit::Meter}, ScaleValue<std::milli> },
    { {Unit::Meter, Unit::Millimeter}, ScaleValue<std::kilo> },
    { {Unit::Centimeter, Unit::Meter}, ScaleValue<std::centi> },
    { {Unit::Meter, Unit::Centimeter}, ScaleValue<std::hecto> },
    { {Unit::Meter, Unit::Meter}, ScaleValue<std::ratio<1,1> > },
    { {Unit::Kilometer, Unit::Meter}, ScaleValue<std::kilo> },
    { {Unit::Meter, Unit::Kilometer}, ScaleValue<std::milli> },
    { {Unit::NauticalMile, Unit::Meter}, ScaleValue<std::ratio<1852, 1> > },
    { {Unit::Meter, Unit::NauticalMile}, ScaleValue<std::ratio<1, 1852> > },
    { {Unit::Inch, Unit::Meter}, USToMeter<std::ratio<1, 12> > },
    { {Unit::Meter, Unit::Inch}, MeterToUS<std::ratio<12, 1> > },
    { {Unit::Foot, Unit::Meter}, FootToMeter },
    { {Unit::Meter, Unit::Foot}, MeterToFoot },
    { {Unit::Yard, Unit::Meter}, USToMeter<std::ratio<3, 1> > },
    { {Unit::Meter, Unit::Yard}, MeterToUS<std::ratio<1, 3> > },
    { {Unit::Mile, Unit::Meter}, USToMeter<std::ratio<5280, 1> > },
    { {Unit::Meter, Unit::Mile}, MeterToUS<std::ratio<1, 5280> > }
  };

  auto iter = CONVERSIONS.find ( Key {fromUnit, toUnit} );

  if (iter == CONVERSIONS.end ())
    {
      NS_FATAL_ERROR ("No conversion defined for " << fromUnit
                                                   << " -> " << toUnit);
    }

  return iter->second (value);
}

double Convert (const ns3::Length::Quantity& from, ns3::Length::Unit toUnit)
{
  return Convert (from.Value (), from.Unit (), toUnit);
}

class EnumHash
{
public:
  std::size_t operator () (ns3::Length::Unit u) const noexcept
  {
    return static_cast<std::size_t> (u);
  }
};

}   // unnamed namespace

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("Length");

// Implement the attribute helper
ATTRIBUTE_HELPER_CPP (Length);

std::tuple<bool, Length>
Length::TryParse (double value, const std::string& unitString)
{
  NS_LOG_FUNCTION (value << unitString);

  bool validUnit = false;
  Length::Unit unit;

  std::tie (validUnit, unit) = FromString (unitString);

  Length length;

  if (validUnit)
    {
      length = Length (value, unit);
    }

  return std::make_tuple (validUnit, length);
}

Length::Length ()
  :   m_value (0)
{
  NS_LOG_FUNCTION (this);
}

Length::Length (const std::string& input)
  :   m_value (0)
{
  NS_LOG_FUNCTION (this << input);

  std::istringstream stream (input);

  stream >> *this;
}

Length::Length (double value, const std::string& unitString)
  :   m_value (0)
{
  NS_LOG_FUNCTION (this << value << unitString);

  bool validUnit;
  Length::Unit unit;

  std::tie (validUnit, unit) = FromString (unitString);

  if (!validUnit)
    {
      NS_FATAL_ERROR ("A Length object could not be constructed from the unit "
                      "string '" << unitString << "', because the string is not associated "
                      "with a Length::Unit entry");
    }

  m_value = Convert (value, unit, Length::Unit::Meter);
}

Length::Length (double value, Length::Unit unit)
  :   m_value (0)
{
  NS_LOG_FUNCTION (this << value << unit);

  m_value = Convert (value, unit, Length::Unit::Meter);
}

Length::Length (Quantity quantity)
  : Length (quantity.Value (), quantity.Unit ())
{
  NS_LOG_FUNCTION (this << quantity);
}

Length&
Length::operator= (const Length::Quantity& q)
{
  NS_LOG_FUNCTION (this << q);

  m_value = Convert (q, Length::Unit::Meter);

  return *this;
}

bool
Length::IsEqual (const Length& other, double tolerance /*=DEFAULT_TOLERANCE*/) const
{
  NS_LOG_FUNCTION (this << m_value << other.m_value << tolerance);

  if ( m_value == other.m_value )
    {
      return true;
    }

  auto diff = std::abs (m_value - other.m_value);

  return diff <= tolerance;
}

bool
Length::IsNotEqual (const Length& other, double tolerance /*=DEFAULT_TOLERANCE*/) const
{
  NS_LOG_FUNCTION (this << m_value << other.m_value << tolerance);

  return !IsEqual (other, tolerance);
}

bool
Length::IsLess (const Length& other, double tolerance /*=DEFAULT_TOLERANCE*/) const
{
  NS_LOG_FUNCTION (this << m_value << other.m_value << tolerance);

  return m_value < other.m_value && IsNotEqual (other, tolerance);
}

bool
Length::IsLessOrEqual (const Length& other, double tolerance /*=DEFAULT_TOLERANCE*/) const
{
  NS_LOG_FUNCTION (this << m_value << other.m_value << tolerance);

  return m_value < other.m_value || IsEqual (other, tolerance);
}

bool
Length::IsGreater (const Length& other, double tolerance /*=DEFAULT_TOLERANCE*/) const
{
  NS_LOG_FUNCTION (this << m_value << other.m_value << tolerance);

  return !IsLessOrEqual (other, tolerance);
}

bool
Length::IsGreaterOrEqual (const Length& other, double tolerance /*=DEFAULT_TOLERANCE*/) const
{
  NS_LOG_FUNCTION (this << m_value << other.m_value << tolerance);

  return !IsLess (other, tolerance);
}

void
Length::swap (Length& other)
{
  using std::swap;

  swap (m_value, other.m_value);
}

double
Length::GetDouble () const
{
  return m_value;
}

Length::Quantity
Length::As (Length::Unit unit) const
{
  NS_LOG_FUNCTION (this << unit);

  double value = Convert (m_value, Length::Unit::Meter, unit);

  return Quantity (value, unit);
}

//silence doxygen warnings about undocumented functions
bool
operator== (const Length& left, const Length& right)
{
  return left.GetDouble () == right.GetDouble ();
}

bool
operator!= (const Length& left, const Length& right)
{
  return left.GetDouble () != right.GetDouble ();
}

bool
operator< (const Length& left, const Length& right)
{
  return left.GetDouble () < right.GetDouble ();
}

bool
operator<= (const Length& left, const Length& right)
{
  return left.GetDouble () <= right.GetDouble ();
}

bool
operator> (const Length& left, const Length& right)
{
  return left.GetDouble () > right.GetDouble ();
}

bool
operator>= (const Length& left, const Length& right)
{
  return left.GetDouble () >= right.GetDouble ();
}

Length
operator+ (const Length& left, const Length& right)
{
  double value = left.GetDouble () + right.GetDouble ();
  return Length ( value, Length::Unit::Meter );
}

Length
operator- (const Length& left, const Length& right)
{
  double value = left.GetDouble () - right.GetDouble ();
  return Length ( value, Length::Unit::Meter );
}

Length
operator* (const Length& left, double scalar)
{
  double value = left.GetDouble () * scalar;
  return Length ( value, Length::Unit::Meter );
}

Length
operator* (double scalar, const Length & right)
{
  return right * scalar;
}

Length
operator/ (const Length & left, double scalar)
{
  if (scalar == 0)
    {
      NS_FATAL_ERROR ("Attempted to divide Length by 0");
    }

  return left * (1.0 / scalar);
}

double
operator/ (const Length & numerator, const Length& denominator)
{
  if (denominator.GetDouble () == 0)
    {
      return std::numeric_limits<double>::quiet_NaN ();
    }

  return numerator.GetDouble () / denominator.GetDouble ();
}

int64_t
Div (const Length& numerator, const Length& denominator, Length* remainder)
{
  double value = numerator / denominator;

  if (std::isnan (value))
    {
      NS_FATAL_ERROR ("numerator / denominator return NaN");
    }

  if ( remainder )
    {
      double rem = std::fmod (numerator.GetDouble (), denominator.GetDouble ());
      *remainder = Length (rem, Length::Unit::Meter);
    }

  return static_cast<int64_t> (std::trunc (value));
}

Length
Mod (const Length& numerator, const Length& denominator)
{
  double rem = std::fmod (numerator.GetDouble (), denominator.GetDouble ());

  if (std::isnan (rem))
    {
      NS_FATAL_ERROR ("numerator / denominator return NaN");
    }

  return Length (rem, Length::Unit::Meter);
}

std::string
ToSymbol (Length::Unit unit)
{
  using StringTable = std::unordered_map<Length::Unit, std::string, EnumHash>;

  static const StringTable STRINGS {
    {Length::Unit::Nanometer, "nm"},
    {Length::Unit::Micrometer, "um"},
    {Length::Unit::Millimeter, "mm"},
    {Length::Unit::Centimeter, "cm"},
    {Length::Unit::Meter, "m"},
    {Length::Unit::Kilometer, "km"},
    {Length::Unit::NauticalMile, "nmi"},
    {Length::Unit::Inch, "in"},
    {Length::Unit::Foot, "ft"},
    {Length::Unit::Yard, "yd"},
    {Length::Unit::Mile, "mi"}
  };

  auto iter = STRINGS.find (unit);

  if (iter == STRINGS.end ())
    {
      NS_FATAL_ERROR ("A symbol could not be found for Length::Unit with value "
                      << EnumHash ()(unit));
    }

  return iter->second;
}

std::string
ToName (Length::Unit unit, bool plural /*=false*/)
{
  using Entry = std::tuple<std::string, std::string>;
  using StringTable = std::unordered_map<Length::Unit, Entry, EnumHash>;

  static const StringTable STRINGS {
    {Length::Unit::Nanometer,    Entry{"nanometer", "nanometers"}},
    {Length::Unit::Micrometer,   Entry{"micrometer", "micrometer"}},
    {Length::Unit::Millimeter,   Entry{"millimeter", "millimeters"}},
    {Length::Unit::Centimeter,   Entry{"centimeter", "centimeters"}},
    {Length::Unit::Meter,        Entry{"meter", "meters"}},
    {Length::Unit::Kilometer,    Entry{"kilometer", "kilometers"}},
    {Length::Unit::NauticalMile, Entry{"nautical mile", "nautical miles"}},
    {Length::Unit::Inch,         Entry{"inch", "inches"}},
    {Length::Unit::Foot,         Entry{"foot", "feet"}},
    {Length::Unit::Yard,         Entry{"yard", "yards"}},
    {Length::Unit::Mile,         Entry{"mile", "miles"}}
  };

  auto iter = STRINGS.find (unit);

  if (iter == STRINGS.end ())
    {
      NS_FATAL_ERROR ("A symbol could not be found for Length::Unit with value "
                      << EnumHash ()(unit));
    }

  if (plural)
    {
      return std::get<1> (iter->second);
    }

  return std::get<0> (iter->second);
}

std::tuple<bool, Length::Unit>
FromString (std::string unitString)
{
  using UnitTable = std::unordered_map<std::string, Length::Unit>;

  static const UnitTable UNITS {
    { "nm", Length::Unit::Nanometer },
    { "nanometer", Length::Unit::Nanometer },
    { "nanometers", Length::Unit::Nanometer },
    { "nanometre", Length::Unit::Nanometer },
    { "nanometres", Length::Unit::Nanometer },
    { "um", Length::Unit::Micrometer },
    { "micrometer", Length::Unit::Micrometer },
    { "micrometers", Length::Unit::Micrometer },
    { "micrometre", Length::Unit::Micrometer },
    { "micrometres", Length::Unit::Micrometer },
    { "mm", Length::Unit::Millimeter },
    { "millimeter", Length::Unit::Millimeter },
    { "millimeters", Length::Unit::Millimeter },
    { "millimetre", Length::Unit::Millimeter },
    { "millimetres", Length::Unit::Millimeter },
    { "cm", Length::Unit::Centimeter },
    { "centimeter", Length::Unit::Centimeter },
    { "centimeters", Length::Unit::Centimeter },
    { "centimetre", Length::Unit::Centimeter },
    { "centimetres", Length::Unit::Centimeter },
    { "m", Length::Unit::Meter },
    { "meter", Length::Unit::Meter },
    { "metre", Length::Unit::Meter },
    { "meters", Length::Unit::Meter },
    { "metres", Length::Unit::Meter },
    { "km", Length::Unit::Kilometer },
    { "kilometer", Length::Unit::Kilometer },
    { "kilometers", Length::Unit::Kilometer },
    { "kilometre", Length::Unit::Kilometer },
    { "kilometres", Length::Unit::Kilometer },
    { "nmi", Length::Unit::NauticalMile },
    { "nauticalmile", Length::Unit::NauticalMile },
    { "nauticalmiles", Length::Unit::NauticalMile },
    { "in", Length::Unit::Inch },
    { "inch", Length::Unit::Inch },
    { "inches", Length::Unit::Inch },
    { "ft", Length::Unit::Foot },
    { "foot", Length::Unit::Foot },
    { "feet", Length::Unit::Foot },
    { "yd", Length::Unit::Yard },
    { "yard", Length::Unit::Yard },
    { "yards", Length::Unit::Yard },
    { "mi", Length::Unit::Mile },
    { "mile", Length::Unit::Mile },
    { "miles", Length::Unit::Mile }
  };

  //function to trim whitespace and convert to lowercase in one pass
  static auto Normalize = [] (const std::string& str)
    {
      std::string output;
      output.reserve (str.size ());

      for (unsigned char c : str)
        {
          //this strips all spaces not just beg/end but is fine for our purposes
          if (std::isspace (c) )
            {
              continue;
            }

          output.push_back (std::tolower (c));
        }

      return output;
    };

  unitString = Normalize (unitString);

  auto iter = UNITS.find (unitString);

  bool valid = false;
  Length::Unit unit;

  if (iter != UNITS.end ())
    {
      valid = true;
      unit = iter->second;
    }

  return std::make_tuple (valid, unit);
}

std::ostream&
operator<< (std::ostream& stream, const Length& l)
{
  stream << l.As (Length::Unit::Meter);

  return stream;
}

std::ostream&
operator<< (std::ostream& stream, const Length::Quantity& q)
{
  stream << q.Value () << ' ' << ToSymbol (q.Unit ());

  return stream;
}

std::ostream&
operator<< (std::ostream& stream, Length::Unit unit)
{
  stream << ToName (unit);

  return stream;
}

std::tuple<bool, double, std::string>
ParseLengthString (const std::string& input)
{
    NS_LOG_FUNCTION (input);

    double value = 0;
    std::size_t pos = 0;
    std::string symbol;

    try
    {
        value = std::stod(input, &pos);
    }
    catch (const std::exception& e)
    {
        NS_LOG_ERROR ("Caught exception while parsing double: " << e.what());

        return std::make_tuple(false, 0, "");
    }

    //skip any whitespace between value and symbol
    while (pos < input.size () && std::isspace(input[pos]))
        ++pos;

    if (pos < input.size ())
    {
        NS_LOG_LOGIC ("String has value and symbol, extracting symbol");

        //input has a double followed by a string
        symbol = input.substr(pos);
    }

    return std::make_tuple(true, value, symbol);
}

std::istream&
operator>> (std::istream& stream, Length& l)
{
  bool success = false;
  double value = 0;
  std::string symbol;
  std::string temp;

  //configure stream to skip whitespace in case it was disabled
  auto origFlags = stream.flags ();
  std::skipws (stream);

  //Read the contents into a temporary string and parse it manually
  stream >> temp;

  std::tie(success, value, symbol) = ParseLengthString (temp);

  if (success && symbol.empty ())
  {
      NS_LOG_LOGIC ("Temp string only contained value, extracting unit symbol from stream");

      //temp only contained the double
      //still need to read the symbol from the stream
      stream >> symbol;
  }

  //special handling for nautical mile which is two words
  if (symbol == "nautical")
    {
      stream >> temp;

      if (!temp.empty ())
        {
          symbol.push_back (' ');
          symbol.append (temp);
        }
    }

  Length (value, symbol).swap (l);

  //restore original flags
  stream.flags (origFlags);

  return stream;
}

Length
NanoMeters (double value)
{
  return Length (value, Length::Unit::Nanometer);
}

Length
MicroMeters (double value)
{
  return Length (value, Length::Unit::Micrometer);
}

Length
MilliMeters (double value)
{
  return Length (value, Length::Unit::Millimeter);
}

Length
CentiMeters (double value)
{
  return Length (value, Length::Unit::Centimeter);
}

Length
Meters (double value)
{
  return Length (value, Length::Unit::Meter);
}

Length
KiloMeters (double value)
{
  return Length (value, Length::Unit::Kilometer);
}

Length
NauticalMiles (double value)
{
  return Length (value, Length::Unit::NauticalMile);
}

Length
Inches (double value)
{
  return Length (value, Length::Unit::Inch);
}

Length
Feet (double value)
{
  return Length (value, Length::Unit::Foot);
}

Length
Yards (double value)
{
  return Length (value, Length::Unit::Yard);
}

Length
Miles (double value)
{
  return Length (value, Length::Unit::Mile);
}

}   // namespace ns3