Exercises Software Development I. 03 Data Representation. Data types, range of values, internal format, literals. October 22nd, 2014

Transcription

1 Exercises Software Development I 03 Data Representation Data types, range of values, ernal format, literals October 22nd, 2014 Software Development I Wer term 2013/2014 Priv.-Doz. Dipl.-Ing. Dr. Andreas Riener Institute for Pervasive Computing Johannes Kepler University Linz riener@pervasive.jku.at

2 Terminology: Variables Each variable is, when defined, related to a specific data type Data type defines the range of values, e.g., byte = (8bit) At runtime, each and every variable has also assigned a concrete value Default value Assigned by the programmer Determined within assignment operation Values (eger, float, characters, etc.) are ernally represented (i.e., working memory) as binary numbers ( calculating with binary numbers?) Data type conversions Possible, but not always without loss (of precision) Software Development I // Exercises // 03 Data Representation // 2

3 Variables: Data Types and Range of Values Integer types byte 8bit -128 to +127 short 16bit to bit to (= to 2 31, 32nd bit used for sign) long 64bit to Floating-po types float 32bit single precision double 64bit double precision Character type char 16bit single character, Unicode character set modes of assignments 1) alphanumeric character in single quote ('a', 'B', etc.) 2) 4-digit hexadecimal Unicode index (\u0000 to \uffff) 3) Integer value (16bit unsigned; 0 to 65535) (?) Software Development I // Exercises // 03 Data Representation // 3

4 Internal Format: Integer Values Values (of any data type) are ernally represented as binary numbers (sequence of digits 0/1) Example: short number1, number2, result; //short 16 bit number1 = 7; number2 = 15; result = number1 + number2; result = (short) number1 + number2; // Java speciality! // (more later) //calculation number1 = number2 = result = Software Development I // Exercises // 03 Data Representation // 4

5 Internal Format: From Binary to Integer Numbers Given: binary number b n+1 b n b n-1... b 2 b 1 //b n+1 = sign Leading sign: 1st (leading) bit as indicator for positive/negative number b n+1 = 0 positive number b n+1 = 1 negative number Wanted: its (positive) eger value x x = n i= 1 2 Example: x x x x x 2 4 = st bit is reserved for the leading sign maximum positive number (data type short): 16bit 1bit (sign) = = = b i i 1 [short: n=15, : n=31, long: n=63] Software Development I // Exercises // 03 Data Representation // 5

6 Internal Format: (Negative) Integer Values Given: binary number b n+1 b n b n-1... b 2 b 1 //b n+1 = sign Wanted: its (negative) eger value x not that easy: different variants possible (dependent, e.g., on computer or operating system architecture) Variant 1: Simple signed Binary number b n+1 b n b n-1... b 2 b 1 Remember: b n+1 =0 for positive numbers, b n+1 =1 for negative numbers Example (datatype short): Integer number 24 = , data type short (2 Byte) Integer number -24 = , data type short (2 Byte) All the other digits are not affected by the most significant digit (sign) Software Development I // Exercises // 03 Data Representation // 6

7 Internal Format: (Negative) Integer Values Variant 2: One s complement b n+1 =1 (negative number): bitwise inversion of every digit Example (datatype short): Integer number 24 = , data type short (2 Byte) Integer number -24 = , data type short (2 Byte) Software Development I // Exercises // 03 Data Representation // Every single digit is affected by the sign inversion is effective! Variant 3: Two s complement (implemented in Java) b n+1 =1 (negative number): one s complement + 1 Example (datatype short): Integer number 24 = , data type short (2 Byte) Integer number -24 = , data type short (2 Byte) [one s complement) Integer number -24 = , data type short (2 Byte) [two s complement) Todays computer system usually implement two s complement reason: simplified ernal representation (no additional control logic)

8 I Internal Format: Why is the negative number range greater by one? Expert knowledge Internal representation (example 16bit): Largest positive number ( = 32767) Largest negative number; Expectation = -(largest positive number + 1)? (1) // if data type not fixed to 16bit, // i.e., no overflow One s complement: (0) Two s complement (=One s complement + 1): Software Development I // Exercises // 03 Data Representation // 8

