Der Datentyp »`bool`« in C++

Einführung

“True ” /tru/ ist das englische Wort für „wahr“, “false ” /fɔls/ ist das englische Wort für „falsch“. George Boole war ein Mathematiker.

Wir haben bisher schon fundamentale Datentypen wie »int« oder »double« kennengelernt. Daneben gibt es in C++ auch noch einen fundamentalen Datentyp namens »bool«.

Es gibt zwei Literale, die den Datentyp »bool« haben, nämlich »true« und »false« („wahr“ beziehungsweise „falsch“). Wir nennen sie auch Wahrheitsliterale.

»true« und »false« sind Schlüsselwörter (C++ 2015: 2.11)

Programmbeispiel

Das folgende Programmbeispiel zeigt, wie die auszuführende Funktion »p« durch den Datentyp eines Arguments (»bool« oder »int«) festgelegt wird.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
using namespace ::std::literals;
void p( bool const ){ ::std::cout << "bool\n"s; }
void p( int const ){ ::std::cout << "int\n"s;  }
int main()
{ p( true );
  p( false );
  p( 0 );
  p( 1 );  }

::std::cout

bool
bool
int
int

Wahrheitswerte

Wir nennen den Wert des Literals »true« ebenfalls »true«, und den Wert des Literals »false« »false«. Andere Werte gibt es bei dem Datentyp »bool« nicht. Diese beiden Werte sind voneinander verschieden.

An einer Stelle, an welcher ein Zahlenwert erwartet wird, wird »true« mit den Wert »1« und »false« mit den Wert »0« interpretiert.

Die Ausgabedarstellung dieser beiden Werte ist voreingestellt »1« (für »true«) beziehungsweise »0« (für »false«).

Programmbeispiel

Das folgende Programmbeispiel zeigt, wie der Wert »true« in der Ausgabe als »1« dargestellt wird und der Wert »false« als »0«.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
using namespace ::std::literals;
int main(){ ::std::cout << true << "\n"s << false << "\n"s; }

::std::cout

1
0

Literale ⁺

Wir erweitern die Definition des Begriffs „Literal“.

Bisher: „Ein Literal ist ein Numerale oder ein Zeichenfolgenliteral.“

Neu: „Ein Literal ist ein Numerale, ein Zeichenfolgenliteral oder eines der beiden Wahrheitsliterale.“

Werte ⁺

Wir erweitern die Definition des Begriffs „Wert“.

Bisher: „Ein Wert ist eine Zahl oder eine Zeichenfolge.“

Neu: „Ein Wert ist eine Zahl, eine Zeichenfolge oder ein Wahrheitswert.“

Textdarstellung

Durch die Auswertung des Ausdrucks »::std::cout << ::std::boolalpha« nach »#include <ios>« wird der Standardausgabestrom »::std::cout« auf Textausgabe von Wahrheitswerten umgestellt.

Durch die Auswertung des Ausdrucks »::std::cout << ::std::noboolalpha« nach »#include <ios>« wird der Standardausgabestrom »::std::cout« auf numerische Ausgabe von Wahrheitswerten umgestellt. Diese Einstellung ist auch beim Programmstart voreingestellt.

Programmbeispiel

Das folgende Programmbeispiel zeigt, wie der Wert »true« und der Wert »false« nach dem Programmstart, nach Auswertung von »::std::cout << ::std::boolalpha« und nach Auswertung von »::std::cout << ::std::boolalpha« ausgegeben werden.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <ios> // ::std::boolalpha, ::std::noboolalpha
#include <string>
using namespace ::std::literals;
void p(){ ::std::cout << true << "\n"s << false << "\n"s; }
int main()
{ p(); ::std::cout << ::std::boolalpha;
  p(); ::std::cout << ::std::noboolalpha;
  p(); }

::std::cout

1
0
true
false
1
0

Ein anderes Programmbeispiel:

main.cpp

