Nyanser av att arbeta med reella tal

1. Avrundning av reella tal

Som vi redan har diskuterat, när ett reellt tal tilldelas en intvariabel, avrundas det alltid nedåt till närmaste mindre heltal - bråkdelen kasseras helt enkelt.

Men det är lätt att föreställa sig en situation när ett bråktal måste avrundas till närmaste heltal i endera riktningen eller till och med avrundas uppåt. Vad gör du i det här fallet?

För detta och för många liknande situationer har Java Mathklassen, som har metoderna round(), ceil(), och .floor()

Math.round()metod

Metoden Math.round()avrundar ett tal till närmaste heltal:

long x = Math.round(real_number)

Men det finns en annan nyans här: den här metoden returnerar ett longheltal (inte ett ) int. Eftersom reella tal kan vara mycket stora, bestämde Javas skapare att använda Javas största tillgängliga heltalstyp: long.

Följaktligen, om en programmerare vill tilldela resultatet till en intvariabel, måste hon uttryckligen ange för kompilatorn att hon accepterar eventuell förlust av data (i händelse av att det resulterande numret inte passar in i en inttyp).

int x = (int) Math.round(real_number)

Exempel:

int x = (int) Math.round(4.1);

4

int x = (int) Math.round(4.5);

5

int x = (int) Math.round(4.9);

5

Math.ceil()metod

Metoden Math.ceil()avrundar ett tal uppåt till ett heltal. Här är exempel:

int x = (int) Math.ceil(4.1);

5

int x = (int) Math.ceil(4.5);

5

int x = (int) Math.ceil(4.9);

5

Math.floor()metod

Metoden Math.floor()avrundar ett tal nedåt till ett heltal. Här är exempel:

int x = (int) Math.floor(4.1);

4

int x = (int) Math.floor(4.5);

4

int x = (int) Math.floor(4.9);

4

Naturligtvis, när du avrundar ett tal nedåt till ett heltal, är det lättare att helt enkelt använda en typ cast-operator:(int)

int x = (int) 4.9

4

Om du tycker att det är svårt att komma ihåg dessa namn hjälper en kort engelsklektion:

• Mathbetyder matematik
• Roundbetyder rund
• Ceilingbetyder tak
• Floorbetyder golv

2. Hur flyttalstal är uppbyggda

Typen doublekan lagra värden i intervallet från till . Detta enorma utbud av värden (jämfört med typen) förklaras av att typen (liksom ) har en helt annan intern struktur än heltalstyper. Internt kodar typen sitt värde som två tal: det första kallas mantissa , och det andra kallas exponent .-1.7*10308+1.7*10308intdoublefloatdouble

Låt oss säga att vi har numret 123456789och lagrar det som en doublevariabel. När vi gör det omvandlas numret till , och internt lagrar typen två nummer — och . Signifikanden ("signifikant del av talet" eller mantissa) är markerad i rött, medan exponenten är markerad i blått.1.23456789*108double234567898

Detta tillvägagångssätt gör det möjligt att lagra både mycket stora och mycket små. Men eftersom talets representation är begränsad till 8 byte (64 bitar) och en del av bitarna används för att lagra exponenten ( liksom mantisans tecken och exponentens tecken), är det maximala antalet tillgängliga siffror för att representera mantissan är 15 .

Detta är en mycket förenklad beskrivning av hur reella tal är uppbyggda.

3. Förlust av precision vid arbete med reella tal

När du arbetar med reella tal, tänk alltid på att reella siffror inte är exakta . Det kan alltid finnas avrundningsfel och konverteringsfel vid konvertering från decimal till binär. Dessutom är den vanligaste felkällan förlust av precision när man adderar/subtraherar tal på radikalt olika skalor.

Detta sista faktum är lite häpnadsväckande för nybörjare.

Om vi ​​subtraherar från får vi .1/109109109

 1000000000.000000000;
-         0.000000001;
 1000000000.000000000;

Vad kan vi säga, programmering är inte detsamma som matematik.

4. Fallgrop när man jämför reella tal

En annan fara ligger och väntar för programmerare när de jämför reella tal. Det uppstår när man arbetar med reella tal, eftersom avrundningsfel kan ackumuleras. Resultatet är att det finns situationer när reella tal förväntas vara lika, men de är det inte. Eller vice versa: siffrorna förväntas vara olika, men de är lika.

Exempel:

double a = 1000000000.0;
double b = 0.000000001;
double c = a - b;

I exemplet ovan, aoch cbör inte vara lika, men de är.

Eller låt oss ta ett annat exempel:

double a = 1.00000000000000001;
double b = 1.00000000000000002;

5. Ett intressant faktum omstrictfp

Java har ett speciellt strictfpnyckelord ( strict f loating point ) , som inte finns i andra programmeringsspråk. Och vet du varför du behöver det? Det försämrar noggrannheten i operationer med flyttal. Här är historien om hur det blev: