Lecture 3AData Types: Basic types, Tuples, Polymorphism,
Functions (incl. curried)COMP 1100
Acknowledgement of Countryü I wish to acknowledge the traditional custodians of the land we
are meeting on, the Ngunnawal people. I wish to acknowledge and respect their continuing culture and the contribution they make to the life of this city and this region. I would also like to acknowledge and welcome any other Aboriginal and Torres Strait Islander people who are enrolled in our courses.
2
Representativesü u7074610 - VongVuthik Kolü u7074608 - Ziyi Yuü u7079217 - Mohit Goyalü u7145384 - Abhaas Goyalü u7199021 - Theodore Darmawan
3
What is a type?ü A type is a name for a collection of related values. For example, in Haskell the
basic type Bool contains the two logical values False and True,ü The type Bool-> Bool contains all functions that map arguments from
Bool to Bool.ü Notation: v :: T means that v is a value in the type T, i.e. v has type T.ü Example
ü The symbol :: can be used as e :: T that evaluates the expression e and produce a value of type T.
ü Example
4
False :: BoolTrue :: Boolnot :: Bool -> Bool
not False :: Boolnot True :: Boolnot (not False) :: Bool
Type errorsü Applying a function to one or more arguments of the wrong type is called a
type error.
ü 1 is a number and False is a logical value, but + requires two numbers.
5
> 1 + Falseerror ...
What is a type?ü Every expression has a type!ü Typing rule
ü Example: then typing not False :: Bool
can be inferred from this rule using the fact thatnot :: Bool -> Bool and False :: Bool.
ü Example: the expression not 3 does not have a type, because this would require 3::Bool.
ü Because type inference precedes evaluation, Haskell programs are type safe.
6
f :: A -> B e :: Af e :: B
Six basic typesü Haskell has a number of basic types, including:1. Bool – logical values2. Char – single character
ü String – strings of characters
7
'H' ::Char
type String = [Char]"Hello world" :: String
Basic types3. Int – fixed-precision integers: −2!" to 2!" − 1
ü CPUs have built-in types, so it’s fast
8
2^63 - 1 :: Int9223372036854775807
2^63 :: Int-9223372036854775808
Most significant bit, 0 for + and 1 for -
Int 64 bits
0 à 00002
1 à 00012
2 à 00102
3 à 00112
4 à 01002
5 à 01012
6 à 011027 à 011128 à 10002
9 à 10012
10 à 10102
11 à 10112
12 à 11002
13 à 11012
14 à 11102
15 à 11112
01
2
3
4
56
7-8-7
-6
-5
-4
-3-2
-1
Singed
Unsignedü Example: N = 4
…
Basic types4. Integer – arbitrary-precision integers
ü Arbitrary precision integers are processed using the slower medium of software.
9
2^63 - 1 :: Integer9223372036854775807
2^63 :: Integer9223372036854775808
Basic types
5. Float – single-precision floating-point numbers6. Double– double precision floating-point numbers
10
sqrt (20000000)^2 :: Float1.9999998e7sqrt (20000000)^2 :: Double2.0e7
ü The IEEE 754 standard specifies a binary32 and binary64ü The numerical form as having: 𝑣𝑎𝑙𝑢𝑒 = −1 𝒔× 1.𝒎 $×2𝒆
ü s is a sign bit, determines whether number is negative or positiveü m is a significand, determines a fractional values in [1.0, 2.0 − 𝜖)ü e is a exponent which weights value by power of 2
exponent 𝐞∗sign: 𝐬 base: 𝐦…Float
1 8-bits 23-bits
…Double1 11-bits 53-bits
Basic typesü What is the type of the expression 7? Is
it Int, Integer, Float, or Double?ü Polymorphic type expressions essentially
describe families of types.
11
> :t 77 :: Num p => p
> :t 7.07.0 :: Fractional p => p
Arbitrary-precision fractions,Extracting components of fractions.
Integral numbers, supporting integer division.
Efficient, machine-independent access to the components of a floating-point number.
List typesü A list is sequence of values of the same type:
ü In general:[t] is the type of lists with elements of type t.
ü The number of elements is a list is called its length.ü The list [] is the empty list.ü Such lists as [False], [’a’], [[]] are called singletons.
12
[False,True,False] :: [Bool]
[’a’,’b’,’c’,’d’] :: [Char]
["One", "Two", "Three"] :: [String]
The empty list as its only element
List typesü Important points
ü The type of a list convey no information about its length
ü No restrictions on the type of the elements of a list
ü No restrictions that a list must have a finite length.
13
> :t [False, True][False, True] :: [Bool]
> :t [False, True, False][False, True, False] :: [Bool]
> [['a', 'b'], ['c', 'd', 'e']] :: [[Char]]["ab","cde"]
Tuple typeü A tuple is a finite sequence of components of possible different types
𝑖th components have type Ti, in the range 1 to n.ü Examples:
ü The number of components in a tuple is called its arity.ü The tuple () of arity zero is called the empty tuple.ü Tuple of arity one, such as (False) are not permitted
14
(T1, T2,..., Tn)
(False, True) :: (Bool, Bool)(False, 'a', True) :: (Bool, Char, Bool)("Yes", True, 'a') :: (String, Bool, Char)
Tuple typeü Important points
ü The type of a tuple conveys its arityü Example: (Bool, Char) contains all pairs produced the by Cartesian product
ü No restrictions on the types of the componentsü Example:
ü Tuples must have a finite arity.
15
('a', (False, 'b')) :: (Char, (Bool, Char))(['a', 'b'], [False, True]) :: ([Char], [Bool])[('a', False), ('b', True)] :: [(Char, Bool)]
Function typesü A function is a mapping from arguments of one type to results of another
type.
ü QUIZ: If 𝑇1 and 𝑇2 are of type Bool, how many different functions can be constructed ?
ü Example:
ü Function can be undefined for some arguments
16
𝑇1 𝑇2
𝑓 ∷ 𝑇1 → 𝑇2
add :: (Int, Int) -> Intadd (x, y) = x + y
zerto :: Int -> [Int]zerto n = [0..n]
> head []*** Exception: Prelude.head: empty list
Example: Tuples and functionsü The point of intersection of two non-parallel lines can be found from the
equations of the two lines.𝑎𝑥 + 𝑏𝑦 = 𝑚𝑐𝑥 + 𝑑𝑦 = 𝑛
ü The set has a unique solution
𝑥& =𝑚𝑑 − 𝑏𝑛𝑎𝑑 − 𝑐𝑏
𝑦& =𝑛𝑎 −𝑚𝑐𝑎𝑑 − 𝑐𝑏
17
intersection :: ((Double, Double, Double), (Double, Double, Double)) -> (Double, Double)
intersection ((a, b, m), (c, d, n)) = ((m*d - b*n)/(a*d - c*b), (n*a - m*c)/(a*d - c*b))
> intersection((1,2,3), (4,5,6))(-1.0,2.0)
Curried functionsü Functions in Haskell are free to return functions as results
add' is a function that takes an argument of type Int, and returns a result that is function of type Int -> Int.ü Important point: add’ takers an integer x and returns a function, that in
turn takes an integer y and returns the result x + y.
18
add' :: Int -> (Int -> Int)add' x y = x + y
add :: (Int, Int) -> Int -- returns a numberadd' :: Int -> (Int -> Int) -- returns a function
Curried functionsü Function with more arguments
ü ConventionsInt -> (Int -> (Int -> Int)) equivalent to Int -> Int -> Int -> Int
((mult x) y) z equivalent to mult x y z
19
mult :: Int -> (Int -> (Int -> Int))mult x y z = x*y*z
> mult 2 3 424> mult2 = mult 2> mult2 3 424> mult3 = mult2 3> mult3 424
QUIZ: tuples and curried functionsü Modify and test the function intersection so that it can take one
argument at a time.
20
intersection :: ((Double, Double, Double), (Double, Double, Double)) -> (Double, Double)
intersection ((a, b, m), (c, d, n)) = ((m*d - b*n)/(a*d - c*b), (n*a - m*c)/(a*d - c*b))
intersection :: (Double, Double, Double) -> (Double, Double, Double)-> (Double, Double)
intersection (a, b, m) (c, d, n) = ((m*d - b*n)/(a*d - c*b), (n*a-m*c)/(a*d - c*b)
)
> intersection2 = intersection (1,2,3)> intersection2 (4,5,6)(-1.0,2.0)
Polymorphic typesü The library function length calculates the length of any list, irrespective of
the type of the elements of the list:
ü The type of length is as follows
For any type a, the function length has type [a] -> Int.
21
> length [1, 3, 5, 7]4> length ["Yes", "No"]2> length [sin, cos, tan]3
length :: [a] -> Int
Polymorphic typesü Examples: Standard prelude functions
ü The type indicates function’s behavior e.g. zip pairs up elements from two lists.
22
fst :: (a, b) -> ahead :: [a] -> atake :: Int -> [a] -> [a]zip :: Int -> [a] -> [b] -> [(a, b)]id :: a -> a
Overloaded typesü Class constraint are written in the form
C awhere C is the name of a class and a is a type variable.ü Example:
ü A type that contains one or more class constrains is called overload.ü Most of the numeric functions in the prelude are overloaded
ü Numbers themselves are overloaded
23
(+) :: Num a => a -> a -> a
overloadan overloaded fn.
(*) :: Num a => a -> a -> anegate :: Num a => a -> aabs :: Num a=> a -> a
3 :: Num a => a
Basic classesü A type is a collection of related values.ü A class is a collection of types that support certain overloaded operation
called methods.ü The commonly used built-in classes are
ü Eq – equality typesü Ord – ordered typesü Show – showable typesü Read – readable typesü Num – numeric typesü Integral – integral typesü Fractional – fractional types
24
Basic classes: Showü This class contains type whose values can be converted into strings of
characters using the following method:
ü All basic types Bool, Char, String, Int, Integer, Float, and Double are instance of the Eq class, as are lists and tuple types.
ü Example
25
show :: a -> String
> show False"False"> show 'a'"'a'"> show 123"123"> show [1, 2, 3]"[1,2,3]"> show ('a', False)"('a',False)"
Basic classes: Readü Contains types whose values can be converted from strings of characters
ü All basic types Bool, Char, String, Int, Integer, Float, and Double are instance of the Eq class, as are lists and tuple types.
ü Example
ü The use of :: resolve the type of the result.ü In practice, the necessary type can be usually inferred automatically
26
read :: String -> a
> read "False" :: BoolFalse> read "'a'" :: Char'a'> read "123" :: Int123> read "[1, 2, 3]" :: [Int][1,2,3]> read "('a', False)" :: (Char, Bool)('a’, False)
> not (read "False")True
Appendix: Basic Data Types:Floating point representation
ü The IEEE 754 standard specifies a binary32 and binary64ü The numerical form as having:
𝑣𝑎𝑙𝑢𝑒 = −1 𝒔× 1.𝒎 $×2𝒆
ü s is a sign bit, determines whether number is negative or positiveü m is a significand, determines a fractional values in [1.0, 2.0 - 𝜖)ü e is a exponent which weights value by power of 2
27
exponent 𝐞∗sign: 𝐬 base: 𝐦…Float
1 8-bits 23-bits
…Double1 11-bits 53-bits
28
The exponent is in excess-127 binary notation• 11111111, reserved for special cases i.e. inf or nan• 00000000, reserved to represent zero• 01111111 = 127 represents an exponent of 0, • 10000000 = 128, represents +1, • 01111110 = 126 represents -1, • 11111110 = 254, represents +127• 00000001 = 1, represents -126 and so forth
𝑣𝑎𝑙𝑢𝑒 = −1 "!"× 1. 𝑏##𝑏#$…𝑏% #×2 "!#"$%…"$! $'$#(
b0b31
exponent 𝐞∗sign: 𝒔 base: 𝒎
ü The IEEE 754 standard specifies a binary32 (Float in Haskell) as having:ü Sign bit: 1 bitü Exponent width: 8 bitsü Significand (mantissa) precision: 24 bits (23 explicitly stored)
b23
Appendix: Single precision
Appendix: : Single precision
ü IEEE 754 Format Parameters for single precisionü emax = +127ü emin = -126The reason for having |emin| < emax is so that the reciprocal of the smallest number 1/2'!"# will not overflow. Although it is true that the reciprocal of the largest number will underflow, underflow is usually less serious than overflow.
29
0 0 1 1 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0exponent: 𝐞∗
sign: 𝒔base: 𝒎
238
0222330
1
31= 0.15625.
ü 𝑠𝑖𝑔𝑛 = 𝑏$% = 0,ü −1 &'() = −1 * = +1,ü 𝑒 = 𝑏$*𝑏+,…𝑏+$ = 𝑏+$-*2* + 𝑏+$-%2% +⋯+ 𝑏+$-.2. = 124,ü 2(01%+.) = 2%+31%+. = 21$,ü 1. 𝑏++𝑏+%…𝑏* = 1 + 𝑏+$1%21% + 𝑏+$1+21+ +⋯+ 𝑏+$1+$21+$ = 1 + 1 ⋅ 21+ = 1.25,ü 𝑣𝑎𝑙𝑢𝑒 = +1 ×1.25×21$ = +0.15625.
Appendix: : Single precision
ü Exampleü Float a = 15213.0;ü 1521310 = 111011011011012 = 1.11011011011012 x 213
ü Significandü m = 1.110110110110100000000002
ü Exponentü 𝐞 = 𝐞∗ – bias = 𝐞∗ – 127 = 13 ü 𝐞∗ = 140 = 100011002
30
0 1 0 0 0 1 1 0 0 1 1 0 1 1 0 1 1 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0
exponent 𝐞∗sign: 𝒔 base: 𝒎
238
0222330
1
31
Appendix: :Single precision
31
ü Numbers with exponents of 11111111 = 255 = 2128 represent non-numeric quantities such as "not a number" (NaN), returned by operations like (0.0/0.0) and positive or negative infinity
Exponent is 0Exponent is 1
Exponent is -1
32
Appendix:Double precision representation
𝑣𝑎𝑙𝑢𝑒 = −1 "&!× 1. 𝑏)$𝑏)%…𝑏% #×2 "&$"&"…"'$ $'$%#*
ü The IEEE 754 standard specifies a binary64 (Double in Haskell) as having:ü Sign bit: 1 bitü Exponent width: 11 bitsü Significand (mantissa) precision: 53 bits (52 explicitly stored)
The exponent is in excess-1023 binary notation• Emin (1) = −1022• E (50) = −973• Emax (2046) = 1023
ü 𝑠𝑖𝑔𝑛 = −1 4!"
ü 𝑒 = 𝑏5+𝑏5%…𝑏6+ = 𝑏6+-*2* + 𝑏6+-%2% +⋯+ 𝑏6+-%*2%%,ü 𝑒7 = 2(01%*+$),ü 𝑚 = 1. 𝑏++𝑏+%…𝑏* = 1 + 𝑏6+1%21% + 𝑏6+1+21+ +⋯+ 𝑏6+16+216+,ü 𝑣𝑎𝑙𝑢𝑒 = 𝑠𝑖𝑔𝑛 ×𝑚 × 𝑒7.
b0b63
exponent 𝑒sign: 𝑠 base: 𝑚
b52
Appendix: American Patriot Missile battery disaster
ü On February 25, 1991, an American Patriot Missile battery failed to track and intercept an incoming missile. 28 soldiers were killed and 100 were injured.
ü The cause was an inaccurate calculation of the time since boot ü Specifically, the time in tenths of second as measured by the system's internal clock
was multiplied by 1/10 to produce the time in seconds. This calculation was performed using a 24 bit fixed point register.
ü The value 1/10, which has a non-terminating binary expansion, was chopped at 24 bits after the radix point. ü the binary expansion of 1/10 is 0.0001100110011001100110011001100ü the 24 bit register in the Patriot stored instead 0.00011001100110011001100ü Error was about 0.000000095 decimalü Multiplying by the number of tenths of a second in 100 hours gives
0.000000095×100×60×60×10=0.34.ü Missile travels 1,676 meters per second, and so travels more than half a kilometer in
this time. This was far enough that the incoming missile was outside the "range gate" that the Patriot tracked.
33
Appendix: Difference between integer and floating-point numbers
1. An integer has no fractional part; A floating-point number can have a fractional part.
2. Floating-point numbers can represent a much larger range of values than integers can.
3. For some arithmetic operations, such as subtracting one large number from another, floating-point numbers are subject to greater loss of precision.
4. Floating-point values are often approximations of a true value. 5. Floating-point operations are normally slower than integer operations.