#include <ios> // ::std::boolalpha, ::std::noboolalpha
#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
using namespace ::std::literals;
int main()
{ ::std::cout        << true << "|\n"s << 
  ::std::boolalpha   << true << "|\n"s << 
  ::std::noboolalpha << true << "|\n"s; }

Protokoll

1|
true|
1|

Prädikate

Einen Ausdruck vom Typ »bool« nennen wir hier auch eine Aussage.

Eine Abbildung, welche eine Ergebnis vom Typ »bool« hat, wird in Analogie zur Logik auch als Prädikat bezeichnet.

Dokumentation (vereinfacht und übersetzt)

Synopsis
  #include <cmath>
  bool signbit( double x );
Die Funktion signbit ergibt, ob das Vorzeichen
ihres Argumentwertes negativ ist.

Programmbeispiel

Das folgende Programmbeispiel zeigt den Wert des Prädikats »::std::signbit« für verschiedene Argumentwerte.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
#include <ios> // ::std::boolalpha
#include <cmath>
using namespace ::std::literals;
void showtype( bool const ){ ::std::cout << "bool\n"s; }
void showtype( int  const ){ ::std::cout << "int\n"s;  }
int main()
{ ::std::cout << ::std::boolalpha;
  showtype( ::std::signbit( 0.0 ));
  ::std::cout << ::std::signbit( +1.0 )<< "\n"s;
  ::std::cout << ::std::signbit( -1.0 )<< "\n"s; }

::std::cout

bool
false
true

Man kann die Anwendung eines Prädikats mit einer geschlossenen Frage vergleichen.

Relationen

Ein Prädikat mit einem Parameter wird auch unäres Prädikat genannt.

Ein Prädikat mit zwei Parametern wird auch binäres Prädikat genannt.

Ein binäres Prädikat wird auch Relation genannt.

Dokumentation (vereinfacht und übersetzt)

Synopsis
  #include <cmath>
  bool isless( double x, double y );
Die Funktion isless ergibt, ob der Wert des ersten Arguments
kleiner als der Wert des zweiten Arguments ist.

Aussprachehinweis

is less ɪzlɛs

Programmbeispiel

Das folgende Programmbeispiel zeigt den Wert der Relation »::std::isless« für verschiedene Argumentwerte.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
#include <ios> // ::std::boolalpha
#include <cmath>
using namespace ::std::literals;
void showtype( bool const ){ ::std::cout << "bool\n"s; }
void showtype( int  const ){ ::std::cout << "int\n"s;  }
int main()
{ ::std::cout << ::std::boolalpha;
  showtype( ::std::isless( 1.0, 2.0 ));
  ::std::cout << ::std::isless( 1.0, 2.0 )<< "\n"s;
  ::std::cout << ::std::isless( 2.0, 1.0 )<< "\n"s; }

::std::cout

bool
true
false

Argumente

Dokumentation (vereinfacht und übersetzt)

Synopsis
  #include <ios>
  namespace ios_base
  bool sync_with_stdio( bool sync );
Der Aufruf mit false erlaubt den Verzicht auf
Synchronisation mit C-Ausgabefunktionen.
(Muß am Programmanfang aufgerufen werden.)

Programmbeispiel

Das folgende Programmbeispiel zeigt die Anwendung der Funktion »::std::ios_base::sync_with_stdio« auf ein Argument vom Typ »bool«.

(Für die C -Funktionen müssen C -Strings ohne »s« verwendet werden.)

main.cpp

#include <cstdio>
#include <ios> // ::std::boolalpha
#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
using namespace ::std::literals;
int main()
{ ::std::ios_base::sync_with_stdio( false );
  ::std::cout << "alpha"s << "\n"s; 
  ::std::puts( "gamma" );
  ::std::cout << "delta"s << "\n"s; 
  ::std::puts( "epsilon" ); }

Protokoll

alpha
delta
gamma
epsilon

Verwendung von Konstanten

Programmbeispiel

