Relación 2

-- I1M 2021-22: Rel_2.hs (08 de octubre de 2021)
-- Definiciones con condicionales, guardas o patrones.
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

-- ---------------------------------------------------------------------
-- Introducción                                                       --
-- ---------------------------------------------------------------------

-- En esta relación se presentan ejercicios con definiciones elementales
-- (no recursivas) de funciones que usan condicionales, guardas o
-- patrones. 
--
-- De forma adicional, se adjuntan ejercicios de repaso para trabajar con
-- operaciones lógicas sobre valores de verdad (o booleanos), sobre todo
-- con &&, || y not. 
-- 
-- Estos ejercicios se corresponden con el tema 4 cuyas transparencias
-- se encuentran en  
--    http://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-4.html

-- ---------------------------------------------------------------------
-- § Librerías auxiliares                                             --
-- ---------------------------------------------------------------------

-- Esta librería se puede instalar de la siguiente forma:
-- 1. Abrir cmd (Windows) o Terminal (MacOS y Linux)
-- 2. Escribir: cabal update
-- 3. Escribir: cabal install QuickCheck

import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir la función 
--    divisionSegura :: Double -> Double -> Double
-- tal que (divisionSegura x y) es x/y si y no es cero y 9999 en caso
-- contrario. Por ejemplo,
--    divisionSegura 7 2  ==  3.5
--    divisionSegura 7 0  ==  9999.0
-- ---------------------------------------------------------------------

--Álvaro Galisteo Bermúdez, Eva González Estrada, Juan Castillo Gavira, Marina Garcia Ruz, Paula Sánchez Toledo, Manuel Hidalgo Aguilar
-- CONDICIONALES
divisionSegura :: Double -> Double -> Double
divisionSegura x y = if y/= 0
                     then  x/y
                     else 9999

-- ECUACIONES GUARDADAS:
divisionSegura1 :: Double -> Double -> Double
divisionSegura1 x y | y/= 0 = x/y
                    | otherwise = 9999
                    
-- EXPRESIONES CASE                          
divisionSegura2 :: Double -> Double -> Double
divisionSegura2 x y = case y of
                        0 -> 9999
                        otherwise -> x/y

-- ---------------------------------------------------------------------
-- Ejercicio 2. Definir la función 
--    intercambia :: (a,b) -> (b,a)
-- tal que (intercambia p)  es el punto obtenido intercambiando las
-- coordenadas del punto p. Por ejemplo, 
--    intercambia (2,5)  ==  (5,2)
--    intercambia (5,2)  ==  (2,5)
-- ---------------------------------------------------------------------

--Álvaro Galisteo Bermúdez, Eva González Estrada, Juan Castillo Gavira, Marina Garcia Ruz, Paula Sánchez Toledo, Manuel Hidalgo Aguilar
intercambia :: (a,b) -> (b,a)
intercambia  (x,y) = (y,x)

intercambia1 :: a -> b -> (b ,a)
intercambia1 x y = (y,x)


-- ---------------------------------------------------------------------
-- Ejercicio 3. Comprobar con QuickCheck que la función intercambia es
-- idempotente; es decir, si se aplica dos veces es lo mismo que no
-- aplicarla ninguna.
-- ---------------------------------------------------------------------

-- Álvaro Galisteo Bermúdez, Eva González Estrada, Juan Castillo Gavira
-- La propiedad es
prop_intercambia :: (Int,Int) -> Bool
prop_intercambia = par =  intercambia ( intercambia par) == par

-- Marina Garcia Ruz, Manuel Hidalgo Aguilar
prop_intercambia :: (Int,Int) -> Bool
prop_intercambia (a,b) = intercambia (intercambia (a,b)) == (a,b)

-- Paula Sánchez Toledo
prop_intercambia :: (Int,Int) -> Bool
prop_intercambia p = intercambia (intercambia p) == p

-- La comprobación es
-- λ> quickCheck prop_intercambia
-- +++ OK, passed 100 tests.

-- ---------------------------------------------------------------------
-- Ejercicio 4.1. Definir una función 
--    ciclo :: [a] -> [a]
-- tal que (ciclo xs) es la lista obtenida permutando cíclicamente los
-- elementos de la lista xs, pasando el último elemento al principio de
-- la lista. Por ejemplo, 
--    ciclo [2,5,7,9]  == [9,2,5,7]
--    ciclo []         == []
--    ciclo [2]        == [2]
-- ---------------------------------------------------------------------

--Álvaro Galisteo Bermúdez, Eva González Estrada, Juan Castillo Gavira, Marina Garcia Ruz, Paula Sánchez Toledo, Manuel Hidalgo Aguilar
-- PARA LISTAS NO VACIAS:
ciclo :: [a] -> [a]
ciclo xs = [last xs ]++ init xs

-- PARA TODOS LOS CASOS:
-- CON CONDICIONALES:
ciclo1 xs  = if null xs
             then []
             else [last xs ]++ init xs
-- o bien:  else last xs :  init xs

-- CON GUARDAS:
ciclo2 xs | null xs = []
          | otherwise = last xs :  init xs
-- CASE
ciclo3 xs = case null xs of
              True -> [] 
              otherwise -> last xs : init xs
ciclo4 xs = case xs of
              [] -> []
              otherwise -> last xs : init xs

-- ---------------------------------------------------------------------
-- Ejercicio 4.2. Comprobar que la longitud es un invariante de la
-- función ciclo; es decir, la longitud de (ciclo xs) es la misma que la
-- de xs.
-- ---------------------------------------------------------------------

--Álvaro Galisteo Bermúdez, Eva González Estrada, Juan Castillo Gavira, Marina Garcia Ruz, Paula Sánchez Toledo, Manuel Hidalgo Aguilar
-- La propiedad es
prop_ciclo :: [Int] -> Bool 
prop_ciclo xs = length (ciclo1 xs) == length xs

-- La comprobación es

-- *Main> quickCheck (prop_ciclo)
-- +++ OK, passed 100 tests.

-- ---------------------------------------------------------------------
-- Ejercicio 5. Definir la función 
--    numeroMayor :: (Num a, Ord a) => a -> a -> a
-- tal que (numeroMayor x y) es el mayor número de dos cifras que puede
-- construirse con los dígitos x e y. Por ejemplo,  
--    numeroMayor 2 5 ==  52
--    numeroMayor 5 2 ==  52
-- ---------------------------------------------------------------------

--Álvaro Galisteo Bermúdez:
numeroMayor :: (Num a, Ord a) => a -> a -> a
numeroMayor x y = max (x*10+y) (y*10+x) 

--Manuel Zamora Bernal:
numeroMayor :: Int -> Int -> Int
numeroMayor x y = (max x y)*10 + (min x y)