9 Internal Format: Floating-po Numbers s e1 e2... e8 f1 f2 f3... f23 Sign s Exponent e Mantissa M 0 = +; 1 = - exp floating-po num. <1; power of 2 (neg.) Normalized representation: (-1) s 2 exp M (for 0 < e < 255) M = f 1 x f 2 x f 3 x f 23 x 2-23 Not every real number can be represented using this floating-po format. Why? Each and every finite erval [a, b[ has room for endless (infinite) real numbers Only a subset of them can be represented using only a finite number of n Bytes (e.g. in Java n=4 for float, n=8 for double) Software Development I // Exercises // 03 Data Representation // 9

10 Internal Format: Floating-po Numbers Example: Floating-po number Leading sign: s = -1 Exponent exp = 134 ( =134) Mantissa M = 0 x x x = 0.25 Result (floating-po number): = = exact, i.e., no loss of precision! Software Development I // Exercises // 03 Data Representation // 10

11 Internal Format: Floating-po Numbers Special cases +/- Infinity and Not-a-Number (NaN) requires particular requirements/predefinitions +/- Infinity: Mantissa M is set to 0, exponent exp is set to Infinity binary representation: floating-po number: = = Infinity - Infinity binary representation: floating-po number: = = -Infinity Not-a-Number: Mantissa M is >0 (any digit!=0), exponent exp is set to 255 NaN binary representation:? ??????????????????????? 2 floating-po number:? ? =? ? = NaN Software Development I // Exercises // 03 Data Representation // 11

12 Internal Format: Floating-po Numbers Floating-po number 0.0 requires special treatment (not representable in standard floating-po format!) s e1 e2... e8 f1 f2 f3... f23 Sign s Exponent e Mantissa M 0 = +; 1 = - exp floating-po num. <1; power of 2 (neg.) Sub-normal representation: (-1) s M (for e=0) M = f 1 x f 2 x f 3 x f 23 x 2-23 Mantissa M = 0, exponent exp = (positive) binary representation: floating-po number: = (negative) binary representation: floating-po number: = -0.0 Software Development I // Exercises // 03 Data Representation // 12

13 I SWE1 UE03 RoundingError.zip Internal Format: Floating-po Numbers Origin of rounding errors Example: float f1 = 1.1f; float f2 = 0.1f; float f3 = f1-2*f2; // exact value: 1.1f-2*0.1f = 0.9f if (f1==1.1f) System.out.prln(f1); // output: "1.1" if (f2==0.1f) System.out.prln(f2); // output: "0.1" if (f3==0.9f) System.out.prln(f3); // never reached; f3 is ! if (f3==(1.1f-2*0.1f)) System.out.prln(f3); // reached; output: " " Software Development I // Exercises // 03 Data Representation // 13

14 Implicit, explicit type conversions

15 I Data Types: Implicit Type Conversion +-*/% char byte short long float double char long float double byte long float double short long float double long float double long long long long long long float double float float float float float float float double double double double double double double double double Software Development I // Exercises // 03 Data Representation // 15

16 Data Types: Numeric Type Conversions Implicit & Explicit Rules for implicit (i.e., no type cast) and explicit type conversions Any eger type can be assigned without explicit conversion to any other greater (i.e., more bits ) eger type (e.g. byte, short to ) Character data type char is without explicit type conversion compatible to be assigned to all eger types (, and long) (Explicitly) converting an eger data type o another eger type of smaller size (i.e., fewer bits ): higher bits are truncated, the leading sign (most significant bit) is cut as well (sign is not adjusted!) Conversion from floating-po type double to float: Result is rounded (that float value with fewest difference to the original double value) Conversion from floating-po to eger data type is done by simply truncating all the decimal places (rounding against zero!); is the eger part of the floating-po number too large to fit o the corresponding eger data type then the result is the maximum (or minimum) representable number of that data type Software Development I // Exercises // 03 Data Representation // 16

17 Data Types: Conversion from Floating-po to Integer Number In any case such a conversion requires an explicit type cast; Java uses rounding against zero loss of precision! Example Truncating public static void main (String[] arg) { res1, res2; float number1 = 12.34f; double number2 = ; } res1 = ()number1; res2 = ()number2; System.out.prln(res1); System.out.prln(res2); Results res1 = 12 res2 = -67 Example Overflow public static void main (String[] arg) { float numfl = f; numint; > MAX(); result: numint = MAX() = Software Development I // Exercises // 03 Data Representation // 17 } numint = ()numfl; System.out.prln(numInt); Result numint =

18 Data Types: Conversion from Integer to Integer Number Converting from large eger type o another eger type of smaller size (i.e., fewer bits ): higher bits are truncated, no sign adjustment public static void main (String[] arg) { numint1 = ; // numint2 = ; // short numshort1 = (short) numint1; // short numshort2 = (short) numint2; // } System.out.prln(numShort1); System.out.prln(numShort2); 32bit 16bit most significant bit = sign! Results numshort1 = numshort2 = 7616 ( =7616) Software Development I // Exercises // 03 Data Representation // 18

19 I Data Types: Character representation (type char) ASCII (American Standard Code for Information Interchange) code table Char Dec Oct Hex Char Dec Oct Hex Char Dec Oct Hex Char Dec Oct Hex (nul) x00 (sp) x40 ` x60 (soh) x01! x21 A x41 a x61 (stx) x02 " x22 B x42 b x62 (etx) x03 # x23 C x43 c x63 (eot) x04 $ x24 D x44 d x64 (enq) x05 % x25 E x45 e x65 (ack) x06 & x26 F x46 f x66 (bel) x07 ' x27 G x47 g x67 (bs) x08 ( x28 H x48 h x68 (ht) x09 ) x29 I x49 i x69 (nl) x0a * x2a J x4a j x6a (vt) x0b x2b K x4b k x6b (np) x0c, x2c L x4c l x6c (cr) x0d x2d M x4d m x6d (so) x0e x2e N x4e n x6e (si) x0f / x2f O x4f o x6f (dle) x x30 P x50 p x70 (dc1) x x31 Q x51 q x71 (dc2) x x32 R x52 r x72 (dc3) x x33 S x53 s x73 (dc4) x x34 T x54 t x74 (nak) x x35 U x55 u x75 (syn) x x36 V x56 v x76 (etb) x x37 W x57 w x77 (can) x x38 X x58 x x78 (em) x x39 Y x59 y x79 (sub) x1a : x3a Z x5a z x7a (esc) x1b ; x3b [ x5b { x7b (fs) x1c < x3c \ x5c x7c (gs) x1d = x3d ] x5d } x7d (rs) x1e > x3e ^ x5e ~ x7e (us) x1f? x3f _ x5f (del) x7f Software Development I // Exercises // 03 Data Representation // 19 Specific mapping between character and number (1-127) After the 128 th character, the mapping allows for country (code table) specific character sets, etc.

20 Data Types: Character representation (type char) Examples: Calculation with characters public static void main (String[] arg) { char charres = 'b'-'a'; = = 1 System.out.prln(()charRes); System.out.prln('b'-'a'); // simplified } Reverse calculation: from number to character public static void main (String[] arg) { char chara = 'A'; char charb; } charb = (char) (chara+1); = (char)(65+1) = (char)66 = 'B' System.out.prln(()charB); System.out.prln('A'+1); // simplified Application: Lowercase to uppercase conversion public static void main (String[] arg) { char charupper, charlower = 'q'; charupper = (char) (charlower-'a'+'a'); } Software Development I // Exercises // 03 Data Representation // 20 = (char)( ) = (char) 81 = 'Q'

21 Literals in Java In computer science, a literal is a notation for representing a fixed value in source code. Almost all programming languages have notations for atomic values such as egers, floating-po numbers, strings, and booleans

22 I Java Literals: General Introduction What you type is what you get By literal we mean any number, text, or other information that represents a (concrete) value ( constant ) Literals in a Java program represent fixed and atomic values Literals must not be mixed up with the declaration of constants Example //eger literal, value 10 month = 10; In Java the following types of literals are known Integer/long numbers: 0; 123; 0xDadaCafe / 12L; 022L; Float/double numbers: 3.2f; -3e-22f / 3.2; -3e-22D Logic literals: true; false Character literals: 'A'; 'z'; '1' String literals: ""; "\""; "Hello World Reference literals: null; this; super Software Development I // Exercises // 03 Data Representation // 22

23 Java Literals: Integer type Integer literals are a sequence of digits To represent the type as long eger the value is followed by a suffix L or l Integer variables may be represented in Decimal format (base 10): default, no prefix/suffix needed - Example age = 19; Decimal format, long - Example long longliteral = L; Octal format (base 8): prefix 0 (zero) followed by digits 0 to 7 - Example octage = 023; Hexadecimal (base 16) : prefix 0x - Examples hexage = 0x13; short largeshort = 0xff32; // Software Development I // Exercises // 03 Data Representation // 23

24 Java Literals: Hands on Experience (Integer) What about eger literals of type short/byte? eger literals are in Java always of type or long no short/byte literals, Examples short s = 100; // max(s)=32767 // ok; literal; implicit type cast to 'short' (compiler) // assigned only if '' literal fits o 'short' type short s = ; // max(s)=32767 // Type mismatch: cannot convert from to short short s = ; // max(s)=32767 // The literal of type is out of range // Type mismatch: cannot convert from to short short s = L; // max(s)=32767 // Type mismatch: cannot convert from long to short Software Development I // Exercises // 03 Data Representation // 24

25 Java Literals: Character type Character literals are specified as a single prable character in a pair of single quote characters (ASCII character set: letters, numerals, punctuations, etc.) Standard characters - Examples char h = 'h', e = 'E', one = '1', special = '#'; Characters represented by their eger value (dec, hex, oct, dec) - Examples char h = 104, e = 0x45, one = 061, special = 35; Special characters (not readily prable through a keyboard): Escape sequences - Examples char newline = '\n', singlequote = '\'', backslash = '\\'; - Newline symbol - can be used to detect if the user has pressed the return key - but: '\n' may have, depending on the platform, different meaning, e.g. carriage return (CR), carriage return + line feed (CR+LF), etc. - in Java both symbols ('\n', '\r' ) have different, fixed values! Software Development I // Exercises // 03 Data Representation // 25

26 Java Literals: Character type (con t) Character literals are specified as a single prable character in a pair of single quote characters (ASCII character set: letters, numerals, punctuations, etc.) Escape sequences in combination with numbers '\d' octal '\xd' hexadecimal '\ud' Unicode character d represents in each case a number Examples char unicodechar = '\u0041' //capital letter A = '\u0030' //digit 0 = '\u0022' //double quote " = '\u003b' //punctuation ; = '\u0009' //horizontal tab Software Development I // Exercises // 03 Data Representation // 26

27 Java Literals: Floating po type Floating po literals are like real numbers in mathematics Java has two kinds of floating po numbers: float and double; default type when you enter a floating po literal is double Floating po literals can be denoted as a decimal po, a fraction part, an exponent (represented by e or E), or as an eger; to represent the precision a suffix f or F (float) or d/d (double) may be added Examples Single precision float one = 1.0f, pi = f, num = 4/5f, small = 2.9e-12f; Double precision double large = 6.5E32, one = 1D, belowzero= ; Software Development I // Exercises // 03 Data Representation // 27

28 Java Literals: Hands on Experience (Float) Mixed operations with float/double literals Example 1 float weight = 1.3; float weight = 1.3f; double weight = 1.3f; float f1 = (float)1.2; Error: double float ( type mismatch: cannot convert... ) Example 2 byte count = 5; float totalweight = count * weight; totalweight = count float * weight float = 5.0 * 1.3 = 6.5 Example 3 double x = 2.0 * 0.5; y; y = x; y = ()x; ok: explicit cast = () 1.0 = 1 Error: double ( type mismatch: cannot convert... ) Software Development I // Exercises // 03 Data Representation // 28

29 I SWE1 UE03 RoundingError.zip Java Literals: Hands on Experience (Float) Wrong result for the division of two numbers ( literals ) Why? Example:! float onethirdwrong = 3/9; // 3() /() 9() = 0() -> 0.0(float) WRONG! float onethirdcorrect = 3f/9; // 3(float) /(float) 9(float) = (float)! number1 = 10; number2 = 3; double result = number1 / number2; // Same as before: division in type (type conversion table!) // Result enlarged to double (3 -> 3.0f), assigned to result WRONG! // Also wrong; 10/3 () = 3 -> 3.0D, assigned to result result = (double)(number1 / number2); // Correct solution ( ): // Use explicit type cast (either of number1 or number2) result = (double)number1 / number2; result = number1 / (double)number2; Software Development I // Exercises // 03 Data Representation // 30

30 I Data Types: Calculations with Different, Mixed Types Just few simple rules Data type with greater range of values dominates Explicit type casts to smaller data types Take care of decimal places and range of values (overflow) In-class activity (try on your own!) //use in each case the initial assignment a = 10; short b = 20; byte c = 30; float d = 1.2f; double e = 2.2; problem1: a + b + c + d + e =? problem2: a + b + c + () (d + e) =? problem3: () (e * e) (5 b c) * d =? Software Development I // Exercises // 03 Data Representation // 31

31 Exercises Software Development I 03 Data Representation Data types, range of values, ernal format, literals October 22nd, 2014 Software Development I Wer term 2013/2014 Priv.-Doz. Dipl.-Ing. Dr. Andreas Riener Institute for Pervasive Computing Johannes Kepler University Linz riener@pervasive.jku.at