Das folgende Programmbeispiel zeigt die Verwendung von bool-Konstanten wie »::std::chrono::system_clock::is_steady«.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <ios> // ::std::boolalpha
#include <chrono>
#include <string>
using namespace ::std::literals;
int main()
{ ::std::cout << ::std::boolalpha;
  ::std::cout << ::std::chrono::system_clock::is_steady          << "\n"s;
  ::std::cout << ::std::chrono::high_resolution_clock::is_steady << "\n"s;
  ::std::cout << ::std::chrono::steady_clock::is_steady          << "\n"s; }

::std::cout

false
false
true

Programmbeispiel ⃗

Das folgende Programmbeispiel zeigt die Verwendung der bool-Konstante wie »::std::chrono::system_clock::is_steady« als Argument eines Aufrufs von »::std::ios_base::sync_with_stdio«. Dies bedeutet, daß genau dann mit »stdio« synchronisiert werden soll, wenn die Systemuhr monoton ist. Es ist schwierig sich vorzustellen, daß so etwas wirklich einmal benötigt wird; es dient hier lediglich als Beispiel für die mögliche Verwendung einer bool-Konstanten.

main.cpp

#include <ios> // ::std::boolalpha
#include <chrono>
int main()
{ ::std::ios_base::sync_with_stdio( ::std::chrono::system_clock::is_steady ); }

::std::cout

(keine Ausgabe)

`const`-Konstanten

Programmbeispiel

Das folgende Programmbeispiel zeigt die Definition und Verwendung einer bool-Konstanten (hier, einer Konstanten der Gattung »const«).

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <ios> // ::std::boolalpha
#include <string>
using namespace ::std::literals;
int main()
{ ::std::cout << ::std::boolalpha;
  ::std::cout << true << "\n"s;
  bool const b{ true };
  ::std::cout << b << "\n"s; }

::std::cout

true
true

Variablen

Programmbeispiel

Das folgende Programmbeispiel zeigt die Definition und Verwendung einer bool-Variable »flag«, die im weiteren Verlauf des Programms gesetzt und wieder gelöscht wird.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <ios> // ::std::boolalpha
#include <string>
using namespace ::std::literals;
int main()
{ ::std::cout << ::std::boolalpha;
  bool flag{ false };
  flag = true;  /* set   flag */
  ::std::cout << flag << "\n"s;
  flag = false; /* clear flag */
  ::std::cout << flag << "\n"s; }

::std::cout

true
false

Parameter

Wertinitialisierung

Bei einer Wertinitialisierung, also einer Initialisierung mit leeren geschweiften Klammern »{}« erfolgt eine Fehlinitialisierung, dies ist hier eine Initialisierung mit dem Fehlwert, welcher beim Datentyp »bool« der Wert »false« ist.

main.cpp

#include <ios>      // ::std::boolalpha
#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
using namespace ::std::literals;
int main()
{ bool b {};
  ::std::cout << ::std::boolalpha;
  ::std::cout << b << "\n"s; }

Protokoll

false

Programmbeispiel

Das folgende Programmbeispiel zeigt die Definition und Verwendung eines bool-Parameters »value«.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <ios>      // ::std::boolalpha
#include <string>
using namespace ::std::literals;
void println( bool const value )
{ ::std::cout << ::std::boolalpha;
  ::std::cout << value << "\n"s; }
  
int main()
{ println( true  );
  println( false ); }

::std::cout

true
false

Wandlung ganzzahliger Werte in Wahrheitswerte

Programmbeispiel

Das folgende Programmbeispiel zeigt die stillschweigende Wandlung ganzzahliger Werte in Wahrheitswerte.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <ios>      // ::std::boolalpha
#include <string>
using namespace ::std::literals;
void println( bool const b )
{ ::std::cout << ::std::boolalpha;
  ::std::cout << b << "\n"s; }
int main()
{ println(  0 );
  println(  1 );
  println( -1 );
  println(  2 );
  println( -2 ); }

::std::cout

false
true
true
true
true

Wandlung von Gleitkommazahlen in Wahrheitswerte ⃗