-- Eva González Estrada, Marina Garcia Ruz:
numeroMayor1 :: (Num a, Ord a) => a -> a -> a
numeroMayor1 x y | x >= y    = x*10+y
                 | otherwise = y*10+x

-- Juan Castillo Gavira, Marina Garcia Ruz, Paula Sánchez Toledo, Manuel Hidalgo Aguilar
numeroMayor :: Int -> Int -> Int
numeroMayor x y = if x>y
                  then x*10+y
                  else y*10 + x
-- ---------------------------------------------------------------------
-- Ejercicio 6. Definir la función 
--    numeroDeRaices :: (Num t, Ord t) => t -> t -> t -> Int
-- tal que (numeroDeRaices a b c) es el número de raíces reales de la
-- ecuación a*x^2 + b*x + c = 0. Por ejemplo,
--    numeroDeRaices 2 0 3    ==  0
--    numeroDeRaices 4 4 1    ==  1
--    numeroDeRaices 5 23 12  ==  2
-- ---------------------------------------------------------------------

--Álvaro Galisteo Bermúdez:
numeroDeRaices :: (Num t, Ord t) => t -> t -> t -> Int
numeroDeRaices a b c | b^2-4*a*c > 0 = 2
                     | b^2-4*a*c < 0 = 0
                     | b^2-4*a*c == 0 = 1

-- Juan Castillo Gavira, Patricia Camino Ferreiro 
numeroDeRaices' :: Double -> Double -> Double -> Int
numeroDeRaices' a b c = if b^2-(4*a*c)<0
                       then 0
                       else if b^2-(4*a*c)>0
                       then 2
                       else 1 

-- Eva González Estrada, Juan Castillo Gavira, Marina Garcia Ruz, Paula Sánchez Toledo, Manuel Hidalgo Aguilar : 
numeroDeRaices1 :: (Num t, Ord t) => t -> t -> t -> Int
numeroDeRaices1 a b c | d > 0 = 2
                     | d < 0 = 0
                     | otherwise = 1
                     where d = b^2-4*a*c
--Marina Garcia Ruz 
numeroDeRaices :: (Num t, Ord t) => t -> t -> t -> Int
numeroDeRaices a b c = if (b^2-(4*a*c)) > 0 then 2 else if (b^2-(4*a*c)) == 0
  then 1 else 0

--Manuel Zamora Bernal
numeroDeRaices :: Double -> Double -> Double -> Int
numeroDeRaices a b c = if b^2-(4*a*c) > 0
                       then 2
                       else if b^2-(4*a*c) < 0
                       then 0
                       else 1

-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir la función 
--    raices :: Double -> Double -> Double -> [Double]
-- tal que (raices a b c) es la lista de las raíces reales de la
-- ecuación ax^2 + bx + c = 0. Por ejemplo, 
--    raices 1 3 2    ==  [-1.0,-2.0]
--    raices 1 (-2) 1 ==  [1.0,1.0]
--    raices 1 0 1    ==  []
-- ---------------------------------------------------------------------

--Álvaro Galisteo Bermúdez, Manuel Zamora Bernal:
raices :: Double -> Double -> Double -> [Double]
raices a b c | b^2-4*a*c < 0   = []
             | otherwise  = [(-b + sqrt(b^2-4*a*c))/2*a,(-b - sqrt(b^2-4*a*c))/2*a] 
-- Eva González Estrada:
raices :: Double -> Double -> Double -> [Double]
raices a b c | n == 0 = []
             | n == 1 = [-b/2*a, -b/2*a]
             | n == 2 = [(((-b)+sqrt(d))/2*a), (((-b)-sqrt(d))/2*a)]
             where n = numeroDeRaices a b c
                   d = b^2 - 4*a*c

-- Juan Castillo Gavira
raices'' :: Double -> Double -> Double -> [Double]
raices'' a b c | d<0 = []
               | d== 0 = [(-b+d)/(2*a), (-b-d)/(2*a)]
               | d>0 = [(-b+d)/(2*a), (-b-d)/(2*a)]
    where d=sqrt (b^2-4*a*c)

--Patricia Camino Ferreiro, Marina Garcia Ruz 
raices''' :: Double -> Double -> Double -> [Double]
raices''' a b c = if (b^2 -4*a*c)>=0 
               then [(-b + sqrt(b^2-4*a*c))/(2*a),(-b-sqrt(b^2-4*a*c))/(2*a)]
               else [] 

--Marina Garcia Ruz, Paula Sánchez Toledo, Manuel Hidalgo Aguilar
raices' a b c | d >= 0 = [((-b)+sqrt(b^2-4*a*c))/2*a,((-b)-sqrt(b^2-4*a*c))/2*a]
              | otherwise = []
             where d = (b^2-(4*a*c))

-- ---------------------------------------------------------------------
-- Ejercicio 8. Definir el operador
--    (~=) :: (Fractional a, Ord a) => a -> a -> Bool
-- tal que (x ~= y) se verifica si x e y son casi iguales; es decir si
-- el valor absoluto de su diferencia es menor que una milésima. Por
-- ejemplo, 
--    12.3457 ~= 12.3459  ==  True
--    12.3457 ~= 12.3479  ==  False
-- ---------------------------------------------------------------------

--Álvaro Galisteo Bermúdez:
(~=) :: (Fractional a, Ord a) => a -> a -> Bool
x ~= y = abs x - abs y < 0.001
-- Eva González Estrada:
(~=) :: (Fractional a, Ord a) => a -> a -> Bool
x ~= y = abs (x-y) <= 0.001
-- Juan Castillo Gavira
(~=) :: Double -> Double -> Bool
x ~= y | abs (x-y) < 0.001 = True
       | abs (x-y) > 0.001 = False

--Marina Garcia Ruz, Paula Sánchez Toledo, Manuel Hidalgo Aguilar
(~=) :: (Fractional a, Ord a) => a -> a -> Bool
x ~= y = if abs (x-y) < 0.001 then True else False

(~=~=) :: (Fractional a, Ord a) => a -> a -> Bool
x ~=~= y | abs (x-y) < 0.001  = True
         | otherwise = False 


-- --------------------------------------------------------------------- 
-- Ejercicio 9. Comprobar con QuickCheck que la suma de las raíces
-- de la ecuación ax^2 + bx + c = 0 (con a no nulo) es -b/a y su
-- producto es c/a.
--
-- Nota. En la comparación usar ~= en lugar de ==
-- ---------------------------------------------------------------------

