ACCU Home page ACCU Conference Page ACCU 2017 Conference Registration Page
Search Contact us ACCU at Flickr ACCU at GitHib ACCU at Google+ ACCU at Facebook ACCU at Linked-in ACCU at Twitter Skip Navigation

pinLetter to the Editor

Overload Journal #125 - February 2015 + Programming Topics + Letters to the Editor   Author: Lion Gutjahr

I recently received an email regarding an article from an Overload published way back in 2001. It is wonderful to hear people are still looking back through items people have written, no matter how long ago. The email drew my attention to C++11’s std::numeric_limits<T>::lowest(), which I hadn’t come across so I thought others might be in the same situation. Lion has kindly taken the time to formalise his initial observations into the following letter, and I have included a response from the original author, Thaddaeus Frogley.

Dear Editor,

I have just read the Overload article ‘An introduction to C++ Traits’ [Frogley01] and noticed that the initialisation of largest in the first code fragment (the one adapted from [Veldhuizen]):

  T largest = std::numeric_limits< T >::min();

is done using std::numeric_limits<T>::min() where it could now be C++11’s std::numeric_limits<T>::lowest() for cases where the type T is float or double and all array members are below or equal to zero.

Although I couldn’t find an explicit reference, this seems to originate from C where INT_MIN and FLT_MIN or DBL_MIN show the same semantic difference; some people guess that it is because the libraries for rational and for integral numbers have been developed by different groups. Fernando Cacciola explains it very nicely in the N1880 proposal to the C++ standard [N1880]:

numeric_limits::min() (18.2.1.2) is defined with a meaning which is inconsistent across integer and floating-point types. Specifically, for integer types, it is the minimum finite value whereas for floating point types it is the minimum positive normalized value. The inconsistency here lies in the interpretation of minimum: in the case of integer types, it signifies lowest, while for floating point types, it signifies smallest non-zero.

N2348 adds some history [N2348]:

At Mont Tremblant, Pete Becker noted that the wording was flawed, because not all floating point representations have the feature that the most negative representable finite value is the negative of the most positive representable finite value.

An example (Listing 1) shows the different behaviour.

#include <limits>
#include <iostream>

template< class T >
T findMax(const T * data, const size_t numItems) {
  // Obtain the minimum value for type T 
  T largest = std::numeric_limits< T >::min();
  for (unsigned int i = 0; i<numItems; ++i)
    if (data[i] > largest)
      largest = data[i];
  return largest;
}

template< class T >
T findMaxNew(const T * data, const size_t numItems) {
  // Obtain the minimum value for type T 
  T largest = std::numeric_limits< T >::lowest();
  for (unsigned int i = 0; i<numItems; ++i)
    if (data[i] > largest)
      largest = data[i];
  return largest;
}
template< class T >
void printAry(const T * data, const size_t numItems) {
  for (unsigned int i = 0; i<numItems; ++i)
    std::cout << data[i] << " ";
  std::cout << std::endl;
}
void test(float* ary, size_t nof) {
  printAry(ary, nof);
  float maxFloat = findMax<float>(ary, nof);
  float newMaxFloat = 
    findMaxNew<float>(ary, nof);
  std::cout << "max in only negative floats is "
            << maxFloat;
  if (std::abs(maxFloat - newMaxFloat) >
    std::numeric_limits<float>::epsilon())
      std::cout << " but should have been " 
                << newMaxFloat;
  std::cout << std::endl << std::endl;
}

int main() {
  float onlyNegativeFloats[] = { -2, -1, -3 };
  std::cout << "array of only negative floats: ";
  test(onlyNegativeFloats, 3);
  float positiveAndNegativeFloats[] = {
    2, -1, -3 };
  std::cout << "array of positive and negative
    floats: ";
  test(positiveAndNegativeFloats, 3);
  return 0;
}
			
Listing 1

Because std::lowest() is not available in C++98, an alternative might be needed. I created a second example which uses the traits technique (see Listing 2).

#include <cstdlib>
#include <cmath>
#include <limits>
#include <iostream>
#include <string>

template< class T >
T findMax(const T * data, const size_t numItems)
{
  // Obtain the minimum value for type T 
  T largest =
    std::numeric_limits< T >::min();
  for (unsigned int i = 0; i<numItems; ++i)
    if (data[i] > largest)
      largest = data[i];
  return largest;
}

