ತೇಲುವ ಚುಕ್ಕಿ

ತೇಲುವ ಚುಕ್ಕಿಯ ಅಂಕೆ (floating point number) ಅಂದರೆ  ಏನು? ಹಾಗೆ  ಯಾಕೆ ಕರೆಯುತ್ತಾರೆ?
ಅದನ್ನೆಲ್ಲ ಮುಂದಿನ ಬರಹದಲ್ಲಿ ತಿಳಿಸುತ್ತೇನೆ. ಆದರೆ, ಸದ್ಯಕ್ಕೆ ಇಶ್ಟು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಿ. ನನ್ನಿಯಂಕೆ(real number)ಗಳನ್ನು ಎಣಿ(computer)ಯಲ್ಲಿ ಉಳಿಸಿ ಇಟ್ಟುಕೊಳ್ಳುವ ಒಂದು ಮಾರಾಳುತನ (representation) ಇದು. ಗಿರಕು ಚುಕ್ಕಿಯ ಮಾರಾಳುತನ(fixed point representation)ವೂ ಇದೆ. ಆದರೆ ಇದು ಹೆಚ್ಚು ಕಟ್ಟುನಿಟ್ಟಾ(precise)ಗಿದ್ದರೂ ತುಂಬಾ ಎಡೆ(space) ಹಿಡಿಸುತ್ತದೆ. ಹಾಗಾಗಿ ಈ ಮಾರಾಳುತನ(representation)ವನ್ನು ಈಗಿನ ಎಣಿಗಳು ಬಳಸುವುದಿಲ್ಲ. ತೇಲುವ ಚುಕ್ಕಿಯ ಮಾರಾಳುತನವನ್ನೇ ಬಳಸುತ್ತವೆ.

ಸಿ ನುಡಿಯಲ್ಲಿ ಮೂರು ಬಗೆಯ ತೇಲುವ ಚುಕ್ಕಿಯ ಅಂಕೆಗಳು ಇವೆ: float, double, long double. floatಗಿಂತ double ಅಂಕೆಯ ಕಟ್ಟುನಿಟ್ಟುತನ (precision) ಇಮ್ಮಡಿ. ಅದಕ್ಕೂ ಹೆಚ್ಚಿನ ಕಟ್ಟುನಿಟ್ಟುತನ ಅಂದರೆ long doubleದು. ಇವುಗಳ ಹರವು(range) ಎಷ್ಟು, ಮತ್ತು ಕಟ್ಟುನಿಟ್ಟುತನ ಎಷ್ಟು ಅಂತ ಮುಂದೆ ಹೇಳುತ್ತೇನೆ.

ಹಾಗಿದ್ದರೆ ನಮ್ಮ ಹಿಂದಿನ ಹಮ್ಮಿ(program)ನಲ್ಲಿ int ಬದಲಾಗಿ ಈ ಯಾವುದಾದರೂ ತೇಲುವ ಚುಕ್ಕಿಯ ಅಂಕೆಯನ್ನು ಬಳಸಬಹುದು. float ಅನ್ನು ಬಳಸಿ ನೋಡೋಣ.

#include<stdio.h>


main() {
   float km;
   int mile;
   scanf("%d",&mile);
   km = 1.61 * mile;
   printf("%f",km);
}

ಒಟ್ಟಿಸಿ (compile), ಎಸಗಿ(execute) ಪಳಿ(output)ಯನ್ನು ನೋಡೋಣ:

$ ./a.out
2
3.220000

$ ./a.out
5
8.050000

ಉತ್ತರಗಳು ಈಗ ಸರಿಯಾಗಿವೆ!

ಹಳ್ಳಿ ದಾರಿಯಲ್ಲಿ.....