-- Eva González Estrada y Juan Castillo (la comprobación nos falla en algo y no sabemos por qué):
-- La propiedad es
prop_raices :: Double -> Double -> Double -> Property
prop_raices a b c = a/= 0 && numeroDeRaices a b c /= 0  ==>
  ((sum (raices a b c)) ~= ((-b)/a)) && ((product (raices a b c)) ~= (c/a))

-- La comprobación es

-- Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Manuel Hidalgo Aguilar:
-- La propiedad es
prop_raices :: Double -> Double -> Double -> Property
prop_raices a b c = a /= 0 && raices a b c /= [] ==> ((sum (raices a b c) ~= (-b/a))) && (product (raices a b c) ~= (c/a))

-- La comprobación es
-- *Main> quickCheck (prop_raices)
-- +++ OK, passed 100 tests; 62 discarded.

-- ---------------------------------------------------------------------
-- Ejercicio 10. En geometría, la fórmula de Herón, descubierta por
-- Herón de Alejandría, dice que el área de un triángulo cuyo lados
-- miden a, b y c es la raíz cuadrada de s(s-a)(s-b)(s-c) donde s es el
-- semiperímetro 
--    s = (a+b+c)/2
-- 
-- Definir la función 
--    area :: Double -> Double -> Double -> Double 
-- tal que (area a b c) es el área del triángulo de lados a, b y c. Por
-- ejemplo, 
--    area 3 4 5  ==  6.0
-- ---------------------------------------------------------------------

--Álvaro Galisteo Bermúdez, Lorenzo Tagua Santana:
area :: Double -> Double -> Double -> Double 
area a b c | maximum[a,b,c] <= a+b+c-maximum[a,b,c] = sqrt(s*(s-a)*(s-b)*(s-c))
           | otherwise = 0 
          where s = (a+b+c)/2

--Eva González Estrada, Juan Castillo Gavira, Paula Sánchez Toledo, Manuel Zamora Bernal, Marina Garcia Ruz, Manuel Hidalgo Aguilar:
area :: Double -> Double -> Double -> Double 
area a b c = sqrt(s*(s-a)*(s-b)*(s-c))
                where s = (a+b+c)/2
--María Ampliato
area :: Double -> Double -> Double -> Double 
area a b c |(s*(s-a)*(s-b)*(s-c))> 0 = (sqrt (s*(s-a)*(s-b)*(s-c)))
      where s = (a+b+c)/2

-- ---------------------------------------------------------------------
-- Ejercicio 11. Los intervalos cerrados se pueden representar mediante
-- una lista de dos números (el primero es el extremo inferior del
-- intervalo y el segundo el superior). 
-- 
-- Definir la función 
--    interseccion :: Ord a => [a] -> [a] -> [a]
-- tal que (interseccion i1 i2) es la intersección de los intervalos i1 e
-- i2. Por ejemplo,
--    interseccion [] [3,5]     ==  []
--    interseccion [3,5] []     ==  []
--    interseccion [2,4] [6,9]  ==  []
--    interseccion [2,6] [6,9]  ==  [6,6]
--    interseccion [2,6] [0,9]  ==  [2,6]
--    interseccion [2,6] [0,4]  ==  [2,4]
--    interseccion [4,6] [0,4]  ==  [4,4]
--    interseccion [5,6] [0,4]  ==  []
-- ---------------------------------------------------------------------

--Álvaro Galisteo Bermúdez, Marina Garcia Ruz:
interseccion :: Ord a => [a] -> [a] -> [a]
interseccion [] _ = []
interseccion _ []= []
interseccion i1 i2  |last i1<head i2 = []
                    |head i1>last i2 = [] 
                    |otherwise = [maximum [head i1,head i2], minimum [last i1,last i2]]

-- Eva González Estrada, Paula Sánchez Toledo, Manuel Hidalgo Aguilar:
interseccion :: Ord a => [a] -> [a] -> [a]
interseccion [] _ = []
interseccion _ [] = []
interseccion [x1,x2] [y1,y2] | x <= y = [x,y]
                             | otherwise = []
                             where x = max x1 y1
                                   y = min x2 y2
-- Juan Castillo Gavira
interseccion :: [Int] -> [Int] -> [Int]
interseccion [a1,b1] [a2,b2] | [a1,b1]==[] = []
                             | [a2,b2]==[] = []
                             | max a1 a2 <= min b1 b2  = [max  a1 a2 ,min  b1 b2]
                             | otherwise = []
--Cristina Ruiz Martín
interseccion :: [Int] -> [Int] -> [Int]
interseccion [x1,x2] [y1,y2] = if x <= y
                               then [x,y]
                               else []
                          where x = max x1 y1
                                y = min x2 y2

--Marta Zaitsev Borrero
interseccion :: [Int] -> [Int] -> [Int]
interseccion [a1,b1] [a2,b2] | a2<=b1 && a1<=b2 = [maximum [a1,a2], minimum [b1,b2]]
                             | otherwise = []

--Marina Garcia Ruz:
interseccion xs ys | null xs = []
                   | null ys = []
                   | last xs < head ys = []
                   | head xs > last ys = []
                   | otherwise = [maximum [head xs,head ys],
                                  minimum [last xs,last ys]]
-- ---------------------------------------------------------------------
-- Ejercicio 12. Comprobar con QuickCheck que la intersección de
-- intervalos es conmutativa.
-- ---------------------------------------------------------------------

-- La propiedad es

--Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Hidalgo Aguilar:
prop_interseccion :: Int -> Int -> Int -> Int -> Bool
prop_interseccion a1 b1 a2 b2 = interseccion [a1,b1] [a2,b2] == interseccion [a2,b2] [a1,b1]

-- Eva González Estrada, Juan Castillo Gavira
prop_interseccion :: Int -> Int -> Int -> Int -> Bool
prop_interseccion a1 b1 a2 b2 =  interseccion [a1,a2] [b1,b2] == interseccion [b1,b2] [a1,a2]

-- La comprobación es
-- quickCheck prop_interseccion
-- +++ OK, passed 100 tests

--Manuel Zamora Bernal:
prop_interseccion :: Int -> Int -> Int -> Int -> Bool
prop_interseccion i1 i2 = interseccion i1 i2 == interseccion i2 i1

-- ---------------------------------------------------------------------
-- Ejercicio 13.1. Los números racionales pueden representarse mediante
-- pares de números enteros. Por ejemplo, el número 2/5 puede
-- representarse mediante el par (2,5). 
-- 
-- Definir la función 
--    formaReducida :: (Int,Int) -> (Int,Int) 
-- tal que (formaReducida x) es la forma reducida del número racional
-- x. Por ejemplo, 
--    formaReducida (4,10)  ==  (2,5)
-- ---------------------------------------------------------------------

--Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Manuel Hidalgo Aguilar:
formaReducida :: (Int,Int) -> (Int,Int)
formaReducida (a,b) = if (a,b) == (0,0) then (0,0) else (div a (gcd a b),div b (gcd a b))

--Eva González Estrada, Patricia Camino Ferreiro:
formaReducida1 :: (Int,Int) -> (Int,Int) 
formaReducida1 (a,b) = (div a c, div b c)
   where c = gcd a b

-- Juan Castillo Gavira
formaReducida :: (Int,Int) -> (Int,Int) 
formaReducida (0,_)=(0,1)
formaReducida (a,b) = if (gcd a b) > 1 then (a `div` (gcd a b),b `div`(gcd a b)) else (a,b)

--Manuel Zamora Bernal:
formaReducida :: (Int,Int) -> (Int,Int) 
formaReducida (a,b) = if b == 0
                      then error "no se puede dividir entre 0"
                      else (div a c, div b c)
  where c = gcd a b

--Marina Garcia Ruz:
formaReducida :: (Int,Int) -> (Int,Int) 
formaReducida (a,b) | b == 0 = error "No se puede dividir entre 0"
                    | otherwise = (div a d , div b d)
                    where d = gcd a b

-- ---------------------------------------------------------------------
-- Ejercicio 13.2. Definir la función 
--    sumaRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
-- tal que (sumaRacional x y) es la suma de los números racionales x e
-- y, expresada en forma reducida. Por ejemplo, 
--    sumaRacional (2,3) (5,6)  ==  (3,2)
-- ---------------------------------------------------------------------
-- Eva González Estrada, Juan Castillo Gavira:
sumaRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
sumaRacional (a,b) (c,d) =  formaReducida ((a*d + b*c), b*d)

--Álvaro Galisteo Bermúdez:
sumaRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
sumaRacional (a,b) (c,d) = formaReducida (a*d+c*b,b*d)

--Patricia Camino Ferreiro, Paula Sánchez Toledo, Manuel Hidalgo Aguilar:
sumaRacional2 :: (Int,Int) -> (Int,Int) -> (Int,Int)
sumaRacional2 (a,b) (c,d) = formaReducida (f,g) 
                           where f=(a*(lcm b d `div`b)+c* (lcm b d `div`d)) 
                                 g= lcm b d 

--Manuel Zamora Bernal:
sumaRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
sumaRacional (a,b) (c,d) = if b == 0 && d == 0
                           then error "no se puede dividir entre cero"
                           else formaReducida ((a*d + b*c), lcm b d)

--Marina Garcia Ruz: 
sumaRacional (a,b) (c,d) | b==d = formaReducida ((a+c),b)
                         | otherwise =
                           formaReducida ((((m`div`b)*a)+((m`div`d)*c)),m)
                         where m = lcm d b 

-- ---------------------------------------------------------------------
-- Ejercicio 13.3. Definir la función 
--    productoRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
-- tal que (productoRacional x y) es el producto de los números
-- racionales x e y. Por ejemplo, 
--    productoRacional (2,3) (5,6)  ==  (5,9)
-- ---------------------------------------------------------------------
-- Eva González Estrada, Juan Castillo Gavira, Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Hidalgo Aguilar:
productoRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
productoRacional (a,b) (c,d) = formaReducida (a*c, b*d)

--Cristina Ruiz Martín
productoRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
productoRacional (a,b) (c,d) = formaReducida (h,g)
                           where h = a*c
                                 g = b*d
-- ----------------------------------------------------------------------------
-- Ejercicio 13.4. Definir la función
--    cocienteRacional ::  (Int,Int) -> (Int,Int) -> (Int,Int)
-- tal que '(cocienteRacional x y)' es el cociente de los números racionales
-- 'x' e 'y'. Por ejemplo,
--    cocienteRacional (2,3) (5,6)  ==  (4,5)
-- ----------------------------------------------------------------------------
-- Eva González Estrada, Juan Castillo Gavira, Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Manuel Zamora Bernal, Marina Garcia Ruz, Manuel Hidalgo Aguilar:
cocienteRacional ::  (Int,Int) -> (Int,Int) -> (Int,Int)
cocienteRacional (x1,x2) (y1,y2) = formaReducida (x1*y2, x2*y1)

-- ---------------------------------------------------------------------
-- Ejercicio 13.5. Definir la función 
--    igualdadRacional :: (Int,Int) -> (Int,Int) -> Bool
-- tal que (igualdadRacional x y) se verifica si los números racionales
-- x e y son iguales. Por ejemplo, 
--    igualdadRacional (6,9) (10,15)  ==  True
--    igualdadRacional (6,9) (11,15)  ==  False
--    igualdadRacional (0,2) (0,-5)   ==  True
-- ---------------------------------------------------------------------
-- Eva González Estrada, Juan Castillo Gavira:
igualdadRacional :: (Int,Int) -> (Int,Int) -> Bool
igualdadRacional (a,b) (c,d) =  formaReducida (a,b) == formaReducida (c,d) 

--Álvaro Galisteo Bermúdez:
igualdadRacional :: (Int,Int) -> (Int,Int) -> Bool
igualdadRacional (a,b) (c,d) = a*d == b*c
--Patricia Camino Ferreiro, Paula Sánchez Toledo, Manuel Hidalgo Aguilar:
igualdadRacional2 (a,b) (c,d) = if a==0 && c==0
                               then True
                               else formaReducida1 (a,b)== formaReducida1 (c,d) 

--Manuel Zamora Bernal:
igualdadRacional :: (Int,Int) -> (Int,Int) -> Bool
igualdadRacional (0,_) (0,_) = True
igualdadRacional (a,b) (c,d) = formaReducida (a,b) == formaReducida (c,d)

--Marina Garcia Ruz:
igualdadRacional (a,b) (c,d) | a==0 && c==0 = True 
                             |otherwise =
                              formaReducida (a,b) == formaReducida (c,d)

-- ---------------------------------------------------------------------
-- Ejercicio 13.6. Comprobar con QuickCheck la propiedad distributiva
-- del producto racional respecto de la suma.
-- ---------------------------------------------------------------------

-- La propiedad es
-- Eva González Estrada (la comprobación me falla en algo y no se por que):
prop_distributiva :: (Int,Int) -> (Int,Int) -> (Int,Int) -> Property
prop_distributiva x y z = x2 /= 0 && y2 /= 0 && z2 /= 0 ==>
  productoRacional x (sumaRacional y z) ==
  sumaRacional (productoRacional x y) (productoRacional x z)
  where x = (x1,x2)
        y = (y1,y2)
        z = (z1,z2)

-- La comprobación es

