IpUtils.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2009 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
 
#ifndef __IPUTILS_HPP__
#define __IPUTILS_HPP__
 
// Standard Ip Include Files
#include "IpTypes.hpp"
#include "IpDebug.hpp"
 
#include <algorithm>
#include <limits>
#include <stdexcept>
#include <sstream>
 
namespace Ipopt
{
 
template<typename T>
inline T Max(
   T a,
   T b
)
{
   return std::max(a, b);
}
 
template<typename T>
inline T Max(
   T a,
   T b,
   T c
)
{
   return std::max(std::max(a, b), c);
}
 
template<typename T>
inline T Max(
   T a,
   T b,
   T c,
   T d
)
{
   return std::max(std::max(a, b), std::max(c, d));
}
 
template<typename T>
inline T Min(
   T a,
   T b
)
{
   return std::min(a, b);
}
 
template<typename T>
inline T Min(
   T a,
   T b,
   T c
)
{
   return std::min(std::min(a, b), c);
}
 
template<typename T>
inline T Min(
   T a,
   T b,
   T c,
   T d
)
{
   return std::min(std::min(a, b), std::min(c, d));
}
 
IPOPTLIB_EXPORT bool IsFiniteNumber(
   Number val
);
 
IPOPTLIB_EXPORT Number IpRandom01();
 
IPOPTLIB_EXPORT void IpResetRandom01();
 
IPOPTLIB_EXPORT Number CpuTime();
 
IPOPTLIB_EXPORT Number SysTime();
 
IPOPTLIB_EXPORT Number WallclockTime();
 
IPOPTLIB_EXPORT bool RegisterInterruptHandler(
   void        (*handle_interrupt)(void),                              
   bool*         interrupt_flag,                                       
   unsigned int  abortlimit = std::numeric_limits<unsigned int>::max() 
);
 
IPOPTLIB_EXPORT bool UnregisterInterruptHandler(void);
 
IPOPTLIB_EXPORT bool Compare_le(
   Number lhs,
   Number rhs,
   Number BasVal
);
 
#ifdef __GNUC__
__attribute__((format(printf, 3, 4)))
#endif
IPOPTLIB_EXPORT int Snprintf(
   char*       str,
   long        size,
   const char* format,
   ...
);
 
template<typename T>
inline void ComputeMemIncrease(
   T&          len,          
   double      recommended,  
   T           min,          
   const char* context       
)
{
   if( recommended >= std::numeric_limits<T>::max() )
   {
      // increase len to the maximum possible, if that is still an increase
      if( len < std::numeric_limits<T>::max() )
      {
         len = std::numeric_limits<T>::max();
      }
      else
      {
         DBG_ASSERT(context != NULL);
         std::stringstream what;
         what << "Cannot allocate more than " << std::numeric_limits<T>::max()*sizeof(T) << " bytes for " << context << " due to limitation on integer type";
         throw std::overflow_error(what.str());
      }
   }
   else
   {
      len = Max(min, (T) recommended);
   }
}
 
} //namespace Ipopt
 
#endif