ಮೈಲಿಗಲ್ಲುಗಳು, ಬೋರ್ಡುಗಳು ಇಲ್ಲದೆ ಇರೋ ಹಳ್ಳಿದಾರಿಯಲ್ಲಿ ಯಾವತ್ತಾದರೂ ಗಾಡಿ ಓಡಿಸ್ಕೊಂಡು ಹೋಗಿದ್ದೀರ? ಅಂತಹ ದಾರಿಯಲ್ಲಿ ಅಲ್ಲಲ್ಲಿ ದಾರಿಯ ಬದಿಯಲ್ಲಿ ಸಿಗೋ ಹಳ್ಳಿಯವರೇ ನಮಗೆ ಮೈಲಿಗಲ್ಲುಗಳು, ಬೋರ್ಡುಗಳು ಎಲ್ಲ. ಆದರೆ ತೊಂದರೆ ಏನು ಅಂದರೆ, ಆ ಮೈಲಿಗಲ್ಲುಗಳು ಕೊಡೋ ಮಾಹಿತಿ ತಲೆನಾ ಮೊಸರುಗಡಿಗೆ ಮಾಡದೇ ಇರಲ್ಲ. "ಸ್ಟ್ರೇಟ್ ವೋಯ್ತಾ ಇರಿ ಸಾರ್, ಇನ್ನು ೮ ಮೈಲಿ ಅಶ್ಟೆ" ಅಂತ ಒಬ್ಬನ ಹತ್ತಿರ ಕೇಳಿ ಇನ್ನೂ ೧೨ ಕಿ.ಮೀ ಬಂದ ಮೇಲೆ ಇನ್ನೇನ್ ನಾವ್ ಹೋಗ್ತಾ ಇರೋ ಊರು ಬಂದೇ ಬಿಡ್ತು (೧ ಮೈಲಿ = ೧.೬೧ ಕಿ.ಮೀ, ೮*೧.೬೧ = ೧೨.೮೮) ಅಂತ ಇನ್ನೊಬ್ಬ ಯಾರೋ ಬದಿಯಲ್ಲಿ ಸಿಕ್ಕಿದ ಅಂತ ಕೇಳಿದ್ರೆ "ಏ, ಇನ್ನೇನ್ ಊರ್ ಬಂತ್ರಿ; ಇಲ್ಲಿಂದ ೫ ಕಿಲೋಮೀಟ್ರು ಅಶ್ಟೆ. ಬೇಕಿದ್ರೆ ಈ ಕಡೆ ಎಡಕ್ ತಿರ್ಕೊಂಡ್ ಓಗ್ಬುಡಿ, ಸ್ಯಾನೆ ಅತ್ರ ಆಯ್ತದೆ". ಇದೇನ್ ಈ ಹಯ್ದ ಹೀಗಂದನಲ್ಲ ಅಂತ ತಲೆ ಕೆಡಿಸ್ಕೊಂಡು ಬೇಗ ಹೋಗೋಣ ಅಂತ ಅವನು ತೋರಿಕೊಟ್ಟ short cut ತೊಗೊಂಡರೆ ಸಿಗೋದು ಗಾಡಿನೇ ಓಡಿಸೋದಕ್ಕೆ ಆಗದೆ ಇರೋ ಅಂತಹ ಬರಿ ಕಲ್ಲು-ಮಣ್ಣುಗಳ ದಾರಿ. ಅಲ್ಲಿ ಒದ್ದಾಡಿಕೊಂಡು ಅರೆ ಗಂಟೆಯಲ್ಲಿ ೨ ಕಿ.ಮೀ ಓಡಿಸಿ ಇನ್ನೊಬ್ಬ ಯಾರೋ ಸಿಕ್ದ ಅಂತ ಅವನನ್ನ ದಾರಿ ಕೇಳೋದಕ್ಕೆ ಹೋದ್ರೆ ಮತ್ತೆ ತಲೆಯನ್ನ ಮೊಸರಗಡಿಗೆ ಮಾಡೋ ಉತ್ತರಾನೇ ಸಿಗೋದು.

ಇದನ್ನೆಲ್ಲ, ಇಲ್ಲಿ ಯಾಕೆ ಹೇಳ್ತಿದ್ದೀನಿ ಅಂದ್ಕೊಂಡ್ರಾ? ನನ್ನ ಬ್ಲಾಗಿನ ಮುಂದಿನ ಬರಹದಲ್ಲಿ ಮೈಲಿಗಳನ್ನು ಕಿ.ಮೀಗೆ ಮಾರ್ಪಡಿಸುವ ಒಂದು ಹಮ್ಮನ್ನು ಬರೆದು ತೋರಿಸೋಣ ಅಂತ ಅಂದ್ಕೊಂಡಿದ್ದೆ. ಆದರೆ, ಏನ್ ಮಾಡಲಿ ಹಳ್ಳಿ ದಾರಿಯಲ್ಲಿ ಆದ ಇಂತಹ ಅನುಭವ ನನಗೆ ಕೂಡಲೇ ನೆನಪಾಯ್ತು, ಮತ್ತು ಅದನ್ನು ಹಂಚಿಕೊಳ್ಳದೆ ಇರಲು ಆಗಲಿಲ್ಲ. ಇರಲಿ ಈಗ, ಮೈಲಿಗಳನ್ನ, ಕಿಲೋಮೀಟರ್ ಆಗಿ ಮಾರ್ಪಡಿಸುವ ಈ ಹಮ್ಮನ್ನು ನೋಡಿ:

#include<stdio.h>

main() {

   int km, mile;

   scanf("%d",&mile);

   km = 1.61 * mile;

   printf("%d",km);

}

ಈ ಹಮ್ಮನ್ನು ಒಟ್ಟಿಸಿ(compile), ಎಸಗಿ ನೋಡೋಣ:

$ ./a.out
2
3 $


$ ./a.out
5
8 $

೨*೧.೬೧=೩.೨೨
೫*೧.೬೧=೮.೦೫
ಆದ್ರೆ ಈ ಹಾಳಾದ್ದು ತಪ್ಪು ಉತ್ತರ ಕೊಡ್ತಿದ್ಯಲ್ಲ? ನಮ್ಮ ಹಳ್ಳಿಯವರ ಬುದ್ದಿ ನಮ್ ಹಮ್ಮಿಗೂ ಅಂಟಿಕೊಂಡಿತು ಅಂತ ಅಂದ್ಕೊಂಡ್ರಾ? ಸರಿಯಾಗಿ ಗಮನಿಸಿ ನೋಡಿ. ಇದು ಕೊಡುತ್ತಿರುವ ಪಳಿ(output)ಯಲ್ಲಿ ಹದಿ-ಚುಕ್ಕೆ (decimal point) ಮತ್ತು ಅದರ ಬಳಿಕ ಬರುವ ಅಂಕಿಗಳು ಮಾಯವಾಗಿದ್ದು ಹದಿ-ಚುಕ್ಕೆಯ ಮೊದಲು ಬರುವ ಅಂಕೆ ಸರಿಯಾಗಿಯೇ ಇದೆ. ನಮ್ಮ ಹಮ್ಮನ್ನು ಒಮ್ಮೆ ನೋಡಿದರೆ ಗೊತ್ತಾಗುತ್ತೆ, ನಾವು ಮೈಲಿಯ ಬೆಲೆಯನ್ನು ಪಡೆಯುವ ಮಾರ್ಪಡಬಲ್ಲ(variable)ವನ್ನು ತುಂಬಂಕೆ(int)ಯಾಗಿ ಸಾರಿದ್ದೇವೆ(declared). ಅಂಕೆಯಲ್ಲಿ ಚುಕ್ಕೆ ಬಂದರೆ ಅದು ತುಂಬಂಕೆಯಲ್ಲವಲ್ಲ, ಅದಕ್ಕೆ ಪಳಿ(output)ಯಲ್ಲಿ ಸರಿ-ಉತ್ತರದ ತುಂಬಂಕೆಯ ಪಾಲು ಮಾತ್ರ ಬಂದಿದ್ದು, ಚುಕ್ಕೆ ಮತ್ತು ಅದರ ಬಳಿಕ ಬರುವ ಅಂಕೆಗಳು ಮಾಯವಾಗಿವೆ.