-- Álvaro Galisteo Bermúdez:
-- La propiedad es
prop_distributiva :: (Int,Int) -> (Int,Int) -> (Int,Int) -> Property
prop_distributiva (a,b) (c,d) (e,f) = productoRacional (a,b) (sumaRacional (c,d) (e,f)) == sumaRacional (productoRacional (a,b) (c,d)) (productoRacional (a,b) (e,f)) ==> True 
 
-- La comprobación es
-- *Main> quickCheck (prop_distributiva)
-- +++ OK, passed 100 tests; 96 discarded.

-- ----------------------------------------------------------------------------
-- Ejercicio 14. Los números complejos se pueden representar mediante pares de 
-- números reales. Por ejemplo, el número 2+5i se puede representar mediante 
-- el par (2,5).
-- ----------------------------------------------------------------------------

-- Lo siguiente significa que el tipo Complejo es lo mismo que decir (Double,Double)
type Complejo = (Double,Double)

-- ----------------------------------------------------------------------------
-- Ejercicio 14.1. Definir la función
--    sumaComplejos :: Complejo -> Complejo -> Complejo
-- tal que '(sumaComplejos x y)' es la suma de los números complejos 'x' e 'y'.
-- Por ejemplo,
--    sumaComplejos (2,3) (5,6)  ==  (7.0,9.0)
-- ----------------------------------------------------------------------------
-- Eva González Estrada, Juan Castillo Gavira, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Hidalgo Aguilar 
sumaComplejos :: Complejo -> Complejo -> Complejo
sumaComplejos (x1,x2) (y1,y2) = (x1+y1, x2+y2)

-- ----------------------------------------------------------------------------
-- Ejercicio 14.2. Definir la función
--    productoComplejos :: Complejo -> Complejo -> Complejo
-- tal que '(productoComplejos x y)' es el producto de los números complejos
-- 'x' e 'y'. Por ejemplo,
--    productoComplejos (2,3) (5,6)  ==  (-8.0,27.0)
-- ----------------------------------------------------------------------------
-- Eva González Estrada, Juan Castillo Gavira, Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Hidalgo Aguilar:
productoComplejos :: Complejo -> Complejo -> Complejo
productoComplejos (x1,x2) (y1,y2) = (x1*y1 - x2*y2, x2*y1 + x1*y2)

-- ----------------------------------------------------------------------------
-- Ejercicio 14.3. Definir la función
--    cocienteComplejos :: Complejo -> Complejo -> Complejo
-- tal que '(cocienteComplejos x y)' es el cociente de los números complejos
-- 'x' e 'y'. Por ejemplo,
--    cocienteComplejos (3,2) (1,-2)  ==  (-0.2,1.6)
-- ----------------------------------------------------------------------------
-- Eva González Estrada:
cocienteComplejos :: Complejo -> Complejo -> Complejo
cocienteComplejos (x1,x2) (y1,y2) = ((x1*y1 + x2*y2)/a, (x2*y1 - x1*y2)/a)
                                    where a = (y1^2+y2^2)
