Exercises02.Hs 3

{-|
Module : HaskellExercises02.Exercises02
Copyright : (c) Curtis D'Alves 2020
License : GPL (see the LICENSE file)
Maintainer : none
Stability : experimental
Portability : portable
Description:
Haskell exercise template Set 02 - McMaster CS 1JC3 2021
-}
module Exercises02 where
import Prelude hiding ((||),(&&),abs)
-----------------------------------------------------------------------------------
------------------------
-- INSTRUCTIONS README!!!
-----------------------------------------------------------------------------------
------------------------
-- 1) DO NOT DELETE/ALTER ANY CODE ABOVE THESE INSTRUCTIONS
-- 2) DO NOT REMOVE / ALTER TYPE DECLERATIONS (I.E THE LINE WITH THE :: ABOUT THE
FUNCTION DECLERATION)
-- IF YOU ARE UNABLE TO COMPLETE A FUNCTION, LEAVE IT'S ORIGINAL IMPLEMENTATION
(I.E. THROW AN ERROR)
-- 3) MAKE SURE THE PROJECT COMPILES (I.E. RUN STACK BUILD AND MAKE SURE THERE ARE
NO ERRORS) BEFORE
-- SUBMITTING, FAILURE TO DO SO WILL RESULT IN A MARK OF 0
-- 4) REPLACE macid = "TODO" WITH YOUR ACTUAL MACID (EX. IF YOUR MACID IS jim THEN
macid = "jim")
-----------------------------------------------------------------------------------
------------------------
macid = "ismaim34"
-- NOTE see the wikipedia page on truth tables

https://en.wikipedia.org/wiki/Truth_table
-- (patricularly the sections Logical conjuction, Logical disjunction, etc)
for a reference
-- on the different boolean operators
-- Exercise A
-----------------------------------------------------------------------------------
------------------------
-- Implement Logical disjunction (OR) using pattern matching
-- NOTE feel free to change the function declaration (pattern match on the
arguments), just don't change
-- the type decleration
-----------------------------------------------------------------------------------
------------------------
(||) :: Bool -> Bool -> Bool
x || y = if x
then True
else y
-- Exercise B
-----------------------------------------------------------------------------------
------------------------
-- Implement Logical conjunction (AND) using pattern matching
-----------------------------------------------------------------------------------
------------------------
(&&) :: Bool -> Bool -> Bool
x && y = if x
then y
else False
-- Exercise C
-----------------------------------------------------------------------------------
------------------------
-- Implement Logical implication using pattern matching
-----------------------------------------------------------------------------------
------------------------
(==>) :: Bool -> Bool -> Bool
x ==> y = if x
then y
else True
-- Exercise D
-----------------------------------------------------------------------------------
------------------------
-- Implement the function abs that returns the absolute value of a number
-----------------------------------------------------------------------------------
------------------------
abs :: (Num a,Ord a) => a -> a
abs x = if x > 0
then x
else (-x)
-- Exercise E
-----------------------------------------------------------------------------------
------------------------
-- Implement a function that compares two floating point numbers, and returns True
if they are within
-- a tolerance of 1e-4 of eachother
-- NOTE use the abs fine you just defined
-- NOTE^2 in general, you should use an operator like this instead of == on two
floating point numbers
-- HOWEVER, you'll need to adjust the tolerance to suit different contexts
-----------------------------------------------------------------------------------
------------------------
(=.) :: (Floating a,Ord a) => a -> a -> Bool
x =. y = let
tol = 1e-4
in abs (x-y) < tol
-- Exercise F
-----------------------------------------------------------------------------------
------------------------
-- Implement a function stack that takes the first element of a list and moves it
to the back
-----------------------------------------------------------------------------------
------------------------
stack :: [a] -> [a]
stack xs = tail xs ++ [head xs]
-- Exercise G
-----------------------------------------------------------------------------------
------------------------
-- Implement a function halves that takes a list of integers and divides each
element of the list in two
-- (using the integer division operator `div`)
-- NOTE use the map function combined with a lambda expression to do the division
-----------------------------------------------------------------------------------
------------------------
halves :: Integral a => [a] -> [a]
halves xs = map (\xs -> xs `div` 2 ) xs

Exercises02.Hs 3

Uploaded by

Copyright:

Available Formats

Exercises02.Hs 3

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Exercises02.Hs 3

Uploaded by

Copyright:

Available Formats

{-|

import Prelude hiding ((||),(&&),abs)

-- NOTE see the wikipedia page on truth tables

You might also like