ಮುಂದಿನ ಬರಹದಲ್ಲಿ ಇದನ್ನು ಸರಿಪಡಿಸುವುದು ಹೇಗೆ ಅಂತ ನೋಡೋಣ.

ಸಿ ಕೀಲಿಪದಗಳು

int ಅನ್ನೋ ತುಂಬಂಕೆ(integer)ಯನ್ನು ಸೂಚಿಸುವ ಕೀಲಿಪದ(keyword)ವನ್ನು ಹಿಂದೆ ನೋಡಿದ್ವಿ. ಇದನ್ನು ನೋಡಿದ ಕೂಡಲೇ ನಮಗೆ ಬರಬಹುದಾದ ಕೆಲವು ಪ್ರಶ್ನೆಗಳು ಇವು:

೧. ಕೀಲಿಪದ ಅಂದರೆ ಏನು?
ಉ. ಸಿಯಲ್ಲಿ ಕೆಲವು ಪದಗಳನ್ನು ಮೀಸಲಾಗಿ ಇಡಲಾಗಿದೆ. ಇವುಗಳನ್ನು ಕೆಲಸ(function), ಮಾರ್ಪಡಬಲ್ಲ(variable)ಗಳ ಹೆಸರುಗಳಾಗಿ ಬಳಸುವಂತಿಲ್ಲ.

೨. ಯಾಕೆ ಬೇಕು ಈ ಕೀಲಿಪದಗಳು?
ಉ. ಹಮ್ಮಿನಲ್ಲಿ ನುಡಿಯ ಕಟ್ಟು(construct)ಗಳನ್ನು ತಿಳಿಸಿವುದಕ್ಕೆ, ಕೊಡೆ ಬಗೆಗಳ(data types)ನ್ನು ಸೂಚಿಸುವುದಕ್ಕೆ, ಒಟ್ಟುಕ(compiler)ಕ್ಕೆ ಕೆಲವು ಸುಳಿವುಗಳನ್ನು ನೀಡುವುದಕ್ಕೆ ಬಳಸಲಾಗುತ್ತದೆ.

೩. ಸಿಯಲ್ಲಿ ಎಶ್ಟು ಕೀಲಿಪದಗಳಿವೆ ಮತ್ತು ಅವು ಯಾವುವು?
ಉ. ೩೨. ಆ ಎಲ್ಲ ೩೨ ಕೀಲಿಪದಗಳ ಪಟ್ಟಿ ಇಲ್ಲಿದೆ:

auto     double   int      struct
break    else     long     switch
case     enum     register typedef
char     extern   return   union
const    float    short    unsigned
continue for      signed   void
default  goto     sizeof   volatile
do       if       static   while

೪. ಈ ಒಂದೊಂದು ಕೀಲಿಪದದ ಹುರುಳೇನು?
ಉ. int ಬಗ್ಗೆ ಆಗಲೇ ಹೇಳಿದ್ದೇನೆ. ಮುಂದಿನ ಬರಹಗಳಲ್ಲಿ ಹೊಸ ಕೀಲಿಪದ ಬಳಸಿದಾಗಲೆಲ್ಲ ಅದರ ಹುರುಳನ್ನೂ, ಕುರಿ(ಉದ್ದೇಶ)ಯನ್ನೂ ಹೇಳುತ್ತೇನೆ.

ಸಿ ಹಮ್ಮುಗೆ ೩