namespace detail {
  template< class T, bool isFloat >
  struct cpp98_numeric_limits_lowest {};
  template< class T >
  struct cpp98_numeric_limits_lowest<T, true> {
    static T value() {
      return -std::numeric_limits<T>::max(); }
  };
  template< class T >
  struct cpp98_numeric_limits_lowest<T, false> {
    static T value() {
      return std::numeric_limits<T>::min(); }
  };
} // end namespace detail

template< class T >
T cpp98_numeric_limits_lowest() {
  return detail::cpp98_numeric_limits_lowest< T,
    std::numeric_limits<T>::is_specialized &&
    !std::numeric_limits<T>::is_integer>
        ::value();
}

template< class T >
T findMaxNew(const T * data,
  const size_t numItems) {
  // Obtain the minimum value for type T 
  T largest = cpp98_numeric_limits_lowest<T>();
  for (unsigned int i = 0; i<numItems; ++i)
    if (data[i] > largest)
      largest = data[i];
  return largest;
}

template< class T >
void printAry(const T * data,
  const size_t numItems) {
  for (unsigned int i = 0; i<numItems; ++i)
    std::cout << data[i] << " ";
  std::cout << std::endl;
}

namespace detail {
  template< typename T, bool isFloat >
  struct areEqual {};
  template< typename T >
  struct areEqual<T, true > {
    static bool value(const T& a, const T& b) {
      return std::abs(a - b) <=
      std::numeric_limits<T>::epsilon(); }
  };
  
    template< class T >
  struct areEqual<T, false > {
    static bool value(const T& a, const T& b) {
      return a == b; }
  };
} // end namespace detail

template< class T >
T areEqual(const T& a, const T& b) {
  return detail::areEqual< T,
    std::numeric_limits<T>::is_specialized &&
    !std::numeric_limits<T>::is_integer>
        ::value(a, b);
}

template< class T >
void test(const std::string& desc,
   const T * data, const size_t numItems) {
  std::cout << "array of " << desc << ": ";
  printAry(data, numItems);

  T maxval = findMax<T>(data, numItems);
  T newMaxval = findMaxNew<T>(data, numItems);

  std::cout << "max in " << desc << " is "
    << maxval;
  if (!areEqual<T>(maxval, newMaxval))
    std::cout << " but should have been " 
    << newMaxval;
  std::cout << std::endl << std::endl;
}
int main()
{
  {float vals[] = { -2, -1, -3 };
  test<float>("only negative floats", vals, 3); }

  {float vals[] = { 2, -1, -3 };
  test<float>("positive and negative floats",
    vals, 3); }

  {double vals[] = { -2, -1, -3 };
  test<double>("only negative doubles",
    vals, 3); }

  {double vals[] = { 2, -1, -3 };
  test<double>("positive and negative doubles",
    vals, 3); }

  {long double vals[] = { -2, -1, -3 };
  test<long double>("only negative long doubles",
    vals, 3); }

  {long double vals[] = { 2, -1, -3 };
  test<long double>("positive and negative long
    doubles", vals, 3); }

  {int vals[] = { -2, -1, -3 };
  test<int>("only negative ints", vals, 3); }

  {int vals[] = { 2, -1, -3 };
  test<int>("positive and negative ints", vals,
    3); }

  {unsigned short vals[] = { 2, 3, 1 };
  test<unsigned short>("unsigned shorts", vals,
    3); }

  return 0;
}
			
Listing 2

Please note that it could be possible to distinguish at compile time between pre and post C++11 so that newer compilers could be routed to lowest() directly, but I couldn’t find a short and clean way to do that, although #if (__cplusplus > 199711L) would come pretty close for many compilers.

Regards,

Lion Gutjahr

References

[Frogley01] Frogley, Thaddaeus ‘An introduction to C++ Traits’, Overload Journal #43 (June 2001)

[N1880] N1880 proposal to the C++ standard http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1880.htm

[N2348] http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2348.pdf

Response from Thaddaeus

If anything, it highlights the need to introduce lowest, if there is (was) no clear and straightforward way to achieve the same goal in the C++ of 2001, noting that -max doesn’t work for unsigned integers!

My preferred solution these days would to write something like this (and this is also a more language agnostic approach):

  template< class T >
  T findMax(const T* data, int numItems)
  {
      assert(numItems>0);
      // Obtain the minimum value for type T
      int i=0;
      T largest = data[i++];
      for (;i < numItems; ++i)
          if (data[i] > largest)
              largest = data[i];
      return largest;
  }

which avoids the problem altogether, provided numItems != 0.

Overload Journal #125 - February 2015 + Programming Topics + Letters to the Editor