2018 Marcin Kukliński. Niesforne bity i bajty

Transkrypt

1 Niesforne bity i bajty

2 2 Kilka słów O senghe@gmail.com

3 3

5 Ekipa cpp-polska 5 Marcin Kukliński Wojciech Razik Michał Rudowicz Bartłomiej Filipek Kompilacja & Mario::Edit CppNews & Modern C++ Modern C++ C++17

6 Nasze statystyki 6

7 Nasze statystyki 7

8 Znajdziecie nas @CppPolska

9 Naszym celem jest: 9 Propagowanie wiedzy o nowoczesnym C++

10 Może do nas dołączysz? 10 Ty

11 11 Wracając do bitów

12 12 To jest bit 1

13 13 To też jest bit 0

14 14 1 A to jest bajt

15 15 Liczby całkowite

16 Kod uzupełnień do jedności (U1) 16

17 Kod uzupełnień do jedności (U1) 17 Kod uzupełnień do jedności to sposób zapisu liczb całkowitych oznaczany jako ZU1 lub U1. Liczby dodatnie zapisywane są jak w naturalnym kodzie binarnym, przy czym najbardziej znaczący bit traktowany jako bit znaku musi mieć wartość 0. Do reprezentowania liczb ujemnych wykorzystywana jest bitowa negacja danej liczby, co sprawia, że bit znaku ma wartość 1. Źródło:

18 Kod uzupełnień do jedności (U1)

22 Kod uzupełnień do jedności (U1) = 67

23 Kod uzupełnień do jedności (U1) =

28 Kod uzupełnień do jedności (U1) = = -67

29 29 Co z zerem?

30 U1 daje nam dwie wartości zerowe 30 Zero dodatnie: Zero ujemne:

31 Kod uzupełnień do dwóch (U2) 31

32 Kod uzupełnień do dwóch (U2) 32 Kod uzupełnień do dwóch (w skrócie U2 lub ZU2) system reprezentacji liczb całkowitych w dwójkowym systemie pozycyjnym. Jest obecnie najpopularniejszym sposobem zapisu liczb całkowitych w systemach cyfrowych. ( ) Zaletą tego kodu jest również istnienie tylko jednego zera. Przedział kodowanych liczb nie jest przez to symetryczny. Źródło:

33 Kod uzupełnień do dwóch (U2)

37 Kod uzupełnień do dwóch (U2) = 67

38 Kod uzupełnień do dwóch (U2) =

43 Kod uzupełnień do dwóch (U2) = = -67 1

44 Kod uzupełnień do dwóch (U2) 44 unsigned char

45 Kod uzupełnień do dwóch (U2) 45 unsigned char signed char

46 46 Dlaczego to jest ważne?

47 Co mówi standard 47 The range of representable values for a signed integer type is 2 N 1 to 2 N 1 1 (inclusive), where N is called the range exponent of the type Źródło:

48 48 Integer Overflow

49 Integer Overflow 49 Wyrzucenie wyjątku INT_MAX + 10 = Exception

50 Integer Overflow 50 Przycięcie wyniku INT_MAX + 10 = 10

51 Integer Overflow 51 Saturacja INT_MAX + 10 = INT_MAX

