🟢Float vs Double in Java part 1🟢

 

🔰 මේ article එකෙන් කතා කරන්නෙ  float datatype එකෙන් ලියන අගයක් RAM එකේ store වෙලා තියෙන්නෙ කොහොමද කියල එහෙම නැත්නම් float value එකක binary representation එක කොහොමද තියෙන්නෙ කියලා

---‐-----------------------------

හරි, Java වල whole numbers එහෙම නැත්තම් පූර්ණ සංඛ්‍යා නිරූපණය කරන්න data types 4 ක් තියෙනවා 

        1. Byte (8bits)

        2. Short (16bits)

        3. Int (32bits)

        4. Long (64bits)

☆ මේ datatypes වල positive හා negative numbers නිරූපණය කරන්න තියෙන technique එක තමා 2's complement කියන්නෙ හැබැයි අපි මේ කතා කරන්න යන float හා double datatypes වල RAM representation එක ඒ කියන්නෙ float හරි double හරි variable එකකට assign කරන value එකක් RAM එකෙ store වෙලා තියෙන විදිය කලින් අපි කතා කරපු int,short,long,byte වගේ datatype වල variable එකක store වෙලා තියෙන value එකට වඩා තරමක් වෙනස්

🔰 float එකක හරි double එකකින්  හරි සංඛ්‍යාවක් ලිවුවම apparently, අපිට දකින්න තියෙන වෙනස තමා float value එකක් 'f' එකකින් අවසන් වෙනවා හැබැයි double value එකක් normally අපි ලියන දශම සංඛ්‍යාවක් විදියට අවසන් වීම

float number1 = 35.35f; //float

double number2 = 35.35; //double

ඔය විදියට තමා Java වල float හා double values නිරූපණය කරන්නෙ

🔰අනිත් එක තමා bit allocation එක. Float වල අගයක් නිරූපණය කරන්න RAM එකෙ bit 32(4 bytes) ඕන වෙනවා එතකොට double value එකක් නිරූපණය කරන්න bit 64(8bytes) ඕන වෙනවා 

🔰එතකොට කෙනෙක්ට හිතෙන්න පුලුවන් int datatype ඒකෙ bit 32 long datatype එකේ bit 64 යිනෙ ඒ හින්ද මේ datatypes වල RAM representation එක පිලිවෙලින් float හා double වල representation එකට සමාන වෙන්නෙ නැද්ද කියල (eventhough they have floating point values).

හැබැයි එහෙම වෙන්නෙ නෑ

📌int value එකක binary representation එක පොඩ්ඩක් බලමු 

Eg:- 

🟢+10 

0   0000000000000000000000000001010

|

|-》sign bit

🟢 -10 

1   1111111111111111111111111110101

|

|-》sign bit

📌Long වලත් ඔය විදියට තමා 2's complement වලට යන්නෙ හැබැයි bit allocation එක විතරක් වෙනස් වෙනවා

🔰හරි දැන් අපිට අවබෝධයක් තියෙනවා කොහොමද int,long වලින් positive හා negative numbers binary represent කරන්නෙ කියලා

දැන් අපි මාතෘකාවට එමු.

-------‐-------------------------

⚙️ මුලින්ම අපි කතා කරමු float datatype එකකින් ලියපු value එකක binary නිරූපණය කොහොමද කියල 

(See image 2)

හරි එතකොට float එකකින් number එකක් ලිවුවහම create වෙන binary number එකෙ structure එක තමා ඔය තියෙන්නෙ (පේනවනෙ කලින් කතා කරපු datatypes 4 වඩා structure එක පොඩ්ඩක් වෙනස් කියලා ) මේ ටික අපි එකින් එක breakdown කරගමු.

📌 Eg:- 4.15f 

උඩ තියෙන float number එක තමා අපි වැඩේට ගන්නෙ

🔰 1st Step:- 

Convert the decimal number in to its binary number 

ඒ කියන්නෙ 10 පාදයෙන් අපි ලග තියෙන සංඛ්‍යාව 2 පාදයට පරිවර්තනය කරගන්න ඕන එතකොට එන අගය 

     

      100.0010011

🔰2nd step:-

Normalize the binary number 

ඒ කියන්නෙ අපි අදාල ද්විමය සංඛ්‍යාව scientific notation එකට ලියාගන්න ඕන. Scientific notation කියන්නෙ ඉතා විශාල සංඛ්‍යාවක් නැත්තම් ඉතා කුඩා සංඛ්‍යාවක් අපිට manage කරගන්න පුලුවන් විදියට ඒ කියන්නේ

Calculations කරන්න, අනිත් විශාල හෝ කුඩා සංඛ්‍යාවන් එක්ක සංසන්දනය කරන්න පුලුවන් විදියට හදාගන්න එක. ඉතින් Scientific notation එකට ඕනම පාදයක්(base) එක්ක  වැඩ කරන්න පුළුවන්.

   100.0010011 --> 1.000010011 × 2²

