floating-point arithmetic

Angol

Főnév

floating-point arithmetic (tsz. floating-point arithmetics)

1. (informatika) A lebegőpontos aritmetika a C++-ban azokat a műveleteket jelenti, amelyek a float, double vagy long double típusokon végezhetők. Ezeket az adattípusokat akkor használjuk, ha törtszámokkal szeretnénk dolgozni.

1. Alapvető lebegőpontos típusok C++-ban

Típus	Bájtméret (általában)	Pontosság (kb.)
float	4 bájt	~7 számjegy
double	8 bájt	~15 számjegy
long double	8/10/16 bájt	függ a rendszertől

A double az alapértelmezett lebegőpontos típus, mert nagyobb pontosságot biztosít, mint a float, miközben elfogadható teljesítményű.

2. Alapvető műveletek

A lebegőpontos számokkal végezhető műveletek hasonlók az egész számokhoz:

#include <iostream>
using namespace std;

int main() {
    float a = 5.2f;
    double b = 3.14;
    long double c = 2.718281828459;

    cout << "Összeg: " << (a + b) << endl;
    cout << "Kivonás: " << (a - b) << endl;
    cout << "Szorzás: " << (a * c) << endl;
    cout << "Osztás: " << (a / b) << endl;

    return 0;
}

A f az 5.2f végén azért kell, mert különben a C++ double-ként értelmezné a számot.

3. Lebegőpontos számok pontatlansága

A lebegőpontos számok nem pontosak bináris ábrázolásuk miatt. Példa erre:

#include <iostream>
using namespace std;

int main() {
    double x = 0.1 + 0.2;
    if (x == 0.3)
        cout << "Egyenlő" << endl;
    else
        cout << "Nem egyenlő! x = " << x << endl;
    return 0;
}

Ennek eredménye általában:

Nem egyenlő! x = 0.30000000000000004

Mivel a 0.1 és 0.2 binárisan nem ábrázolható pontosan, a művelet eredménye kissé eltérhet a várttól.

4. Kerekítési hibák csökkentése

Ha két lebegőpontos számot szeretnénk összehasonlítani, célszerű egy toleranciát használni:

#include <iostream>
#include <cmath>
using namespace std;

int main() {
    double x = 0.1 + 0.2;
    double y = 0.3;
    double epsilon = 1e-9; // Kisebb érték = nagyobb pontosság

    if (fabs(x - y) < epsilon)
        cout << "Majdnem egyenlő" << endl;
    else
        cout << "Nem egyenlő" << endl;

    return 0;
}

Itt az fabs(x - y) < epsilon megoldás biztosítja, hogy az apró lebegőpontos eltéréseket figyelmen kívül hagyjuk.

5. A std::setprecision() használata

A iostream könyvtár setprecision() függvénye segít a számok formázásában:

#include <iostream>
#include <iomanip> // setprecision használatához
using namespace std;

int main() {
    double pi = 3.141592653589793;
    cout << fixed << setprecision(4) << "Pi: " << pi << endl;
    return 0;
}

Kimenet:

Pi: 3.1416

A setprecision(4) négy tizedesjegyre kerekíti a kimenetet.

6. Különleges értékek

A lebegőpontos számok speciális értékeket is felvehetnek: - Végtelen (inf) – Pl. 1.0 / 0.0 - Nem szám (NaN) – Pl. sqrt(-1.0)

Ellenőrzésük:

#include <iostream>
#include <cmath>
using namespace std;

int main() {
    double x = sqrt(-1.0);
    if (isnan(x))
        cout << "x NaN!" << endl;

    double y = 1.0 / 0.0;
    if (isinf(y))
        cout << "y végtelen!" << endl;

    return 0;
}

Összegzés

• A float, double, long double használatos lebegőpontos számokhoz.
• A double az alapértelmezett és ajánlott a legtöbb esetben.
• A lebegőpontos műveletek nem mindig pontosak, ezért epsilon értékkel hasonlítsunk.
• A setprecision() segíthet a formázásban.
• Léteznek speciális értékek (NaN, inf), amelyeket isnan(), isinf() segítségével vizsgálhatunk.

További információk

• floating-point arithmetic - Szótár.net (en-hu)
• floating-point arithmetic - Sztaki (en-hu)
• floating-point arithmetic - Merriam–Webster
• floating-point arithmetic - Cambridge
• floating-point arithmetic - WordNet
• floating-point arithmetic - Яндекс (en-ru)
• floating-point arithmetic - Google (en-hu)
• floating-point arithmetic - Wikidata
• floating-point arithmetic - Wikipédia (angol)