Stilfrage: "a<=b&&b<c" oder "b>=c&&b<c"?

[steilguido]

Was schreibt ihr?

if (0<=x && x<=10);

oder

if (x>=0 && x<=10);

oder was anderes?

Praxisbeispiel wäre 'a'<=c && c<='z' vs c>='a' && c<='z' , kommt aber häufig auch woanders vor.

Kommt alles aufs gleiche raus, aber welche Version ist gebräuchlicher?

[TNA]

Ist Geschmackssache. Ich würde die erste Version bevorzugen, weil ich dort optisch schneller erfassen kann, das x in einem Intervall liegen soll.

[clamper]

Natürlich

x==boost::algorithm::clamp(x, 'a', 'z')

!!!

[Dobi]

Ich bin für sowas in der Art:

template <typename T>
bool IsInClosedInterval( const T& lower, const T& upper, const T& x )
{
    return lower <= x && x <= upper;
}

http://codepad.org/tuVH8Ewl

if ( IsInClosedInterval( 0, 10, x )

edit: Swordfish hat natürlich recht.

[Swordfish]

Dobi schrieb:

template <typename T>
bool IsInClosedInterval( const T& lower, const T& upper, const T& x )
{
    return lower <= x && x <= upper;
}

ftfy.

[Th69]

Dobi, dann aber x als ersten Parameter oder aber in die Mitte stellen

[qq]

Sicher letzteres. Erstere Variante sieht man bestenfalls von Leuten, die gerade frisch von der Uni abgegangen sind.

[Dobi]

@Swordfish: Oh, so wollte ich es ursprünglich auch, hab den eigentlichen Teil dann aber wegen des ganzen drumherums doch falsch gemacht. Habs gefixt.

@Th69: Das Interval habe ich vorne hingeschrieben, weil es mit currying dann einfacher ist, Spezialisierungen der Funktionen zu erzeugen:

asClosedIntervalIncludes :: Ord a => (a, a) -> a -> Bool
asClosedIntervalIncludes (lower, upper) x = lower <= x && x <= upper

isInClosedInterval0to10 = asClosedIntervalIncludes (0, 10)

http://codepad.org/f54J4m6j
Ich seh aber natürlich ein, dass das in C++ nicht so viel bringt.

In z.B. Python gehts übrigens am schönsten, finde ich:

def isInClosedInterval(lower, upper, x):
    return lower <= x <= upper

http://codepad.org/nofRqEWo

edit: Funktion dank häksel's berechtigter Kritik umbenannt.

[häksel]

In Haskell benennt man Funktionen so, dass sie Sinn machen, wenn man sie Infix schreibt. "x `isInClosedInterval` (0, 10)" sagt genau das, was man will, "(0, 10) `isInClosedInterval` x" ist genau falsch.

Und "isInClosedInterval0to10 = (`isInClosedInterval` (0, 10))" ist nicht viel umständlicher.

[oenone]

Dobi schrieb:

In z.B. Python gehts übrigens am schönsten, finde ich:

In Ada:

if X in 1..10 then

[Dobi]

@häksel: Da hast du natürlich recht, danke für den Hinweis. Hab meine Funktion dementsprechend umbenannt, auch wenn mir deine Variante eigentlich noch besser gefällt. Meine Ausrede, dass ich nicht darauf gekommen bin, ist dass ich momentan viel in Elm schreibe, und es da keine sections gibt.

@oenone: Wird dann O(1) zu O(n)? Oder geht das auch mit nicht-integralen Typen?

[bloost]

<pre><code>boost/numeric/interval/utility.hpp</code></pre> schrieb:

template<class T, class Policies> inline
bool in(const T& x, const interval<T, Policies>& y)
{
  if (interval_lib::detail::test_input(x, y)) return false;
  return y.lower() <= x && x <= y.upper();
}

Damit ist die Sache geklärt. Man schreibt das x in der Mitte.

[oenone]

Dobi schrieb:

@oenone: Wird dann O(1) zu O(n)? Oder geht das auch mit nicht-integralen Typen?

Ja, geht auch mit Floating Point:

if X in 0.0 .. 10.0 then

Der Compiler macht daraus einfach zwei Vergleiche, so in etwa (beim Integer Beispiel):

cmpl    $0, -20(%rbp)
        jle     .L4
        cmpl    $10, -20(%rbp)
        jg      .L4

[std__iota&lt;fan&gt;]

template <typename T,
          typename = typename std::enable_if<std::is_integral<T>::value>::type>
bool isin(T x, T l, T r) {
  using std::begin;
  using std::end;
  std::vector<int> v(r - l);
  std::iota(begin(v), end(v), l);
  return std::find(begin(v), end(v), x) != end(v);
}

[std__iota&lt;fan&gt;]

Edit:

return std::binary_search(begin(v), end(v), x);

[volkard]

steilguido schrieb:

Was schreibt ihr?

if (0<=x && x<=10);

oder

if (x>=0 && x<=10);

oder was anderes?

Praxisbeispiel wäre 'a'<=c && c<='z' vs c>='a' && c<='z' , kommt aber häufig auch woanders vor.

Kommt alles aufs gleiche raus, aber welche Version ist gebräuchlicher?

Ich benutze erstere. Sieht eher nach 0<=x<=10 aus, wie es in den Mathebüchern steht.
Die erste Funktion dafür, die ich kenne, heißt range(min,x,max) und wurde mit Borland3.1 ausgeliefert. In der Tat schlechter Stil, weils range(x,min,max) heißen sollte. Alternativ sorted(min,x,max).