ඔය තියෙන්නෙ අපි හදාගත්ත binary number එකේ scientific notation එක. ඕකෙ අපි 2 බලය 2 විදියට අපි ලියල තියෙනවනෙ අදාල සංඛ්‍යාව, ඒකෙ power එකට නැත්තම් බලයට තමා exponent කියල කියන්නෙ(මන් හිතනවා image 2 එකේ exponent කියන කොටස ගැන පොඩි idea එකක් එන්න ඇති කියලා. Float එකක exponent එකට අපි bit 8ක් වෙන් කරනවා )

🔰එතකොට ඇයි අපි power එකට විදියට 2 දැම්මෙ . ඒකට හේතුව තමා 100.0010011 value එකේ bits දෙකක් left side එකට shift කරපු එක.

මේ scientific notation එක තේරුම් ගන්න පොඩි example එකක් බලමු. 

Eg:- 10.75 base 10

මේක 10 පාදයේ සංඛ්‍යාවක් . මේ සංඛ්‍යාව අපි scientific notation එකෙන් ලිව්වොත් එන්නෙ

    1.075 × 10¹

🔰10¹ කියන්නෙ 10 නෙ කොහොමත්. එතකොට 10 × 1.075 උත්තරේ එන්නෙ 10.75. මේ විදියටම තමා අපි කලින් binary number එක scientific notation එකට හරවගත්තෙ (but in base 2)

🔰likewise computer එක වැඩ කරන්නෙ machine language (0,1) එක්ක හින්දා අපි binary scientific notation එක use කරා.

හරි දැන් අපි 3rd step එකට යමු.

🔰3rd step :-

Add a bais value to exponent

අපිට float,double වල negative numbers represent කරන්න 2's complement භාවිතා කරන්නෙ නෑ ඒ වෙනුවට IEE 754 format මත පදනම් වෙච්ච sign- magnitude system එකක් තමා use කරන්නෙ. Bais කියල  කියන්නෙ negative හා positive exponent නිරූපණය කරන්න use කරන concept එකක්

(කොහොමහරි bais කියලා සංකල්පයක් තියෙනවා කියලා idea එකක් තියෙන්න ඕන)

මේ bais කියන value එක නිකම් constant එකක්(නියතයක්) වගේ හැම float value එකකම bais values එක constant  අගයක් . Bais එක හොයන්න පොඩි formula එකක් තියෙනවා.

📌Bais value = 2(n-1) -1

⭕️Note : (n-1) කියන්නෙ 2 power එක 

🔰එතකොට n කියන්නෙ exponent එකෙ bit ගණන. float  වල exponent එකේ bit 8 හින්ද n වල අගය 8. එතකොට අපේ bais value එක

=  2(n-1) -1

=  2(8-1) -1

=  2 ⁷ -1

=  128 -1

=  127

🔰 4th step :- 

Final step එක තමා exponent එක noramlize කිරීම. ඒ කියන්නෙ අපි ගාව තියෙන exponent value එක(2) අපි හදාගත්ත bais value එකට(127) එකතු කරන්න ඕන 

📌Normalized =  Actual exponent + bais 

     Exponent 

                         = 2  + 127

                         = 129

🔰Exponent එක noramlize කරන්නෙ positive හා negative exponent use කරන්න පුලුවන් වෙන්න

----------------------------------

🔰දැන් අපි ගාව ඕන කරන items ඔක්කොම වගේ තියෙනවා

1) sign bit එක 0(since 4.15  '+' number)

2) Exponent value එක(10000001)

ඒත් එක්කම අපි image 2 එකේ කතා කරපු Mantissa එහෙම නැත්තම් significand part එකත් තියෙනවා 

1.000010011 × 2² value එකෙ .000010011 තමා Mantissa කියන්නෙ.

🔰මෙතනදි අපි dot(.) එකට කලින් තියෙන 1 නොසලකා හරිනවා මොකද අපි binary value එකක් noramlize කරද්දි 

'1' තමා මුලට එන්නෙ 

🔰හැබැයි Mantissa එකෙ bit 23 තියෙනවනෙ Float එකට අදාලව ඒ හින්දා අපි කලින් Mantissa eket assign කරපු 000010011 set එකේ ඉතුරු bit ටිකට '0' assign කරනවා

🔰So finally. Binary representation of 4.15f will be 

0  10000001 00001001100000000000000

-----------------------------------------------------------------------------------------------------------------------------

ඉතින්  ඔහොම තමා අපි java වල float value එකක් RAM එකේ store කරලා තියෙන විදිය. 

So that's it 💚. Negative exponent වැඩ කරන්නෙ කොහොමද, Double එකේ binary representation කොහොමද කියල ඊලගට කතා කරමු.

Image credits and references:

https://javarevisited.blogspot.com/2016/05/difference-between-float-and-double-in-java.html?m=1

https://www.log2base2.com/storage/how-float-values-are-stored-in-memory.html