Programmbeispiel ⃗

Das folgende Programmbeispiel zeigt die stillschweigende Wandlung von Gleitkommazahlen in Wahrheitswerte.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <ios>      // ::std::boolalpha
#include <string>
using namespace ::std::literals;
void println( bool const b )
{ ::std::cout << ::std::boolalpha;
  ::std::cout << b << "\n"s; }
int main()
{ println(  0.0 );
  println(  1.0 );
  println( -1.0 );
  println(  0.1 );
  println( -0.1 );
  println(  0.9 );
  println( -0.9 ); }

::std::cout

false
true
true
true
true
true
true

Wandlung von Zeichenfolgen in Wahrheitswerte ⃗

Programmbeispiel ⃗

Das folgende Programmbeispiel zeigt die stillschweigende Wandlung von Zeichenfolgen (C-Zeichenfolgen mit dem Typ »char *«) in Wahrheitswerte.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <ios>      // ::std::boolalpha
#include <string>
using namespace ::std::literals;
void println( bool const value )
{ ::std::cout << ::std::boolalpha;
  ::std::cout << value << "\n"s; }
  
int main()
{ println( "alpha"  );
  println( "true"   );
  println( "false"  );
  println( "0"      );
  println( "1"      );
  println( ""       ); }

::std::cout

true
true
true
true
true
true

Wandlung von Wahrheitswerten in ganze Zahlen

Programmbeispiel

Das folgende Programmbeispiel zeigt die stillschweigende Wandlung von Wahrheitswerten in ganze Zahlen.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
using namespace ::std::literals;
void println( int const i )
{ ::std::cout << i << "\n"s; }
int main()
{ println( false );
  println( true  ); }

::std::cout

0
1

Wandlung von Wahrheitswerten in Gleitkommazahlen ⃗

Programmbeispiel ⃗

Das folgende Programmbeispiel zeigt die stillschweigende Wandlung von Wahrheitswerten in Gleitkommazahlen.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
using namespace ::std::literals;
void println( double const x )
{ ::std::cout << x << "\n"s; }
int main()
{ println( false );
  println( true  ); }

::std::cout

0
1

Wandlung von Wahrheitswerten in Operatorausdrücken

Programmbeispiel

Das folgende Programmbeispiel zeigt die stillschweigende Wandlung von Wahrheitswerten bei Verknüpfung mit numerischen Operatoren.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <ios>      // ::std::boolalpha
#include <string>
using namespace ::std::literals;
void println( bool const b )
{ ::std::cout << ::std::boolalpha;
  ::std::cout << "bool:   "s << b << "\n"s; }
void println( int const i )
{ ::std::cout << "int:    "s << i << "\n"s; }
void println( double const x )
{ ::std::cout << "double: "s << x << "\n"s; }
int main()
{ println( true        );
  println( 1 * true    );
  println( 1.0 * true  );
  println( 3.0 * true  );
  println( true + true ); }

Im Falle von »true + true« werden beide Operanden nach »int« „erweitert“, da arithmetische Berechnungen immer mit einem numerischen Datentyp stattfinden, der mindestens so groß wie »int« ist (»bool« gilt als kleiner als »int«).

::std::cout

bool:   true
int:    1
double: 1
double: 3
int:    2

Programmbeispiel

Das folgende Programmbeispiel zeigt die Werte von bool-Ausdrücken bei Verknüpfung mit numerischen Operatoren.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
using namespace ::std::literals;
int main()
{ ::std::cout << true << "\n"s;
  ::std::cout << 1 * true << "\n"s;
  ::std::cout << 1.0 * true << "\n"s;
  ::std::cout << 3.0 * true << "\n"s;
  ::std::cout << true + true << "\n"s; }

::std::cout

Rückgabewerte in `bool`-Funktionen

Programmbeispiel

Das folgende Programmbeispiel zeigt, die Rückgabe von Werte verschiedener Typen in bool-Funktionen.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <ios>      // ::std::boolalpha
#include <string>
using namespace ::std::literals;

