Skutečné typy (nebo typy s pohyblivou řádovou čárkou) představují hodnoty, které mají zlomkovou část. V MQL4 existují dva typy čísel s pohyblivou řádovou čárkou. Způsob reprezentace reálných čísel v paměti počítače je definován standardem IEEE 754 a nezávisí na platformách, operačních systémech a programovacích jazycích.

Velikost v bajtech

Minimální kladná hodnota

Název double znamená, že přesnost těchto čísel je dvojnásobná než u plovoucích čísel. Ve většině případů je nejvhodnější dvojitý typ. Omezená přesnost plovoucích čísel prostě v mnoha případech nestačí. Důvodem, proč se stále používá typ float, je úspora úložného prostoru (to je důležité pro velká pole reálných čísel).

Konstanty s plovoucí desetinnou čárkou se skládají z celé části, tečky (.) a zlomkové části. Celé číslo a zlomkové části jsou posloupnosti desetinných číslic.

dvojité a= 12.111;
dvojité b=- 956.1007;
float c = 0.0001;
plovák d = 16;

Existuje vědecký způsob zápisu skutečných konstant, často je tento způsob zápisu kompaktnější než tradiční.

dvojité c1=1.12123515e-25;
double c2=0.000000000000000000000000112123515; // 24 nul za desetinnou čárkou

Print(“1. c1 gt-block”>Print(“2. c1 gt-block”>Print(“3. c2 gt-block”>void OnStart()
<
//—
dvojitá tři = 3.0;
dvojité x,y,z;
x = 1/tři;
y=4/tři;
z = 5/tři;
if (x+y==z) Tisk ( “1/3 + 4/3 == 5/3” );
else Tisk(“1/3 + 4/3 != 5/3”);
// Výsledek: 1/3 + 4/3 != 5/3
>

Pokud stále potřebujete porovnat dvě reálná čísla pro rovnost, můžete to udělat dvěma různými způsoby. První metodou je porovnat rozdíl mezi dvěma čísly s nějakou malou hodnotou, která specifikuje přesnost srovnání.

bool EqualDoubles (double d1, double d2, double epsilon)
<
if (epsilon <0) epsilon=-epsilon;
//—
if (d1-d2>epsilon) return false;
if (d1-d2 <-epsilon) return false;
//—
vrátit true ;
>
void OnStart()
<
dvojitá d_val=0.7;
float f_val=0.7;
if (EqualDoubles(d_val,f_val,0.000000000000001)) Tisk (d_val, “rovná se” ,f_val);
else Print(“Different: d_val f_val gt-block”>bool CompareDoubles( dvojité číslo1, dvojité číslo2)
<
if ( NormalizeDouble (číslo1-číslo2,8)==0) return ( true );
else return (false);
>
void OnStart()
<
dvojitá d_val=0.3;
float f_val=0.3;
if (CompareDoubles(d_val,f_val)) Tisk (d_val, “rovná se” ,f_val);
else Print(“Different: d_val f_val gt-block”>double abnormální = MathArcsin(2.0);
Print(“MathArcsin(2.0) gt-block”>struct str1
<
dvojité d;
>;
struct str2
<
longl;
>;

//- Začněme
str1 s1;
str2 s2;
//—
sl.d= MathArcsin(1); // získat neplatné číslo -2.0.#IND
s2=s1;
printf(“1. %f %I64X” ,s1.d,s2.l);
//—
s2.l=0xFFFF000000000000; // neplatné číslo -1.#QNAN
s1=s2;
printf(“2. %f %I64X” ,s1.d,s2.l);
//—
s2.l=0x7FF7000000000000; // největší nečíslo SNaN
s1=s2;
printf(“3. %f %I64X” ,s1.d,s2.l);
//—
s2.l=0x7FF8000000000000; // nejmenší nečíslo QNaN
s1=s2;
printf(“4. %f %I64X” ,s1.d,s2.l);
//—
s2.l=0x7FFF000000000000; // největší nečíslo QNaN
s1=s2;
printf(“5. %f %I64X” ,s1.d,s2.l);
//—
s2.l=0x7FF0000000000000; // plus nekonečno 1.#INF a nejmenší nečíslo SNaN
s1=s2;
printf(“6. %f %I64X” ,s1.d,s2.l);
//—
s2.l=0xFFF0000000000000; // minus nekonečno -1.#INF
s1=s2;
printf(“7. %f %I64X” ,s1.d,s2.l);
//—
s2.l=0x8000000000000000; // záporná nula -0.0
s1=s2;
printf(“8. %f %I64X” ,s1.d,s2.l);
//—
s2.l=0x3FE0000000000000; // 0.5
s1=s2;
printf(“9. %f %I64X” ,s1.d,s2.l);
//—
s2.l=0x3FF0000000000000; // 1.0
s1=s2;
printf(“10. %f %I64X” ,s1.d,s2.l);
//—
s2.l=0x7FEFFFFFFFFFFFFFF; // největší normalizované číslo (MAX_DBL)
s1=s2;
printf(“11.%.16e %I64X” ,s1.d,s2.l);
//—
s2.l=0x0010000000000000; // nejméně pozitivní normalizované (MIN_DBL)
s1=s2;
printf(“12.%.16e%.16I64X” ,s1.d,s2.l);
//—
sl.d=1; // ukaž, že číslo 0.7 je nekonečný zlomek
s2=s1;
printf(“13.%.16e%.16I64X” ,s1.d,s2.l);
/*
1. -1.#IND00 FFF8000000000000
2. -1.#QNAN0 FFFF000000000000
3. 1.#SNAN0 7FF7000000000000
4. 1.#QNAN0 7FF8000000000000
5. 1.#QNAN0 7FFF000000000000
6. 1.#INF00 7FF0000000000000
7. -1.#INF00 FFF0000000000000
8. -0.000000 8000000000000000
9. 0.500000 3FE0000000000000
10. 1.000000 3FF0000000000000
11. 1.7976931348623157e+308 7FEFFFFFFFFFFFF
12. 2.2250738585072014e-308 0010000000000000
13. 6.9999999999999996e-001 3FE6666666666666
*/

ČTĚTE VÍCE
Kde je nejlepší místo pro výsadbu Keria?

Pro práci s reálnými (zlomkovými) čísly používá Java dvojitý typ. V paměti zabírá 8 bajtů (dvakrát větší než typ int) a může ukládat hodnoty v rozsahu -1.7*10 až +308*1.7. Pro srovnání může typ int uložit hodnotu v rozsahu -10*308 až +2*10.

V reálných číslech se za tečkou píše zlomková část. Například 123.456 nebo 2.5 nebo 100.00 nebo 0.01. Takovým číslům se také říká čísla s pohyblivou řádovou čárkou – počítačový název pro reálná čísla.

Mimochodem, kromě typu double existuje i skutečný typ float (velikost pouze 4 bajty). Jeho název pochází z plovoucí desetinné čárky. Název double pochází z dvojitého plováku. Dvojitý typ je dvakrát větší než float: 8 bajtů oproti 4. Říká se mu také reálné číslo s dvojitou přesností.

2. Vytvoření dvojité proměnné

Dvojitý typ se používá k ukládání reálných čísel. Chcete-li vytvořit proměnnou v kódu, která bude schopna ukládat reálná čísla, musíte použít příkaz:

double имя;

Vytvoření dvojité proměnné

Kde name je název proměnné. Příklady:

double price;