Different results using std::exp() and units::math::exp().

[nholthaus-units-user]

I am using the units.h file as of commit ea6d126. The issue described below can be reproduced using gcc-11.2.0 (and probably using any other C++14 compiler).

Using std::exp() and units::math::exp() on the same value can produce confusingly different results and the reason for it is non-intuitive. Here is some code that illustrates this:

#include "units.h"

#include <iostream>
#include <cmath>

using namespace units::literals;

int main()
{
    const auto a = -1.0 / 1_m ;
    const auto b = 1_um ;
    const auto c = a * b ;
    std::cout << "c                   : " << c << std::endl ;
    std::cout << "units::math::exp(c) : " << units::math::exp(c) << std::endl ;
    std::cout << "std::exp(c.value()) : " << std::exp(c.value()) << std::endl ;
    return EXIT_SUCCESS ;
}

The output looks something like the following:

c                   : -1e-06
units::math::exp(c) : 0.367879
std::exp(c.value()) : 0.999999

The value of c appears to be -1e-06 here and, hence, std::exp(c.value()) appears to produce the expected result. However, units::math::exp(c) produces a different result.

Is this intended/expected behavior?

[ts826848]

I suspect this behavior is unintended.

units::math::exp() uses operator()():

units/include/units.h

Lines 4467 to 4472 in ea6d126

	template<class ScalarUnit>
	dimensionless::scalar_t exp(const ScalarUnit x) noexcept
	{
	static_assert(traits::is_dimensionless_unit<ScalarUnit>::value, "Type `ScalarUnit` must be a dimensionless unit derived from `unit_t`.");
	return dimensionless::scalar_t(std::exp(x()));
	}

return dimensionless::scalar_t(std::exp(x())); 
//                                       ^^ 

operator()() returns the "raw" underlying value, completely disregarding any information that is encoded in the unit's type:

units/include/units.h

Line 2472 in ea6d126

inline constexpr T operator()() const noexcept { return m_value; } ///< returns value.

Unfortunately, there is some relevant information in the type (emphasis added using ***):

(lldb) p c
(const units::unit_t<units::unit<***std::ratio<1, 1000000>***, units::base_unit<std::ratio<0, 1>, std::ratio<0, 1>, std::ratio<0, 1>, std::ratio<0, 1>, std::ratio<0, 1>, std::ratio<0, 1>, std::ratio<0, 1>, std::ratio<0, 1>, std::ratio<0, 1> >, std::ratio<0, 1>, std::ratio<0, 1> >, double, units::linear_scale>) $6 = {
  units::linear_scale<double> = (m_value = -1)
}

This means that operator()() is not the right choice here, as it discards information about the "real" value.

Not all is lost, though; value() delegates to conversion operators, and the conversion operators explicitly call convert() to ensure the information encoded in the type is correctly accounted for:

units/include/units.h

Lines 2133 to 2142 in ea6d126

	/**
	* @brief implicit type conversion.
	* @details only enabled for scalar unit types.
	*/
	template<class Ty, std::enable_if_t<traits::is_dimensionless_unit<Units>::value && std::is_arithmetic<Ty>::value, int> = 0>
	inline constexpr operator Ty() const noexcept
	{
	// this conversion also resolves any PI exponents, by converting from a non-zero PI ratio to a zero-pi ratio.
	return static_cast<Ty>(units::convert<Units, unit<std::ratio<1>, units::category::scalar_unit>>((*this)()));
	}

This means the fix should be easy. Just replace x() with x.value() in exp(), and you should get the correct answer.

Before:

c                   : -1e-06
c()                 : -1
c.value()           : -1e-06
units::math::exp(c) : 0.367879
std::exp(c.value()) : 0.999999

After:

c                   : -1e-06
c()                 : -1
c.value()           : -1e-06
units::math::exp(c) : 0.999999
std::exp(c.value()) : 0.999999

I would guess a similar change would need to be made to other functions.

---

Looks like the v3.x branch suffers from a similar issue:

#include <cmath>
#include <iostream>
#include <units/length.h>

using units::literals::operator""_m;
using units::literals::operator""_um;

int main()
{
	const auto a = -1.0 / 1_m;
	const auto b = 1_um;
	const auto c = a * b;
	std::cout << "c                   : " << c << std::endl;
	std::cout << "double(c)           : " << double(c) << std::endl;
	std::cout << "c.value()           : " << c.value() << std::endl;
	std::cout << "units::math::exp(c) : " << units::exp(c) << std::endl;
	std::cout << "std::exp(c.value()) : " << std::exp(c.value()) << std::endl;
	std::cout << "std::exp(double(c)) : " << std::exp(double(c)) << std::endl;
	return EXIT_SUCCESS;
}

Output:

c                   : -1e-06
double(c)           : -1e-06
c.value()           : -1
units::math::exp(c) : 3.67879e-07
std::exp(c.value()) : 0.367879
std::exp(double(c)) : 0.999999

(lldb) p c
(const units::unit<units::conversion_factor<std::ratio<1, 1000000>, units::dimension_t<>, std::ratio<0, 1>, std::ratio<0, 1> >, double, units::linear_scale>) $0 = (linearized_value = -1)

I think the fix here is a similar idea - use the conversion operator to obtain the underlying value instead of value(), since the latter appears to throw away potentially useful information.

---

I can't make a PR right away, but I should be able to come up with something in the coming days.

[ts826848]

Sorry it took so long; I submitted #288 to try to address your issue.

Still have to make a version for v3.x as well, but that's something for another day...