-- Juan Castillo Gavira:
cocienteComplejos :: Complejo -> Complejo -> Complejo
cocienteComplejos (x1,x2) (y1,y2) = ((x1*y1-x2*(-y2))/(y1^2+y2^2),(x1*(-y2)+x2*y1)/(y1^2+y2^2)

--Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Manuel Hidalgo Aguilar: 
cocienteComplejos :: Complejo -> Complejo -> Complejo
cocienteComplejos (x1,x2) (y1,y2) = ((x1*y1+x2*y2)/(y1^2+y2^2),(x2*y1-x1*y2)/(y1^2+y2^2))

-- ----------------------------------------------------------------------------
-- Ejercicio 14.4. Definir la función
--    conjugado :: Complejo -> Complejo
-- tal que '(conjugado x)' es el conjugado del número complejo 'x'. Por
-- ejemplo,
--    conjugado (2,3)  ==  (2.0,-3.0)
-- ----------------------------------------------------------------------------
-- Eva González Estrada, Juan Castillo Gavira, Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Hidalgo Aguilar:
conjugado :: Complejo -> Complejo
conjugado (x1,x2) = (x1, -x2)

-- ----------------------------------------------------------------------------
-- Ejercicio 15. Los rectángulos pueden representarse por sus dimensiones, base
-- y altura, como un par de números enteros. Por ejemplo, (5,3) representa un
-- rectángulo de base 5 y altura 3.
--
-- Definir la función
--    mayorRectangulo :: (Int,Int) -> (Int,Int) -> (Int,Int)
-- tal que '(mayorRectangulo r1 r2)' es el rectángulo de mayor área entre 'r1'
-- y 'r2'. Por ejemplo,
--    mayorRectangulo (4,6) (3,7)  ==  (4,6)
--    mayorRectangulo (4,6) (3,8)  ==  (4,6)
--    mayorRectangulo (4,6) (3,9)  ==  (3,9)
-- ----------------------------------------------------------------------------
-- Eva González Estrada, Paula Sánchez Toledo, Manuel Hidalgo Aguilar: 
mayorRectangulo :: (Int,Int) -> (Int,Int) -> (Int,Int)
mayorRectangulo (x1,y1) (x2,y2) =  | a >= b = (x1,y1)
                                   | otherwise = (x2,y2)
                                where a = x1*y1
                                      b = x2*y2
-- Juan Castillo Gavira:
mayorRectangulo :: (Int,Int) -> (Int,Int) -> (Int,Int)
mayorRectangulo (x1,y1) (x2,y2) | r1 > r2 = (x1,y1)
                                | r2 > r1 = (x2,y2)
                                | otherwise = (x1,y1) 
  where r1 = x1*y1
        r2 = x2*y2

--Álvaro Galisteo Bermúdez:
mayorRectangulo :: (Int,Int) -> (Int,Int) -> (Int,Int)
mayorRectangulo (x1,y1) (x2,y2) | x1*y1 > x2*y2 = (x1,y1)
                                | x1*y1 < x2*y2 = (x2,y2)
                                | x1*y1 == x2*y2 = (x1,y1)

--Marina Garcia Ruz 
mayorRectangulo (x1,y1) (x2,y2) | x1*y1 >= x2*y2 = (x1,y1)
                                | otherwise = (x2,y2)

--Manuel Zamora Bernal
mayorRectangulo :: (Int,Int) -> (Int,Int) -> (Int,Int)
mayorRectangulo (x1,y1) (x2,y2) = if x1*y1 > x2*y2
                                  then (x1,y1)
                                  else (x2,y2)

-- ----------------------------------------------------------------------------
-- Ejercicio 16. Definir la función
--    cuadrante :: (Int,Int) -> Int
-- tal que '(cuadrante p)' es el cuadrante en el que se encuentra el punto 'p'.
-- Si el punto está sobre los ejes el resultado debe ser 0. Por ejemplo,
--    cuadrante (0,4)    ==  0
--    cuadrante (-3,0)   ==  0
--    cuadrante (0,0)    ==  0
--    cuadrante (3,5)    ==  1
--    cuadrante (-3,5)   ==  2
--    cuadrante (-3,-5)  ==  3
--    cuadrante (3,-5)   ==  4
-- ----------------------------------------------------------------------------
-- Eva González Estrada:
cuadrante :: (Int,Int) -> Int
cuadrante (x1,x2) | x1 == 0 || x2 == 0 = 0
                  | x1 > 0 && x2 > 0   = 1
                  | x1 < 0 && x2 > 0   = 2
                  | x1 < 0 && x2 < 0   = 3
                  | x1 > 0 && x2 < 0   = 4

-- Juan Castillo Gavira, Paula Sánchez Toledo, Manuel Zamora Bernal, Manuel Hidalgo Aguilar:
cuadrante :: (Int,Int) -> Int
cuadrante (x1,x2) |(x1 > 0) && (x2 > 0) = 1
                  |(x1 < 0) && (x2 > 0) = 2
                  |(x1 < 0) && (x2 < 0) = 3
                  |(x1 > 0) && (x2 < 0) = 4
                  |otherwise = 0

-- Álvaro Galisteo Bermúdez:
cuadrante :: (Int,Int) -> Int 
cuadrante (x1,x2) = if x1>0 && x2>0 then 1
                    else if x1>0 && x2<0 then 4
                    else if x1<0 && x2>0 then 2
                    else if x1<0 && x2<0 then 3
                    else 0
--Marina Garcia Ruz 
cuadrante (x1,y1) | x1 == 0 = 0
                  | y1 == 0 = 0
                  | signum x1 > 0 && signum y1 > 0 = 1
                  | signum x1 < 0 && signum y1 > 0 = 2
                  | signum x1 < 0 && signum y1 < 0 = 3
                  | otherwise = 4

--Con patrones:
cuadrante' :: (Int,Int) -> Int
cuadrante' (0,_) = 0
cuadrante' (_,0) = 0
cuadrante' (x1,y1) | signum x1 > 0 && signum y1 > 0 = 1
                   | signum x1 < 0 && signum y1 > 0 = 2
                   | signum x1 < 0 && signum y1 < 0 = 3
                   | otherwise = 4
-- ----------------------------------------------------------------------------
-- Ejercicio 17. Definir la función
--    simetricoH :: (Int,Int) -> (Int,Int)
-- tal que '(simetricoH p)' es el punto simétrico de 'p' respecto del eje
-- horizontal. Por ejemplo,
--    simetricoH (2,5)   ==  (2,-5)
--    simetricoH (2,-5)  ==  (2,5)
-- ----------------------------------------------------------------------------
-- Eva González Estrada, Juan Castillo Gavira, Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Hidalgo Aguilar :
simetricoH :: (Int,Int) -> (Int,Int)
simetricoH (x1,x2) = (x1, -x2)

-- ----------------------------------------------------------------------------
-- Ejercicio 18. Definir la función
--    simetricoV :: (Int,Int) -> (Int,Int)
-- tal que '(simetricoV p)' es el punto simétrico de 'p' respecto del eje
-- vertical. Por ejemplo,
--    simetricoV (2,5)   ==  (-2,5)
--    simetricoV (2,-5)  ==  (-2,-5)
-- ----------------------------------------------------------------------------
-- Eva González Estrada, Juan Castillo Gavira, Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Hidalgo Aguilar:
simetricoV :: (Int,Int) -> (Int,Int)
simetricoV (x1,x2) = (-x1,x2)

-- ----------------------------------------------------------------------------
-- Ejercicio 19. Definir la función
--    distancia :: (Float,Float) -> (Float,Float) -> Float
-- tal que '(distancia p1 p2)' es la distancia entre los puntos 'p1' y 'p2'.
-- Por ejemplo,
--    distancia (1,2) (4,6)  ==  5.0
-- ----------------------------------------------------------------------------
-- Eva González Estrada,Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Hidalgo Aguilar:
distancia :: (Float,Float) -> (Float,Float) -> Float
distancia (x1,x2) (y1,y2) = sqrt ((x1-y1)^2 + (x2-y2)^2)
-- Juan Castillo Gavira:
distancia :: (Float,Float) -> (Float,Float) -> Float
distancia (x1,x2) (y1,y2) = sqrt (x^2+y^2)
 where x=y1-x1
       y=y2-x2

--Álvaro Galisteo Bermúdez, Manuel Zamora Bernal:
distancia :: (Float,Float) -> (Float,Float) -> Float
distancia (x1,x2) (y1,y2) = sqrt((y1-x1)^2+(y2-x2)^2)

-- ----------------------------------------------------------------------------
-- Ejercicio 20. Comprobar con QuickCheck que se verifica la propiedad
-- triangular de la distancia; es decir, dados tres puntos p1, p2 y p3, la
-- distancia de p1 a p3 es menor o igual que la suma de las distancias de p1 a
-- p2 y de p2 a p3.
-- ----------------------------------------------------------------------------

-- La propiedad es
-- Eva González Estrada, Juan Castillo Gavira, Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Zamora Bernal, Manuel Hidalgo Aguilar:
prop_triangular :: (Float,Float) -> (Float,Float) -> (Float,Float) -> Bool
prop_triangular p1 p2 p3 = distancia p1 p3 <= distancia p1 p2 + distancia p2 p3

-- La comprobación es
--    > quickCheck prop_triangular
-- +++ OK, passed 100 tests.
-- ----------------------------------------------------------------------------
-- Ejercicio 21. Definir la función
--    puntoMedio :: (Float,Float) -> (Float,Float) -> (Float,Float)
-- tal que '(puntoMedio p1 p2)' es el punto medio entre los puntos 'p1' y 'p2'.
-- Por ejemplo,
--    puntoMedio (0,2) (0,6)   ==  (0.0,4.0)
--    puntoMedio (-1,2) (7,6)  ==  (3.0,4.0)
-- ----------------------------------------------------------------------------
-- Eva González Estrada, Juan Castillo Gavira, Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Zamora Bernal, Manuel Hidalgo Aguilar:
puntoMedio :: (Float,Float) -> (Float,Float) -> (Float,Float)
puntoMedio (x1,x2) (y1,y2) = ((x1+y1)/2, (x2+y2)/2)


-- ---------------------------------------------------------------------
-- Repaso de operaciones lógicas                                      --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 22.1. La disyunción excluyente xor de dos fórmulas se
-- verifica si una es verdadera y la otra es falsa. Su tabla de verdad
-- es
--    x     | y     | xor x y
--    ------+-------+---------
--    True  | True  | False 
--    True  | False | True
--    False | True  | True
--    False | False | False
--    
-- Definir la función 
--    xor1 :: Bool -> Bool -> Bool
-- tal que (xor1 x y) es la disyunción excluyente de x e y, calculada a
-- partir de la tabla de verdad. Usar 4 ecuaciones, una por cada línea
-- de la tabla. 
-- ---------------------------------------------------------------------
-- Eva González Estrada, Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Hidalgo Aguilar:
xor1 :: Bool -> Bool -> Bool
xor1 True True   = False
xor1 True False  = True
xor1 False True  = True
xor1 False False = False

-- Juan Castillo gavira:
xor1 :: Bool -> Bool -> Bool
xor1 x y | x==True && y==True = False
         | x==True && y==False = True
         | x==False && y==True = True
         | x==False && y==False = False

-- ---------------------------------------------------------------------
-- Ejercicio 22.2. Definir la función 
--    xor2 :: Bool -> Bool -> Bool
-- tal que (xor2 x y) es la disyunción excluyente de x e y, calculada a
-- partir de la tabla de verdad y patrones. Usar 2 ecuaciones, una por
-- cada valor del primer argumento. 
-- ---------------------------------------------------------------------
-- Eva González Estrada, Marina Garcia Ruz:
xor2 :: Bool -> Bool -> Bool
xor2 True  x = not x
xor2 False x = x

-- Juan Castillo Gavira, Álvaro Galisteo Bermúdez, Manuel Hidalgo Aguilar:
xor2 :: Bool -> Bool -> Bool
xor2 x y | x /= y = True
         | x == y = False

-- ---------------------------------------------------------------------
-- Ejercicio 22.3. Definir la función 
--    xor3 :: Bool -> Bool -> Bool
-- tal que (xor3 x y) es la disyunción excluyente de x e y, calculada 
-- a partir de la disyunción (||), conjunción (&&) y negación (not). 
-- Usar 1 ecuación. 
-- ---------------------------------------------------------------------
-- Eva González Estrada:
xor3 :: Bool -> Bool -> Bool
xor3 x y = ((not (x && y)) && (x || y))

-- Juan Castillo Gavira, Marina Garcia Ruz, Manuel Hidalgo Aguilar:
xor3' :: Bool -> Bool -> Bool
xor3' x y = (x && not(y)) || (y && not(x))

--Álvaro Galisteo Bermúdez:
xor3 :: Bool -> Bool -> Bool
xor3 x y = not (x && y) || (x || y) 


-- ---------------------------------------------------------------------
-- Ejercicio 22.4. Definir la función 
--    xor4 :: Bool -> Bool -> Bool
-- tal que (xor3 x y) es la disyunción excluyente de x e y, calculada
-- a partir de desigualdad (/=). Usar 1 ecuación.
-- ---------------------------------------------------------------------
-- Eva González Estrada, Juan Castillo Gavira, Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Hidalgo Aguilar:
xor4 :: Bool -> Bool -> Bool
xor4 x y = x /= y

-- ---------------------------------------------------------------------
-- Ejercicio 22.5. Comprobar con QuickCheck que las cuatro definiciones
-- de xor son equivalentes.
-- ---------------------------------------------------------------------

-- La propiedad es
--Eva González Estrada, Juan Castillo Gavira, Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Hidalgo Aguilar :
prop_xor_equivalentes :: Bool -> Bool -> Bool
prop_xor_equivalentes x y = ((xor1 x y) == (xor2 x y)) &&
                            ((xor1 x y) == (xor3 x y)) &&
                            ((xor1 x y) == (xor4 x y))

-- La comprobación es
--  +++ OK, passed 100 tests
-- ---------------------------------------------------------------------
-- Ejercicio 23.1 Definir la función 
--    or3 :: Bool -> Bool -> Bool -> Bool
-- tal que (or3 a b c) es la disyunción entre a, b y c; es decir,
-- ocurre a o b o c. Definir la función usando '||'. Por ejemplo,
--    or3 True True False  ==  True
--    or3 False False False ==  False
-- ---------------------------------------------------------------------
-- Juan Castillo Gavira, Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Manuel Hidalgo Aguilar:
or3 :: Bool -> Bool -> Bool-> Bool 
or3 a b c = a || b || c

--Marina Garcia Ruz 
or3 x y z = ( x || y ) || ( x || z )

-- ---------------------------------------------------------------------
-- Ejercicio 23.2 Definir la función 
--    or3' :: Bool -> Bool -> Bool -> Bool
-- tal que (or3' a b c) es la disyunción entre a, b y c; es decir,
-- ocurre a o b o c. Definir la función usando 'or' para listas.
-- Por ejemplo,
--    or3' True True False  ==  True
--    or3' False False False ==  False
-- ---------------------------------------------------------------------
-- Juan Castillo Gavira:
or3' :: Bool -> Bool -> Bool -> Bool
or3' a b c = or [a==True, b==True, c==True]

--Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Hidalgo Aguilar:
or3' :: Bool -> Bool -> Bool -> Bool
or3' a b c = or [a,b,c]

-- ---------------------------------------------------------------------
-- Ejercicio 24.1 Definir la función 
--    and3 :: Bool -> Bool -> Bool -> Bool
-- tal que (and3 a b c) es la conjunción entre a, b y c; es decir,
-- ocurre a y b y c. Definir la función usando '&&'. Por ejemplo,
--    and3 True True True  ==  True
--    and3 False True False ==  False
-- ---------------------------------------------------------------------

-- Juan Castillo Gavira, Álvaro Galisteo Bermúdez, Manuel Hidalgo Aguilar:
and3 :: Bool -> Bool -> Bool -> Bool
and3 a b c = ((a&&b) && (b&&c)) && (a&&c)

--Marina Garcia Ruz 
and3 x y z = ( x && y ) && ( y && z )

-- ---------------------------------------------------------------------
-- Ejercicio 24.2 Definir la función 
--    and3' :: Bool -> Bool -> Bool -> Bool 
-- tal que (and3' a b c) es la conjunción entre a, b y c; es decir,
-- ocurre a o b o c. Definir la función usando 'and' para listas.
-- Por ejemplo,
--    and3' True True True  ==  True
--    and3' False True False ==  False
-- ---------------------------------------------------------------------

-- Juan Castillo Gavira, Álvaro Galisteo Bermúdez, Manuel Hidalgo Aguilar:
and3' :: Bool -> Bool -> Bool -> Bool
and3' a b c = and [a==b,b==c,a==c]

--Marina Garcia Ruz : 
and3' x y z = and [ x , y , z ]

-- ---------------------------------------------------------------------
-- Ejercicio 25.1. Definir la función 
--    siglo20 :: Int -> Bool 
-- tal que (siglo20 x) indica si el ańo x perteneció al siglo 20; es decir,
-- si está comprendido entre el ańo 1901 y 2000.
-- Por ejemplo,
--    siglo20 1902  == True
--    siglo20 2001 == False
-- ---------------------------------------------------------------------
-- Juan Castillo Gavira, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Hidalgo Aguilar 
siglo20 :: Int -> Bool
siglo20 x = (1901 <= x) && (x <= 2000)

--Álvaro Galisteo Bermúdez:
siglo20 :: Int -> Bool
siglo20 x = 1901 <= x &&  x <= 2000

-- ---------------------------------------------------------------------
-- Ejercicio 25.2. Definir la función 
--    noSiglo20 :: Int -> Bool 
-- tal que (noSiglo20 x) indica si el ańo x no perteneció al siglo 20; es decir,
-- si no está comprendido entre el ańo 1901 y 2000.
-- Definirla de tres formas distintas, una usando la función (siglo20 x), otra
-- usando '&&' y otra usando '||'.
--
-- Por ejemplo,
--    noSiglo20 1902  == False
--    noSiglo20 2001 == True
-- ---------------------------------------------------------------------
-- Juan Castillo Gavira
noSiglo20 :: Int -> Bool
noSiglo20 x =  not (siglo20 x)
noSiglo20' x = undefined 
noSiglo20'' x = (x<1901) || (x>2000)

--Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Hidalgo Aguilar :
noSiglo20 :: Int -> Bool
noSiglo20 x = not (siglo20 x)
noSiglo20' x = not (1901 <= x &&  x <= 2000)
noSiglo20'' x = x<1901 || x>2000

-- ---------------------------------------------------------------------
-- Ejercicio 26. Definir la función 
--    xnor :: Bool -> Bool -> Bool 
-- tal que (xnor a b) se calcula con su tabla de verdad, que
-- es
--    x     | y     | xnor x y
--    ------+-------+---------
--    False | False | True 
--    False | True  | False
--    True  | False | False
--    True  | True  | True
--
-- Emplear solo operadores lógicos (&&, ||, not).
-- 
-- Por ejemplo,
--    xnor True True  ==  True
--    xnor False True ==  False
--    xnor False False  ==  True
-- ---------------------------------------------------------------------
-- Juan Castillo Gavira
xnor :: Bool -> Bool -> Bool
xnor x y = if x==y then True else False

--Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Manuel Hidalgo Aguilar:
xnor :: Bool -> Bool -> Bool
xnor x y = x && y || not (x || y)

-- Marta Zaitsev Borrero 
xnor :: Bool -> Bool -> Bool
xnor a b = not(a/=b) 

-- ---------------------------------------------------------------------
-- Ejercicio 27. Definir la función 
--    aprueba :: Float -> Float -> Float -> Bool
-- tal que (aprueba n1 n2 n3) indica si con las notas de los
-- exámenes parciales n1, n2 y n3 se consigue aprobar la
-- asignatura. Los criterios para aprobar la asignatura son los siguientes:
--   * La media de las notas debe ser mayor o igual que 5, y
--   * Cada una de las notas de los exámenes parciales son mayor o igual
--     que 4.0,
--   * O en el último exámen se obtuvo un 10 (entonces siempre se aprueba)
-- Por ejemplo,
--    aprueba 5.0 6.0 5.0 == True
--    aprueba 1.5 6.0 8.0 == False
--    aprueba 3.7 1.5 10.0 == True
-- ---------------------------------------------------------------------
-- Juan Castillo Gavira
aprueba :: Float -> Float -> Float -> Bool
aprueba n1 n2 n3 = if n3==10 then True
                     else if ((n1<4)||(n2<4)||(n3<4))==True then False
                          else if media n1 n2 n3 >= 5 then True
                               else False
  where media n1 n2 n3 = (n1+n2+n3)/3

--Álvaro Galisteo Bermúdez:
aprueba :: Float -> Float -> Float -> Bool
aprueba _ _ 10 = True
aprueba n1 n2 n3 = n1 >= 4 && n2>=4 && n3>=4 && (n1+n2+n3)/2 >= 5

-- Paula Sánchez Toledo, Manuel Hidalgo Aguilar
aprueba :: Float -> Float -> Float -> Bool
aprueba n1 n2 n3 = ((n1+n2+n3)/3 >= 5 && n1>=4 && n2>=4 && n3>=4) || n3==10

--Marina Garcia Ruz 
aprueba n1 n2 n3 | n3 == 10 = True
                 | n1 >= 4 && n2 >= 4 && n3 >= 4 && m >= 5 = True 
                 | otherwise = False
                  where m = ( n1 + n2 + n3 ) / 3

-- Marta Zaitsev Borrero
aprueba :: Float -> Float -> Float -> Bool
aprueba n1 n2 n3 = and[(((n1+n2+n3)/3)>= 5 && n1>= 4 && n2>= 4 && n3>= 4) || n3==10

-- ---------------------------------------------------------------------
-- Ejercicio 28. Comprobar las leyes de Morgan con QuickCheck. Las
-- leyes de Morgan se definen como sigue:
--   * ley 1: no (A o B) == (no A) y (no B)
--   * ley 2: no (A y B) == (no A) o (no B)
-- Consejo: definir cada ley como una función por separado para componer
-- la propiedad
-- ---------------------------------------------------------------------
-- Juan Castillo Gavira
ley1:: Bool -> Bool -> Bool 
ley1 a b = not (a || b) == not (a) && not (b)

ley2:: Bool -> Bool -> Bool 
ley2 a b = not (a && b) == not (a) || not (b)

-- Juan Castillo Gavira (con las definiciones de arriba, me sale que 
-- falla la ley 1 y la ley 2 pasa 100 test de manera exitosa
-- La propiedad es
prop_leyes_morgan :: Bool -> Bool -> Bool 
prop_leyes_morgan = undefined


--Álvaro Galisteo Bermúdez, Paula Sánchez Toledo, Marina Garcia Ruz, Manuel Hidalgo Aguilar:

ley1:: Bool -> Bool -> Bool 
ley1 a b = (not (a||b)) == ((not a) &&  (not b))

ley2:: Bool -> Bool -> Bool 
ley2 a b = not (a && b) == (not a) || (not b)

-- La propiedad es
prop_leyes_morgan :: Bool -> Bool -> Bool 
prop_leyes_morgan a b = ley1 a b == ley2 a b

-- La comprobación es:
-- *Main> quickCheck (prop_leyes_morgan)
-- +++ OK, passed 100 tests.