void println( bool const b )
{ ::std::cout << ::std::boolalpha;
  ::std::cout << b << "\n"s; }
  
bool f(){ return 22; }
bool g(){ return -27.2; }
bool h(){ return "Anton"; }

int main()
{ println( f() );
  println( g() );
  println( h() ); }

::std::cout

true
true
true

Programmbeispiel

Das folgende Programmbeispiel zeigt die Implementation eines Münzwurfs durch eine Funktion, die in zirka 50 Prozent aller Fälle »true« ergibt.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <ios>      // ::std::boolalpha
#include <cstdlib>  // ::std::rand, RAND_MAX
#include <string>
#include <ctime>
using namespace ::std::literals;

void println( bool const b )
{ ::std::cout << ::std::boolalpha;
  ::std::cout << b << "\n"s; }
  
bool coin(){ return rand() /( RAND_MAX / 2 ); }

int main()
{ srand( time( nullptr )* time( nullptr )); rand(); rand(); rand();
  println( coin() );
  println( coin() );
  println( coin() ); }

Protokoll

false
true
false

`bool`-Ausdrücke in `return`-Anweisungen

Programmbeispiel

Das folgende Programmbeispiel zeigt die Verwendung von bool-Ausdrücken in return-Anweisungen in Funktionen verschiedener Rückgabetypen.

»::std::fixed« stellt die Ausgabe von Gleitkommazahlen so ein, daß wir sie von ganzen Zahlen unterscheiden können.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <ios>      // ::std::boolalpha
#include <string>
using namespace ::std::literals;

bool   f(){ return true; }
int    g(){ return true; }
double h(){ return true; }

int main()
{ ::std::cout << ::std::boolalpha << ::std::fixed;
  ::std::cout << f() << "\n"s;
  ::std::cout << g() << "\n"s;
  ::std::cout << h() << "\n"s; }

::std::cout

true
1
1.000000

Abbildungen

Programmbeispiel

Das folgende Programmbeispiel zeigt die Implementation einer Funktion zur „Verneinung“ (Negation) eines Wahrheitswertes.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
using namespace ::std::literals;

void println( bool const b )
{ ::std::cout << ::std::boolalpha;
  ::std::cout << b << "\n"s; }
  
bool non( bool const b )
{ return 1 - b; }

int main()
{ println( non( true  ));
  println( non( false )); }

::std::cout

false
true

Übungsfragen

? Übungsfrage

Welchen Datentyp haben die folgenden Literale jeweils?

Zu Auswahl stehen »int«, »double«, »::std::string«, und »bool«.

Beispiele für Literale

17.2
12
"false"s
false
12E2
"12E2"s
1.

? Übungsfrage *

Ist »::std::signbit( +1.0 )« ein Prädikat?

Übungsaufgaben

/ Wahrheitsfunktion

Schreiben Sie die Deklaration einer parameterlosen Funktion namens »t«, welche den Wert »true« zurückgibt. Der Rückgabetyp dieser Funktion soll »bool« sein.

/ Wahrheitsfunktion (1)

Schreiben Sie die Deklaration einer Funktion namens »p«, welche einen Ausdruck vom Typ »bool« als Argument akzeptiert. Sie soll »7« ausgeben, wenn das Argument den Wert »false« hat und sonst »3«. Diese Funktion soll keinen Wert liefern.

/ Normalisierung

Schreiben Sie die Deklaration einer Funktion namens »n«, welche einen Ausdruck vom Typ »int« als Argument akzeptiert. Sie soll keine Wirkung haben und »0« ergeben, wenn der Argumentaudruck den Wert »0« hat und »1« sonst.

/ Und-Verknüpfung

Schreiben Sie die Deklaration einer Funktion namens »und«, welche zwei Ausdrücke vom Typ »bool« als Argumente akzeptiert. Sie soll keine Wirkung haben. Sie soll »true« ergeben, wenn beide Argumente den Wert »true« haben und »false« sonst.

