{- conjunto de reales distintos de 0 -}
conj Rno0 = { r en R | r /= 0 }

 
{- conjunto de enteros distintos de 0 -}
conj Zno0 = { z en Z | z /= 0 }


{- conjunto de los natulares -}
conj N = { x en Z | x >= 0  }  

{- conjunto de naturales sin el 0 -}
conj Nno0 = { x en Z | x > 0  }  

conj Bool = { True, False }

conj Rango = { x en Z | (-10 <= x, x <= 10) }

{- conj Mes = { Enero, Febrero, Marzo, Abril, Mayo, Junio, Julio, Agosto, Setiembre, Octubre, Noviembre, Diciembre }

conj Dias = { Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo } -}

conj SecnoV = { xs en R* | xs /= [] }

{- predecesor de un natural -}
pred :: N -> N
pred (x) = 0 si x == 0
         o x - 1

pred1 :: Nno0 -> N
pred1 (n) = n-1

{- sucesor de un natural -}
suc :: N -> N
suc (x) = x + 1

max :: R X R -> R
max (x, y) = x si x >= y
             o y
 
min :: R X R -> R
min(a,b) = a si a <= b
          o b
             
{- cociente de division de dos naturales -}
div :: N X Nno0 -> N
div (x,y) = 0 si x < y
          o 1 + div (x-y,y)

{- resto de division de dos naturales -}
mod :: N X Nno0 -> N
mod (x,y) = x si x < y
          o mod (x-y,y)
        
{- funcion auxiliar para divisores -}        
divis :: N X Nno0 -> N* 
divis(a,b) = a : []                  si b == a
           o b : divis(a, b+1)       si mod (a,b) == 0
           o divis (a, b+1)
{- divisores de un natural ditinto de 0-}
divisores :: Nno0 -> N*
divisores(a) = divis (a,1)

{- dado un natural mayor que 0 dice si es primo o no -}
esprimo :: Nno0 -> Bool
esprimo(n) = True si (divisores (n) == 1 : n : [])
           o False
           
              
{- multiplos de un numero hasta una cota dada a partir de un i. La funcion multiplos usa i = 1-}           
mulcota :: Nno0 X Nno0 X N-> N*
mulcota (a,c,i) =  []                  si a * i >= c
              o a * i : mulcota(a,c,i+1)      

multiplos :: Nno0 X Nno0 -> N*
multiplos (a,c) = mulcota (a,c,1)

{- otra definicion de multiplos de a hasta c -}
mulcota2 :: Nno0 X Nno0 -> N*
mulcota2 (a,c) = rango(a,c,a)

largo :: R* -> N
largo (lis) = 0 si lis == []
            o 1 + largo (resto(lis))
            
sumaSec :: R* -> R
sumaSec (lis) = 0 si lis == []
           o primero(lis) + sumaSec (resto (lis))
    
prodSec :: R* -> R
prodSec (lis) = 1 si lis == []
                o primero(lis) * prodSec(resto(lis))


{- dada una lista no vacia  y una posicion devuelve el elemento de la lista en la posicion -}

elemPos :: SecnoV X N -> R
elemPos (xs,n) = primero(xs) si n == 0
               o elemPos(resto(xs),n-1)

{- función que determina si un elemento (Z o R) pertenece a una secuencia dada o no -}

estaZ :: Z X Z* -> Bool
estaZ (x, xs) = { False si xs == []
               { True  si (primero(xs)==x)
               { estaZ(x,resto(xs))   
   
estaR :: R X R* -> Bool       
estaR (x, xs) = False si xs == [] 
             o True si x == primero(xs) 
             o estaR(x,resto(xs))
             

{- map para juntar: función que junta una secuencia de figuras, 
   para no tener que andar escribiendo cosas como juntar(..., juntar(.., juntar(...))) -}
juntarFigs :: Fig* -> Fig
juntarFigs (fs) = { FigVacia si fs == []
                  { juntar(primero(fs),juntarFigs(resto(fs)))