Valores de polinomios y de expresiones

Las expresiones aritméticas construidas con una variables, los números enteros y las operaciones de sumar y multiplicar se pueden representar mediante el tipo de datos Exp definido por

   data Exp = Var | Const Int | Sum Exp Exp | Mul Exp  Exp
              deriving Show

1 2	data Exp = Var \| Const Int \| Sum Exp Exp \| Mul Exp Exp deriving Show

Por ejemplo, la expresión 3+5x^2 se puede representar por

   exp1 :: Exp
   exp1 = Sum (Const 3) (Mul Var (Mul Var (Const 5)))

1 2	exp1 :: Exp exp1 = Sum (Const 3) (Mul Var (Mul Var (Const 5)))

Por su parte, los polinomios se pueden representar por la lista de sus coeficientes. Por ejemplo, el polinomio 3+5x^2 se puede representar por [3,0,5].

Definir las funciones

   valorE :: Exp -> Int -> Int
   expresion :: [Int] -> Exp
   valorP :: [Int] -> Int -> Int

valorE :: Exp -> Int -> Int

expresion :: [Int] -> Exp

valorP :: [Int] -> Int -> Int

tales que

(valorE e n) es el valor de la expresión e cuando se sustituye su variable por n. Por ejemplo,

     λ> valorE (Sum (Const 3) (Mul Var (Mul Var (Const 5)))) 2
     23

1 2	λ> valorE (Sum (Const 3) (Mul Var (Mul Var (Const 5)))) 2 23

(expresion p) es una expresión aritmética equivalente al polinomio p. Por ejemplo,

     λ> expresion [3,0,5]
     Sum (Const 3) (Mul Var (Sum (Const 0) (Mul Var (Const 5))))

1 2	λ> expresion [3,0,5] Sum (Const 3) (Mul Var (Sum (Const 0) (Mul Var (Const 5))))

(valorP p n) es el valor del polinomio p cuando se sustituye su variable por n. Por ejemplo,

     λ> valorP [3,0,5] 2
     23

1 2	λ> valorP [3,0,5] 2 23

Comprobar con QuickCheck que, para todo polinomio p y todo entero n,

   valorP p n == valorE (expresion p) n

1	valorP p n == valorE (expresion p) n

Soluciones

[schedule expon=’2017-06-14′ expat=»06:00″]

Las soluciones se pueden escribir en los comentarios hasta el 14 de junio.
El código se debe escribir entre una línea con <pre lang=»haskell»> y otra con </pre>

[/schedule]

[schedule on=’2017-06-14′ at=»06:00″]

import Test.QuickCheck

data Exp = Var | Const Int | Sum Exp Exp | Mul Exp  Exp
           deriving Show
 
exp1 :: Exp
exp1 = Sum (Const 3) (Mul Var (Mul Var (Const 5)))
 
valorE :: Exp -> Int -> Int
valorE Var         n = n
valorE (Const a)   n = a
valorE (Sum e1 e2) n = valorE e1 n + valorE e2 n
valorE (Mul e1 e2) n = valorE e1 n * valorE e2 n
 
expresion :: [Int] -> Exp
expresion [a]   = Const a
expresion (a:p) = Sum (Const a) (Mul Var (expresion p))
 
valorP :: [Int] -> Int -> Int
valorP [a] _ = a
valorP (a:p) n = a + n * valorP p n
 
-- La propiedad es
prop_valor :: [Int] -> Int -> Property
prop_valor p n =
    not (null p) ==> 
    valorP p n == valorE (expresion p) n
 
-- La comprobación es
--    λ> quickCheck prop_valor
--    +++ OK, passed 100 tests.

import Test.QuickCheck

data Exp = Var | Const Int | Sum Exp Exp | Mul Exp Exp

deriving Show

exp1 :: Exp

exp1 = Sum (Const 3) (Mul Var (Mul Var (Const 5)))

valorE :: Exp -> Int -> Int

valorE Var n = n

valorE (Const a) n = a

valorE (Sum e1 e2) n = valorE e1 n + valorE e2 n

valorE (Mul e1 e2) n = valorE e1 n * valorE e2 n

expresion :: [Int] -> Exp

expresion [a] = Const a

expresion (a:p) = Sum (Const a) (Mul Var (expresion p))

valorP :: [Int] -> Int -> Int

valorP [a] _ = a

valorP (a:p) n = a + n * valorP p n

-- La propiedad es

prop_valor :: [Int] -> Int -> Property