ಹಿಂದಿನ ಬರಹದಲ್ಲಿ ಒಂದು ಹೆದೆ (string)ಯನ್ನು ತೆರೆಯ ಮೇಲೆ ಅಚ್ಚಿಸಿದೆವು. ಈಗ ನಮ್ಮ ಎಣಿ(computer)ಯಿಂದ ಕೊಂಚ ಕೆಲಸ ಮಾಡಿಸೋಣ. ದೊಡ್ಡ ಕೆಲಸವೇನೂ ಅಲ್ಲ. ಕೂಡೋ ಲೆಕ್ಕ ಮಾಡಿಸೋಣ. ನಮ್ಮ ಹಮ್ಮು (program) ಎಸಗಿದಾಗ ಮಾಡ ಬೇಕಾಗಿರುವುದು ಇಶ್ಟು:

ಒಂದಾದ ಮೆಲೊಂದಂತೆ ಎರಡು integer ಅಂಕಿಗಳನ್ನು ತೊಗೋಬೇಕು. ಅಂದರೆ ಒಳವೊಡ್ಡಿಗಳಂತೆ (ಒಳ + ಒಡ್ಡು + ಇ = input) ತೊಗೋಬೇಕು. ಆಮೇಲೆ ಅವೆರಡನ್ನೂ ಕೂಡಿಸಿ ಅದರ ಮೊತ್ತವನ್ನು ಪಳಿ(output)ಯಾಗಿ ತೆರೆಯ ಮೇಲೆ ಅಚ್ಚಿಸ ಬೇಕು.

ಬಹಳ ಸುಳುವಾದ ತೊಂದರೆಯ ಹೇಳಿಕೆ (problem statement) ಅಲ್ವಾ? ಇದರ ಬಗೆಹರಿಕೆಯೂ ಅಶ್ಟೆ ಸಲೀಸಾದುದು. ನೋಡೋಣ ಬನ್ನಿ.

#include

main() {

int koodi1, koodi2;

int motta;

main() ಅಲ್ಲಿ ಮೂರು ಮಾರ್ಪಡಬಲ್ಲ(variable)ಗಳನ್ನು ಸಾರಿದ್ದೇವೆ (declare). ಮೊದಲನೇ ಸಾಲಿನಲ್ಲಿ ಎರಡು ಮಾರ್ಪಡಬಲ್ಲಗಳು ನಮ್ಮ ಎರಡು ಕೂಡಿ(addend)ಗಳ ಬೆಲೆ(value)ಗಳನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವುದಕ್ಕೆ. ಅಂದರೆ ಎರಡು ಅಂಕಿಗಳನ್ನು ಒಳವೊಡ್ಡಿ(input)ಯಾಗಿ ಕೊಡ್ತೀವಲ್ವಾ, ಈ ಎರಡು ಮಾರ್ಪಡಬಲ್ಲಗಳು ಒಳವೊಡ್ಡಿದ ಅಂಕಿಗಳ ಬೆಲೆಗಳನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತವೆ. ಮತ್ತು ಇವೆರಡನ್ನು ಕೂಡಿದ ಮೊತ್ತದ ಬೆಲೆಯನ್ನು ಉಳಿಸುವುದಕ್ಕಾಗಿ 'motta' ಎಂಬ ಮಾರ್ಪಡಬಲ್ಲವನ್ನು ಸಾರಿದ್ದೇವೆ. ಇವು ತುಂಬಂಕೆ(integer)ಯ ಬೆಲೆಗಳನ್ನು ಹೊಂದುವುದರಿಂದ int ಎಂಬ ಕೀಲಿಪದ(keyword)ವನ್ನು ಸಾರಿಗೆ(declaration)ಯ ಮೊದಲಲ್ಲಿ ಬಲಸಲಾಗಿದೆ. ಸಾರಿಗೆಯ ಹೇಳಿಕೆಗಳ ಸೋಲ್ಲಿಟ್ಟಳ(syntax)ವನ್ನು, ಕೀಲಿಪದಗಳು ಮತ್ತು ಅವುಗಳ ಬಳಕೆಯನ್ನು ಮುಂದಿನ ಬರಹಗಳಲ್ಲಿ ತಿಳಿಸುತ್ತೇನೆ.

ಈಗ ಒಳವೊಡ್ಡಿಗಳನ್ನು ಪಡೆದುಕೊಳ್ಳೋಣ:

scanf("%d", &koodi1);

scanf("%d", &koodi2);

ಅಶ್ಟೆ! scanf() ಎಂಬುದು stdio.h ಕಣಜ(library)ದಲ್ಲಿರುವ ಒಂದು ಕೆಲಸ(function). ಇದು ಬಳಕೆಗಾರನು ತೆರೆಯ ಮೇಲೆ ನೀಡುವ ಒಳವೊಡ್ಡಿಗಾಗಿ ಕಾಯುತ್ತಿರುತ್ತದೆ. %d ಎಂಬುದು ಬರುವ ಬೆಲೆಯ ಕೊಡೆ ಬಗೆ(data type)ಯು integer ಎಂದು ತಿಳಿಸುತ್ತದೆ.

ಮತ್ತು ಎರಡನೇ ಬಿತ್ತಿಗೆ (parameter) '&koodi1' ಒಳವೊಡ್ಡಿದ ಬೆಲೆಯನ್ನು koodi1 ಮಾರ್ಪಡಬಲ್ಲಕ್ಕೆ ಪಡಿಯಿಸ (copy) ಬೇಕೆಂದು ಹೇಳುತ್ತದೆ. ಎರಡು ಸಲ scanf() ಕರೆಯುವುದರ ಕುರಿ (ಉದ್ದೇಶ) ಎರಡು ಕೂಡಿ(addend)ಗಳ ಬೆಲೆಗಳನ್ನು ಒಳವೊಡ್ಡುವುದು.

ಅದೇನೋ ಸರಿ, ಆದರೆ ಎರಡನೇ ಬಿತ್ತಿಗೆಯಲ್ಲಿ, kood1 ಮತ್ತು koodi2 ಮುಂದೆ & ಯಾಕೆ ಬಂದಿದೆ? 'ಹಮ್ಮುಗೆ'(programming)ಯಲ್ಲಿ ಕೆಲಸ(function)ಗಳಿಗೆ ಬಿತ್ತಿಗೆಗಳನ್ನು ಕೊಡುವ ಎರಡು ಬಗೆಗಳಿವೆ: 'ಬೆಲೆಯನ್ನು ಪಡಿಯಿಸುವುದು' ಮತ್ತು 'ಪತ್ತುಗೆಯನ್ನು ಪಡಿಯಿಸುವುದು' (copy by value, copy by reference). ಮುಂದೆ & ಹಾಕುವುದರಿಂದ ಕೆಲಸದೊಳಕ್ಕೆ ಪತ್ತುಗೆಯನ್ನು ಪಡಿಯಿಸಲಾಗುತ್ತದೆ. ಇದು ಏನು, ಯಾಕೆ, ಎತ್ತ ಅಂತೆಲ್ಲ ಈಗ ತಲೆ ಕೆಡಿಸ್ಕೊಳ್ಳೋದು ಬೇಡ. ಮುಂದೆ ಯಾವಾಗಲಾದರೂ ಹೇಳುತ್ತೇನೆ. ಸದ್ಯಕ್ಕೆ & ಬಳಸಬೇಕು ಅಂತ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಿ ಸಾಕು.

ಎರಡು ಕೂಡಿಗಳ ಬೆಲೆ ತೆಗೆದು ಕೊಂಡಿದ್ದಾಯಿತು. ಈಗ ಅವೆರಡನ್ನೂ ಕೂಡಿಸಿ mottaಕ್ಕೆ ಅದರ ಬೆಲೆಯನ್ನು ಒಪ್ಪಿಸೋಣ (assign).

motta = koodi1 + koodi2;

ಈಗ ಅದನ್ನು ತೆರೆಯ ಮೇಲೆ ಅಚ್ಚಿಸೋಣ.

printf("\n%d", motta);

main() ಕೆಲಸ (function)ವನ್ನು ಮುಕ್ತಾಯ ಮಾಡೋಣ.

}