Auf inf überprüfen

Wie kann ich überprüfen ob eine Zahl infinity ist?

Sowas hier geht nicht:

if( a = inf ) { blablabla }

unskilled

es gibt (u.a.) 2 Makros in der cmath:

INFINITY
und
NAN

bb

HändyÄndy schrieb:

if( a = inf ) { blablabla }

Das ist ja auch eine Zuweisung...

Ehrlich gesagt: Ich habe keine Ahnung...

Ich spar mir jetzt mal den 'let me google that for you'-Link

Es gibt wohl in

#include<limits>
if(std::isinf(myValue)){}

Gruß,
CSpille

SeppJ

Falls du einen C++ Compiler hast, der auch die Erweiterungen von C99 unterstützt (das tun eigentlich fast alle, außer wenn man sie per Schalter zum strengen Einhalten des Standards zwingt), dann kannst du isinf() aus math.h benutzen. Dazu passt dann auch isnan() zur Prüfung auf NaN.

edit: @unskilled: Man kann aber mit NAN nicht auf Gleichheit prüfen. Und bei INFINITY bin ich mir da auch nicht so sicher, müsste man mal nachlesen.

unskilled

zur not gibts aber in numeric_limits auch wirklich was für C++:

static const bool has_infinity = false;
  static const bool has_quiet_NaN = false;
  static const bool has_signaling_NaN = false;
/*...*/
  static T infinity() throw();
  static T quiet_NaN() throw();
  static T signalign_NaN() throw();

ich hab zwar keinen plan, was der unterschied zwischen quiet_nan und signaling_nan ist, aber ok... ^^

bb

SeppJ

unskilled schrieb:

zur not gibts aber in numeric_limits auch wirklich was für C++:
static const bool has_infinity = false;
  static const bool has_quiet_NaN = false;
  static const bool has_signaling_NaN = false;
/*...*/
  static T infinity() throw();
  static T quiet_NaN() throw();
  static T signalign_NaN() throw();
ich hab zwar keinen plan, was der unterschied zwischen quiet_nan und signaling_nan ist, aber ok... ^^

bb

Aber was nützt das? Damit kann man doch nur feststellen was der Typ so kann, aber man kann nicht prüfen ob eine variable von diesem Typ diesen Wert hat. Denn nan != nan.

Der Unterschied zwischen quiet_NaN und signaling_NaN ist, ist dass ein signaling_NaN eine Exception wirft wenn man bestimmte Sachen damit macht, während ein quiet_nan einfach durchgereicht wird. Ich wüsste aber keinen Fall, wo signaling_nans tatsächlich vorkommen würden, auch wenn die Idee ganz nett ist.

unskilled

y, es ging aber hier nur um infinity, richtig!? : P

template<typename T>
bool is_infinity(const T& to_proof, bool only_positive = false)
{
  if(!std::numeric_limits<T>::has_infinity())
    return false;

  if(to_proof == std::numeric_limits<T>::infinity())
    return true;

  if(only_positive)
    return false;

  return to_proof == -std::numeric_limits<T>::infinity();
}

bb

edit: wenn es nur einen NaN-Zustand gäbe, könnte man ja mit memcmp was anstellen - das ist das ja aber nicht der Fall..
allerdings kann man das ==-op verhalten ja auch ausnutzen:

template<typename T>
bool is_nan(const T& test_me)
{
  if(!std::numeric_limits<T>::has_quiet_NaN())
    return false;

  return test_me != test_me;
}