prop_valor p n =

not (null p) ==>

valorP p n == valorE (expresion p) n

-- La comprobación es

-- λ> quickCheck prop_valor

-- +++ OK, passed 100 tests.

[/schedule]

4 Comentarios

import Test.QuickCheck

data Exp = Var | Const Int | Sum Exp Exp | Mul Exp Exp
         deriving Show

valorE :: Exp -> Int -> Int
valorE (Var)     x = x
valorE (Const n) x = n
valorE (Sum i d) x = valorE i x + valorE d x
valorE (Mul i d) x = valorE i x * valorE d x

expresion :: [Int] -> Exp
expresion []     = Const 0
expresion [n]    = Const n
expresion (n:xs) = Sum (Const n) (Mul Var (expresion xs))

valorP :: [Int] -> Int -> Int
valorP [] _ = 0
valorP xs n = foldr (\x y -> x + n*y) 0 xs 

valorP2 :: [Int] -> Int -> Int
valorP2 = valorE . expresion

prop_valor :: [Int] -> Int -> Bool
prop_valor xs n = valorP xs n == valorP2 xs n

-- *Main> quickCheck prop_valor
-- +++ OK, passed 100 tests.

import Test.QuickCheck

data Exp = Var | Const Int | Sum Exp Exp | Mul Exp Exp

deriving Show

valorE :: Exp -> Int -> Int

valorE (Var) x = x

valorE (Const n) x = n

valorE (Sum i d) x = valorE i x + valorE d x

valorE (Mul i d) x = valorE i x * valorE d x

expresion :: [Int] -> Exp

expresion [] = Const 0

expresion [n] = Const n

expresion (n:xs) = Sum (Const n) (Mul Var (expresion xs))

valorP :: [Int] -> Int -> Int

valorP [] _ = 0

valorP xs n = foldr (\x y -> x + n*y) 0 xs

valorP2 :: [Int] -> Int -> Int

valorP2 = valorE . expresion

prop_valor :: [Int] -> Int -> Bool

prop_valor xs n = valorP xs n == valorP2 xs n

-- *Main> quickCheck prop_valor

-- +++ OK, passed 100 tests.

Responder

Cescarde dice:

7-junio-2017 a las 09:47

Enrique ere el + mejón :)) tq

Responder

cambios :: [Int] -> [(Int,Int)]
cambios xs = filter sgDist (adyacentes ys)
  where ys = filter (/= 0) xs

nRaicesPositivas :: [Int] -> [Int]
nRaicesPositivas p = [n,n-2..0]
  where n = length (cambios p)

sgDist :: (Int,Int) -> Bool
sgDist (x,y) = signum x /= signum y

adyacentes :: [a] -> [(a,a)]
adyacentes xs = zip xs (tail xs)

cambios :: [Int] -> [(Int,Int)]

cambios xs = filter sgDist (adyacentes ys)

where ys = filter (/= 0) xs

nRaicesPositivas :: [Int] -> [Int]

nRaicesPositivas p = [n,n-2..0]

where n = length (cambios p)

sgDist :: (Int,Int) -> Bool

sgDist (x,y) = signum x /= signum y

adyacentes :: [a] -> [(a,a)]

adyacentes xs = zip xs (tail xs)

Responder

valorE :: Exp -> Int -> Int
valorE Var n = n
valorE (Const x) n = x
valorE (Sum a b) n = valorE a n + valorE b n
valorE (Mul a b) n = valorE a n * valorE b n

expresion :: [Int] -> Exp
expresion [] = Const 0
expresion [x] = Const x
expresion (x:xs) = Sum (Const x) (Mul Var (expresion xs))

valorP :: [Int] -> Int -> Int
valorP [] _ = 0
valorP [x] n = x*n
valorP (x:y:xs) n = x+y*n + (valorP (y:xs) n)

valorE :: Exp -> Int -> Int

valorE Var n = n

valorE (Const x) n = x

valorE (Sum a b) n = valorE a n + valorE b n

valorE (Mul a b) n = valorE a n * valorE b n

expresion :: [Int] -> Exp

expresion [] = Const 0

expresion [x] = Const x

expresion (x:xs) = Sum (Const x) (Mul Var (expresion xs))

valorP :: [Int] -> Int -> Int

valorP [] _ = 0

valorP [x] n = x*n

valorP (x:y:xs) n = x+y*n + (valorP (y:xs) n)

Responder

Valores de polinomios y de expresiones

Soluciones

4 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

4 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico