Conversion and Rounding

Restricting Types

For most of the cases, there is no need for conversion, it is sufficient to restrict the type instead.

Test>
1 :% 10 :: Rational
Test>
0.10000000000000009 :: Double
Test>
0.100000024 :: Float
Test>
121 :% 100 :: Rational
Test>
1.2100000000000002 :: Double

No conversion happens there, the literals are created with the given type.

The (type) information flows backwards due to the polymorphic nature of the (-) and (*) operators.

Exercises

Is there any difference between them?

Test>
Test>
Test>

What will happen to this expression below?

Test>

Default Types

If the given type cannot be inferred from the environment, but we want to use the value, then

Test>
6 :: Integer
Test>
0.6666666666666666 :: Double

Exercises

What is the type of the exponent in this expression?

Test>

Try to change the type for 4! (However, note that the result will not be observeable.)

Conversion of Integer Numbers

fromIntegral :: (Integral a, Num b) => a -> b

The fromIntegral function can help with the following conversions:

In Haskell, there is no implicit conversion purposely between the different number types.

Conversion of Fractions

realToFrac :: (Real a, Fractional b) => a -> b

The realToFrac function can help with the following conversions:

Exercises

Is it possible to do conversions between the following types (with any of the functions above)?

Int            -> Integer
Int            -> Double
Float          -> Rational
Rational       -> Integer

Roundings

truncate :: (RealFrac a, Integral b) => a -> b -- rounding towards the zero
round :: (RealFrac a, Integral b) => a -> b -- rounding towards the nearest integer
ceiling :: (RealFrac a, Integral b) => a -> b -- rounding upwards
floor :: (RealFrac a, Integral b) => a -> b -- rounding downwards

Exercises

True or not?

ceiling x  ==  1 + floor x

truncate x  ==  (floor x + ceiling x) `div` 2

Exercises

sqrt :: Floating a => a -> a -- square root

Determine the neareast integer to the square root of 10^9.

Solution>