/ Oder-Verknüpfung

Schreiben Sie die Deklaration einer Funktion namens »oder«, welche zwei Ausdrücke vom Typ »bool« als Argumente akzeptiert. Sie soll keine Wirkung haben. Sie soll »false« ergeben, wenn beide Argumente den Wert »false« haben und »true« sonst.

/ Gleichheitsprüfung

Schreiben Sie die Deklaration einer Funktion namens »equals«, welche zwei Ausdrücke vom Typ »int« als Argumente akzeptiert. Sie soll keine Wirkung haben. Sie soll »true« ergeben, wenn beide Argumente den gleichen Wert haben und »false« sonst. Diese Funktion sollte möglichst ohne (direkte oder indirekten) Aufruf einer Funktion aus der Standardbibliothek programmiert werden.

/ »`isless`« implementieren

Schreiben Sie die Deklaration einer bool-Funktion »isless«, so daß der Wert der Auswertung des Aufrufausdrucks »isless( x, y )« angibt, ob x kleiner als y ist. Zur Implementation soll dabei »::std::isless« nicht verwendet werden. Diese Funktion soll vielmehr mit Hilfe einer Subtraktion und von »::std::signbit« realisiert werden.

/ »`pi_ausgeben`«

Schreiben Sie die Deklaration einer parameterlosen Wirkfunktion »piAusgeben«, so daß die Wirkung der Auswertung des Aufrufausdrucks »piAusgeben()« die Ausgabe einer Nährung an die Kreiszahl π (mit mindestens 10 Nachkommastellen) ist. Diese Wirkfunktion soll keinen Wert liefern.

/ »`sqrt2`«

Schreiben Sie die Deklaration einer parameterlosen Wertfunktion »sqrt2«, so daß der Wert des Aufrufausdrucks »sqrt2()« eine Näherung an die Quadratwurzel der Zahl 2 vom Datentyp »double« ist. Diese Wertfunktion soll keine Wirkung haben.

Der Datentyp »bool« in C++

Einführung

Programmbeispiel

Wahrheitswerte

Programmbeispiel

Literale ⁺

Werte ⁺

Textdarstellung

Programmbeispiel

Prädikate

Programmbeispiel

Relationen

Programmbeispiel

Argumente

Programmbeispiel

Verwendung von Konstanten

Programmbeispiel

Programmbeispiel ⃗

const-Konstanten

Programmbeispiel

Variablen

Programmbeispiel

Parameter

Wertinitialisierung

Programmbeispiel

Wandlung ganzzahliger Werte in Wahrheitswerte

Programmbeispiel

Wandlung von Gleitkommazahlen in Wahrheitswerte ⃗

Programmbeispiel ⃗

Wandlung von Zeichenfolgen in Wahrheitswerte ⃗

Programmbeispiel ⃗

Wandlung von Wahrheitswerten in ganze Zahlen

Programmbeispiel

Wandlung von Wahrheitswerten in Gleitkommazahlen ⃗

Programmbeispiel ⃗

Wandlung von Wahrheitswerten in Operatorausdrücken

Programmbeispiel

Programmbeispiel

Rückgabewerte in bool-Funktionen

Programmbeispiel

Programmbeispiel

bool-Ausdrücke in return-Anweisungen

Programmbeispiel

Abbildungen

Programmbeispiel

Übungsfragen

? Übungsfrage

? Übungsfrage *

Übungsaufgaben

/ Wahrheitsfunktion

/ Wahrheitsfunktion (1)

/ Normalisierung

/ Und-Verknüpfung

/ Oder-Verknüpfung

/ Gleichheitsprüfung

/ »isless« implementieren

/ »pi_ausgeben«

/ »sqrt2«

Der Datentyp »`bool`« in C++

`const`-Konstanten

Rückgabewerte in `bool`-Funktionen

`bool`-Ausdrücke in `return`-Anweisungen

/ »`isless`« implementieren

/ »`pi_ausgeben`«

/ »`sqrt2`«