52 Co mówi standard 52 For each of the standard signed integer types, there exists a corresponding (but different) standard unsigned integer type: unsigned char, unsigned short int, unsigned int, unsigned long int, and unsigned long long int. Likewise, for each of the extended signed integer types, there exists a corresponding extended unsigned integer type. The standard and extended unsigned integer types are collectively called unsigned integer types. An unsigned integer type has the same range exponent N as the corresponding signed integer type. The range of representable values for the unsigned type is 0 to 2 N 1 (inclusive); arithmetic for the unsigned type is performed modulo 2 N. [ Note: Unsigned arithmetic does not overflow. Overflow for signed arithmetic yields undefined behavior Źródło:

53 53 Integer Overflow to UB

54 Undefined Behavior 54 Nie mamy pewności, co zostanie wykonane przez procesor

55 Undefined Behavior 55 Nie mamy pewności, co zostanie wykonane przez procesor Kompilator zakłada, że niezdefiniowane zachowanie nigdy nie ma miejsca

56 Undefined Behavior 56 Nie mamy pewności, co zostanie wykonane przez procesor Kompilator zakłada, że niezdefiniowane zachowanie nigdy nie ma miejsca Cała odpowiedzialność zostaje zrzucona na programistę

57 57 UB vs Implementation Defined

58 Jak radzić sobie z Integer Overflow? 58 int add(int a, int b) { } int sum = a + b; if (a > 0 && b > 0) { if (sum < a) { throw E(); } if (sum < b) { } } return sum; throw E();

59 Jak radzić sobie z Integer Overflow? 59 int add(int a, int b) { int sum = a + b; if (a > 0 && b > 0) { // if (sum < a) { // throw E(); // } // if (sum < b) { // throw E(); // } } } return sum;

60 Jak radzić sobie z Integer Overflow? 60 unsigned add(unsigned a, unsigned b) { if (INT_MAX-a < b) { throw E(); } return a + b; }

61 Jak radzić sobie z Integer Overflow? 61 unsigned add(unsigned a, unsigned b) { if (INT_MAX-a < b) { throw E(); } return a + b; }

62 Jak radzić sobie z Integer Overflow? 62 int add(int a, int b) { } if (b > 0 && a > 0) { if (INT_MAX-a < b) { throw E(); } } else if (b < 0 && a < 0) { if (INT_MIN-a > b) { } throw E(); } return a + b;

66 66 Ukryty Integer Overflow

67 Ukryty Integer Overflow 67 int main(int argc, char* argv[]) { uint64_t v = 0x * 2; std::cout << std::hex << v << std::endl; return 0; }?

68 Ukryty Integer Overflow 68 int main(int argc, char* argv[]) { uint64_t v = 0x * 2; std::cout << std::hex << v << std::endl; return 0; }

71 Ukryty Integer Overflow 71 int main(int argc, char* argv[]) { uint64_t v = 0x ULL * 2; std::cout << std::hex << v << std::endl; return 0; }

72 Ukryty Integer Overflow 72 int main(int argc, char* argv[]) { uint64_t v = 0x * 2ULL; std::cout << std::hex << v << std::endl; return 0; }

73 Ukryty Integer Overflow 73 int main(int argc, char* argv[]) { uint64_t v = 0x * 2ULL; std::cout << std::hex << v << std::endl; return 0; }

74 74 Czym jest promocja typu?

75 Czym jest promocja typu 75 Promocją typu nazywamy proces polegający na zwiększeniu ilości bajtów przechowujących konkretną wartość bez zmiany tej wartości.

76 Czym jest promocja typu 76 8 bit => 16 bit

77 Czym jest promocja typu 77 8 bit => 16 bit unsigned => unsigned =>

78 Czym jest promocja typu 78 8 bit => 16 bit unsigned => unsigned => signed => signed =>

79 79 Czym jest konwersja typu?

80 Czym jest konwersja typu? 80 Konwersją typu nazywamy proces polegający na zmianie kodowania przechowywanej wartości, niekoniecznie zmieniając przy tym samą wartość.

81 Czym jest konwersja typu? 81 int32_t 42 =>

82 Czym jest konwersja typu? 82 int32_t 42 => float 42.0f =>

83 Ukryty Integer Overflow 83 #include <iostream> int main(int argc, char* argv[]) { std::cout << abs(int_min) << std::endl; return 0; }?

84 Ukryty Integer Overflow 84 #include <iostream> int main(int argc, char* argv[]) { std::cout << abs(int_min) << std::endl; return 0; }

85 Zwykła implementacja 85 unsigned abs(int value) { if (value < 0) { return -value; } return value; }

86 Poprawna implementacja 86 unsigned safe_abs(int value) { if (value == INT_MIN) { throw E{}; } return abs(value); }

87 87 Big Integer

88 Big Integer 88 Każda cyfra przechowywana jest jako kolejny element tablicy (niekoniecznie w formie dziesiętnej)

89 Big Integer 89 Każda cyfra przechowywana jest jako kolejny element tablicy (niekoniecznie w formie dziesiętnej) Operacje na Big Integer-ach przypominają operacje pisemne stosowane w szkole podstawowej

90 Big Integer 90 Każda cyfra przechowywana jest jako kolejny element tablicy (niekoniecznie w formie dziesiętnej) Operacje na Big Integer-ach przypominają operacje pisemne stosowane w szkole podstawowej Biblioteka standardowa C++ nie posiada implementacji dla Big Integer

91 Big Integer 91 Każda cyfra przechowywana jest jako kolejny element tablicy (niekoniecznie w formie dziesiętnej) Operacje na Big Integer-ach przypominają operacje pisemne stosowane w szkole podstawowej Biblioteka standardowa C++ nie posiada implementacji dla Big Integer Biblioteka Boost posiada implementację Big Integer: boost/multiprecision/cpp_int

92 Big Integer 92 Zaleta: Ogarniamy duże liczby

93 Big Integer 93 Zaleta: Ogarniamy duże liczby Wada: Procesory natywnie nie wspierają Big Integer-ów

94 Big Integer 94 Zaleta: Ogarniamy duże liczby Wada: Procesory natywnie nie wspierają Big Integer-ów Wada: Im większa liczba, tym wolniej się liczy

95 95 Ułamki bitowe

96 Ułamki bitowe dec =?bin

97 Ułamki bitowe dec =?bin 14 / 2 = / 2 = / 2 = / 2 = 0 1

98 Ułamki bitowe dec = 1110.?bin

99 Ułamki bitowe dec = 1110.?bin * 2 = * 2 = * 2 = * 2 = * 2 = 0

100 Ułamki bitowe dec = bin

101 Ułamki bitowe dec = bin

102 Ułamki bitowe 102 Stosując ułamki bitowe, to my decydujemy o ich dokładności

103 Ułamki bitowe 103 Stosując ułamki bitowe, to my decydujemy o ich dokładności Na ułamkach bitowych można operować podobnie jak na liczbach całkowitych

104 Ułamki bitowe 104 Stosując ułamki bitowe, to my decydujemy o ich dokładności Na ułamkach bitowych można operować podobnie jak na liczbach całkowitych Biblioteka standardowa C++ nie posiada implementacji dla liczb stałoprzecinkowych

105 Ułamki bitowe 105 Stosując ułamki bitowe, to my decydujemy o ich dokładności Na ułamkach bitowych można operować podobnie jak na liczbach całkowitych Biblioteka standardowa C++ nie posiada implementacji dla liczb stałoprzecinkowych Przykładowa implementacja: fixed_point

106 106 Liczby zmiennoprzecinkowe

107 Ile razy zostanie wykonana pętla? 107 #include <iostream> int main() { float i=0.0f; do { std::cout << "Loop " << std::endl; i+=0.1f; } while (i!= 1.0f); }

108 Ile razy zostanie wykonana pętla? 108 #include <iostream> int main() { float i=0.0f; do { std::cout << "Loop " << std::endl; i+=0.1f; } while (i!= 1.0f); } Odpowiedź: to jest pętla nieskończona

109 109 Ale dlaczego?

110 Niedokładne liczby zmiennoprzecinkowe 110 #include <iostream> #include <iomanip> int main() { std::cout << std::setprecision(10) << 0.1f << std::endl; } Na wyjściu:

111 Co pojawi się na wyjściu? 111 #include <iostream> #include <iomanip> int main() { float amountofproduct = f; unsigned long int quantity = ; float amountofcheckout = amountofproduct*quantity; } std::cout << std::setprecision(15) << amountofcheckout << std::endl; return 0;

112 Co pojawi się na wyjściu? 112 #include <iostream> #include <iomanip> int main() { float amountofproduct = f; unsigned long int quantity = ; float amountofcheckout = amountofproduct*quantity; } std::cout << std::setprecision(15) << amountofcheckout << std::endl; return 0; Odpowiedź:

113 Co mówi standard 113 There are three floating-point types: float, double, and long double. The type double provides at least as much precision as float, and the type long double provides at least as much precision as double. The set of values of the type float is a subset of the set of values of the type double; the set of values of the type double is a subset of the set of values of the type long double. The value representation of floating-point types is implementation-defined. [ Note: This document imposes no requirements on the accuracy of floating-point operations; see also [support.limits]. end note ] Integral and floating-point types are collectively called arithmetic types. Specializations of the standard library template std::numeric_limits shall specify the maximum and minimum values of each arithmetic type for an implementation. Źródło:

114 114 Standard IEEE 754

115 Standard IEEE dec = bin

116 Standard IEEE Znak Wykładnik Mantysa 0.1dec = bin

117 Standard IEEE Znak Wykładnik Mantysa 0.1dec = bin float 1 bit 8 bitów 23 bity

118 Standard IEEE Znak Wykładnik Mantysa 0.1dec = bin float double 1 bit 8 bitów 23 bity 1 bit 11 bitów 52 bity

119 Standard IEEE Znak Wykładnik Mantysa 0.1dec = bin float double 1 bit 8 bitów 23 bity 1 bit 11 bitów 52 bity bias = 127 bias = 1023

120 120 Float to bin

121 Standard IEEE dec =

122 Standard IEEE Znak dec = 1

123 Standard IEEE Znak dec = 1 41 / 2 = / 2 = / 2 = / 2 = / 2 = / 2 = 0 1

124 Standard IEEE Znak Mantysa dec =

125 Standard IEEE dec = Znak Mantysa 0.27 * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = * 2 = 0.08

129 Standard IEEE Znak Mantysa dec = = 132dec =

130 Standard IEEE Znak Mantysa dec = = 132dec = 132 / 2 = / 2 = / 2 = 16 1 = bin 16 / 2 = / 2 = / 2 = / 2 = / 2 = 0 1

131 Standard IEEE Znak Wykładnik Mantysa dec =

134 134 Bin to float

135 Standard IEEE Znak Wykładnik Mantysa?dec =

136 Standard IEEE Znak Wykładnik Mantysa?dec = L = (-1) Z * M * 2 K-bias

137 Standard IEEE Znak Wykładnik Mantysa?dec = L = (-1) Z * M * 2 K-bias

138 Standard IEEE Znak Wykładnik Mantysa?dec = L = (-1) 1 * M * 2 K-bias

139 Standard IEEE Znak Wykładnik Mantysa?dec = L = (-1) 1 * M * 2 K-127

140 Standard IEEE Znak Wykładnik Mantysa?dec = L = (-1) 1 * M *

141 Standard IEEE Znak Wykładnik Mantysa?dec = L = (-1) 1 * *

142 Standard IEEE Znak Wykładnik Mantysa?dec = L = -1 * * 2 5

143 Standard IEEE Znak Wykładnik Mantysa?dec = L = * 32

144 Standard IEEE Znak Wykładnik Mantysa?dec = L =

147 Standard IEEE Wartości specjalne NaN =>

148 Standard IEEE Wartości specjalne NaN => INF =>

149 Standard IEEE Wartości specjalne NaN => INF => INF =>

150 150 Boost multiprecision

151 Boost multiprecision 151 // Sprawdzamy, czy możemy osiągnąć wartość 0.1 long double a = 0.1; std::cout << std::setprecision(100) << a << std::endl; cpp_dec_float_100 b("0.1"); std::cout << std::setprecision(100) << b << std::endl;

152 Boost multiprecision 152 long double a = 0.1; std::cout << std::setprecision(100) << a << std::endl; cpp_dec_float_100 b("0.1"); std::cout << std::setprecision(100) << b << std::endl; Na wyjściu:

153 Boost multiprecision 153 cpp_dec_float_100 counter; // Domyślna wartość jest ustawiana na 0 do { std::cout << "Loop " << std::endl; counter += cpp_dec_float_100("0.1"); } while (counter!= 1.0);

154 Boost multiprecision 154 cpp_dec_float_100 counter; // Domyślna wartość jest ustawiana na 0 do { std::cout << "Loop " << std::endl; counter += cpp_dec_float_100("0.1"); } while (counter!= 1.0); Pętla wykona się dokładnie 10 razy

155 Boost multiprecision 155 float amountofproduct = f; unsigned long int quantity = ; float amountofcheckout = amountofproduct*quantity; std::cout << std::setprecision(30) << amountofcheckout << std::endl; cpp_dec_float_50 amountofproduct2 = cpp_dec_float_50("254.99"); cpp_dec_float_50 quantity2 = cpp_dec_float_50(" "); cpp_dec_float_50 amountofcheckout2 = cpp_dec_float_50(amountofproduct2*quantity2); std::cout << std::setprecision(30) << amountofcheckout2 << std::endl;

156 Boost multiprecision 156 float amountofproduct = f; unsigned long int quantity = ; float amountofcheckout = amountofproduct*quantity; std::cout << std::setprecision(30) << amountofcheckout << std::endl; cpp_dec_float_50 amountofproduct2 = cpp_dec_float_50("254.99"); cpp_dec_float_50 quantity2 = cpp_dec_float_50(" "); cpp_dec_float_50 amountofcheckout2 = cpp_dec_float_50(amountofproduct2*quantity2); std::cout << std::setprecision(30) << amountofcheckout2 << std::endl; Na wyjściu:

157 Decimal float a standard C Są propozycje dodania typów decimal floating-point do standardu:

158 158 K NIEC