Haskell y Python – Página 4

TAD de los grafos: Grafos completos

PorJosé A. Alonso 24-mayo-20233-junio-2023

El grafo completo de orden n, K(n), es un grafo no dirigido cuyos conjunto de vértices es {1,..n} y tiene una arista entre cada par de vértices distintos.

Usando el tipo abstracto de datos de los grafos, definir la función,

   completo :: Int -> Grafo Int Int

1	completo :: Int -> Grafo Int Int

tal que completo n es el grafo completo de orden n. Por ejemplo,

   λ> completo 4
   G ND ([1,2,3,4],[(1,2),(1,3),(1,4),(2,3),(2,4),(3,4)])

1 2	λ> completo 4 G ND ([1,2,3,4],[(1,2),(1,3),(1,4),(2,3),(2,4),(3,4)])

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Grafos_completos where

import TAD.Grafo (Grafo, Orientacion (ND), creaGrafo')
import Test.Hspec (Spec, hspec, it, shouldBe)

completo :: Int -> Grafo Int Int
completo n =
  creaGrafo' ND (1,n) [(x,y) | x <- [1..n], y <- [x+1..n]]

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    show (completo 4) `shouldBe`
    "G ND ([1,2,3,4],[(1,2),(1,3),(1,4),(2,3),(2,4),(3,4)])"

-- La verificación es
--    λ> verifica
--
--    e1
--
--    Finished in 0.0004 seconds
--    1 example, 0 failures

module Grafo_Grafos_completos where

import TAD.Grafo (Grafo, Orientacion (ND), creaGrafo')

import Test.Hspec (Spec, hspec, it, shouldBe)

completo :: Int -> Grafo Int Int

completo n =

creaGrafo' ND (1,n) [(x,y) | x <- [1..n], y <- [x+1..n]]

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

show (completo 4) `shouldBe`

"G ND ([1,2,3,4],[(1,2),(1,3),(1,4),(2,3),(2,4),(3,4)])"

-- La verificación es

-- λ> verifica

-- e1

-- Finished in 0.0004 seconds

-- 1 example, 0 failures

Soluciones en Python

from src.TAD.Grafo import Grafo, Orientacion, creaGrafo_

def completo(n: int) -> Grafo:
    return creaGrafo_(Orientacion.ND,
                      (1, n),
                      [(x, y)
                       for x in range(1, n + 1)
                       for y in range(x + 1, n+1)])

# Verificación
# ============

def test_completo() -> None:
    assert str(completo(4)) == \
        "G ND ([1, 2, 3, 4], [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)])"
    print("Verificado")

# La verificación es
#    >>> test_completo()
#    Verificado

from src.TAD.Grafo import Grafo, Orientacion, creaGrafo_

def completo(n: int) -> Grafo:

return creaGrafo_(Orientacion.ND,

(1, n),

[(x, y)

for x in range(1, n + 1)

for y in range(x + 1, n+1)])

# Verificación

# ============

def test_completo() -> None:

assert str(completo(4)) == \

"G ND ([1, 2, 3, 4], [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)])"

print("Verificado")

# La verificación es

# >>> test_completo()

# Verificado

El tipo abstracto de datos de los grafos

PorJosé A. Alonso 23-mayo-202320-mayo-2023

1. El tipo abstracto de datos de los grafos

Un grafo es una estructura que consta de un conjunto de vértices y un conjunto de aristas que conectan los vértices entre sí. Cada vértice representa una entidad o un elemento, y cada arista representa una relación o conexión entre dos vértices.

Por ejemplo,

         12
    1 -------- 2
    | \78     /|
    |  \   32/ |
    |   \   /  |
  34|     5    |55
    |   /   \  |
    |  /44   \ |
    | /     93\|
    3 -------- 4
         61

1 -------- 2

| \78 /|

| \ 32/ |

| \ / |

34| 5 |55

| / \ |

| /44 \ |

| / 93\|

3 -------- 4

representa un grafo no dirigido, lo que significa que las aristas tienen una dirección específica. Cada arista tiene un peso asociado, que puede representar una medida o una valoración de la relación entre los vértices que conecta.

El grafo consta de cinco vértices numerados del 1 al 5. Las aristas especificadas en la lista indican las conexiones entre los vértices y sus respectivos pesos. Por ejemplo, la arista (1,2,12) indica que existe una conexión entre el vértice 1 y el vértice 2 con un peso de 12.

En el grafo representado, se pueden observar las conexiones entre los vértices de la siguiente manera:

El vértice 1 está conectado con el vértice 2 (peso 12), el vértice 3 (peso 34) y el vértice 5 (peso 78).
El vértice 2 está conectado con el vértice 4 (peso 55) y el vértice 5 (peso 32).
El vértice 3 está conectado con el vértice 4 (peso 61) y el vértice 5 (peso 44).
El vértice 4 está conectado con el vértice 5 (peso 93).

Las operaciones del tipo abstracto de datos (TAD) de los grafos son

   creaGrafo  :: (Ix v, Num p, Ord v, Ord p) =>
                  Orientacion -> (v,v) -> [(v,v,p)] -> Grafo v p
   creaGrafo' :: (Ix v, Num p, Ord v, Ord p) =>
                  Orientacion -> (v,v) -> [(v,v)] -> Grafo v p
   dirigido   :: (Ix v,Num p) => (Grafo v p) -> Bool
   adyacentes :: (Ix v,Num p) => (Grafo v p) -> v -> [v]
   nodos      :: (Ix v,Num p) => (Grafo v p) -> [v]
   aristas    :: (Ix v,Num p) => (Grafo v p) -> [(v,v,p)]
   aristaEn   :: (Ix v,Num p) => (Grafo v p) -> (v,v) -> Bool
   peso       :: (Ix v,Num p) => v -> v -> (Grafo v p) -> p

creaGrafo :: (Ix v, Num p, Ord v, Ord p) =>

Orientacion -> (v,v) -> [(v,v,p)] -> Grafo v p

creaGrafo' :: (Ix v, Num p, Ord v, Ord p) =>

Orientacion -> (v,v) -> [(v,v)] -> Grafo v p

dirigido :: (Ix v,Num p) => (Grafo v p) -> Bool

adyacentes :: (Ix v,Num p) => (Grafo v p) -> v -> [v]

nodos :: (Ix v,Num p) => (Grafo v p) -> [v]

aristas :: (Ix v,Num p) => (Grafo v p) -> [(v,v,p)]

aristaEn :: (Ix v,Num p) => (Grafo v p) -> (v,v) -> Bool

peso :: (Ix v,Num p) => v -> v -> (Grafo v p) -> p

tales que
+ creaGrafo o cs as es un grafo (dirigido o no, según el de o), con el par de cotas cs y listas de aristas as (cada arista es un trío formado por los dos vértices y su peso).
+ creaGrafo' es la versión de creaGrafo para los grafos sin pesos.
+ dirigido g se verifica si g es dirigido.
+ nodos g es la lista de todos los nodos del grafo g.
+ aristas g es la lista de las aristas del grafo g.
+ adyacentes g v es la lista de los vértices adyacentes al nodo v en el grafo g.
+ aristaEn g a se verifica si a es una arista del grafo g.
+ peso v1 v2 g es el peso de la arista que une los vértices v1 y v2 en el grafo g.

Usando el TAD de los grafos, el grafo anterior se puede definir por

   creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),
                       (2,4,55),(2,5,32),
                       (3,4,61),(3,5,44),
                       (4,5,93)]

creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),

(2,4,55),(2,5,32),

(3,4,61),(3,5,44),

(4,5,93)]

con los siguientes argumentos:

ND: Es un parámetro de tipo Orientacion que indica si el es dirigido o no. En este caso, se utiliza ND, lo que significa «no dirigido». Por lo tanto, el grafo creado será no dirigido, lo que implica que las aristas no tienen una dirección específica.
(1,5): Es el par de cotas que define los vértices del grafo. En este caso, el grafo tiene vértices numerados desde 1 hasta 5.
[(1,2,12),(1,3,34),(1,5,78),(2,4,55),(2,5,32),(3,4,61),(3,5,44),(4,5,93)]: Es una lista de aristas, donde cada arista está representada por un trío de valores. Cada trío contiene los dos vértices que están conectados por la arista y el peso de dicha arista.

Para usar el TAD hay que usar una implementación concreta. En principio, consideraremos las siguientes:
+ mediante lista de adyacencia,
+ mediante vector de adyacencia y
+ mediante matriz de adyacencia.

Hay que elegir la que se desee utilizar, descomentándola y comentando las otras.

2. Los grafos en Haskell

2.1. El tipo abstracto de datos de los grafos en Haskell

El TAD de los grafos se encuentra en el módulo Grafo.hs cuyo contenido es el siguiente:

module TAD.Grafo
  (Orientacion (..),
   Grafo,
   creaGrafo,
   creaGrafo',
   dirigido,
   adyacentes,
   nodos,
   aristas,
   aristaEn,
   peso
  ) where

import TAD.GrafoConListaDeAdyacencia
-- import TAD.GrafoConVectorDeAdyacencia
-- import TAD.GrafoConMatrizDeAdyacencia

module TAD.Grafo

(Orientacion (..),

Grafo,

creaGrafo,

creaGrafo',

dirigido,

adyacentes,

nodos,

aristas,

aristaEn,

peso

) where

import TAD.GrafoConListaDeAdyacencia

-- import TAD.GrafoConVectorDeAdyacencia

-- import TAD.GrafoConMatrizDeAdyacencia

2.2. Implementación de los grafos mediante listas de adyacencia

La implementación se encuentra en el módulo GrafoConListaDeAdyacencia cuyo contenido es el siguiente:

{-# LANGUAGE FlexibleInstances #-}

module TAD.GrafoConListaDeAdyacencia
    (Orientacion (..),
     Grafo,
     creaGrafo,
     creaGrafo',
     dirigido,
     adyacentes,
     nodos,
     aristas,
     aristaEn,
     peso
    ) where

-- Librerías auxiliares                                               --
import Data.Array
import Data.List

-- Orientacion es D (dirigida) ó ND (no dirigida).
data Orientacion = D | ND
  deriving (Eq, Show)

-- (Grafo v p) es un grafo con vértices de tipo v y pesos de tipo p.
data Grafo v p = G Orientacion ([v],[((v,v),p)])
  deriving Eq

-- (escribeGrafo g) es la cadena correspondiente al grafo g. Por
-- ejemplo,
--    λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(2,3,5),(2,2,0)])
--    "G ND ([1,2,3],[((1,2),0),((2,2),0),((2,3),5)])"
--    λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(2,3,5),(2,2,0)])
--    "G D ([1,2,3],[((1,2),0),((2,2),0),((2,3),5)])"
--    λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(2,3,0),(2,2,0)])
--    "G ND ([1,2,3],[(1,2),(2,2),(2,3)])"
--    λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(2,3,0),(2,2,0)])
--    "G D ([1,2,3],[(1,2),(2,2),(2,3)])"
--    λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(3,2,0),(2,2,0)])
--    "G D ([1,2,3],[(1,2),(2,2),(3,2)])"
--    λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(3,2,0),(2,2,0)])
--    "G ND ([1,2,3],[(1,2),(2,2),(2,3)])"
escribeGrafo :: (Ix v,Num p,Eq p,Show v,Show p) => Grafo v p -> String
escribeGrafo (G o (vs,as)) =
  "G " ++ show o ++ " (" ++ show vs ++ "," ++ escribeAristas ++ ")"
  where
    aristasReducidas
      | o == D    = as
      | otherwise = [((x,y),p) | ((x,y),p) <- as, x <= y]
    escribeAristas
      | ponderado = show aristasReducidas
      | otherwise = show [a | (a,_) <- aristasReducidas]
    ponderado = any (\((_,_),p) -> p /= 0) as

-- Procedimiento de escritura de grafos
instance (Ix v,Num p,Eq p,Show v,Show p) => Show (Grafo v p) where
  show = escribeGrafo

-- (creaGrafo o cs as) es un grafo (dirigido o no, según el valor de o),
-- con el par de cotas cs y listas de aristas as (cada arista es un trío
-- formado por los dos vértices y su peso). Por ejemplo,
--    λ> creaGrafo ND (1,3) [(1,2,12),(1,3,34)]
--    G ND ([1,2,3],[((1,2),12),((1,3),34),((2,1),12),((3,1),34)])
--    λ> creaGrafo D (1,3) [(1,2,12),(1,3,34)]
--    G D ([1,2,3],[((1,2),12),((1,3),34)])
--    λ> creaGrafo D (1,4) [(1,2,12),(1,3,34)]
--    G D ([1,2,3,4],[((1,2),12),((1,3),34)])
creaGrafo :: (Ix v, Num p, Ord v, Ord p) =>
             Orientacion -> (v,v) -> [(v,v,p)] -> Grafo v p
creaGrafo o cs as =
  G o (range cs,
       sort ([((x1,x2),p) | (x1,x2,p) <- as] ++
             if o == D then []
             else [((x2,x1),p) | (x1,x2,p) <- as, x1 /= x2]))

-- (creaGrafo' o cs as) es un grafo (dirigido o no, según el valor de o),
-- con el par de cotas cs y listas de aristas as (cada arista es un par
-- de vértices y se supone que su peso es 0). Por ejemplo,
--    λ> creaGrafo' ND (1,3) [(2,1),(1,3)]
--    G ND ([1,2,3],[(1,2),(1,3)])
--    λ> creaGrafo' D (1,3) [(2,1),(1,3)]
--    G D ([1,2,3],[(1,3),(2,1)])
creaGrafo' :: (Ix v, Num p, Ord v, Ord p) =>
              Orientacion -> (v,v) -> [(v,v)] -> Grafo v p
creaGrafo' o cs as =
  creaGrafo o cs [(v1,v2,0) | (v1,v2) <- as]

-- ejGrafoND es el grafo
--             12
--        1 -------- 2
--        | \78     /|
--        |  \   32/ |
--        |   \   /  |
--      34|     5    |55
--        |   /   \  |
--        |  /44   \ |
--        | /     93\|
--        3 -------- 4
--             61
-- Se define por
ejGrafoND :: Grafo Int Int
ejGrafoND = creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),
                                (2,4,55),(2,5,32),
                                (3,4,61),(3,5,44),
                                (4,5,93)]

ejGrafoD :: Grafo Int Int
ejGrafoD = creaGrafo D (1,5) [(1,2,12),(1,3,34),(1,5,78),
                              (2,4,55),(2,5,32),
                              (3,4,61),(3,5,44),
                              (4,5,93)]

-- (dirigido g) se verifica si g es dirigido. Por ejemplo,
--    dirigido ejGrafoD   ==  True
--    dirigido ejGrafoND  ==  False
dirigido :: (Ix v,Num p) => Grafo v p -> Bool
dirigido (G o _) = o == D

-- (nodos g) es la lista de todos los nodos del grafo g. Por ejemplo,
--    nodos ejGrafoND  ==  [1,2,3,4,5]
--    nodos ejGrafoD   ==  [1,2,3,4,5]
nodos :: (Ix v,Num p) => Grafo v p -> [v]
nodos (G _ (ns,_)) = ns

-- (adyacentes g v) es la lista de los vértices adyacentes al nodo v en
-- el grafo g. Por ejemplo,
--    adyacentes ejGrafoND 4  ==  [2,3,5]
--    adyacentes ejGrafoD  4  ==  [5]
adyacentes :: (Ix v, Num p) => Grafo v p -> v -> [v]
adyacentes (G _ (_,e)) v = nub [u | ((w,u),_) <- e, w == v]

-- (aristaEn g a) se verifica si a es una arista del grafo g. Por
-- ejemplo,
--    aristaEn ejGrafoND (5,1)  ==  True
--    aristaEn ejGrafoND (4,1)  ==  False
--    aristaEn ejGrafoD  (5,1)  ==  False
--    aristaEn ejGrafoD  (1,5)  ==  True
aristaEn :: (Ix v,Num p) => Grafo v p -> (v,v) -> Bool
aristaEn g (x,y) = y `elem` adyacentes g x

-- (peso v1 v2 g) es el peso de la arista que une los vértices v1 y v2
-- en el grafo g. Por ejemplo,
--    peso 1 5 ejGrafoND  ==  78
--    peso 1 5 ejGrafoD   ==  78
peso :: (Ix v,Num p) => v -> v -> Grafo v p -> p
peso x y (G _ (_,gs)) = head [c | ((x',y'),c) <- gs, (x,y) == (x',y')]

-- (aristas g) es la lista de las aristas del grafo g. Por ejemplo,
--    λ> aristas ejGrafoD
--    [((1,2),12),((1,3),34),((1,5),78),
--     ((2,4),55),((2,5),32),
--     ((3,4),61),((3,5),44),
--     ((4,5),93)]
--    λ> aristas ejGrafoND
--    [((1,2),12),((1,3),34),((1,5),78),
--     ((2,1),12),((2,4),55),((2,5),32),
--     ((3,1),34),((3,4),61),((3,5),44),
--     ((4,2),55),((4,3),61),((4,5),93),
--     ((5,1),78),((5,2),32),((5,3),44),((5,4),93)]
aristas :: (Ix v,Num p) => Grafo v p -> [((v,v),p)]
aristas (G _ (_,g)) = [((v1,v2),p) | ((v1,v2),p) <- g]

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

{-# LANGUAGE FlexibleInstances #-}

module TAD.GrafoConListaDeAdyacencia

(Orientacion (..),

Grafo,

creaGrafo,

creaGrafo',

dirigido,

adyacentes,

nodos,

aristas,

aristaEn,

peso

) where

-- Librerías auxiliares --

import Data.Array

import Data.List

-- Orientacion es D (dirigida) ó ND (no dirigida).

data Orientacion = D | ND

deriving (Eq, Show)

-- (Grafo v p) es un grafo con vértices de tipo v y pesos de tipo p.

data Grafo v p = G Orientacion ([v],[((v,v),p)])

deriving Eq

-- (escribeGrafo g) es la cadena correspondiente al grafo g. Por

-- ejemplo,

-- λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(2,3,5),(2,2,0)])

-- "G ND ([1,2,3],[((1,2),0),((2,2),0),((2,3),5)])"

-- λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(2,3,5),(2,2,0)])

-- "G D ([1,2,3],[((1,2),0),((2,2),0),((2,3),5)])"

-- λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(2,3,0),(2,2,0)])

-- "G ND ([1,2,3],[(1,2),(2,2),(2,3)])"

-- λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(2,3,0),(2,2,0)])

-- "G D ([1,2,3],[(1,2),(2,2),(2,3)])"

-- λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(3,2,0),(2,2,0)])

-- "G D ([1,2,3],[(1,2),(2,2),(3,2)])"

-- λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(3,2,0),(2,2,0)])

-- "G ND ([1,2,3],[(1,2),(2,2),(2,3)])"

escribeGrafo :: (Ix v,Num p,Eq p,Show v,Show p) => Grafo v p -> String

escribeGrafo (G o (vs,as)) =

"G " ++ show o ++ " (" ++ show vs ++ "," ++ escribeAristas ++ ")"

where

aristasReducidas

| o == D = as

| otherwise = [((x,y),p) | ((x,y),p) <- as, x <= y]

escribeAristas

| ponderado = show aristasReducidas

| otherwise = show [a | (a,_) <- aristasReducidas]

ponderado = any (\((_,_),p) -> p /= 0) as

-- Procedimiento de escritura de grafos

instance (Ix v,Num p,Eq p,Show v,Show p) => Show (Grafo v p) where

show = escribeGrafo

-- (creaGrafo o cs as) es un grafo (dirigido o no, según el valor de o),

-- con el par de cotas cs y listas de aristas as (cada arista es un trío

-- formado por los dos vértices y su peso). Por ejemplo,

-- λ> creaGrafo ND (1,3) [(1,2,12),(1,3,34)]

-- G ND ([1,2,3],[((1,2),12),((1,3),34),((2,1),12),((3,1),34)])

-- λ> creaGrafo D (1,3) [(1,2,12),(1,3,34)]

-- G D ([1,2,3],[((1,2),12),((1,3),34)])

-- λ> creaGrafo D (1,4) [(1,2,12),(1,3,34)]

-- G D ([1,2,3,4],[((1,2),12),((1,3),34)])

creaGrafo :: (Ix v, Num p, Ord v, Ord p) =>

Orientacion -> (v,v) -> [(v,v,p)] -> Grafo v p

creaGrafo o cs as =

G o (range cs,

sort ([((x1,x2),p) | (x1,x2,p) <- as] ++

if o == D then []

else [((x2,x1),p) | (x1,x2,p) <- as, x1 /= x2]))

-- (creaGrafo' o cs as) es un grafo (dirigido o no, según el valor de o),

-- con el par de cotas cs y listas de aristas as (cada arista es un par

-- de vértices y se supone que su peso es 0). Por ejemplo,

-- λ> creaGrafo' ND (1,3) [(2,1),(1,3)]

-- G ND ([1,2,3],[(1,2),(1,3)])

-- λ> creaGrafo' D (1,3) [(2,1),(1,3)]

-- G D ([1,2,3],[(1,3),(2,1)])

creaGrafo' :: (Ix v, Num p, Ord v, Ord p) =>

Orientacion -> (v,v) -> [(v,v)] -> Grafo v p

creaGrafo' o cs as =

creaGrafo o cs [(v1,v2,0) | (v1,v2) <- as]

-- ejGrafoND es el grafo

-- 12

-- 1 -------- 2

-- | \78 /|

-- | \ 32/ |

-- | \ / |

-- 34| 5 |55

-- | / \ |

-- | /44 \ |

-- | / 93\|

-- 3 -------- 4

-- 61

-- Se define por

ejGrafoND :: Grafo Int Int

ejGrafoND = creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),

(2,4,55),(2,5,32),

(3,4,61),(3,5,44),

(4,5,93)]

ejGrafoD :: Grafo Int Int

ejGrafoD = creaGrafo D (1,5) [(1,2,12),(1,3,34),(1,5,78),

(2,4,55),(2,5,32),

(3,4,61),(3,5,44),

(4,5,93)]

-- (dirigido g) se verifica si g es dirigido. Por ejemplo,

-- dirigido ejGrafoD == True

-- dirigido ejGrafoND == False

dirigido :: (Ix v,Num p) => Grafo v p -> Bool

dirigido (G o _) = o == D

-- (nodos g) es la lista de todos los nodos del grafo g. Por ejemplo,

-- nodos ejGrafoND == [1,2,3,4,5]

-- nodos ejGrafoD == [1,2,3,4,5]

nodos :: (Ix v,Num p) => Grafo v p -> [v]

nodos (G _ (ns,_)) = ns

-- (adyacentes g v) es la lista de los vértices adyacentes al nodo v en

-- el grafo g. Por ejemplo,

-- adyacentes ejGrafoND 4 == [2,3,5]

-- adyacentes ejGrafoD 4 == [5]

adyacentes :: (Ix v, Num p) => Grafo v p -> v -> [v]

adyacentes (G _ (_,e)) v = nub [u | ((w,u),_) <- e, w == v]

-- (aristaEn g a) se verifica si a es una arista del grafo g. Por

-- ejemplo,

-- aristaEn ejGrafoND (5,1) == True

-- aristaEn ejGrafoND (4,1) == False

-- aristaEn ejGrafoD (5,1) == False

-- aristaEn ejGrafoD (1,5) == True

aristaEn :: (Ix v,Num p) => Grafo v p -> (v,v) -> Bool

aristaEn g (x,y) = y `elem` adyacentes g x

-- (peso v1 v2 g) es el peso de la arista que une los vértices v1 y v2

-- en el grafo g. Por ejemplo,

-- peso 1 5 ejGrafoND == 78

-- peso 1 5 ejGrafoD == 78

peso :: (Ix v,Num p) => v -> v -> Grafo v p -> p

peso x y (G _ (_,gs)) = head [c | ((x',y'),c) <- gs, (x,y) == (x',y')]

-- (aristas g) es la lista de las aristas del grafo g. Por ejemplo,

-- λ> aristas ejGrafoD

-- [((1,2),12),((1,3),34),((1,5),78),

-- ((2,4),55),((2,5),32),

-- ((3,4),61),((3,5),44),

-- ((4,5),93)]

-- λ> aristas ejGrafoND

-- [((1,2),12),((1,3),34),((1,5),78),

-- ((2,1),12),((2,4),55),((2,5),32),

-- ((3,1),34),((3,4),61),((3,5),44),

-- ((4,2),55),((4,3),61),((4,5),93),

-- ((5,1),78),((5,2),32),((5,3),44),((5,4),93)]

aristas :: (Ix v,Num p) => Grafo v p -> [((v,v),p)]

aristas (G _ (_,g)) = [((v1,v2),p) | ((v1,v2),p) <- g]

2.3. Implementación de los grafos mediante vectores de adyacencia

La implementación se encuentra en el módulo GrafoConVectorDeAdyacencia cuyo contenido es el siguiente:

{-# LANGUAGE FlexibleInstances #-}

module TAD.GrafoConVectorDeAdyacencia
  (Orientacion (..),
   Grafo,
   creaGrafo,
   creaGrafo',
   dirigido,
   adyacentes,
   nodos,
   aristas,
   aristaEn,
   peso
  ) where

-- Librerías auxiliares
import Data.Array (Array, Ix, accumArray, indices, (!))
import Data.List (sort)
import Test.QuickCheck

-- Orientacion es D (dirigida) ó ND (no dirigida).
data Orientacion = D | ND
  deriving (Eq, Show)

-- (Grafo v p) es un grafo con vértices de tipo v y pesos de tipo p.
data Grafo v p = G Orientacion (Array v [(v,p)])
  deriving Eq

-- (escribeGrafo g) es la cadena correspondiente al grafo g. Por
-- ejemplo,
--    λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(2,3,5),(2,2,0)])
--    "G ND ([1,2,3],[((1,2),0),((2,2),0),((2,3),5)])"
--    λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(2,3,5),(2,2,0)])
--    "G D ([1,2,3],[((1,2),0),((2,2),0),((2,3),5)])"
--    λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(2,3,0),(2,2,0)])
--    "G ND ([1,2,3],[(1,2),(2,2),(2,3)])"
--    λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(2,3,0),(2,2,0)])
--    "G D ([1,2,3],[(1,2),(2,2),(2,3)])"
--    λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(3,2,0),(2,2,0)])
--    "G D ([1,2,3],[(1,2),(2,2),(3,2)])"
--    λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(3,2,0),(2,2,0)])
--    "G ND ([1,2,3],[(1,2),(2,2),(2,3)])"
escribeGrafo :: (Ix v,Num p,Ord v, Ord p,Show v,Show p) => Grafo v p -> String
escribeGrafo g@(G o _) =
  "G " ++ show o ++ " (" ++ show vs ++ "," ++ escribeAristas ++ ")"
  where
    as = sort (aristas g)
    vs = nodos g
    aristasReducidas
      | o == D    = as
      | otherwise = [((x,y),p) | ((x,y),p) <- as, x <= y]
    escribeAristas
      | ponderado = show aristasReducidas
      | otherwise = show [a | (a,_) <- aristasReducidas]
    ponderado = any (\((_,_),p) -> p /= 0) as

-- Procedimiento de escritura de grafos
instance (Ix v,Num p,Ord v, Ord p,Show v,Show p) => Show (Grafo v p) where
  show = escribeGrafo

-- (creaGrafo o cs as) es un grafo (dirigido o no, según el valor de o),
-- con el par de cotas cs y listas de aristas as (cada arista es un trío
-- formado por los dos vértices y su peso). Ver el ejemplo a continuación.
creaGrafo :: (Ix v, Num p) => Orientacion -> (v,v) -> [(v,v,p)] -> Grafo v p
creaGrafo o cs vs =
  G o (accumArray (\xs x -> xs++[x]) [] cs
                  ((if o == D then []
                    else [(x2,(x1,p))|(x1,x2,p) <- vs, x1 /= x2]) ++
                   [(x1,(x2,p)) | (x1,x2,p) <- vs]))

-- (creaGrafo' o cs as) es un grafo (dirigido o no, según el valor de o),
-- con el par de cotas cs y listas de aristas as (cada arista es un par
-- de vértices y se supone que su peso es 0). Por ejemplo,
--    λ> creaGrafo' ND (1,3) [(2,1),(1,3)]
--    G ND ([1,2,3],[(1,2),(1,3)])
--    λ> creaGrafo' D (1,3) [(2,1),(1,3)]
--    G D ([1,2,3],[(1,3),(2,1)])
creaGrafo' :: (Ix v, Num p, Ord v, Ord p) =>
              Orientacion -> (v,v) -> [(v,v)] -> Grafo v p
creaGrafo' o cs as =
  creaGrafo o cs [(v1,v2,0) | (v1,v2) <- as]

-- ejGrafoND es el grafo
--             12
--        1 -------- 2
--        | \78     /|
--        |  \   32/ |
--        |   \   /  |
--      34|     5    |55
--        |   /   \  |
--        |  /44   \ |
--        | /     93\|
--        3 -------- 4
--             61
-- representado mediante un vector de adyacencia; es decir,
--    λ> ejGrafoND
--    G ND ([1,2,3,4,5],
--          [((1,2),12),((1,3),34),((1,5),78),
--           ((2,4),55),((2,5),32),
--           ((3,4),61),((3,5),44),
--           ((4,5),93)])
ejGrafoND :: Grafo Int Int
ejGrafoND = creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),
                                (2,4,55),(2,5,32),
                                (3,4,61),(3,5,44),
                                (4,5,93)]

-- ejGrafoD es el mismo grafo que ejGrafoND pero orientando las aristas;
-- es decir,
--    λ> ejGrafoD
--    G D ([1,2,3,4,5],
--         [((1,2),12),((1,3),34),((1,5),78),
--          ((2,4),55),((2,5),32),
--          ((3,4),61),((3,5),44),
--          ((4,5),93)])
ejGrafoD :: Grafo Int Int
ejGrafoD = creaGrafo D (1,5) [(1,2,12),(1,3,34),(1,5,78),
                              (2,4,55),(2,5,32),
                              (3,4,61),(3,5,44),
                              (4,5,93)]

-- (dirigido g) se verifica si g es dirigido. Por ejemplo,
--    dirigido ejGrafoD   ==  True
--    dirigido ejGrafoND  ==  False
dirigido :: (Ix v,Num p) => Grafo v p -> Bool
dirigido (G o _) = o == D

-- (nodos g) es la lista de todos los nodos del grafo g. Por ejemplo,
--    nodos ejGrafoND  ==  [1,2,3,4,5]
--    nodos ejGrafoD   ==  [1,2,3,4,5]
nodos :: (Ix v,Num p) => Grafo v p -> [v]
nodos (G _ g) = indices g

-- (adyacentes g v) es la lista de los vértices adyacentes al nodo v en
-- el grafo g. Por ejemplo,
--    adyacentes ejGrafoND 4  ==  [2,3,5]
--    adyacentes ejGrafoD  4  ==  [5]
adyacentes :: (Ix v,Num p) => Grafo v p -> v -> [v]
adyacentes (G _ g) v = map fst (g!v)

-- (aristaEn g a) se verifica si a es una arista del grafo g. Por
-- ejemplo,
--    aristaEn ejGrafoND (5,1)  ==  True
--    aristaEn ejGrafoND (4,1)  ==  False
--    aristaEn ejGrafoD (5,1)   ==  False
--    aristaEn ejGrafoD (1,5)   ==  True
aristaEn :: (Ix v,Num p) => Grafo v p -> (v,v) -> Bool
aristaEn g (x,y) = y `elem` adyacentes g x

-- (peso v1 v2 g) es el peso de la arista que une los vértices v1 y v2
-- en el grafo g. Por ejemplo,
--    peso 1 5 ejGrafoND  ==  78
--    peso 1 5 ejGrafoD   ==  78
peso :: (Ix v,Num p) => v -> v -> Grafo v p -> p
peso x y (G _ g) = head [c | (a,c) <- g!x , a == y]

-- (aristas g) es la lista de las aristas del grafo g. Por ejemplo,
--    λ> aristas ejGrafoD
--    [((1,2),12),((1,3),34),((1,5),78),
--     ((2,4),55),((2,5),32),
--     ((3,4),61),((3,5),44),
--     ((4,5),93)]
--    λ> aristas ejGrafoND
--    [((1,2),12),((1,3),34),((1,5),78),
--     ((2,1),12),((2,4),55),((2,5),32),
--     ((3,1),34),((3,4),61),((3,5),44),
--     ((4,2),55),((4,3),61),((4,5),93),
--     ((5,1),78),((5,2),32),((5,3),44),((5,4),93)]
aristas :: (Ix v,Num p) => Grafo v p -> [((v,v),p)]
aristas (G o g) = [((v1,v2),w) | v1 <- nodos (G o g) , (v2,w) <- g!v1]

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

{-# LANGUAGE FlexibleInstances #-}

module TAD.GrafoConVectorDeAdyacencia

(Orientacion (..),

Grafo,

creaGrafo,

creaGrafo',

dirigido,

adyacentes,

nodos,

aristas,

aristaEn,

peso

) where

-- Librerías auxiliares

import Data.Array (Array, Ix, accumArray, indices, (!))

import Data.List (sort)

import Test.QuickCheck

-- Orientacion es D (dirigida) ó ND (no dirigida).

data Orientacion = D | ND

deriving (Eq, Show)

-- (Grafo v p) es un grafo con vértices de tipo v y pesos de tipo p.

data Grafo v p = G Orientacion (Array v [(v,p)])

deriving Eq

-- (escribeGrafo g) es la cadena correspondiente al grafo g. Por

-- ejemplo,

-- λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(2,3,5),(2,2,0)])

-- "G ND ([1,2,3],[((1,2),0),((2,2),0),((2,3),5)])"

-- λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(2,3,5),(2,2,0)])

-- "G D ([1,2,3],[((1,2),0),((2,2),0),((2,3),5)])"

-- λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(2,3,0),(2,2,0)])

-- "G ND ([1,2,3],[(1,2),(2,2),(2,3)])"

-- λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(2,3,0),(2,2,0)])

-- "G D ([1,2,3],[(1,2),(2,2),(2,3)])"

-- λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(3,2,0),(2,2,0)])

-- "G D ([1,2,3],[(1,2),(2,2),(3,2)])"

-- λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(3,2,0),(2,2,0)])

-- "G ND ([1,2,3],[(1,2),(2,2),(2,3)])"

escribeGrafo :: (Ix v,Num p,Ord v, Ord p,Show v,Show p) => Grafo v p -> String

escribeGrafo g@(G o _) =

"G " ++ show o ++ " (" ++ show vs ++ "," ++ escribeAristas ++ ")"

where

as = sort (aristas g)

vs = nodos g

aristasReducidas

| o == D = as

| otherwise = [((x,y),p) | ((x,y),p) <- as, x <= y]

escribeAristas

| ponderado = show aristasReducidas

| otherwise = show [a | (a,_) <- aristasReducidas]

ponderado = any (\((_,_),p) -> p /= 0) as

-- Procedimiento de escritura de grafos

instance (Ix v,Num p,Ord v, Ord p,Show v,Show p) => Show (Grafo v p) where

show = escribeGrafo

-- (creaGrafo o cs as) es un grafo (dirigido o no, según el valor de o),

-- con el par de cotas cs y listas de aristas as (cada arista es un trío

-- formado por los dos vértices y su peso). Ver el ejemplo a continuación.

creaGrafo :: (Ix v, Num p) => Orientacion -> (v,v) -> [(v,v,p)] -> Grafo v p

creaGrafo o cs vs =

G o (accumArray (\xs x -> xs++[x]) [] cs

((if o == D then []

else [(x2,(x1,p))|(x1,x2,p) <- vs, x1 /= x2]) ++

[(x1,(x2,p)) | (x1,x2,p) <- vs]))

-- (creaGrafo' o cs as) es un grafo (dirigido o no, según el valor de o),

-- con el par de cotas cs y listas de aristas as (cada arista es un par

-- de vértices y se supone que su peso es 0). Por ejemplo,

-- λ> creaGrafo' ND (1,3) [(2,1),(1,3)]

-- G ND ([1,2,3],[(1,2),(1,3)])

-- λ> creaGrafo' D (1,3) [(2,1),(1,3)]

-- G D ([1,2,3],[(1,3),(2,1)])

creaGrafo' :: (Ix v, Num p, Ord v, Ord p) =>

Orientacion -> (v,v) -> [(v,v)] -> Grafo v p

creaGrafo' o cs as =

creaGrafo o cs [(v1,v2,0) | (v1,v2) <- as]

-- ejGrafoND es el grafo

-- 12

-- 1 -------- 2

-- | \78 /|

-- | \ 32/ |

-- | \ / |

-- 34| 5 |55

-- | / \ |

-- | /44 \ |

-- | / 93\|

-- 3 -------- 4

-- 61

-- representado mediante un vector de adyacencia; es decir,

-- λ> ejGrafoND

-- G ND ([1,2,3,4,5],

-- [((1,2),12),((1,3),34),((1,5),78),

-- ((2,4),55),((2,5),32),

-- ((3,4),61),((3,5),44),

-- ((4,5),93)])

ejGrafoND :: Grafo Int Int

ejGrafoND = creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),

(2,4,55),(2,5,32),

(3,4,61),(3,5,44),

(4,5,93)]

-- ejGrafoD es el mismo grafo que ejGrafoND pero orientando las aristas;

-- es decir,

-- λ> ejGrafoD

-- G D ([1,2,3,4,5],

-- [((1,2),12),((1,3),34),((1,5),78),

-- ((2,4),55),((2,5),32),

-- ((3,4),61),((3,5),44),

-- ((4,5),93)])

ejGrafoD :: Grafo Int Int

ejGrafoD = creaGrafo D (1,5) [(1,2,12),(1,3,34),(1,5,78),

(2,4,55),(2,5,32),

(3,4,61),(3,5,44),

(4,5,93)]

-- (dirigido g) se verifica si g es dirigido. Por ejemplo,

-- dirigido ejGrafoD == True

-- dirigido ejGrafoND == False

dirigido :: (Ix v,Num p) => Grafo v p -> Bool

dirigido (G o _) = o == D

-- (nodos g) es la lista de todos los nodos del grafo g. Por ejemplo,

-- nodos ejGrafoND == [1,2,3,4,5]

-- nodos ejGrafoD == [1,2,3,4,5]

nodos :: (Ix v,Num p) => Grafo v p -> [v]

nodos (G _ g) = indices g

-- (adyacentes g v) es la lista de los vértices adyacentes al nodo v en

-- el grafo g. Por ejemplo,

-- adyacentes ejGrafoND 4 == [2,3,5]

-- adyacentes ejGrafoD 4 == [5]

adyacentes :: (Ix v,Num p) => Grafo v p -> v -> [v]

adyacentes (G _ g) v = map fst (g!v)

-- (aristaEn g a) se verifica si a es una arista del grafo g. Por

-- ejemplo,

-- aristaEn ejGrafoND (5,1) == True

-- aristaEn ejGrafoND (4,1) == False

-- aristaEn ejGrafoD (5,1) == False

-- aristaEn ejGrafoD (1,5) == True

aristaEn :: (Ix v,Num p) => Grafo v p -> (v,v) -> Bool

aristaEn g (x,y) = y `elem` adyacentes g x

-- (peso v1 v2 g) es el peso de la arista que une los vértices v1 y v2

-- en el grafo g. Por ejemplo,

-- peso 1 5 ejGrafoND == 78

-- peso 1 5 ejGrafoD == 78

peso :: (Ix v,Num p) => v -> v -> Grafo v p -> p

peso x y (G _ g) = head [c | (a,c) <- g!x , a == y]

-- (aristas g) es la lista de las aristas del grafo g. Por ejemplo,

-- λ> aristas ejGrafoD

-- [((1,2),12),((1,3),34),((1,5),78),

-- ((2,4),55),((2,5),32),

-- ((3,4),61),((3,5),44),

-- ((4,5),93)]

-- λ> aristas ejGrafoND

-- [((1,2),12),((1,3),34),((1,5),78),

-- ((2,1),12),((2,4),55),((2,5),32),

-- ((3,1),34),((3,4),61),((3,5),44),

-- ((4,2),55),((4,3),61),((4,5),93),

-- ((5,1),78),((5,2),32),((5,3),44),((5,4),93)]

aristas :: (Ix v,Num p) => Grafo v p -> [((v,v),p)]

aristas (G o g) = [((v1,v2),w) | v1 <- nodos (G o g) , (v2,w) <- g!v1]

2.3. Implementación de los grafos mediante vectores de adyacencia

La implementación se encuentra en el módulo GrafoConMatrizDeAdyacencia cuyo contenido es el siguiente:

{-# LANGUAGE FlexibleInstances #-}

module TAD.GrafoConMatrizDeAdyacencia
  (Orientacion (..),
   Grafo,
   creaGrafo,
   creaGrafo',
   dirigido,
   adyacentes,
   nodos,
   aristas,
   aristaEn,
   peso
  ) where

-- Librerías auxiliares                                               --
import Data.Array
import Data.Maybe (isJust)
import Data.List (sort)
import Test.QuickCheck

-- Orientacion es D (dirigida) ó ND (no dirigida).
data Orientacion = D | ND
  deriving (Eq, Show)

-- (Grafo v p) es un grafo con vértices de tipo v y pesos de tipo p.
data Grafo v p = G Orientacion (Array (v,v) (Maybe p))
  deriving Eq

-- (escribeGrafo g) es la cadena correspondiente al grafo g. Por
-- ejemplo,
--    λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(2,3,5),(2,2,0)])
--    "G ND ([1,2,3],[((1,2),0),((2,2),0),((2,3),5)])"
--    λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(2,3,5),(2,2,0)])
--    "G D ([1,2,3],[((1,2),0),((2,2),0),((2,3),5)])"
--    λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(2,3,0),(2,2,0)])
--    "G ND ([1,2,3],[(1,2),(2,2),(2,3)])"
--    λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(2,3,0),(2,2,0)])
--    "G D ([1,2,3],[(1,2),(2,2),(2,3)])"
--    λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(3,2,0),(2,2,0)])
--    "G D ([1,2,3],[(1,2),(2,2),(3,2)])"
--    λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(3,2,0),(2,2,0)])
--    "G ND ([1,2,3],[(1,2),(2,2),(2,3)])"
escribeGrafo :: (Ix v,Num p,Ord v, Ord p,Show v,Show p) => Grafo v p -> String
escribeGrafo g@(G o _) =
  "G " ++ show o ++ " (" ++ show vs ++ "," ++ escribeAristas ++ ")"
  where
    as = sort (aristas g)
    vs = nodos g
    aristasReducidas
      | o == D    = as
      | otherwise = [((x,y),p) | ((x,y),p) <- as, x <= y]
    escribeAristas
      | ponderado = show aristasReducidas
      | otherwise = show [a | (a,_) <- aristasReducidas]
    ponderado = any (\((_,_),p) -> p /= 0) as

-- Procedimiento de escritura de grafos
instance (Ix v,Num p,Ord v, Ord p,Show v,Show p) => Show (Grafo v p) where
  show = escribeGrafo

-- (creaGrafo d cs as) es un grafo (dirigido o no, según el valor de o),
-- con el par de cotas cs y listas de aristas as (cada arista es un trío
-- formado por los dos vértices y su peso). Ver el ejemplo a continuación.
creaGrafo :: (Ix v,Num p) => Orientacion -> (v,v) -> [(v,v,p)] -> Grafo v p
creaGrafo D cs as =
  G D (matrizVacia cs // [((v1,v2),Just c) | (v1,v2,c) <- as])
creaGrafo ND cs as =
  G ND (matrizVacia cs // ([((v1,v2),Just c) | (v1,v2,c) <- as] ++
                           [((v2,v1),Just c) | (v1,v2,c) <- as, v1 /= v2]))

matrizVacia :: Ix v => (v,v) -> Array (v,v) (Maybe p)
matrizVacia (l,u) =
  listArray ((l,l),(u,u)) (repeat Nothing)

-- (creaGrafo' o cs as) es un grafo (dirigido o no, según el valor de o),
-- con el par de cotas cs y listas de aristas as (cada arista es un par
-- de vértices y se supone que su peso es 0). Por ejemplo,
--    λ> creaGrafo' ND (1,3) [(2,1),(1,3)]
--    G ND ([1,2,3],[(1,2),(1,3)])
--    λ> creaGrafo' D (1,3) [(2,1),(1,3)]
--    G D ([1,2,3],[(1,3),(2,1)])
creaGrafo' :: (Ix v, Num p, Ord v, Ord p) =>
              Orientacion -> (v,v) -> [(v,v)] -> Grafo v p
creaGrafo' o cs as =
  creaGrafo o cs [(v1,v2,0) | (v1,v2) <- as]

-- ejGrafoND es el grafo
--             12
--        1 -------- 2
--        | \78     /|
--        |  \   32/ |
--        |   \   /  |
--      34|     5    |55
--        |   /   \  |
--        |  /44   \ |
--        | /     93\|
--        3 -------- 4
--             61
-- representado mediante una matriz de adyacencia.
--    λ> ejGrafoND
--    G ND array ((1,1),(5,5))
--               [((1,1),Nothing),((1,2),Just 12),((1,3),Just 34),
--                ((1,4),Nothing),((1,5),Just 78),((2,1),Just 12),
--                ((2,2),Nothing),((2,3),Nothing),((2,4),Just 55),
--                ((2,5),Just 32),((3,1),Just 34),((3,2),Nothing),
--                ((3,3),Nothing),((3,4),Just 61),((3,5),Just 44),
--                ((4,1),Nothing),((4,2),Just 55),((4,3),Just 61),
--                ((4,4),Nothing),((4,5),Just 93),((5,1),Just 78),
--                ((5,2),Just 32),((5,3),Just 44),((5,4),Just 93),
--                ((5,5),Nothing)]
ejGrafoND :: Grafo Int Int
ejGrafoND = creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),
                                (2,4,55),(2,5,32),
                                (3,4,61),(3,5,44),
                                (4,5,93)]

-- ejGrafoD es el mismo grafo que ejGrafoND pero orientando las aristas;
-- es decir,
--    λ> ejGrafoD
--    G D (array ((1,1),(5,5))
--               [((1,1),Nothing),((1,2),Just 12),((1,3),Just 34),
--                ((1,4),Nothing),((1,5),Just 78),((2,1),Nothing),
--                ((2,2),Nothing),((2,3),Nothing),((2,4),Just 55),
--                ((2,5),Just 32),((3,1),Nothing),((3,2),Nothing),
--                ((3,3),Nothing),((3,4),Just 61),((3,5),Just 44),
--                ((4,1),Nothing),((4,2),Nothing),((4,3),Nothing),
--                ((4,4),Nothing),((4,5),Just 93),((5,1),Nothing),
--                ((5,2),Nothing),((5,3),Nothing),((5,4),Nothing),
--                ((5,5),Nothing)])
ejGrafoD :: Grafo Int Int
ejGrafoD = creaGrafo D (1,5) [(1,2,12),(1,3,34),(1,5,78),
                              (2,4,55),(2,5,32),
                              (3,4,61),(3,5,44),
                              (4,5,93)]

-- (dirigido g) se verifica si g es dirigido. Por ejemplo,
--    dirigido ejGrafoD   ==  True
--    dirigido ejGrafoND  ==  False
dirigido :: (Ix v,Num p) => Grafo v p -> Bool
dirigido (G o _) = o == D

-- (nodos g) es la lista de todos los nodos del grafo g. Por ejemplo,
--    nodos ejGrafoND  ==  [1,2,3,4,5]
--    nodos ejGrafoD   ==  [1,2,3,4,5]
nodos :: (Ix v,Num p) => Grafo v p -> [v]
nodos (G _ g) = range (l,u)
  where ((l,_),(u,_)) = bounds g

-- (adyacentes g v) es la lista de los vértices adyacentes al nodo v en
-- el grafo g. Por ejemplo,
--    adyacentes ejGrafoND 4  ==  [2,3,5]
--    adyacentes ejGrafoD  4  ==  [5]
adyacentes :: (Ix v,Num p,Eq p) => Grafo v p -> v -> [v]
adyacentes (G o g) v =
  [v' | v' <- nodos (G o g), isJust (g!(v,v'))]

-- (aristaEn g a) se verifica si a es una arista del grafo g. Por
-- ejemplo,
--    aristaEn ejGrafoND (5,1)  ==  True
--    aristaEn ejGrafoND (4,1)  ==  False
aristaEn :: (Ix v,Num p,Eq p) => Grafo v p -> (v,v) -> Bool
aristaEn (G _o g) (x,y) = isJust (g!(x,y))

-- (peso v1 v2 g) es el peso de la arista que une los vértices v1 y v2
-- en el grafo g. Por ejemplo,
--    peso 1 5 ejGrafoND  ==  78
--    peso 1 5 ejGrafoD   ==  78
peso :: (Ix v,Num p) => v -> v -> Grafo v p -> p
peso x y (G _ g)  = w where (Just w) = g!(x,y)

-- (aristas g) es la lista de las aristas del grafo g. Por ejemplo,
--    λ> aristas ejGrafoD
--    [(1,2,12),(1,3,34),(1,5,78),(2,4,55),(2,5,32),(3,4,61),
--     (3,5,44),(4,5,93)]
--    λ> aristas ejGrafoND
--    [(1,2,12),(1,3,34),(1,5,78),(2,1,12),(2,4,55),(2,5,32),
--     (3,1,34),(3,4,61),(3,5,44),(4,2,55),(4,3,61),(4,5,93),
--     (5,1,78),(5,2,32),(5,3,44),(5,4,93)]
aristas :: (Ix v,Num p, Eq p) => Grafo v p -> [((v,v),p)]
aristas g@(G _ e) = [((v1,v2),extrae(e!(v1,v2)))
                     | v1 <- nodos g,
                       v2 <- nodos g,
                       aristaEn g (v1,v2)]
  where extrae (Just w) = w
        extrae _        = error "Imposible"

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

{-# LANGUAGE FlexibleInstances #-}

module TAD.GrafoConMatrizDeAdyacencia

(Orientacion (..),

Grafo,

creaGrafo,

creaGrafo',

dirigido,

adyacentes,

nodos,

aristas,

aristaEn,

peso

) where

-- Librerías auxiliares --

import Data.Array

import Data.Maybe (isJust)

import Data.List (sort)

import Test.QuickCheck

-- Orientacion es D (dirigida) ó ND (no dirigida).

data Orientacion = D | ND

deriving (Eq, Show)

-- (Grafo v p) es un grafo con vértices de tipo v y pesos de tipo p.

data Grafo v p = G Orientacion (Array (v,v) (Maybe p))

deriving Eq

-- (escribeGrafo g) es la cadena correspondiente al grafo g. Por

-- ejemplo,

-- λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(2,3,5),(2,2,0)])

-- "G ND ([1,2,3],[((1,2),0),((2,2),0),((2,3),5)])"

-- λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(2,3,5),(2,2,0)])

-- "G D ([1,2,3],[((1,2),0),((2,2),0),((2,3),5)])"

-- λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(2,3,0),(2,2,0)])

-- "G ND ([1,2,3],[(1,2),(2,2),(2,3)])"

-- λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(2,3,0),(2,2,0)])

-- "G D ([1,2,3],[(1,2),(2,2),(2,3)])"

-- λ> escribeGrafo (creaGrafo D (1,3) [(1,2,0),(3,2,0),(2,2,0)])

-- "G D ([1,2,3],[(1,2),(2,2),(3,2)])"

-- λ> escribeGrafo (creaGrafo ND (1,3) [(1,2,0),(3,2,0),(2,2,0)])

-- "G ND ([1,2,3],[(1,2),(2,2),(2,3)])"

escribeGrafo :: (Ix v,Num p,Ord v, Ord p,Show v,Show p) => Grafo v p -> String

escribeGrafo g@(G o _) =

"G " ++ show o ++ " (" ++ show vs ++ "," ++ escribeAristas ++ ")"

where

as = sort (aristas g)

vs = nodos g

aristasReducidas

| o == D = as

| otherwise = [((x,y),p) | ((x,y),p) <- as, x <= y]

escribeAristas

| ponderado = show aristasReducidas

| otherwise = show [a | (a,_) <- aristasReducidas]

ponderado = any (\((_,_),p) -> p /= 0) as

-- Procedimiento de escritura de grafos

instance (Ix v,Num p,Ord v, Ord p,Show v,Show p) => Show (Grafo v p) where

show = escribeGrafo

-- (creaGrafo d cs as) es un grafo (dirigido o no, según el valor de o),

-- con el par de cotas cs y listas de aristas as (cada arista es un trío

-- formado por los dos vértices y su peso). Ver el ejemplo a continuación.

creaGrafo :: (Ix v,Num p) => Orientacion -> (v,v) -> [(v,v,p)] -> Grafo v p

creaGrafo D cs as =

G D (matrizVacia cs // [((v1,v2),Just c) | (v1,v2,c) <- as])

creaGrafo ND cs as =

G ND (matrizVacia cs // ([((v1,v2),Just c) | (v1,v2,c) <- as] ++

[((v2,v1),Just c) | (v1,v2,c) <- as, v1 /= v2]))

matrizVacia :: Ix v => (v,v) -> Array (v,v) (Maybe p)

matrizVacia (l,u) =

listArray ((l,l),(u,u)) (repeat Nothing)

-- (creaGrafo' o cs as) es un grafo (dirigido o no, según el valor de o),

-- con el par de cotas cs y listas de aristas as (cada arista es un par

-- de vértices y se supone que su peso es 0). Por ejemplo,

-- λ> creaGrafo' ND (1,3) [(2,1),(1,3)]

-- G ND ([1,2,3],[(1,2),(1,3)])

-- λ> creaGrafo' D (1,3) [(2,1),(1,3)]

-- G D ([1,2,3],[(1,3),(2,1)])

creaGrafo' :: (Ix v, Num p, Ord v, Ord p) =>

Orientacion -> (v,v) -> [(v,v)] -> Grafo v p

creaGrafo' o cs as =

creaGrafo o cs [(v1,v2,0) | (v1,v2) <- as]

-- ejGrafoND es el grafo

-- 12

-- 1 -------- 2

-- | \78 /|

-- | \ 32/ |

-- | \ / |

-- 34| 5 |55

-- | / \ |

-- | /44 \ |

-- | / 93\|

-- 3 -------- 4

-- 61

-- representado mediante una matriz de adyacencia.

-- λ> ejGrafoND

-- G ND array ((1,1),(5,5))

-- [((1,1),Nothing),((1,2),Just 12),((1,3),Just 34),

-- ((1,4),Nothing),((1,5),Just 78),((2,1),Just 12),

-- ((2,2),Nothing),((2,3),Nothing),((2,4),Just 55),

-- ((2,5),Just 32),((3,1),Just 34),((3,2),Nothing),

-- ((3,3),Nothing),((3,4),Just 61),((3,5),Just 44),

-- ((4,1),Nothing),((4,2),Just 55),((4,3),Just 61),

-- ((4,4),Nothing),((4,5),Just 93),((5,1),Just 78),

-- ((5,2),Just 32),((5,3),Just 44),((5,4),Just 93),

-- ((5,5),Nothing)]

ejGrafoND :: Grafo Int Int

ejGrafoND = creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),

(2,4,55),(2,5,32),

(3,4,61),(3,5,44),

(4,5,93)]

-- ejGrafoD es el mismo grafo que ejGrafoND pero orientando las aristas;

-- es decir,

-- λ> ejGrafoD

-- G D (array ((1,1),(5,5))

-- [((1,1),Nothing),((1,2),Just 12),((1,3),Just 34),

-- ((1,4),Nothing),((1,5),Just 78),((2,1),Nothing),

-- ((2,2),Nothing),((2,3),Nothing),((2,4),Just 55),

-- ((2,5),Just 32),((3,1),Nothing),((3,2),Nothing),

-- ((3,3),Nothing),((3,4),Just 61),((3,5),Just 44),

-- ((4,1),Nothing),((4,2),Nothing),((4,3),Nothing),

-- ((4,4),Nothing),((4,5),Just 93),((5,1),Nothing),

-- ((5,2),Nothing),((5,3),Nothing),((5,4),Nothing),

-- ((5,5),Nothing)])

ejGrafoD :: Grafo Int Int

ejGrafoD = creaGrafo D (1,5) [(1,2,12),(1,3,34),(1,5,78),

(2,4,55),(2,5,32),

(3,4,61),(3,5,44),

(4,5,93)]

-- (dirigido g) se verifica si g es dirigido. Por ejemplo,

-- dirigido ejGrafoD == True

-- dirigido ejGrafoND == False

dirigido :: (Ix v,Num p) => Grafo v p -> Bool

dirigido (G o _) = o == D

-- (nodos g) es la lista de todos los nodos del grafo g. Por ejemplo,

-- nodos ejGrafoND == [1,2,3,4,5]

-- nodos ejGrafoD == [1,2,3,4,5]

nodos :: (Ix v,Num p) => Grafo v p -> [v]

nodos (G _ g) = range (l,u)

where ((l,_),(u,_)) = bounds g

-- (adyacentes g v) es la lista de los vértices adyacentes al nodo v en

-- el grafo g. Por ejemplo,

-- adyacentes ejGrafoND 4 == [2,3,5]

-- adyacentes ejGrafoD 4 == [5]

adyacentes :: (Ix v,Num p,Eq p) => Grafo v p -> v -> [v]

adyacentes (G o g) v =

[v' | v' <- nodos (G o g), isJust (g!(v,v'))]

-- (aristaEn g a) se verifica si a es una arista del grafo g. Por

-- ejemplo,

-- aristaEn ejGrafoND (5,1) == True

-- aristaEn ejGrafoND (4,1) == False

aristaEn :: (Ix v,Num p,Eq p) => Grafo v p -> (v,v) -> Bool

aristaEn (G _o g) (x,y) = isJust (g!(x,y))

-- (peso v1 v2 g) es el peso de la arista que une los vértices v1 y v2

-- en el grafo g. Por ejemplo,

-- peso 1 5 ejGrafoND == 78

-- peso 1 5 ejGrafoD == 78

peso :: (Ix v,Num p) => v -> v -> Grafo v p -> p

peso x y (G _ g) = w where (Just w) = g!(x,y)

-- (aristas g) es la lista de las aristas del grafo g. Por ejemplo,

-- λ> aristas ejGrafoD

-- [(1,2,12),(1,3,34),(1,5,78),(2,4,55),(2,5,32),(3,4,61),

-- (3,5,44),(4,5,93)]

-- λ> aristas ejGrafoND

-- [(1,2,12),(1,3,34),(1,5,78),(2,1,12),(2,4,55),(2,5,32),

-- (3,1,34),(3,4,61),(3,5,44),(4,2,55),(4,3,61),(4,5,93),

-- (5,1,78),(5,2,32),(5,3,44),(5,4,93)]

aristas :: (Ix v,Num p, Eq p) => Grafo v p -> [((v,v),p)]

aristas g@(G _ e) = [((v1,v2),extrae(e!(v1,v2)))

| v1 <- nodos g,

v2 <- nodos g,

aristaEn g (v1,v2)]

where extrae (Just w) = w

extrae _ = error "Imposible"

3. Los grafos en Python

3.1. El tipo abstracto de los grafos en Python

La implementación se encuentra en el módulo Grafo.py cuyo contenido es el siguiente:

__all__ = [
    'Orientacion',
    'Grafo',
    'creaGrafo',
    'creaGrafo_',
    'dirigido',
    'adyacentes',
    'nodos',
    'aristas',
    'aristaEn',
    'peso'
    ]

from src.TAD.GrafoConListaDeAdyacencia import (Grafo, Orientacion, adyacentes,
                                               aristaEn, aristas, creaGrafo,
                                               creaGrafo_, dirigido, nodos, peso)

__all__ = [

'Orientacion',

'Grafo',

'creaGrafo',

'creaGrafo_',

'dirigido',

'adyacentes',

'nodos',

'aristas',

'aristaEn',

'peso'

]

from src.TAD.GrafoConListaDeAdyacencia import (Grafo, Orientacion, adyacentes,

aristaEn, aristas, creaGrafo,

creaGrafo_, dirigido, nodos, peso)

3.2. Implementación de los grafos mediante listas

Se define la clase Grafo con los siguientes métodos:

dirigido() se verifica si el grafo es dirigido.
nodos() es la lista de todos los nodos del grafo.
aristas() es la lista de las aristas del grafo.
adyacentes(v) es la lista de los vértices adyacentes al vértice v en el grafo.
aristaEn(a) se verifica si a es una arista del grafo.
peso(v1, v2) es el peso de la arista que une los vértices v1 y v2 en el grafo.

Por ejemplo,

>>> Grafo(Orientacion.D, (1,3), [((1,2),0),((3,2),0),((2,2),0)])
G D ([1, 2, 3], [(1, 2), (2, 2), (3, 2)])
>>> Grafo(Orientacion.ND, (1,3), [((1,2),0),((3,2),0),((2,2),0)])
G ND ([1, 2, 3], [(1, 2), (2, 2), (2, 3)])
>>> Grafo(Orientacion.ND, (1,3), [((1,2),0),((3,2),5),((2,2),0)])
G ND ([1, 2, 3], [((1, 2), 0), ((2, 2), 0), ((2, 3), 5)])
>>> Grafo(Orientacion.D, (1,3), [((1,2),0),((3,2),5),((2,2),0)])
G D ([1, 2, 3], [((1, 2), 0), ((2, 2), 0), ((3, 2), 5)])
>>> ejGrafoND: Grafo = Grafo(Orientacion.ND,
                             (1, 5),
                             [((1, 2), 12), ((1, 3), 34), ((1, 5), 78),
                              ((2, 4), 55), ((2, 5), 32),
                              ((3, 4), 61), ((3, 5), 44),
                              ((4, 5), 93)])
>>> ejGrafoND
G ND ([1, 2, 3, 4, 5],
      [((1, 2), 12), ((1, 3), 34), ((1, 5), 78),
       ((2, 4), 55), ((2, 5), 32),
       ((3, 4), 61), ((3, 5), 44),
       ((4, 5), 93)])
>> ejGrafoD: Grafo = Grafo(Orientacion.D,
                           (1,5),
                           [((1, 2), 12), ((1, 3), 34), ((1, 5), 78),
                            ((2, 4), 55), ((2, 5), 32),
                            ((3, 4), 61), ((3, 5), 44),
                            ((4, 5), 93)])
>>> ejGrafoD
G D ([1, 2, 3, 4, 5],
     [((1, 2), 12), ((1, 3), 34), ((1, 5), 78),
      ((2, 4), 55), ((2, 5), 32),
      ((3, 4), 61), ((3, 5), 44),
      ((4, 5), 93)])
>>> ejGrafoD.dirigido()
True
>>> ejGrafoND.dirigido()
False
>>> ejGrafoND.nodos()
[1, 2, 3, 4, 5]
>>> ejGrafoD.nodos()
[1, 2, 3, 4, 5]
>>> ejGrafoND.adyacentes(4)
[2, 3, 5]
>>> ejGrafoD.adyacentes(4)
[5]
>>> ejGrafoND.aristaEn((5, 1))
True
>>> ejGrafoND.aristaEn((4, 1))
False
>>> ejGrafoD.aristaEn((5, 1))
False
>>> ejGrafoD.aristaEn((1, 5))
True
>>> ejGrafoND.peso(1, 5)
78
>>> ejGrafoD.peso(1, 5)
78
>>> ejGrafoD._aristas
[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),
 ((2, 4), 55), ((2, 5), 32),
 ((3, 4), 61), ((3, 5), 44),
 ((4, 5), 93)]
>>> ejGrafoND._aristas
[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),
 ((2, 1), 12), ((2, 4), 55), ((2, 5), 32),
 ((3, 1), 34), ((3, 4), 61), ((3, 5), 44),
 ((4, 2), 55), ((4, 3), 61), ((4, 5), 93),
 ((5, 1), 78), ((5, 2), 32), ((5, 3), 44),
 ((5, 4), 93)]

>>> Grafo(Orientacion.D, (1,3), [((1,2),0),((3,2),0),((2,2),0)])

G D ([1, 2, 3], [(1, 2), (2, 2), (3, 2)])

>>> Grafo(Orientacion.ND, (1,3), [((1,2),0),((3,2),0),((2,2),0)])

G ND ([1, 2, 3], [(1, 2), (2, 2), (2, 3)])

>>> Grafo(Orientacion.ND, (1,3), [((1,2),0),((3,2),5),((2,2),0)])

G ND ([1, 2, 3], [((1, 2), 0), ((2, 2), 0), ((2, 3), 5)])

>>> Grafo(Orientacion.D, (1,3), [((1,2),0),((3,2),5),((2,2),0)])

G D ([1, 2, 3], [((1, 2), 0), ((2, 2), 0), ((3, 2), 5)])

>>> ejGrafoND: Grafo = Grafo(Orientacion.ND,

(1, 5),

[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),

((2, 4), 55), ((2, 5), 32),

((3, 4), 61), ((3, 5), 44),

((4, 5), 93)])

>>> ejGrafoND

G ND ([1, 2, 3, 4, 5],

[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),

((2, 4), 55), ((2, 5), 32),

((3, 4), 61), ((3, 5), 44),

((4, 5), 93)])

>> ejGrafoD: Grafo = Grafo(Orientacion.D,

(1,5),

[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),

((2, 4), 55), ((2, 5), 32),

((3, 4), 61), ((3, 5), 44),

((4, 5), 93)])

>>> ejGrafoD

G D ([1, 2, 3, 4, 5],

[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),

((2, 4), 55), ((2, 5), 32),

((3, 4), 61), ((3, 5), 44),

((4, 5), 93)])

>>> ejGrafoD.dirigido()

True

>>> ejGrafoND.dirigido()

False

>>> ejGrafoND.nodos()

[1, 2, 3, 4, 5]

>>> ejGrafoD.nodos()

[1, 2, 3, 4, 5]

>>> ejGrafoND.adyacentes(4)

[2, 3, 5]

>>> ejGrafoD.adyacentes(4)

[5]

>>> ejGrafoND.aristaEn((5, 1))

True

>>> ejGrafoND.aristaEn((4, 1))

False

>>> ejGrafoD.aristaEn((5, 1))

False

>>> ejGrafoD.aristaEn((1, 5))

True

>>> ejGrafoND.peso(1, 5)

>>> ejGrafoD.peso(1, 5)

>>> ejGrafoD._aristas

[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),

((2, 4), 55), ((2, 5), 32),

((3, 4), 61), ((3, 5), 44),

((4, 5), 93)]

>>> ejGrafoND._aristas

[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),

((2, 1), 12), ((2, 4), 55), ((2, 5), 32),

((3, 1), 34), ((3, 4), 61), ((3, 5), 44),

((4, 2), 55), ((4, 3), 61), ((4, 5), 93),

((5, 1), 78), ((5, 2), 32), ((5, 3), 44),

((5, 4), 93)]

Además se definen las correspondientes funciones. Por ejemplo,

>>> creaGrafo(Orientacion.ND, (1,3), [((1,2),12),((1,3),34)])
G ND ([1, 2, 3], [((1, 2), 12), ((1, 3), 34), ((2, 1), 12), ((3, 1), 34)])
>>> creaGrafo(Orientacion.D, (1,3), [((1,2),12),((1,3),34)])
G D ([1, 2, 3], [((1, 2), 12), ((1, 3), 34)])
>>> creaGrafo(Orientacion.D, (1,4), [((1,2),12),((1,3),34)])
G D ([1, 2, 3, 4], [((1, 2), 12), ((1, 3), 34)])
>>> ejGrafoND2: Grafo = creaGrafo(Orientacion.ND,
                                  (1,5),
                                  [((1,2),12),((1,3),34),((1,5),78),
                                   ((2,4),55),((2,5),32),
                                   ((3,4),61),((3,5),44),
                                   ((4,5),93)])
>>> ejGrafoND2
G ND ([1, 2, 3, 4, 5],
      [((1, 2), 12), ((1, 3), 34), ((1, 5), 78),
       ((2, 4), 55), ((2, 5), 32),
       ((3, 4), 61), ((3, 5), 44),
       ((4, 5), 93)])
>>> ejGrafoD2: Grafo = creaGrafo(Orientacion.D,
                                 (1,5),
                                 [((1,2),12),((1,3),34),((1,5),78),
                                  ((2,4),55),((2,5),32),
                                  ((3,4),61),((3,5),44),
                                  ((4,5),93)])
>>> ejGrafoD2
G D ([1, 2, 3, 4, 5],
     [((1, 2), 12), ((1, 3), 34), ((1, 5), 78),
      ((2, 4), 55), ((2, 5), 32),
      ((3, 4), 61), ((3, 5), 44),
      ((4, 5), 93)])
>>> creaGrafo_(Orientacion.D, (1,3), [(2, 1), (1, 3)])
G D ([1, 2, 3], [(1, 3), (2, 1)])
>>> creaGrafo_(Orientacion.ND, (1,3), [(2, 1), (1, 3)])
G ND ([1, 2, 3], [(1, 2), (1, 3)])
>>> dirigido(ejGrafoD2)
True
>>> dirigido(ejGrafoND2)
False
>>> nodos(ejGrafoND2)
[1, 2, 3, 4, 5]
>>> nodos(ejGrafoD2)
[1, 2, 3, 4, 5]
>>> adyacentes(ejGrafoND2, 4)
[2, 3, 5]
>>> adyacentes(ejGrafoD2, 4)
[5]
>>> aristaEn(ejGrafoND2, (5,1))
True
>>> aristaEn(ejGrafoND2, (4,1))
False
>>> aristaEn(ejGrafoD2, (5,1))
False
>>> aristaEn(ejGrafoD2, (1,5))
True
>>> peso(1, 5, ejGrafoND2)
78
>>> peso(1, 5, ejGrafoD2)
78
>>> aristas(ejGrafoD2)
[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),
 ((2, 4), 55), ((2, 5), 32),
 ((3, 4), 61), ((3, 5), 44),
 ((4, 5), 93)]
>>> aristas(ejGrafoND2)
[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),
 ((2, 1), 12), ((2, 4), 55), ((2, 5), 32),
 ((3, 1), 34), ((3, 4), 61), ((3, 5), 44),
 ((4, 2), 55), ((4, 3), 61), ((4, 5), 93),
 ((5, 1), 78), ((5, 2), 32), ((5, 3), 44), ((5, 4), 93)]

>>> creaGrafo(Orientacion.ND, (1,3), [((1,2),12),((1,3),34)])

G ND ([1, 2, 3], [((1, 2), 12), ((1, 3), 34), ((2, 1), 12), ((3, 1), 34)])

>>> creaGrafo(Orientacion.D, (1,3), [((1,2),12),((1,3),34)])

G D ([1, 2, 3], [((1, 2), 12), ((1, 3), 34)])

>>> creaGrafo(Orientacion.D, (1,4), [((1,2),12),((1,3),34)])

G D ([1, 2, 3, 4], [((1, 2), 12), ((1, 3), 34)])

>>> ejGrafoND2: Grafo = creaGrafo(Orientacion.ND,

(1,5),

[((1,2),12),((1,3),34),((1,5),78),

((2,4),55),((2,5),32),

((3,4),61),((3,5),44),

((4,5),93)])

>>> ejGrafoND2

G ND ([1, 2, 3, 4, 5],

[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),

((2, 4), 55), ((2, 5), 32),

((3, 4), 61), ((3, 5), 44),

((4, 5), 93)])

>>> ejGrafoD2: Grafo = creaGrafo(Orientacion.D,

(1,5),

[((1,2),12),((1,3),34),((1,5),78),

((2,4),55),((2,5),32),

((3,4),61),((3,5),44),

((4,5),93)])

>>> ejGrafoD2

G D ([1, 2, 3, 4, 5],

[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),

((2, 4), 55), ((2, 5), 32),

((3, 4), 61), ((3, 5), 44),

((4, 5), 93)])

>>> creaGrafo_(Orientacion.D, (1,3), [(2, 1), (1, 3)])

G D ([1, 2, 3], [(1, 3), (2, 1)])

>>> creaGrafo_(Orientacion.ND, (1,3), [(2, 1), (1, 3)])

G ND ([1, 2, 3], [(1, 2), (1, 3)])

>>> dirigido(ejGrafoD2)

True

>>> dirigido(ejGrafoND2)

False

>>> nodos(ejGrafoND2)

[1, 2, 3, 4, 5]

>>> nodos(ejGrafoD2)

[1, 2, 3, 4, 5]

>>> adyacentes(ejGrafoND2, 4)

[2, 3, 5]

>>> adyacentes(ejGrafoD2, 4)

[5]

>>> aristaEn(ejGrafoND2, (5,1))

True

>>> aristaEn(ejGrafoND2, (4,1))

False

>>> aristaEn(ejGrafoD2, (5,1))

False

>>> aristaEn(ejGrafoD2, (1,5))

True

>>> peso(1, 5, ejGrafoND2)

>>> peso(1, 5, ejGrafoD2)

>>> aristas(ejGrafoD2)

[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),

((2, 4), 55), ((2, 5), 32),

((3, 4), 61), ((3, 5), 44),

((4, 5), 93)]

>>> aristas(ejGrafoND2)

[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),

((2, 1), 12), ((2, 4), 55), ((2, 5), 32),

((3, 1), 34), ((3, 4), 61), ((3, 5), 44),

((4, 2), 55), ((4, 3), 61), ((4, 5), 93),

((5, 1), 78), ((5, 2), 32), ((5, 3), 44), ((5, 4), 93)]

La implementación se encuentra en el módulo GrafoConListaDeAdyacencia cuyo contenido es el siguiente:

from enum import Enum

Orientacion = Enum('Orientacion', ['D', 'ND'])

Vertice = int
Cotas = tuple[Vertice, Vertice]
Peso = float
Arista = tuple[tuple[Vertice, Vertice], Peso]

class Grafo:
    def __init__(self,
                 _orientacion: Orientacion,
                 _cotas: Cotas,
                 _aristas: list[Arista]):
        self._orientacion = _orientacion
        self._cotas = _cotas
        if _orientacion == Orientacion.ND:
            simetricas = [((v2, v1), p) for ((v1, v2), p)
                          in _aristas
                          if v1 != v2]
            self._aristas = sorted(_aristas + simetricas)
        else:
            self._aristas = sorted(_aristas)

    def nodos(self) -> list[Vertice]:
        (x, y) = self._cotas
        return list(range(x, 1 + y))

    def __repr__(self) -> str:
        o = self._orientacion
        vs = nodos(self)
        ns = self._aristas
        escribeOrientacion = "D" if o == Orientacion.D else "ND"
        ponderado = {p for ((_, _), p) in ns} != {0}
        aristasReducidas = ns if o == Orientacion.D \
            else [((x, y), p)
                  for ((x, y), p) in ns
                  if x <= y]
        escribeAristas = str(aristasReducidas) if ponderado \
            else str([a for (a, _) in aristasReducidas])
        return f"G {escribeOrientacion} ({vs}, {escribeAristas})"

    def dirigido(self) -> bool:
        return self._orientacion == Orientacion.D

    def adyacentes(self, v: int) -> list[int]:
        return list(set(u for ((w, u), _)
                        in self._aristas
                        if w == v))

    def aristaEn(self, a: tuple[Vertice, Vertice]) -> bool:
        (x, y) = a
        return y in self.adyacentes(x)

    def peso(self, v1: Vertice, v2: Vertice) -> Peso:
        return [p for ((x1, x2), p)
                in self._aristas
                if (x1, x2) == (v1, v2)][0]

def creaGrafo(o: Orientacion,
              cs: Cotas,
              as_: list[Arista]) -> Grafo:
    return Grafo(o, cs, as_)

def creaGrafo_(o: Orientacion,
              cs: Cotas,
              as_: list[tuple[Vertice, Vertice]]) -> Grafo:
    return Grafo(o, cs, [((v1, v2), 0) for (v1, v2) in as_])

def dirigido(g: Grafo) -> bool:
    return g.dirigido()

def nodos(g: Grafo) -> list[Vertice]:
    return g.nodos()

def adyacentes(g: Grafo, v: Vertice) -> list[Vertice]:
    return g.adyacentes(v)

def aristaEn(g: Grafo, a: tuple[Vertice, Vertice]) -> bool:
    return g.aristaEn(a)

def peso(v1: Vertice, v2: Vertice, g: Grafo) -> Peso:
    return g.peso(v1, v2)

def aristas(g: Grafo) -> list[Arista]:
    return g._aristas

# En los ejemplos se usarán los grafos (no dirigido y dirigido)
# correspondientes a
#             12
#        1 -------- 2
#        | \78     /|
#        |  \   32/ |
#        |   \   /  |
#      34|     5    |55
#        |   /   \  |
#        |  /44   \ |
#        | /     93\|
#        3 -------- 4
#             61
# definidos por
ejGrafoND: Grafo = Grafo(Orientacion.ND,
                         (1, 5),
                         [((1, 2), 12), ((1, 3), 34), ((1, 5), 78),
                          ((2, 4), 55), ((2, 5), 32),
                          ((3, 4), 61), ((3, 5), 44),
                          ((4, 5), 93)])
ejGrafoD: Grafo = Grafo(Orientacion.D,
                        (1,5),
                        [((1, 2), 12), ((1, 3), 34), ((1, 5), 78),
                         ((2, 4), 55), ((2, 5), 32),
                         ((3, 4), 61), ((3, 5), 44),
                         ((4, 5), 93)])

ejGrafoND2: Grafo = creaGrafo(Orientacion.ND,
                              (1,5),
                              [((1,2),12),((1,3),34),((1,5),78),
                               ((2,4),55),((2,5),32),
                               ((3,4),61),((3,5),44),
                               ((4,5),93)])

ejGrafoD2: Grafo = creaGrafo(Orientacion.D,
                             (1,5),
                             [((1,2),12),((1,3),34),((1,5),78),
                              ((2,4),55),((2,5),32),
                              ((3,4),61),((3,5),44),
                              ((4,5),93)])

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

from enum import Enum

Orientacion = Enum('Orientacion', ['D', 'ND'])

Vertice = int

Cotas = tuple[Vertice, Vertice]

Peso = float

Arista = tuple[tuple[Vertice, Vertice], Peso]

class Grafo:

def __init__(self,

_orientacion: Orientacion,

_cotas: Cotas,

_aristas: list[Arista]):

self._orientacion = _orientacion

self._cotas = _cotas

if _orientacion == Orientacion.ND:

simetricas = [((v2, v1), p) for ((v1, v2), p)

in _aristas

if v1 != v2]

self._aristas = sorted(_aristas + simetricas)

else:

self._aristas = sorted(_aristas)

def nodos(self) -> list[Vertice]:

(x, y) = self._cotas

return list(range(x, 1 + y))

def __repr__(self) -> str:

o = self._orientacion

vs = nodos(self)

ns = self._aristas

escribeOrientacion = "D" if o == Orientacion.D else "ND"

ponderado = {p for ((_, _), p) in ns} != {0}

aristasReducidas = ns if o == Orientacion.D \

else [((x, y), p)

for ((x, y), p) in ns

if x <= y]

escribeAristas = str(aristasReducidas) if ponderado \

else str([a for (a, _) in aristasReducidas])

return f"G {escribeOrientacion} ({vs}, {escribeAristas})"

def dirigido(self) -> bool:

return self._orientacion == Orientacion.D

def adyacentes(self, v: int) -> list[int]:

return list(set(u for ((w, u), _)

in self._aristas

if w == v))

def aristaEn(self, a: tuple[Vertice, Vertice]) -> bool:

(x, y) = a

return y in self.adyacentes(x)

def peso(self, v1: Vertice, v2: Vertice) -> Peso:

return [p for ((x1, x2), p)

in self._aristas

if (x1, x2) == (v1, v2)][0]

def creaGrafo(o: Orientacion,

cs: Cotas,

as_: list[Arista]) -> Grafo:

return Grafo(o, cs, as_)

def creaGrafo_(o: Orientacion,

cs: Cotas,

as_: list[tuple[Vertice, Vertice]]) -> Grafo:

return Grafo(o, cs, [((v1, v2), 0) for (v1, v2) in as_])

def dirigido(g: Grafo) -> bool:

return g.dirigido()

def nodos(g: Grafo) -> list[Vertice]:

return g.nodos()

def adyacentes(g: Grafo, v: Vertice) -> list[Vertice]:

return g.adyacentes(v)

def aristaEn(g: Grafo, a: tuple[Vertice, Vertice]) -> bool:

return g.aristaEn(a)

def peso(v1: Vertice, v2: Vertice, g: Grafo) -> Peso:

return g.peso(v1, v2)

def aristas(g: Grafo) -> list[Arista]:

return g._aristas

# En los ejemplos se usarán los grafos (no dirigido y dirigido)

# correspondientes a

# 12

# 1 -------- 2

# | \78 /|

# | \ 32/ |

# | \ / |

# 34| 5 |55

# | / \ |

# | /44 \ |

# | / 93\|

# 3 -------- 4

# 61

# definidos por

ejGrafoND: Grafo = Grafo(Orientacion.ND,

(1, 5),

[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),

((2, 4), 55), ((2, 5), 32),

((3, 4), 61), ((3, 5), 44),

((4, 5), 93)])

ejGrafoD: Grafo = Grafo(Orientacion.D,

(1,5),

[((1, 2), 12), ((1, 3), 34), ((1, 5), 78),

((2, 4), 55), ((2, 5), 32),

((3, 4), 61), ((3, 5), 44),

((4, 5), 93)])

ejGrafoND2: Grafo = creaGrafo(Orientacion.ND,

(1,5),

[((1,2),12),((1,3),34),((1,5),78),

((2,4),55),((2,5),32),

((3,4),61),((3,5),44),

((4,5),93)])

ejGrafoD2: Grafo = creaGrafo(Orientacion.D,

(1,5),

[((1,2),12),((1,3),34),((1,5),78),

((2,4),55),((2,5),32),

((3,4),61),((3,5),44),

((4,5),93)])

TAD de los polinomios: Factorización de un polinomio

PorJosé A. Alonso 22-mayo-202322-mayo-2023

Usando el tipo abstracto de los polinomios, definir la función

   factorizacion :: Polinomio Int -> [Polinomio Int]

1	factorizacion :: Polinomio Int -> [Polinomio Int]

tal que factorizacion p es la lista de la descomposición del polinomio p en factores obtenida mediante el regla de Ruffini. Por ejemplo,

   λ> ejPol1 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))
   λ> ejPol1
   x^5 + 5*x^2 + 4*x
   λ> factorizacion ejPol1
   [1*x,1*x + 1,x^3 + -1*x^2 + 1*x + 4]
   λ> ejPol2 = consPol 3 1 (consPol 2 2 (consPol 1 (-1) (consPol 0 (-2) polCero)))
   λ> ejPol2
   x^3 + 2*x^2 + -1*x + -2
   λ> factorizacion ejPol2
   [1*x + -1,1*x + 1,1*x + 2,1]

λ> ejPol1 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))

λ> ejPol1

x^5 + 5*x^2 + 4*x

λ> factorizacion ejPol1

[1*x,1*x + 1,x^3 + -1*x^2 + 1*x + 4]

λ> ejPol2 = consPol 3 1 (consPol 2 2 (consPol 1 (-1) (consPol 0 (-2) polCero)))

λ> ejPol2

x^3 + 2*x^2 + -1*x + -2

λ> factorizacion ejPol2

[1*x + -1,1*x + 1,1*x + 2,1]

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Pol_Factorizacion_de_un_polinomio where

import TAD.Polinomio (Polinomio, consPol, polCero, esPolCero)
import Pol_Termino_independiente_de_un_polinomio (terminoIndep)
import Pol_Raices_enteras_de_un_polinomio (divisores)
import Pol_Regla_de_Ruffini (cocienteRuffini)
import Pol_Reconocimiento_de_raices_por_la_regla_de_Ruffini (esRaizRuffini)
import Pol_Transformaciones_polinomios_densas (densaApolinomio)
import Test.Hspec (Spec, hspec, it, shouldBe)

factorizacion :: Polinomio Int -> [Polinomio Int]
factorizacion p
  | esPolCero p = [p]
  | otherwise   = aux (0 : divisores (terminoIndep p))
  where
    aux [] = [p]
    aux (r:rs)
        | esRaizRuffini r p =
            densaApolinomio [1,-r] : factorizacion (cocienteRuffini r p)
        | otherwise = aux rs

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    map show (factorizacion ejPol1)
      `shouldBe` ["1*x","1*x + 1","x^3 + -1*x^2 + 1*x + 4"]
  it "e2" $
    map show (factorizacion ejPol2)
      `shouldBe` ["1*x + -1","1*x + 1","1*x + 2","1"]
  where
    ejPol1 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))
    ejPol2 = consPol 3 1 (consPol 2 2 (consPol 1 (-1) (consPol 0 (-2) polCero)))

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--
--    Finished in 0.0015 seconds
--    2 examples, 0 failures

module Pol_Factorizacion_de_un_polinomio where

import TAD.Polinomio (Polinomio, consPol, polCero, esPolCero)

import Pol_Termino_independiente_de_un_polinomio (terminoIndep)

import Pol_Raices_enteras_de_un_polinomio (divisores)

import Pol_Regla_de_Ruffini (cocienteRuffini)

import Pol_Reconocimiento_de_raices_por_la_regla_de_Ruffini (esRaizRuffini)

import Pol_Transformaciones_polinomios_densas (densaApolinomio)

import Test.Hspec (Spec, hspec, it, shouldBe)

factorizacion :: Polinomio Int -> [Polinomio Int]

factorizacion p

| esPolCero p = [p]

| otherwise = aux (0 : divisores (terminoIndep p))

where

aux [] = [p]

aux (r:rs)

| esRaizRuffini r p =

densaApolinomio [1,-r] : factorizacion (cocienteRuffini r p)

| otherwise = aux rs

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

map show (factorizacion ejPol1)

`shouldBe` ["1*x","1*x + 1","x^3 + -1*x^2 + 1*x + 4"]

it "e2" $

map show (factorizacion ejPol2)

`shouldBe` ["1*x + -1","1*x + 1","1*x + 2","1"]

where

ejPol1 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))

ejPol2 = consPol 3 1 (consPol 2 2 (consPol 1 (-1) (consPol 0 (-2) polCero)))

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- Finished in 0.0015 seconds

-- 2 examples, 0 failures

Soluciones en Python

from src.Pol_Raices_enteras_de_un_polinomio import divisores
from src.Pol_Reconocimiento_de_raices_por_la_regla_de_Ruffini import \
    esRaizRuffini
from src.Pol_Regla_de_Ruffini import cocienteRuffini
from src.Pol_Termino_independiente_de_un_polinomio import terminoIndep
from src.Pol_Transformaciones_polinomios_densas import densaApolinomio
from src.TAD.Polinomio import Polinomio, consPol, esPolCero, polCero


def factorizacion(p: Polinomio[int]) -> list[Polinomio[int]]:
    def aux(xs: list[int]) -> list[Polinomio[int]]:
        if not xs:
            return [p]
        r, *rs = xs
        if esRaizRuffini(r, p):
            return [densaApolinomio([1, -r])] + factorizacion(cocienteRuffini(r, p))
        return aux(rs)

    if esPolCero(p):
        return [p]
    return aux([0] + divisores(terminoIndep(p)))

# Verificación
# ============

def test_factorizacion() -> None:
    ejPol1 = consPol(5, 1, consPol(2, 5, consPol(1, 4, polCero())))
    assert list(map(str, factorizacion(ejPol1))) \
        == ["1*x", "1*x + 1", "x^3 + -1*x^2 + 1*x + 4"]
    ejPol2 = consPol(3, 1, consPol(2, 2, consPol(1, -1, consPol(0, -2, polCero()))))
    assert list(map(str, factorizacion(ejPol2))) \
        == ["1*x + -1", "1*x + 1", "1*x + 2", "1"]
    print("Verificado")

# La verificación es
#    >>> test_factorizacion()
#    Verificado

from src.Pol_Raices_enteras_de_un_polinomio import divisores

from src.Pol_Reconocimiento_de_raices_por_la_regla_de_Ruffini import \

esRaizRuffini

from src.Pol_Regla_de_Ruffini import cocienteRuffini

from src.Pol_Termino_independiente_de_un_polinomio import terminoIndep

from src.Pol_Transformaciones_polinomios_densas import densaApolinomio

from src.TAD.Polinomio import Polinomio, consPol, esPolCero, polCero

def factorizacion(p: Polinomio[int]) -> list[Polinomio[int]]:

def aux(xs: list[int]) -> list[Polinomio[int]]:

if not xs:

return [p]

r, *rs = xs

if esRaizRuffini(r, p):

return [densaApolinomio([1, -r])] + factorizacion(cocienteRuffini(r, p))

return aux(rs)

if esPolCero(p):

return [p]

return aux([0] + divisores(terminoIndep(p)))

# Verificación

# ============

def test_factorizacion() -> None:

ejPol1 = consPol(5, 1, consPol(2, 5, consPol(1, 4, polCero())))

assert list(map(str, factorizacion(ejPol1))) \

== ["1*x", "1*x + 1", "x^3 + -1*x^2 + 1*x + 4"]

ejPol2 = consPol(3, 1, consPol(2, 2, consPol(1, -1, consPol(0, -2, polCero()))))

assert list(map(str, factorizacion(ejPol2))) \

== ["1*x + -1", "1*x + 1", "1*x + 2", "1"]

print("Verificado")

# La verificación es

# >>> test_factorizacion()

# Verificado

TAD de los polinomios: Raíces enteras de un polinomio

PorJosé A. Alonso 19-mayo-202322-mayo-2023

Usando el tipo abstracto de los polinomios, definir la función

    raicesRuffini :: Polinomio Int -> [Int]

1	raicesRuffini :: Polinomio Int -> [Int]

tal que raicesRuffini p es la lista de las raices enteras de p, calculadas usando el regla de Ruffini. Por ejemplo,

    λ> ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))
    λ> ejPol1
    3*x^4 + -5*x^2 + 3
    λ> raicesRuffini ejPol1
    []
    λ> ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))
    λ> ejPol2
    x^5 + 5*x^2 + 4*x
    λ> raicesRuffini ejPol2
    [0,-1]
    λ> ejPol3 = consPol 4 6 (consPol 1 2 polCero)
    λ> ejPol3
    6*x^4 + 2*x
    λ> raicesRuffini ejPol3
    [0]
    λ> ejPol4 = consPol 3 1 (consPol 2 2 (consPol 1 (-1) (consPol 0 (-2) polCero)))
    λ> ejPol4
    x^3 + 2*x^2 + -1*x + -2
    λ> raicesRuffini ejPol4
    [1,-1,-2]

λ> ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))

λ> ejPol1

3*x^4 + -5*x^2 + 3

λ> raicesRuffini ejPol1

[]

λ> ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))

λ> ejPol2

x^5 + 5*x^2 + 4*x

λ> raicesRuffini ejPol2

[0,-1]

λ> ejPol3 = consPol 4 6 (consPol 1 2 polCero)

λ> ejPol3

6*x^4 + 2*x

λ> raicesRuffini ejPol3

[0]

λ> ejPol4 = consPol 3 1 (consPol 2 2 (consPol 1 (-1) (consPol 0 (-2) polCero)))

λ> ejPol4

x^3 + 2*x^2 + -1*x + -2

λ> raicesRuffini ejPol4

[1,-1,-2]

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Pol_Raices_enteras_de_un_polinomio where

import TAD.Polinomio (Polinomio, consPol, polCero, esPolCero)
import Pol_Termino_independiente_de_un_polinomio (terminoIndep)
import Pol_Regla_de_Ruffini (cocienteRuffini)
import Pol_Reconocimiento_de_raices_por_la_regla_de_Ruffini (esRaizRuffini)
import Test.Hspec (Spec, hspec, it, shouldBe)

raicesRuffini :: Polinomio Int -> [Int]
raicesRuffini p
  | esPolCero p = []
  | otherwise   = aux (0 : divisores (terminoIndep p))
  where aux [] = []
        aux (r:rs)
          | esRaizRuffini r p = r : raicesRuffini (cocienteRuffini r p)
          | otherwise         = aux rs

-- (divisores n) es la lista de todos los divisores enteros de n. Por
-- ejemplo,
--    divisores 4     ==  [1,-1,2,-2,4,-4]
--    divisores (-6)  ==  [1,-1,2,-2,3,-3,6,-6]
divisores :: Int -> [Int]
divisores n = concat [[x,-x] | x <- [1..abs n], rem n x == 0]

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    raicesRuffini ejPol1 `shouldBe` []
  it "e2" $
    raicesRuffini ejPol2 `shouldBe` [0,-1]
  it "e3" $
    raicesRuffini ejPol3 `shouldBe` [0]
  it "e4" $
    raicesRuffini ejPol4 `shouldBe` [1,-1,-2]
  where
    ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))
    ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))
    ejPol3 = consPol 4 6 (consPol 1 2 polCero)
    ejPol4 = consPol 3 1 (consPol 2 2 (consPol 1 (-1) (consPol 0 (-2) polCero)))

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--    e3
--    e4
--
--    Finished in 0.0013 seconds
--    4 examples, 0 failures

module Pol_Raices_enteras_de_un_polinomio where

import TAD.Polinomio (Polinomio, consPol, polCero, esPolCero)

import Pol_Termino_independiente_de_un_polinomio (terminoIndep)

import Pol_Regla_de_Ruffini (cocienteRuffini)

import Pol_Reconocimiento_de_raices_por_la_regla_de_Ruffini (esRaizRuffini)

import Test.Hspec (Spec, hspec, it, shouldBe)

raicesRuffini :: Polinomio Int -> [Int]

raicesRuffini p

| esPolCero p = []

| otherwise = aux (0 : divisores (terminoIndep p))

where aux [] = []

aux (r:rs)

| esRaizRuffini r p = r : raicesRuffini (cocienteRuffini r p)

| otherwise = aux rs

-- (divisores n) es la lista de todos los divisores enteros de n. Por

-- ejemplo,

-- divisores 4 == [1,-1,2,-2,4,-4]

-- divisores (-6) == [1,-1,2,-2,3,-3,6,-6]

divisores :: Int -> [Int]

divisores n = concat [[x,-x] | x <- [1..abs n], rem n x == 0]

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

raicesRuffini ejPol1 `shouldBe` []

it "e2" $

raicesRuffini ejPol2 `shouldBe` [0,-1]

it "e3" $

raicesRuffini ejPol3 `shouldBe` [0]

it "e4" $

raicesRuffini ejPol4 `shouldBe` [1,-1,-2]

where

ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))

ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))

ejPol3 = consPol 4 6 (consPol 1 2 polCero)

ejPol4 = consPol 3 1 (consPol 2 2 (consPol 1 (-1) (consPol 0 (-2) polCero)))

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- e3

-- e4

-- Finished in 0.0013 seconds

-- 4 examples, 0 failures

Soluciones en Python

from src.Pol_Reconocimiento_de_raices_por_la_regla_de_Ruffini import \
    esRaizRuffini
from src.Pol_Regla_de_Ruffini import cocienteRuffini
from src.Pol_Termino_independiente_de_un_polinomio import terminoIndep
from src.TAD.Polinomio import Polinomio, consPol, esPolCero, polCero


# (divisores n) es la lista de todos los divisores enteros de n. Por
# ejemplo,
#    divisores(4)  == [1, 2, 4, -1, -2, -4]
#    divisores(-6) == [1, 2, 3, 6, -1, -2, -3, -6]
def divisores(n: int) -> list[int]:
    xs = [x for x in range(1, abs(n)+1) if n % x == 0]
    return xs + [-x for x in xs]

def raicesRuffini(p: Polinomio[int]) -> list[int]:
    if esPolCero(p):
        return []
    def aux(rs: list[int]) -> list[int]:
        if not rs:
            return []
        x, *xs = rs
        if esRaizRuffini(x, p):
            return [x] + raicesRuffini(cocienteRuffini(x, p))
        return aux(xs)

    return aux([0] + divisores(terminoIndep(p)))

# Verificación
# ============

def test_raicesRuffini() -> None:
    ejPol1 = consPol(4, 3, consPol(2, -5, consPol(0, 3, polCero())))
    assert raicesRuffini(ejPol1) == []
    ejPol2 = consPol(5, 1, consPol(2, 5, consPol(1, 4, polCero())))
    assert raicesRuffini(ejPol2) == [0, -1]
    ejPol3 = consPol(4, 6, consPol(1, 2, polCero()))
    assert raicesRuffini(ejPol3) == [0]
    ejPol4 = consPol(3, 1, consPol(2, 2, consPol(1, -1, consPol(0, -2, polCero()))))
    assert raicesRuffini(ejPol4) == [1, -1, -2]
    print("Verificado")

# La verificación es
#    >>> test_raicesRuffini()
#    Verificado

from src.Pol_Reconocimiento_de_raices_por_la_regla_de_Ruffini import \

esRaizRuffini

from src.Pol_Regla_de_Ruffini import cocienteRuffini

from src.Pol_Termino_independiente_de_un_polinomio import terminoIndep

from src.TAD.Polinomio import Polinomio, consPol, esPolCero, polCero

# (divisores n) es la lista de todos los divisores enteros de n. Por

# ejemplo,

# divisores(4) == [1, 2, 4, -1, -2, -4]

# divisores(-6) == [1, 2, 3, 6, -1, -2, -3, -6]

def divisores(n: int) -> list[int]:

xs = [x for x in range(1, abs(n)+1) if n % x == 0]

return xs + [-x for x in xs]

def raicesRuffini(p: Polinomio[int]) -> list[int]:

if esPolCero(p):

return []

def aux(rs: list[int]) -> list[int]:

if not rs:

return []

x, *xs = rs

if esRaizRuffini(x, p):

return [x] + raicesRuffini(cocienteRuffini(x, p))

return aux(xs)

return aux([0] + divisores(terminoIndep(p)))

# Verificación

# ============

def test_raicesRuffini() -> None:

ejPol1 = consPol(4, 3, consPol(2, -5, consPol(0, 3, polCero())))

assert raicesRuffini(ejPol1) == []

ejPol2 = consPol(5, 1, consPol(2, 5, consPol(1, 4, polCero())))

assert raicesRuffini(ejPol2) == [0, -1]

ejPol3 = consPol(4, 6, consPol(1, 2, polCero()))

assert raicesRuffini(ejPol3) == [0]

ejPol4 = consPol(3, 1, consPol(2, 2, consPol(1, -1, consPol(0, -2, polCero()))))

assert raicesRuffini(ejPol4) == [1, -1, -2]

print("Verificado")

# La verificación es

# >>> test_raicesRuffini()

# Verificado

TAD de los polinomios: Reconocimiento de raíces por la regla de Ruffini

PorJosé A. Alonso 18-mayo-202310-mayo-2023

Usando el tipo abstracto de los polinomios, definir la función

   esRaizRuffini :: Int -> Polinomio Int -> Bool

1	esRaizRuffini :: Int -> Polinomio Int -> Bool

tal que esRaizRuffini r p se verifica si r es una raiz de p, usando para ello el regla de Ruffini. Por ejemplo,

   λ> ejPol = consPol 4 6 (consPol 1 2 polCero)
   λ> ejPol
   6*x^4 + 2*x
   λ> esRaizRuffini 0 ejPol
   True
   λ> esRaizRuffini 1 ejPol
   False

λ> ejPol = consPol 4 6 (consPol 1 2 polCero)

λ> ejPol

6*x^4 + 2*x

λ> esRaizRuffini 0 ejPol

True

λ> esRaizRuffini 1 ejPol

False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Pol_Reconocimiento_de_raices_por_la_regla_de_Ruffini where

import TAD.Polinomio (Polinomio, consPol, polCero)
import Pol_Regla_de_Ruffini (restoRuffini)

esRaizRuffini :: Int -> Polinomio Int -> Bool
esRaizRuffini r p = restoRuffini r p == 0

module Pol_Reconocimiento_de_raices_por_la_regla_de_Ruffini where

import TAD.Polinomio (Polinomio, consPol, polCero)

import Pol_Regla_de_Ruffini (restoRuffini)

esRaizRuffini :: Int -> Polinomio Int -> Bool

esRaizRuffini r p = restoRuffini r p == 0

Soluciones en Python

from src.Pol_Regla_de_Ruffini import restoRuffini
from src.TAD.Polinomio import Polinomio, consPol, polCero


def esRaizRuffini(r: int, p: Polinomio[int]) -> bool:
    return restoRuffini(r, p) == 0

from src.Pol_Regla_de_Ruffini import restoRuffini

from src.TAD.Polinomio import Polinomio, consPol, polCero

def esRaizRuffini(r: int, p: Polinomio[int]) -> bool:

return restoRuffini(r, p) == 0

TAD de los polinomios: Regla de Ruffini

PorJosé A. Alonso 17-mayo-20239-mayo-2023

Usando el tipo abstracto de los polinomios, definir las funciones

   cocienteRuffini :: Int -> Polinomio Int -> Polinomio Int
   restoRuffini    :: Int -> Polinomio Int -> Int

1 2	cocienteRuffini :: Int -> Polinomio Int -> Polinomio Int restoRuffini :: Int -> Polinomio Int -> Int

tales que

cocienteRuffini r p es el cociente de dividir el polinomio p por el polinomio x-r. Por ejemplo:

     λ> ejPol = consPol 3 1 (consPol 2 2 (consPol 1 (-1) (consPol 0 (-2) polCero)))
     λ> ejPol
     x^3 + 2*x^2 + -1*x + -2
     λ> cocienteRuffini 2 ejPol
     x^2 + 4*x + 7
     λ> cocienteRuffini (-2) ejPol
     x^2 + -1
     λ> cocienteRuffini 3 ejPol
     x^2 + 5*x + 14

λ> ejPol = consPol 3 1 (consPol 2 2 (consPol 1 (-1) (consPol 0 (-2) polCero)))

λ> ejPol

x^3 + 2*x^2 + -1*x + -2

λ> cocienteRuffini 2 ejPol

x^2 + 4*x + 7

λ> cocienteRuffini (-2) ejPol

x^2 + -1

λ> cocienteRuffini 3 ejPol

x^2 + 5*x + 14

restoRuffini r p es el resto de dividir el polinomio p por el polinomio x-r. Por ejemplo,

     λ> restoRuffini 2 ejPol
     12
     λ> restoRuffini (-2) ejPol
     0
     λ> restoRuffini 3 ejPol
     40

λ> restoRuffini 2 ejPol

λ> restoRuffini (-2) ejPol

λ> restoRuffini 3 ejPol

Comprobar con QuickCheck que, dado un polinomio p y un número entero r, las funciones anteriores verifican la propiedad de la división euclídea.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, consPol, polCero)
import Pol_Transformaciones_polinomios_densas (densaApolinomio,
                                               polinomioAdensa)
import Pol_Division_de_Ruffini_con_representacion_densa (ruffiniDensa)
import Pol_Producto_polinomios (multPol)
import Pol_Suma_de_polinomios (sumaPol)
import Pol_Crea_termino (creaTermino)
import Test.QuickCheck

-- 1ª definición de cocienteRuffini
-- ================================

cocienteRuffini :: Int -> Polinomio Int -> Polinomio Int
cocienteRuffini r p = densaApolinomio (init (ruffiniDensa r (polinomioAdensa p)))

-- 2ª definición de cocienteRuffini
-- ================================

cocienteRuffini2 :: Int -> Polinomio Int -> Polinomio Int
cocienteRuffini2 r = densaApolinomio . ruffiniDensa r . init . polinomioAdensa

-- 1ª definición de restoRuffini
-- =============================

restoRuffini :: Int -> Polinomio Int -> Int
restoRuffini r p = last (ruffiniDensa r (polinomioAdensa p))

-- 2ª definición de restoRuffini
-- =============================

restoRuffini2 :: Int -> Polinomio Int -> Int
restoRuffini2 r = last . ruffiniDensa r . polinomioAdensa

-- Comprobación de la propiedad
-- ============================

-- La propiedad es
prop_diviEuclidea :: Int -> Polinomio Int -> Bool
prop_diviEuclidea r p =
  p == sumaPol (multPol coci divi) rest
  where coci = cocienteRuffini r p
        divi = densaApolinomio [1,-r]
        rest = creaTermino 0 (restoRuffini r p)

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

import TAD.Polinomio (Polinomio, consPol, polCero)

import Pol_Transformaciones_polinomios_densas (densaApolinomio,

polinomioAdensa)

import Pol_Division_de_Ruffini_con_representacion_densa (ruffiniDensa)

import Pol_Producto_polinomios (multPol)

import Pol_Suma_de_polinomios (sumaPol)

import Pol_Crea_termino (creaTermino)

import Test.QuickCheck

-- 1ª definición de cocienteRuffini

-- ================================

cocienteRuffini :: Int -> Polinomio Int -> Polinomio Int

cocienteRuffini r p = densaApolinomio (init (ruffiniDensa r (polinomioAdensa p)))

-- 2ª definición de cocienteRuffini

-- ================================

cocienteRuffini2 :: Int -> Polinomio Int -> Polinomio Int

cocienteRuffini2 r = densaApolinomio . ruffiniDensa r . init . polinomioAdensa

-- 1ª definición de restoRuffini

-- =============================

restoRuffini :: Int -> Polinomio Int -> Int

restoRuffini r p = last (ruffiniDensa r (polinomioAdensa p))

-- 2ª definición de restoRuffini

-- =============================

restoRuffini2 :: Int -> Polinomio Int -> Int

restoRuffini2 r = last . ruffiniDensa r . polinomioAdensa

-- Comprobación de la propiedad

-- ============================

-- La propiedad es

prop_diviEuclidea :: Int -> Polinomio Int -> Bool

prop_diviEuclidea r p =

p == sumaPol (multPol coci divi) rest

where coci = cocienteRuffini r p

divi = densaApolinomio [1,-r]

rest = creaTermino 0 (restoRuffini r p)

-- La comprobación es

-- λ> quickCheck prop_diviEuclidea

-- +++ OK, passed 100 tests.

Soluciones en Python

from hypothesis import given
from hypothesis import strategies as st

from src.Pol_Crea_termino import creaTermino
from src.Pol_Division_de_Ruffini_con_representacion_densa import ruffiniDensa
from src.Pol_Producto_polinomios import multPol
from src.Pol_Suma_de_polinomios import sumaPol
from src.Pol_Transformaciones_polinomios_densas import (densaApolinomio,
                                                        polinomioAdensa)
from src.TAD.Polinomio import (Polinomio, consPol, esPolCero, polCero,
                               polinomioAleatorio)


def cocienteRuffini(r: int, p: Polinomio[int]) -> Polinomio[int]:
    if esPolCero(p):
        return polCero()
    return densaApolinomio(ruffiniDensa(r, polinomioAdensa(p))[:-1])

def restoRuffini(r: int, p: Polinomio[int]) -> int:
    if esPolCero(p):
        return 0
    return ruffiniDensa(r, polinomioAdensa(p))[-1]

# Comprobación de la propiedad
# ============================

# La propiedad es
@given(r=st.integers(), p=polinomioAleatorio())
def test_diviEuclidea (r: int, p: Polinomio[int]) -> None:
    coci = cocienteRuffini(r, p)
    divi = densaApolinomio([1, -r])
    rest = creaTermino(0, restoRuffini(r, p))
    assert p == sumaPol(multPol(coci, divi), rest)

# La comprobación es
#    src> poetry run pytest -q Pol_Regla_de_Ruffini.py
#    1 passed in 0.32s

from hypothesis import given

from hypothesis import strategies as st

from src.Pol_Crea_termino import creaTermino

from src.Pol_Division_de_Ruffini_con_representacion_densa import ruffiniDensa

from src.Pol_Producto_polinomios import multPol

from src.Pol_Suma_de_polinomios import sumaPol

from src.Pol_Transformaciones_polinomios_densas import (densaApolinomio,

polinomioAdensa)

from src.TAD.Polinomio import (Polinomio, consPol, esPolCero, polCero,

polinomioAleatorio)

def cocienteRuffini(r: int, p: Polinomio[int]) -> Polinomio[int]:

if esPolCero(p):

return polCero()

return densaApolinomio(ruffiniDensa(r, polinomioAdensa(p))[:-1])

def restoRuffini(r: int, p: Polinomio[int]) -> int:

if esPolCero(p):

return 0

return ruffiniDensa(r, polinomioAdensa(p))[-1]

# Comprobación de la propiedad

# ============================

# La propiedad es

@given(r=st.integers(), p=polinomioAleatorio())

def test_diviEuclidea (r: int, p: Polinomio[int]) -> None:

coci = cocienteRuffini(r, p)

divi = densaApolinomio([1, -r])

rest = creaTermino(0, restoRuffini(r, p))

assert p == sumaPol(multPol(coci, divi), rest)

# La comprobación es

# src> poetry run pytest -q Pol_Regla_de_Ruffini.py

# 1 passed in 0.32s

TAD de los polinomios: Regla de Ruffini con representación densa

PorJosé A. Alonso 16-mayo-20238-mayo-2023

Usando el tipo abstracto de los polinomios definir la función

   ruffiniDensa :: Int -> [Int] -> [Int]

1	ruffiniDensa :: Int -> [Int] -> [Int]

tal que ruffiniDensa r cs es la lista de los coeficientes del cociente junto con el rsto que resulta de aplicar la regla de Ruffini para dividir el polinomio cuya representación densa es cs entre x-r. Por ejemplo,

   ruffiniDensa 2 [1,2,-1,-2] == [1,4,7,12]
   ruffiniDensa 1 [1,2,-1,-2] == [1,3,2,0]

1 2	ruffiniDensa 2 [1,2,-1,-2] == [1,4,7,12] ruffiniDensa 1 [1,2,-1,-2] == [1,3,2,0]

ya que

     | 1  2  -1  -2           | 1  2  -1  -2
   2 |    2   8  14         1 |    1   3   2
   --+--------------        --+-------------
     | 1  4   7  12           | 1  3   2   0

| 1 2 -1 -2 | 1 2 -1 -2

2 | 2 8 14 1 | 1 3 2

--+-------------- --+-------------

| 1 4 7 12 | 1 3 2 0

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Test.QuickCheck

-- 1ª solución
-- ===========

ruffiniDensa :: Int -> [Int] -> [Int]
ruffiniDensa _ [] = []
ruffiniDensa r p@(c:cs) =
  c : [x+r*y | (x,y) <- zip cs (ruffiniDensa r p)]

-- 2ª solución
-- ===========

ruffiniDensa2 :: Int -> [Int] -> [Int]
ruffiniDensa2 r =
  scanl1 (\s x -> s * r + x)

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_ruffiniDensa :: Int -> [Int] -> Bool
prop_ruffiniDensa r cs =
  ruffiniDensa r cs == ruffiniDensa2 r cs

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

import Test.QuickCheck

-- 1ª solución

-- ===========

ruffiniDensa :: Int -> [Int] -> [Int]

ruffiniDensa _ [] = []

ruffiniDensa r p@(c:cs) =

c : [x+r*y | (x,y) <- zip cs (ruffiniDensa r p)]

-- 2ª solución

-- ===========

ruffiniDensa2 :: Int -> [Int] -> [Int]

ruffiniDensa2 r =

scanl1 (\s x -> s * r + x)

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_ruffiniDensa :: Int -> [Int] -> Bool

prop_ruffiniDensa r cs =

ruffiniDensa r cs == ruffiniDensa2 r cs

-- La comprobación es

-- λ> quickCheck prop_ruffiniDensa

-- +++ OK, passed 100 tests.

Soluciones en Python

def ruffiniDensa(r: int, p: list[int]) -> list[int]:
    if not p:
        return []
    res = [p[0]]
    for x in p[1:]:
        res.append(x + r * res[-1])
    return res

def ruffiniDensa(r: int, p: list[int]) -> list[int]:

if not p:

return []

res = [p[0]]

for x in p[1:]:

res.append(x + r * res[-1])

return res

TAD de los polinomios: Término independiente de un polinomio

PorJosé A. Alonso 15-mayo-20237-mayo-2023

Usando el tipo abstracto de datos de los polinomios definir la función

   terminoIndep :: (Num a, Eq a) => Polinomio  a -> a

1	terminoIndep :: (Num a, Eq a) => Polinomio a -> a

tal que terminoIndep p es el término independiente del polinomio p. Por ejemplo,

   λ> ejPol1 = consPol 4 3 (consPol 2 5 (consPol 0 3 polCero))
   λ> ejPol1
   3*x^4 + 5*x^2 + 3
   λ> terminoIndep ejPol1
   3
   λ> ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))
   λ> ejPol2
   x^5 + 5*x^2 + 4*x
   λ> terminoIndep ejPol2
   0

λ> ejPol1 = consPol 4 3 (consPol 2 5 (consPol 0 3 polCero))

λ> ejPol1

3*x^4 + 5*x^2 + 3

λ> terminoIndep ejPol1

λ> ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))

λ> ejPol2

x^5 + 5*x^2 + 4*x

λ> terminoIndep ejPol2

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, consPol, polCero)
import Pol_Coeficiente (coeficiente)

terminoIndep :: (Num a, Eq a) => Polinomio  a -> a
terminoIndep = coeficiente 0

import TAD.Polinomio (Polinomio, consPol, polCero)

import Pol_Coeficiente (coeficiente)

terminoIndep :: (Num a, Eq a) => Polinomio a -> a

terminoIndep = coeficiente 0

Soluciones en Python

from typing import TypeVar

from src.Pol_Coeficiente import coeficiente
from src.TAD.Polinomio import Polinomio, consPol, polCero

A = TypeVar('A', int, float, complex)

def terminoIndep(p: Polinomio[A]) -> A:
    return coeficiente(0, p)

from typing import TypeVar

from src.Pol_Coeficiente import coeficiente

from src.TAD.Polinomio import Polinomio, consPol, polCero

A = TypeVar('A', int, float, complex)

def terminoIndep(p: Polinomio[A]) -> A:

return coeficiente(0, p)

TAD de los polinomios: Método de Horner del valor de un polinomio

PorJosé A. Alonso 12-mayo-20234-mayo-2023

El método de Horner para calcular el valor de un polinomio se basa en representarlo de una forma forma alernativa. Por ejemplo, para calcular el valor de

   a*x^5 + b*x^4 + c*x^3 + d*x^2 + e*x + f

1	ax^5 + bx^4 + cx^3 + dx^2 + e*x + f

se representa como

  (((((0 * x + a) * x + b) * x + c) * x + d) * x + e) * x + f

1	(((((0 * x + a) * x + b) * x + c) * x + d) * x + e) * x + f

y se evalúa de dentro hacia afuera; es decir,

  v(0) = 0
  v(1) = v(0)*x+a = 0*x+a = a
  v(2) = v(1)*x+b = a*x+b
  v(3) = v(2)*x+c = (a*x+b)*x+c = a*x^2+b*x+c
  v(4) = v(3)*x+d = (a*x^2+b*x+c)*x+d = a*x^3+b*x^2+c*x+d
  v(5) = v(4)*x+e = (a*x^3+b*x^2+c*x+d)*x+e = a*x^4+b*x^3+c*x^2+d*x+e
  v(6) = v(5)*x+f = (a*x^4+b*x^3+c*x^2+d*x+e)*x+f = a*x^5+b*x^4+c*x^3+d*x^2+e*x+f

v(0) = 0

v(1) = v(0)*x+a = 0*x+a = a

v(2) = v(1)*x+b = a*x+b

v(3) = v(2)*x+c = (a*x+b)*x+c = a*x^2+b*x+c

v(4) = v(3)*x+d = (a*x^2+b*x+c)*x+d = a*x^3+b*x^2+c*x+d

v(5) = v(4)*x+e = (a*x^3+b*x^2+c*x+d)*x+e = a*x^4+b*x^3+c*x^2+d*x+e

v(6) = v(5)*x+f = (a*x^4+b*x^3+c*x^2+d*x+e)*x+f = a*x^5+b*x^4+c*x^3+d*x^2+e*x+f

Usando el tipo abstracto de los polinomios, definir la función

   horner :: (Num a, Eq a) => Polinomio a -> a -> a

1	horner :: (Num a, Eq a) => Polinomio a -> a -> a

tal que horner p x es el valor del polinomio p al sustituir su variable por el número x. Por ejemplo,

   λ> pol1 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))
   λ> pol1
   x^5 + 5*x^2 + 4*x
   λ> horner pol1 0
   0
   λ> horner pol1 1
   10
   λ> horner pol1 1.5
   24.84375
   λ> import Data.Ratio
   λ> horner pol1 (3%2)
   795 % 32

λ> pol1 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))

λ> pol1

x^5 + 5*x^2 + 4*x

λ> horner pol1 0

λ> horner pol1 1

λ> horner pol1 1.5

24.84375

λ> import Data.Ratio

λ> horner pol1 (3%2)

795 % 32

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, polCero, consPol)
import Pol_Transformaciones_polinomios_densas (polinomioAdensa)

-- 1ª solución
-- ===========

horner :: (Num a, Eq a) => Polinomio a -> a -> a
horner p x = hornerAux (polinomioAdensa p) 0
  where hornerAux [] v     = v
        hornerAux (a:as) v = hornerAux as (v*x+a)

-- El cálculo de (horner pol1 2) es el siguiente
--    horner pol1 2
--    = hornerAux [1,0,0,5,4,0] 0
--    = hornerAux   [0,0,5,4,0] ( 0*2+1) = hornerAux   [0,0,5,4,0] 1
--    = hornerAux     [0,5,4,0] ( 1*2+0) = hornerAux     [0,5,4,0] 2
--    = hornerAux       [5,4,0] ( 2*2+0) = hornerAux       [5,4,0] 4
--    = hornerAux         [4,0] ( 4*2+5) = hornerAux         [4,0] 13
--    = hornerAux           [0] (13*2+4) = hornerAux           [0] 30
--    = hornerAux            [] (30*2+0) = hornerAux            [] 60

-- 2ª solución
-- ===========

horner2 :: (Num a, Eq a) => Polinomio a -> a -> a
horner2 p x = foldl (\a b -> a*x + b) 0 (polinomioAdensa p)

import TAD.Polinomio (Polinomio, polCero, consPol)

import Pol_Transformaciones_polinomios_densas (polinomioAdensa)

-- 1ª solución

-- ===========

horner :: (Num a, Eq a) => Polinomio a -> a -> a

horner p x = hornerAux (polinomioAdensa p) 0

where hornerAux [] v = v

hornerAux (a:as) v = hornerAux as (v*x+a)

-- El cálculo de (horner pol1 2) es el siguiente

-- horner pol1 2

-- = hornerAux [1,0,0,5,4,0] 0

-- = hornerAux [0,0,5,4,0] ( 0*2+1) = hornerAux [0,0,5,4,0] 1

-- = hornerAux [0,5,4,0] ( 1*2+0) = hornerAux [0,5,4,0] 2

-- = hornerAux [5,4,0] ( 2*2+0) = hornerAux [5,4,0] 4

-- = hornerAux [4,0] ( 4*2+5) = hornerAux [4,0] 13

-- = hornerAux [0] (13*2+4) = hornerAux [0] 30

-- = hornerAux [] (30*2+0) = hornerAux [] 60

-- 2ª solución

-- ===========

horner2 :: (Num a, Eq a) => Polinomio a -> a -> a

horner2 p x = foldl (\a b -> a*x + b) 0 (polinomioAdensa p)

Soluciones en Python

from functools import reduce

from src.Pol_Transformaciones_polinomios_densas import polinomioAdensa
from src.TAD.Polinomio import Polinomio, consPol, polCero

# 1ª solución
# ===========

def horner(p: Polinomio[float], x: float) -> float:
    def hornerAux(ys: list[float], v: float) -> float:
        if not ys:
            return v
        return hornerAux(ys[1:], v * x + ys[0])

    return hornerAux(polinomioAdensa(p), 0)

# El cálculo de horner(pol1, 2) es el siguiente
#    horner pol1 2
#    = hornerAux [1,0,0,5,4,0] 0
#    = hornerAux   [0,0,5,4,0] ( 0*2+1) = hornerAux   [0,0,5,4,0] 1
#    = hornerAux     [0,5,4,0] ( 1*2+0) = hornerAux     [0,5,4,0] 2
#    = hornerAux       [5,4,0] ( 2*2+0) = hornerAux       [5,4,0] 4
#    = hornerAux         [4,0] ( 4*2+5) = hornerAux         [4,0] 13
#    = hornerAux           [0] (13*2+4) = hornerAux           [0] 30
#    = hornerAux            [] (30*2+0) = hornerAux            [] 60

# 2ª solución
# ===========

def horner2(p: Polinomio[float], x: float) -> float:
    return reduce(lambda a, b: a * x + b, polinomioAdensa(p) , 0.0)

from functools import reduce

from src.Pol_Transformaciones_polinomios_densas import polinomioAdensa

from src.TAD.Polinomio import Polinomio, consPol, polCero

# 1ª solución

# ===========

def horner(p: Polinomio[float], x: float) -> float:

def hornerAux(ys: list[float], v: float) -> float:

if not ys:

return v

return hornerAux(ys[1:], v * x + ys[0])

return hornerAux(polinomioAdensa(p), 0)

# El cálculo de horner(pol1, 2) es el siguiente

# horner pol1 2

# = hornerAux [1,0,0,5,4,0] 0

# = hornerAux [0,0,5,4,0] ( 0*2+1) = hornerAux [0,0,5,4,0] 1

# = hornerAux [0,5,4,0] ( 1*2+0) = hornerAux [0,5,4,0] 2

# = hornerAux [5,4,0] ( 2*2+0) = hornerAux [5,4,0] 4

# = hornerAux [4,0] ( 4*2+5) = hornerAux [4,0] 13

# = hornerAux [0] (13*2+4) = hornerAux [0] 30

# = hornerAux [] (30*2+0) = hornerAux [] 60

# 2ª solución

# ===========

def horner2(p: Polinomio[float], x: float) -> float:

return reduce(lambda a, b: a * x + b, polinomioAdensa(p) , 0.0)

TAD de los polinomios: Divisibilidad de polinomios

PorJosé A. Alonso 11-mayo-20233-mayo-2023

Usando el tipo abstracto de los polinomios, definir la función

   divisiblePol :: (Fractional a, Eq a) =>
                   Polinomio a -> Polinomio a -> Bool

1 2	divisiblePol :: (Fractional a, Eq a) => Polinomio a -> Polinomio a -> Bool

tal que divisiblePol p q se verifica si el polinomio p es divisible por el polinomio q. Por ejemplo,

   λ> pol1 = consPol 2 8 (consPol 1 14 (consPol 0 3 polCero))
   λ> pol1
   8*x^2 + 14*x + 3
   λ> pol2 = consPol 1 2 (consPol 0 3 polCero)
   λ> pol2
   2*x + 3
   λ> pol3 = consPol 2 6 (consPol 1 2 polCero)
   λ> pol3
   6*x^2 + 2*x
   λ> divisiblePol pol1 pol2
   True
   λ> divisiblePol pol1 pol3
   False

λ> pol1 = consPol 2 8 (consPol 1 14 (consPol 0 3 polCero))

λ> pol1

8*x^2 + 14*x + 3

λ> pol2 = consPol 1 2 (consPol 0 3 polCero)

λ> pol2

2*x + 3

λ> pol3 = consPol 2 6 (consPol 1 2 polCero)

λ> pol3

6*x^2 + 2*x

λ> divisiblePol pol1 pol2

True

λ> divisiblePol pol1 pol3

False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, polCero, consPol, esPolCero)
import Pol_Division_de_polinomios (resto)

divisiblePol :: (Fractional a, Eq a) =>
                Polinomio a -> Polinomio a -> Bool
divisiblePol p q = esPolCero (resto p q)

import TAD.Polinomio (Polinomio, polCero, consPol, esPolCero)

import Pol_Division_de_polinomios (resto)

divisiblePol :: (Fractional a, Eq a) =>

Polinomio a -> Polinomio a -> Bool

divisiblePol p q = esPolCero (resto p q)

Soluciones en Python

from src.Pol_Division_de_polinomios import resto
from src.TAD.Polinomio import Polinomio, consPol, esPolCero, polCero


def divisiblePol(p: Polinomio[float], q: Polinomio[float]) -> bool:
    return esPolCero(resto(p, q))

from src.Pol_Division_de_polinomios import resto

from src.TAD.Polinomio import Polinomio, consPol, esPolCero, polCero

def divisiblePol(p: Polinomio[float], q: Polinomio[float]) -> bool:

return esPolCero(resto(p, q))

TAD de los polinomios: División de polinomios

PorJosé A. Alonso 10-mayo-20232-mayo-2023

Usando el tipo abstracto de los polinomios, definir las funciones

   cociente :: (Fractional a, Eq a) =>
               Polinomio a -> Polinomio a -> Polinomio a
   resto    :: (Fractional a, Eq a) =>
               Polinomio a -> Polinomio a -> Polinomio a

cociente :: (Fractional a, Eq a) =>

Polinomio a -> Polinomio a -> Polinomio a

resto :: (Fractional a, Eq a) =>

Polinomio a -> Polinomio a -> Polinomio a

tales que

cociente p q es el cociente de la división de p entre q. Por ejemplo,

     λ> pol1 = consPol 3 2 (consPol 2 9 (consPol 1 10 (consPol 0 4 polCero)))
     λ> pol1
     2*x^3 + 9*x^2 + 10*x + 4
     λ> pol2 = consPol 2 1 (consPol 1 3 polCero)
     λ> pol2
     x^2 + 3*x
     λ> cociente pol1 pol2
     2.0*x + 3.0

λ> pol1 = consPol 3 2 (consPol 2 9 (consPol 1 10 (consPol 0 4 polCero)))

λ> pol1

2*x^3 + 9*x^2 + 10*x + 4

λ> pol2 = consPol 2 1 (consPol 1 3 polCero)

λ> pol2

x^2 + 3*x

λ> cociente pol1 pol2

2.0*x + 3.0

resto p q es el resto de la división de p entre q. Por ejemplo,

     λ> resto pol1 pol2
     1.0*x + 4.0

1 2	λ> resto pol1 pol2 1.0*x + 4.0

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, polCero, consPol, grado, coefLider)
import Pol_Crea_termino (creaTermino)
import Pol_Producto_polinomios (multPol, multPorTerm)
import Pol_Resta_de_polinomios (restaPol)
import Pol_Multiplicacion_de_un_polinomio_por_un_numero (multEscalar)

cociente :: (Fractional a, Eq a) =>
            Polinomio a -> Polinomio a -> Polinomio a
cociente p q
  | n2 == 0   = multEscalar (1/a2) p
  | n1 < n2   = polCero
  | otherwise = consPol n3 a3 (cociente p3 q)
  where n1 = grado p
        a1 = coefLider p
        n2 = grado q
        a2 = coefLider q
        n3 = n1-n2
        a3 = a1/a2
        p3 = restaPol p (multPorTerm (creaTermino n3 a3) q)

resto :: (Fractional a, Eq a) =>
         Polinomio a -> Polinomio a -> Polinomio a
resto p q = restaPol p (multPol (cociente p q) q)

import TAD.Polinomio (Polinomio, polCero, consPol, grado, coefLider)

import Pol_Crea_termino (creaTermino)

import Pol_Producto_polinomios (multPol, multPorTerm)

import Pol_Resta_de_polinomios (restaPol)

import Pol_Multiplicacion_de_un_polinomio_por_un_numero (multEscalar)

cociente :: (Fractional a, Eq a) =>

Polinomio a -> Polinomio a -> Polinomio a

cociente p q

| n2 == 0 = multEscalar (1/a2) p

| n1 < n2 = polCero

| otherwise = consPol n3 a3 (cociente p3 q)

where n1 = grado p

a1 = coefLider p

n2 = grado q

a2 = coefLider q

n3 = n1-n2

a3 = a1/a2

p3 = restaPol p (multPorTerm (creaTermino n3 a3) q)

resto :: (Fractional a, Eq a) =>

Polinomio a -> Polinomio a -> Polinomio a

resto p q = restaPol p (multPol (cociente p q) q)

Soluciones en Python

from src.Pol_Crea_termino import creaTermino
from src.Pol_Multiplicacion_de_un_polinomio_por_un_numero import multEscalar
from src.Pol_Producto_polinomios import multPol, multPorTerm
from src.Pol_Resta_de_polinomios import restaPol
from src.TAD.Polinomio import Polinomio, coefLider, consPol, grado, polCero


def cociente(p: Polinomio[float], q: Polinomio[float]) -> Polinomio[float]:
    n1 = grado(p)
    a1 = coefLider(p)
    n2 = grado(q)
    a2 = coefLider(q)
    n3 = n1 - n2
    a3 = a1 / a2
    p3 = restaPol(p, multPorTerm(creaTermino(n3, a3), q))
    if n2 == 0:
        return multEscalar(1 / a2, p)
    if n1 < n2:
        return polCero()
    return consPol(n3, a3, cociente(p3, q))

def resto(p: Polinomio[float], q: Polinomio[float]) -> Polinomio[float]:
    return restaPol(p, multPol(cociente(p, q), q))

from src.Pol_Crea_termino import creaTermino

from src.Pol_Multiplicacion_de_un_polinomio_por_un_numero import multEscalar

from src.Pol_Producto_polinomios import multPol, multPorTerm

from src.Pol_Resta_de_polinomios import restaPol

from src.TAD.Polinomio import Polinomio, coefLider, consPol, grado, polCero

def cociente(p: Polinomio[float], q: Polinomio[float]) -> Polinomio[float]:

n1 = grado(p)

a1 = coefLider(p)

n2 = grado(q)

a2 = coefLider(q)

n3 = n1 - n2

a3 = a1 / a2

p3 = restaPol(p, multPorTerm(creaTermino(n3, a3), q))

if n2 == 0:

return multEscalar(1 / a2, p)

if n1 < n2:

return polCero()

return consPol(n3, a3, cociente(p3, q))

def resto(p: Polinomio[float], q: Polinomio[float]) -> Polinomio[float]:

return restaPol(p, multPol(cociente(p, q), q))

TAD de los polinomios: Multiplicación de un polinomio por un número

PorJosé A. Alonso 9-mayo-20231-mayo-2023

Usando el tipo abstracto de los polinomios, definir la función

   multEscalar :: (Num a, Eq a) => a -> Polinomio a -> Polinomio a

1	multEscalar :: (Num a, Eq a) => a -> Polinomio a -> Polinomio a

tal que multEscalar c p es el polinomio obtenido multiplicando el número c por el polinomio p. Por ejemplo,

   λ> ejPol = consPol 1 2 (consPol 0 3 polCero)
   λ> ejPol
   2*x + 3
   λ> multEscalar 4 ejPol
   8*x + 12
   λ> multEscalar (1 % 4) ejPol
   1 % 2*x + 3 % 4

λ> ejPol = consPol 1 2 (consPol 0 3 polCero)

λ> ejPol

2*x + 3

λ> multEscalar 4 ejPol

8*x + 12

λ> multEscalar (1 % 4) ejPol

1 % 2*x + 3 % 4

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, polCero, esPolCero, consPol, grado,
                      coefLider, restoPol)
import Data.Ratio

multEscalar :: (Num a, Eq a) => a -> Polinomio a -> Polinomio a
multEscalar c p
  | esPolCero p = polCero
  | otherwise   = consPol n (c*b) (multEscalar c r)
  where n = grado p
        b = coefLider p
        r = restoPol p

import TAD.Polinomio (Polinomio, polCero, esPolCero, consPol, grado,

coefLider, restoPol)

import Data.Ratio

multEscalar :: (Num a, Eq a) => a -> Polinomio a -> Polinomio a

multEscalar c p

| esPolCero p = polCero

| otherwise = consPol n (c*b) (multEscalar c r)

where n = grado p

b = coefLider p

r = restoPol p

Soluciones en Python

from typing import TypeVar

from src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,
                               polCero, restoPol)

A = TypeVar('A', int, float, complex)

def multEscalar(c: A, p: Polinomio[A]) -> Polinomio[A]:
    if esPolCero(p):
        return polCero()
    n = grado(p)
    b = coefLider(p)
    r = restoPol(p)
    return consPol(n, c * b, multEscalar(c, r))

from typing import TypeVar

from src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,

polCero, restoPol)

A = TypeVar('A', int, float, complex)

def multEscalar(c: A, p: Polinomio[A]) -> Polinomio[A]:

if esPolCero(p):

return polCero()

n = grado(p)

b = coefLider(p)

r = restoPol(p)

return consPol(n, c * b, multEscalar(c, r))

TAD de los polinomios: Integral definida de un polinomio

PorJosé A. Alonso 8-mayo-202330-abril-2023

Usando el tipo abstracto de datos de los polinomios definir la función

   integralDef :: (Fractional t, Eq t) => Polinomio t -> t -> t -> t

1	integralDef :: (Fractional t, Eq t) => Polinomio t -> t -> t -> t

tal que integralDef p a b es la integral definida del polinomio p entre a y b. Por ejemplo,

   λ> ejPol = consPol 7 2 (consPol 4 5 (consPol 2 5 polCero))
   λ> ejPol
   2*x^7 + 5*x^4 + 5*x^2
   λ> integralDef ejPol 0 1
   2.916666666666667
   λ> integralDef ejPol 0 1 :: Rational
   35 % 12

λ> ejPol = consPol 7 2 (consPol 4 5 (consPol 2 5 polCero))

λ> ejPol

2*x^7 + 5*x^4 + 5*x^2

λ> integralDef ejPol 0 1

2.916666666666667

λ> integralDef ejPol 0 1 :: Rational

35 % 12

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, consPol, polCero)
import Pol_Valor_de_un_polinomio_en_un_punto (valor)
import Pol_Integral_de_un_polinomio (integral)

integralDef :: (Fractional t, Eq t) => Polinomio t -> t -> t -> t
integralDef p a b = valor q b - valor q a
  where q = integral p

import TAD.Polinomio (Polinomio, consPol, polCero)

import Pol_Valor_de_un_polinomio_en_un_punto (valor)

import Pol_Integral_de_un_polinomio (integral)

integralDef :: (Fractional t, Eq t) => Polinomio t -> t -> t -> t

integralDef p a b = valor q b - valor q a

where q = integral p

Soluciones en Python

from src.Pol_Integral_de_un_polinomio import integral
from src.Pol_Valor_de_un_polinomio_en_un_punto import valor
from src.TAD.Polinomio import Polinomio, consPol, polCero


def integralDef(p: Polinomio[float], a: float, b: float) -> float:
    q = integral(p)
    return valor(q, b) - valor(q, a)

from src.Pol_Integral_de_un_polinomio import integral

from src.Pol_Valor_de_un_polinomio_en_un_punto import valor

from src.TAD.Polinomio import Polinomio, consPol, polCero

def integralDef(p: Polinomio[float], a: float, b: float) -> float:

q = integral(p)

return valor(q, b) - valor(q, a)

TAD de los polinomios: Integral de un polinomio

PorJosé A. Alonso 5-mayo-202329-abril-2023

Usando el tipo abstracto de los polinomios, definir la función

   integral :: (Fractional a, Eq a) => Polinomio a -> Polinomio a

1	integral :: (Fractional a, Eq a) => Polinomio a -> Polinomio a

tal que integral p es la integral del polinomio p cuyos coefientes son números racionales. Por ejemplo,

   λ> ejPol = consPol 7 2 (consPol 4 5 (consPol 2 5 polCero))
   λ> ejPol
   2*x^7 + 5*x^4 + 5*x^2
   λ> integral ejPol
   0.25*x^8 + x^5 + 1.6666666666666667*x^3
   λ> integral ejPol :: Polinomio Rational
   1 % 4*x^8 + x^5 + 5 % 3*x^3

λ> ejPol = consPol 7 2 (consPol 4 5 (consPol 2 5 polCero))

λ> ejPol

2*x^7 + 5*x^4 + 5*x^2

λ> integral ejPol

0.25*x^8 + x^5 + 1.6666666666666667*x^3

λ> integral ejPol :: Polinomio Rational

1 % 4*x^8 + x^5 + 5 % 3*x^3

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, polCero, consPol, esPolCero, grado,
                      coefLider, restoPol)
import Data.Ratio

integral :: (Fractional a, Eq a) => Polinomio a -> Polinomio a
integral p
  | esPolCero p = polCero
  | otherwise   = consPol (n+1) (b / fromIntegral (n+1)) (integral r)
  where n = grado p
        b = coefLider p
        r = restoPol p

import TAD.Polinomio (Polinomio, polCero, consPol, esPolCero, grado,

coefLider, restoPol)

import Data.Ratio

integral :: (Fractional a, Eq a) => Polinomio a -> Polinomio a

integral p

| esPolCero p = polCero

| otherwise = consPol (n+1) (b / fromIntegral (n+1)) (integral r)

where n = grado p

b = coefLider p

r = restoPol p

Soluciones en Python

from src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,
                               polCero, restoPol)


def integral(p: Polinomio[float]) -> Polinomio[float]:
    if esPolCero(p):
        return  polCero()
    n = grado(p)
    b = coefLider(p)
    r = restoPol(p)
    return consPol(n + 1, b / (n + 1), integral(r))

from src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,

polCero, restoPol)

def integral(p: Polinomio[float]) -> Polinomio[float]:

if esPolCero(p):

return polCero()

n = grado(p)

b = coefLider(p)

r = restoPol(p)

return consPol(n + 1, b / (n + 1), integral(r))

TAD de los polinomios: Potencia de un polinomio

PorJosé A. Alonso 4-mayo-202327-abril-2023

Usando el tipo abstracto de los polinomios, definir la función

   potencia :: (Num a, Eq a) => Polinomio a -> Int -> Polinomio a

1	potencia :: (Num a, Eq a) => Polinomio a -> Int -> Polinomio a

tal que potencia p n es la potencia n-ésima del polinomio p. Por ejemplo,

   λ> ejPol = consPol 1 2 (consPol 0 3 polCero)
   λ> ejPol
   2*x + 3
   λ> potencia ejPol 2
   4*x^2 + 12*x + 9
   λ> potencia ejPol 3
   8*x^3 + 36*x^2 + 54*x + 27

λ> ejPol = consPol 1 2 (consPol 0 3 polCero)

λ> ejPol

2*x + 3

λ> potencia ejPol 2

4*x^2 + 12*x + 9

λ> potencia ejPol 3

8*x^3 + 36*x^2 + 54*x + 27

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, polCero, consPol)
import Pol_Producto_polinomios (multPol)
import Test.QuickCheck

-- 1ª solución
-- ===========

potencia :: (Num a, Eq a) => Polinomio a -> Int -> Polinomio a
potencia _ 0 = polUnidad
potencia p n = multPol p (potencia p (n-1))

polUnidad :: (Num a, Eq a) => Polinomio a
polUnidad = consPol 0 1 polCero

-- 2ª solución
-- ===========

potencia2 :: (Num a, Eq a) => Polinomio a -> Int -> Polinomio a
potencia2 _ 0 = polUnidad
potencia2 p n
  | even n    = potencia2 (multPol p p) (n `div` 2)
  | otherwise = multPol p (potencia2 (multPol p p) ((n-1) `div` 2))

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_potencia :: Polinomio Int -> NonNegative Int -> Bool
prop_potencia p (NonNegative n) =
  potencia p n == potencia2 p n

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

-- Comparación de eficiencia
-- =========================

-- La comparación es
--    λ> import TAD.Polinomio (grado)
--    λ> ejPol = consPol 1 2 (consPol 0 3 polCero)
--    λ> grado (potencia ejPol 1000)
--    1000
--    (4.57 secs, 2,409,900,720 bytes)
--    λ> grado (potencia2 ejPol 1000)
--    1000
--    (2.78 secs, 1,439,596,632 bytes)

import TAD.Polinomio (Polinomio, polCero, consPol)

import Pol_Producto_polinomios (multPol)

import Test.QuickCheck

-- 1ª solución

-- ===========

potencia :: (Num a, Eq a) => Polinomio a -> Int -> Polinomio a

potencia _ 0 = polUnidad

potencia p n = multPol p (potencia p (n-1))

polUnidad :: (Num a, Eq a) => Polinomio a

polUnidad = consPol 0 1 polCero

-- 2ª solución

-- ===========

potencia2 :: (Num a, Eq a) => Polinomio a -> Int -> Polinomio a

potencia2 _ 0 = polUnidad

potencia2 p n

| even n = potencia2 (multPol p p) (n `div` 2)

| otherwise = multPol p (potencia2 (multPol p p) ((n-1) `div` 2))

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_potencia :: Polinomio Int -> NonNegative Int -> Bool

prop_potencia p (NonNegative n) =

potencia p n == potencia2 p n

-- La comprobación es

-- λ> quickCheck prop_potencia

-- +++ OK, passed 100 tests.

-- Comparación de eficiencia

-- =========================

-- La comparación es

-- λ> import TAD.Polinomio (grado)

-- λ> ejPol = consPol 1 2 (consPol 0 3 polCero)

-- λ> grado (potencia ejPol 1000)

-- 1000

-- (4.57 secs, 2,409,900,720 bytes)

-- λ> grado (potencia2 ejPol 1000)

-- 1000

-- (2.78 secs, 1,439,596,632 bytes)

Soluciones en Python

from sys import setrecursionlimit
from timeit import Timer, default_timer
from typing import TypeVar

from hypothesis import given
from hypothesis import strategies as st

from src.Pol_Producto_polinomios import multPol
from src.TAD.Polinomio import Polinomio, consPol, polCero, polinomioAleatorio

setrecursionlimit(10**6)

A = TypeVar('A', int, float, complex)

# 1ª solución
# ===========

def potencia(p: Polinomio[A], n: int) -> Polinomio[A]:
    if n == 0:
        return consPol(0, 1, polCero())
    return multPol(p, potencia(p, n - 1))

# 2ª solución
# ===========

def potencia2(p: Polinomio[A], n: int) -> Polinomio[A]:
    if n == 0:
        return consPol(0, 1, polCero())
    if n % 2 == 0:
        return potencia2(multPol(p, p), n // 2)
    return multPol(p, potencia2(multPol(p, p), (n - 1) // 2))

# 3ª solución
# ===========

def potencia3(p: Polinomio[A], n: int) -> Polinomio[A]:
    r: Polinomio[A] = consPol(0, 1, polCero())
    for _ in range(0, n):
        r = multPol(p, r)
    return r

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(p=polinomioAleatorio(),
       n=st.integers(min_value=1, max_value=10))
def test_potencia(p: Polinomio[int], n: int) -> None:
    r = potencia(p, n)
    assert potencia2(p, n) == r
    assert potencia3(p, n) == r

# La comprobación es
#    src> poetry run pytest -q Pol_Potencia_de_un_polinomio.py
#    1 passed in 0.89s

# Comparación de eficiencia
# =========================

def tiempo(e: str) -> None:
    """Tiempo (en segundos) de evaluar la expresión e."""
    t = Timer(e, "", default_timer, globals()).timeit(1)
    print(f"{t:0.2f} segundos")

# La comparación es
#    >>> from src.TAD.Polinomio import grado
#    >>> ejPol = consPol(1, 2, consPol(0, 3, polCero()))
#    >>> tiempo('grado(potencia(ejPol, 1000))')
#    8.58 segundos
#    >>> tiempo('grado(potencia2(ejPol, 1000))')
#    8.75 segundos

from sys import setrecursionlimit

from timeit import Timer, default_timer

from typing import TypeVar

from hypothesis import given

from hypothesis import strategies as st

from src.Pol_Producto_polinomios import multPol

from src.TAD.Polinomio import Polinomio, consPol, polCero, polinomioAleatorio

setrecursionlimit(10**6)

A = TypeVar('A', int, float, complex)

# 1ª solución

# ===========

def potencia(p: Polinomio[A], n: int) -> Polinomio[A]:

if n == 0:

return consPol(0, 1, polCero())

return multPol(p, potencia(p, n - 1))

# 2ª solución

# ===========

def potencia2(p: Polinomio[A], n: int) -> Polinomio[A]:

if n == 0:

return consPol(0, 1, polCero())

if n % 2 == 0:

return potencia2(multPol(p, p), n // 2)

return multPol(p, potencia2(multPol(p, p), (n - 1) // 2))

# 3ª solución

# ===========

def potencia3(p: Polinomio[A], n: int) -> Polinomio[A]:

r: Polinomio[A] = consPol(0, 1, polCero())

for _ in range(0, n):

r = multPol(p, r)

return r

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(p=polinomioAleatorio(),

n=st.integers(min_value=1, max_value=10))

def test_potencia(p: Polinomio[int], n: int) -> None:

r = potencia(p, n)

assert potencia2(p, n) == r

assert potencia3(p, n) == r

# La comprobación es

# src> poetry run pytest -q Pol_Potencia_de_un_polinomio.py

# 1 passed in 0.89s

# Comparación de eficiencia

# =========================

def tiempo(e: str) -> None:

"""Tiempo (en segundos) de evaluar la expresión e."""

t = Timer(e, "", default_timer, globals()).timeit(1)

print(f"{t:0.2f} segundos")

# La comparación es

# >>> from src.TAD.Polinomio import grado

# >>> ejPol = consPol(1, 2, consPol(0, 3, polCero()))

# >>> tiempo('grado(potencia(ejPol, 1000))')

# 8.58 segundos

# >>> tiempo('grado(potencia2(ejPol, 1000))')

# 8.75 segundos

TAD de los polinomios: Resta de polinomios

PorJosé A. Alonso 3-mayo-202326-abril-2023

Usando el tipo abstracto de los polinomios, definir la función

   restaPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a

1	restaPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a

tal que restaPol p q es el polinomio obtenido restándole a p el q. Por ejemplo,

   λ> ejPol1 = consPol 5 1 (consPol 4 5 (consPol 2 5 (consPol 0 9 polCero)))
   λ> ejPol2 = consPol 4 3 (consPol 2 5 (consPol 0 3 polCero))
   λ> ejPol1
   x^5 + 5*x^4 + 5*x^2 + 9
   λ> ejPol2
   3*x^4 + 5*x^2 + 3
   λ> restaPol ejPol1 ejPol2
   x^5 + 2*x^4 + 6

λ> ejPol1 = consPol 5 1 (consPol 4 5 (consPol 2 5 (consPol 0 9 polCero)))

λ> ejPol2 = consPol 4 3 (consPol 2 5 (consPol 0 3 polCero))

λ> ejPol1

x^5 + 5*x^4 + 5*x^2 + 9

λ> ejPol2

3*x^4 + 5*x^2 + 3

λ> restaPol ejPol1 ejPol2

x^5 + 2*x^4 + 6

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, polCero, consPol)
import Pol_Suma_de_polinomios (sumaPol)
import Pol_Crea_termino (creaTermino)
import Pol_Producto_polinomios (multPorTerm)

restaPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a
restaPol p q  =
  sumaPol p (multPorTerm (creaTermino 0 (-1)) q)

import TAD.Polinomio (Polinomio, polCero, consPol)

import Pol_Suma_de_polinomios (sumaPol)

import Pol_Crea_termino (creaTermino)

import Pol_Producto_polinomios (multPorTerm)

restaPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a

restaPol p q =

sumaPol p (multPorTerm (creaTermino 0 (-1)) q)

Soluciones en Python

from typing import TypeVar

from src.Pol_Crea_termino import creaTermino
from src.Pol_Producto_polinomios import multPorTerm
from src.Pol_Suma_de_polinomios import sumaPol
from src.TAD.Polinomio import Polinomio, consPol, polCero

A = TypeVar('A', int, float, complex)

def restaPol(p: Polinomio[A], q: Polinomio[A]) -> Polinomio[A]:
    return sumaPol(p, multPorTerm(creaTermino(0, -1), q))

from typing import TypeVar

from src.Pol_Crea_termino import creaTermino

from src.Pol_Producto_polinomios import multPorTerm

from src.Pol_Suma_de_polinomios import sumaPol

from src.TAD.Polinomio import Polinomio, consPol, polCero

A = TypeVar('A', int, float, complex)

def restaPol(p: Polinomio[A], q: Polinomio[A]) -> Polinomio[A]:

return sumaPol(p, multPorTerm(creaTermino(0, -1), q))

TAD de los polinomios: Derivada de un polinomio

PorJosé A. Alonso 2-mayo-202326-abril-2023

Usando el tipo abstracto de los polinomios, definir la función

   derivada :: (Eq a, Num a) => Polinomio a -> Polinomio a

1	derivada :: (Eq a, Num a) => Polinomio a -> Polinomio a

tal que derivada p es la derivada del polinomio p. Por ejemplo,

   λ> ejPol = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))
   λ> ejPol
   x^5 + 5*x^2 + 4*x
   λ> derivada ejPol
   5*x^4 + 10*x + 4

λ> ejPol = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))

λ> ejPol

x^5 + 5*x^2 + 4*x

λ> derivada ejPol

5*x^4 + 10*x + 4

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, polCero, consPol, grado, coefLider,
                      restoPol)
import Pol_Suma_de_polinomios (sumaPol)
import Test.QuickCheck

derivada :: (Eq a, Num a) => Polinomio a -> Polinomio a
derivada p
  | n == 0     = polCero
  | otherwise  = consPol (n-1) (b * fromIntegral n) (derivada r)
  where n = grado p
        b = coefLider p
        r = restoPol p

-- Propiedad. La derivada de la suma es la suma de las derivadas.
prop_derivada :: Polinomio Int -> Polinomio Int -> Bool
prop_derivada p q =
  derivada (sumaPol p q) == sumaPol (derivada p) (derivada q)

-- Comprobación
--    λ> quickCheck prop_derivada
--    OK, passed 100 tests.

import TAD.Polinomio (Polinomio, polCero, consPol, grado, coefLider,

restoPol)

import Pol_Suma_de_polinomios (sumaPol)

import Test.QuickCheck

derivada :: (Eq a, Num a) => Polinomio a -> Polinomio a

derivada p

| n == 0 = polCero

| otherwise = consPol (n-1) (b * fromIntegral n) (derivada r)

where n = grado p

b = coefLider p

r = restoPol p

-- Propiedad. La derivada de la suma es la suma de las derivadas.

prop_derivada :: Polinomio Int -> Polinomio Int -> Bool

prop_derivada p q =

derivada (sumaPol p q) == sumaPol (derivada p) (derivada q)

-- Comprobación

-- λ> quickCheck prop_derivada

-- OK, passed 100 tests.

Soluciones en Python

from typing import TypeVar

from hypothesis import given

from src.Pol_Suma_de_polinomios import sumaPol
from src.TAD.Polinomio import (Polinomio, coefLider, consPol, grado, polCero,
                               polinomioAleatorio, restoPol)

A = TypeVar('A', int, float, complex)


def derivada(p: Polinomio[A]) -> Polinomio[A]:
    n = grado(p)
    if n == 0:
        return polCero()
    b = coefLider(p)
    r = restoPol(p)
    return consPol(n - 1, b * n, derivada(r))

# Propiedad. La derivada de la suma es la suma de las derivadas.
@given(p=polinomioAleatorio(), q=polinomioAleatorio())
def test_derivada(p: Polinomio[int], q: Polinomio[int]) -> None:
    assert derivada(sumaPol(p, q)) == sumaPol(derivada(p), derivada(q))

# La comprobación es
#    > poetry run pytest -q Pol_Derivada_de_un_polinomio.py
#    1 passed in 0.46s

from typing import TypeVar

from hypothesis import given

from src.Pol_Suma_de_polinomios import sumaPol

from src.TAD.Polinomio import (Polinomio, coefLider, consPol, grado, polCero,

polinomioAleatorio, restoPol)

A = TypeVar('A', int, float, complex)

def derivada(p: Polinomio[A]) -> Polinomio[A]:

n = grado(p)

if n == 0:

return polCero()

b = coefLider(p)

r = restoPol(p)

return consPol(n - 1, b * n, derivada(r))

# Propiedad. La derivada de la suma es la suma de las derivadas.

@given(p=polinomioAleatorio(), q=polinomioAleatorio())

def test_derivada(p: Polinomio[int], q: Polinomio[int]) -> None:

assert derivada(sumaPol(p, q)) == sumaPol(derivada(p), derivada(q))

# La comprobación es

# > poetry run pytest -q Pol_Derivada_de_un_polinomio.py

# 1 passed in 0.46s

TAD de los polinomios: Comprobación de raíces de polinomios

PorJosé A. Alonso 1-mayo-202324-abril-2023

Usando el tipo abstracto de los polinomios,
definir la función

   esRaiz :: (Num a, Eq a) => a -> Polinomio a -> Bool

1	esRaiz :: (Num a, Eq a) => a -> Polinomio a -> Bool

tal que esRaiz c p se verifica si c es una raiz del polinomio p. Por ejemplo,

   λ> ejPol = consPol 4 6 (consPol 1 2 polCero)
   λ> ejPol
   6*x^4 + 2*x
   λ> esRaiz 0 ejPol
   True
   λ> esRaiz 1 ejPol
   False

λ> ejPol = consPol 4 6 (consPol 1 2 polCero)

λ> ejPol

6*x^4 + 2*x

λ> esRaiz 0 ejPol

True

λ> esRaiz 1 ejPol

False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, polCero, consPol)
import Pol_Valor_de_un_polinomio_en_un_punto (valor)

esRaiz :: (Num a, Eq a) => a -> Polinomio a -> Bool
esRaiz c p = valor p c == 0

import TAD.Polinomio (Polinomio, polCero, consPol)

import Pol_Valor_de_un_polinomio_en_un_punto (valor)

esRaiz :: (Num a, Eq a) => a -> Polinomio a -> Bool

esRaiz c p = valor p c == 0

Soluciones en Python

from typing import TypeVar

from src.Pol_Valor_de_un_polinomio_en_un_punto import valor
from src.TAD.Polinomio import Polinomio, consPol, polCero

A = TypeVar('A', int, float, complex)

def esRaiz(c: A, p: Polinomio[A]) -> bool:
    return valor(p, c) == 0

from typing import TypeVar

from src.Pol_Valor_de_un_polinomio_en_un_punto import valor

from src.TAD.Polinomio import Polinomio, consPol, polCero

A = TypeVar('A', int, float, complex)

def esRaiz(c: A, p: Polinomio[A]) -> bool:

return valor(p, c) == 0

TAD de los polinomios: Valor de un polinomio en un punto

PorJosé A. Alonso 28-abril-202323-abril-2023

Usando el tipo abstracto de los polinomios, definir la función

   valor :: (Num a, Eq a) => Polinomio a -> a -> a

1	valor :: (Num a, Eq a) => Polinomio a -> a -> a

tal que valor p c es el valor del polinomio p al sustituir su variable por c. Por ejemplo,

   λ> ejPol = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))
   λ> ejPol
   3*x^4 + -5*x^2 + 3
   λ> valor ejPol 0
   3
   λ> valor ejPol 1
   1
   λ> valor ejPol (-2)
   31

λ> ejPol = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))

λ> ejPol

3*x^4 + -5*x^2 + 3

λ> valor ejPol 0

λ> valor ejPol 1

λ> valor ejPol (-2)

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, polCero, esPolCero, consPol, grado,
                      coefLider, restoPol)

valor :: (Num a, Eq a) => Polinomio a -> a -> a
valor p c
  | esPolCero p = 0
  | otherwise   =  b*c^n + valor r c
  where n = grado p
        b = coefLider p
        r = restoPol p

import TAD.Polinomio (Polinomio, polCero, esPolCero, consPol, grado,

coefLider, restoPol)

valor :: (Num a, Eq a) => Polinomio a -> a -> a

valor p c

| esPolCero p = 0

| otherwise = b*c^n + valor r c

where n = grado p

b = coefLider p

r = restoPol p

Soluciones en Python

from typing import TypeVar

from src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,
                               polCero, restoPol)

A = TypeVar('A', int, float, complex)

def valor(p: Polinomio[A], c: A) -> A:
    if esPolCero(p):
        return 0
    n = grado(p)
    b = coefLider(p)
    r = restoPol(p)
    return b*c**n + valor(r, c)

from typing import TypeVar

from src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,

polCero, restoPol)

A = TypeVar('A', int, float, complex)

def valor(p: Polinomio[A], c: A) -> A:

if esPolCero(p):

return 0

n = grado(p)

b = coefLider(p)

r = restoPol(p)

return b*c**n + valor(r, c)

TAD de los polinomios: Producto de polinomios

PorJosé A. Alonso 27-abril-202320-abril-2023

Usando el tipo abstracto de los polinomios, definir la función

   multPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a

1	multPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a

tal que multPol p q es el producto de los polinomios p y q. Por ejemplo,

   λ> ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))
   λ> ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))
   λ> ejPol1
   3*x^4 + -5*x^2 + 3
   λ> ejPol2
   x^5 + 5*x^2 + 4*x
   λ> multPol ejPol1 ejPol2
   3*x^9 + -5*x^7 + 15*x^6 + 15*x^5 + -25*x^4 + -20*x^3 + 15*x^2 + 12*x

λ> ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))

λ> ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))

λ> ejPol1

3*x^4 + -5*x^2 + 3

λ> ejPol2

x^5 + 5*x^2 + 4*x

λ> multPol ejPol1 ejPol2

3*x^9 + -5*x^7 + 15*x^6 + 15*x^5 + -25*x^4 + -20*x^3 + 15*x^2 + 12*x

Comprobar con QuickCheck las siguientes propiedades

El producto de polinomios es conmutativo.
El producto es distributivo respecto de la suma.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, polCero, esPolCero, consPol, grado,
                      coefLider, restoPol)
import Pol_Termino_lider (termLider)
import Pol_Suma_de_polinomios (sumaPol)
import Test.QuickCheck

multPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a
multPol p q
  | esPolCero p = polCero
  | otherwise    = sumaPol (multPorTerm (termLider p) q)
                           (multPol (restoPol p) q)

-- (multPorTerm t p) es el producto del término t por el polinomio
-- p. Por ejemplo,
--    ejTerm                     ==  4*x
--    ejPol2                     ==  x^5 + 5*x^2 + 4*x
--    multPorTerm ejTerm ejPol2  ==  4*x^6 + 20*x^3 + 16*x^2
multPorTerm :: (Num t, Eq t) => Polinomio t -> Polinomio t -> Polinomio t
multPorTerm term pol
  | esPolCero pol = polCero
  | otherwise     = consPol (n+m) (a*b) (multPorTerm term r)
  where n = grado term
        a = coefLider term
        m = grado pol
        b = coefLider pol
        r = restoPol pol

-- El producto de polinomios es conmutativo.
prop_conmutativaProducto :: Polinomio Int -> Polinomio Int -> Bool
prop_conmutativaProducto p q =
  multPol p q == multPol q p

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

-- El producto es distributivo respecto de la suma.
prop_distributivaProductoSuma :: Polinomio Int -> Polinomio Int
                                 -> Polinomio Int -> Bool
prop_distributivaProductoSuma p q r =
  multPol p (sumaPol q r) == sumaPol (multPol p q) (multPol p r)

-- Comprobación:
--    λ> quickCheck prop_distributivaProductoSuma
--    OK, passed 100 tests.

import TAD.Polinomio (Polinomio, polCero, esPolCero, consPol, grado,

coefLider, restoPol)

import Pol_Termino_lider (termLider)

import Pol_Suma_de_polinomios (sumaPol)

import Test.QuickCheck

multPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a

multPol p q

| esPolCero p = polCero

| otherwise = sumaPol (multPorTerm (termLider p) q)

(multPol (restoPol p) q)

-- (multPorTerm t p) es el producto del término t por el polinomio

-- p. Por ejemplo,

-- ejTerm == 4*x

-- ejPol2 == x^5 + 5*x^2 + 4*x

-- multPorTerm ejTerm ejPol2 == 4*x^6 + 20*x^3 + 16*x^2

multPorTerm :: (Num t, Eq t) => Polinomio t -> Polinomio t -> Polinomio t

multPorTerm term pol

| esPolCero pol = polCero

| otherwise = consPol (n+m) (a*b) (multPorTerm term r)

where n = grado term

a = coefLider term

m = grado pol

b = coefLider pol

r = restoPol pol

-- El producto de polinomios es conmutativo.

prop_conmutativaProducto :: Polinomio Int -> Polinomio Int -> Bool

prop_conmutativaProducto p q =

multPol p q == multPol q p

-- La comprobación es

-- λ> quickCheck prop_conmutativaProducto

-- OK, passed 100 tests.

-- El producto es distributivo respecto de la suma.

prop_distributivaProductoSuma :: Polinomio Int -> Polinomio Int

-> Polinomio Int -> Bool

prop_distributivaProductoSuma p q r =

multPol p (sumaPol q r) == sumaPol (multPol p q) (multPol p r)

-- Comprobación:

-- λ> quickCheck prop_distributivaProductoSuma

-- OK, passed 100 tests.

Soluciones en Python

from typing import TypeVar

from hypothesis import given

from src.Pol_Suma_de_polinomios import sumaPol
from src.Pol_Termino_lider import termLider
from src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,
                               polCero, polinomioAleatorio, restoPol)

A = TypeVar('A', int, float, complex)

# multPorTerm(t, p) es el producto del término t por el polinomio
# p. Por ejemplo,
#    ejTerm                     ==  4*x
#    ejPol2                     ==  x^5 + 5*x^2 + 4*x
#    multPorTerm ejTerm ejPol2  ==  4*x^6 + 20*x^3 + 16*x^2
def multPorTerm(term: Polinomio[A], pol: Polinomio[A]) -> Polinomio[A]:
    n = grado(term)
    a = coefLider(term)
    m = grado(pol)
    b = coefLider(pol)
    r = restoPol(pol)
    if esPolCero(pol):
        return polCero()
    return consPol(n + m, a * b, multPorTerm(term, r))

def multPol(p: Polinomio[A], q: Polinomio[A]) -> Polinomio[A]:
    if esPolCero(p):
        return polCero()
    return sumaPol(multPorTerm(termLider(p), q),
                   multPol(restoPol(p), q))

# El producto de polinomios es conmutativo.
@given(p=polinomioAleatorio(),
       q=polinomioAleatorio())
def test_conmutativaProducto(p: Polinomio[int], q: Polinomio[int]) -> None:
    assert multPol(p, q) == multPol(q, p)

# El producto es distributivo respecto de la suma.
@given(p=polinomioAleatorio(),
       q=polinomioAleatorio(),
       r=polinomioAleatorio())
def test_distributivaProductoSuma(p: Polinomio[int],
                                  q: Polinomio[int],
                                  r: Polinomio[int]) -> None:
    assert multPol(p, sumaPol(q, r)) == sumaPol(multPol(p, q), multPol(p, r))

# La comprobación es
#    > poetry run pytest -v Pol_Producto_polinomios.py
#    test_conmutativaProducto PASSED
#    test_distributivaProductoSuma PASSED

from typing import TypeVar

from hypothesis import given

from src.Pol_Suma_de_polinomios import sumaPol

from src.Pol_Termino_lider import termLider

from src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,

polCero, polinomioAleatorio, restoPol)

A = TypeVar('A', int, float, complex)

# multPorTerm(t, p) es el producto del término t por el polinomio

# p. Por ejemplo,

# ejTerm == 4*x

# ejPol2 == x^5 + 5*x^2 + 4*x

# multPorTerm ejTerm ejPol2 == 4*x^6 + 20*x^3 + 16*x^2

def multPorTerm(term: Polinomio[A], pol: Polinomio[A]) -> Polinomio[A]:

n = grado(term)

a = coefLider(term)

m = grado(pol)

b = coefLider(pol)

r = restoPol(pol)

if esPolCero(pol):

return polCero()

return consPol(n + m, a * b, multPorTerm(term, r))

def multPol(p: Polinomio[A], q: Polinomio[A]) -> Polinomio[A]:

if esPolCero(p):

return polCero()

return sumaPol(multPorTerm(termLider(p), q),

multPol(restoPol(p), q))

# El producto de polinomios es conmutativo.

@given(p=polinomioAleatorio(),

q=polinomioAleatorio())

def test_conmutativaProducto(p: Polinomio[int], q: Polinomio[int]) -> None:

assert multPol(p, q) == multPol(q, p)

# El producto es distributivo respecto de la suma.

@given(p=polinomioAleatorio(),

q=polinomioAleatorio(),

r=polinomioAleatorio())

def test_distributivaProductoSuma(p: Polinomio[int],

q: Polinomio[int],

r: Polinomio[int]) -> None:

assert multPol(p, sumaPol(q, r)) == sumaPol(multPol(p, q), multPol(p, r))

# La comprobación es

# > poetry run pytest -v Pol_Producto_polinomios.py

# test_conmutativaProducto PASSED

# test_distributivaProductoSuma PASSED

TAD de los polinomios: Suma de polinomios

PorJosé A. Alonso 26-abril-202319-abril-2023

Usando el tipo abstracto de los polinomios, definir la función

   sumaPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a

1	sumaPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a

tal que (sumaPol p q) es la suma de los polinomios p y q. Por ejemplo,

   λ> ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))
   λ> ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))
   λ> ejPol1
   3*x^4 + -5*x^2 + 3
   λ> ejPol2
   x^5 + 5*x^2 + 4*x
   λ> sumaPol ejPol1 ejPol2
   x^5 + 3*x^4 + 4*x + 3

λ> ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))

λ> ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))

λ> ejPol1

3*x^4 + -5*x^2 + 3

λ> ejPol2

x^5 + 5*x^2 + 4*x

λ> sumaPol ejPol1 ejPol2

x^5 + 3*x^4 + 4*x + 3

Comprobar con QuickCheck las siguientes propiedades:

polCero es el elemento neutro de la suma.
la suma es conmutativa.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, polCero, esPolCero, consPol, grado,
                      coefLider, restoPol)
import Test.QuickCheck

sumaPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a
sumaPol p q
  | esPolCero p = q
  | esPolCero q = p
  | n1 > n2      = consPol n1 a1 (sumaPol r1 q)
  | n1 < n2      = consPol n2 a2 (sumaPol p r2)
  | otherwise    = consPol n1 (a1+a2) (sumaPol r1 r2)
  where (n1, a1, r1) = (grado p, coefLider p, restoPol p)
        (n2, a2, r2) = (grado q, coefLider q, restoPol q)

-- Propiedad. El polinomio cero es el elemento neutro de la suma.
prop_neutroSumaPol :: Polinomio Int -> Bool
prop_neutroSumaPol p =
  sumaPol polCero p == p

-- Comprobación con QuickCheck.
--    λ> quickCheck prop_neutroSumaPol
--    OK, passed 100 tests.

-- Propiedad. La suma es conmutativa.
prop_conmutativaSuma :: Polinomio Int -> Polinomio Int -> Bool
prop_conmutativaSuma p q =
  sumaPol p q == sumaPol q p

-- Comprobación:
--    λ> quickCheck prop_conmutativaSuma
--    OK, passed 100 tests.

import TAD.Polinomio (Polinomio, polCero, esPolCero, consPol, grado,

coefLider, restoPol)

import Test.QuickCheck

sumaPol :: (Num a, Eq a) => Polinomio a -> Polinomio a -> Polinomio a

sumaPol p q

| esPolCero p = q

| esPolCero q = p

| n1 > n2 = consPol n1 a1 (sumaPol r1 q)

| n1 < n2 = consPol n2 a2 (sumaPol p r2)

| otherwise = consPol n1 (a1+a2) (sumaPol r1 r2)

where (n1, a1, r1) = (grado p, coefLider p, restoPol p)

(n2, a2, r2) = (grado q, coefLider q, restoPol q)

-- Propiedad. El polinomio cero es el elemento neutro de la suma.

prop_neutroSumaPol :: Polinomio Int -> Bool

prop_neutroSumaPol p =

sumaPol polCero p == p

-- Comprobación con QuickCheck.

-- λ> quickCheck prop_neutroSumaPol

-- OK, passed 100 tests.

-- Propiedad. La suma es conmutativa.

prop_conmutativaSuma :: Polinomio Int -> Polinomio Int -> Bool

prop_conmutativaSuma p q =

sumaPol p q == sumaPol q p

-- Comprobación:

-- λ> quickCheck prop_conmutativaSuma

-- OK, passed 100 tests.

Soluciones en Python

from typing import TypeVar

from hypothesis import given

from src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,
                               polCero, polinomioAleatorio, restoPol)

A = TypeVar('A', int, float, complex)

# 1ª solución
# ===========

def sumaPol(p: Polinomio[A], q: Polinomio[A]) -> Polinomio[A]:
    if esPolCero(p):
        return q
    if esPolCero(q):
        return p
    n1, a1, r1 = grado(p), coefLider(p), restoPol(p)
    n2, a2, r2 = grado(q), coefLider(q), restoPol(q)
    if n1 > n2:
        return consPol(n1, a1, sumaPol(r1, q))
    if n1 < n2:
        return consPol(n2, a2, sumaPol(p, r2))
    return consPol(n1, a1 + a2, sumaPol(r1, r2))

# 2ª solución
# ===========

def sumaPol2(p: Polinomio[A], q: Polinomio[A]) -> Polinomio[A]:
    if p.esPolCero():
        return q
    if q.esPolCero():
        return p
    n1, a1, r1 = p.grado(), p.coefLider(), p.restoPol()
    n2, a2, r2 = q.grado(), q.coefLider(), q.restoPol()
    if n1 > n2:
        return sumaPol(r1, q).consPol(n1, a1)
    if n1 < n2:
        return sumaPol(p, r2).consPol(n2, a2)
    return sumaPol(r1, r2).consPol(n1, a1 + a2)

# Equivalencia de las definiciones
# ================================

# La propiedad es
@given(p=polinomioAleatorio(), q=polinomioAleatorio())
def test_sumaPol(p: Polinomio[int], q: Polinomio[int]) -> None:
    assert sumaPol(p, q) == sumaPol2(p,q)

# Propiedad. El polinomio cero es el elemento neutro de la suma.
@given(p=polinomioAleatorio())
def test_neutroSumaPol(p: Polinomio[int]) -> None:
    assert sumaPol(polCero(), p) == p
    assert sumaPol(p, polCero()) == p

# -- Propiedad. La suma es conmutativa.
@given(p=polinomioAleatorio(), q=polinomioAleatorio())
def test_conmutativaSuma(p: Polinomio[int], q: Polinomio[int]) -> None:
    assert sumaPol(p, q) == sumaPol(q, p)

# La comprobación es
#    > poetry run pytest -v Pol_Suma_de_polinomios.py
#    test_sumaPol PASSED
#    test_neutroSumaPol PASSED
#    test_conmutativaSuma PASSED

from typing import TypeVar

from hypothesis import given

from src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,

polCero, polinomioAleatorio, restoPol)

A = TypeVar('A', int, float, complex)

# 1ª solución

# ===========

def sumaPol(p: Polinomio[A], q: Polinomio[A]) -> Polinomio[A]:

if esPolCero(p):

return q

if esPolCero(q):

return p

n1, a1, r1 = grado(p), coefLider(p), restoPol(p)

n2, a2, r2 = grado(q), coefLider(q), restoPol(q)

if n1 > n2:

return consPol(n1, a1, sumaPol(r1, q))

if n1 < n2:

return consPol(n2, a2, sumaPol(p, r2))

return consPol(n1, a1 + a2, sumaPol(r1, r2))

# 2ª solución

# ===========

def sumaPol2(p: Polinomio[A], q: Polinomio[A]) -> Polinomio[A]:

if p.esPolCero():

return q

if q.esPolCero():

return p

n1, a1, r1 = p.grado(), p.coefLider(), p.restoPol()

n2, a2, r2 = q.grado(), q.coefLider(), q.restoPol()

if n1 > n2:

return sumaPol(r1, q).consPol(n1, a1)

if n1 < n2:

return sumaPol(p, r2).consPol(n2, a2)

return sumaPol(r1, r2).consPol(n1, a1 + a2)

# Equivalencia de las definiciones

# ================================

# La propiedad es

@given(p=polinomioAleatorio(), q=polinomioAleatorio())

def test_sumaPol(p: Polinomio[int], q: Polinomio[int]) -> None:

assert sumaPol(p, q) == sumaPol2(p,q)

# Propiedad. El polinomio cero es el elemento neutro de la suma.

@given(p=polinomioAleatorio())

def test_neutroSumaPol(p: Polinomio[int]) -> None:

assert sumaPol(polCero(), p) == p

assert sumaPol(p, polCero()) == p

# -- Propiedad. La suma es conmutativa.

@given(p=polinomioAleatorio(), q=polinomioAleatorio())

def test_conmutativaSuma(p: Polinomio[int], q: Polinomio[int]) -> None:

assert sumaPol(p, q) == sumaPol(q, p)

# La comprobación es

# > poetry run pytest -v Pol_Suma_de_polinomios.py

# test_sumaPol PASSED

# test_neutroSumaPol PASSED

# test_conmutativaSuma PASSED

TAD de los polinomios: Término líder de un polinomio

PorJosé A. Alonso 25-abril-202318-abril-2023

Usando el tipo abstracto de los polinomios, definir la función

   termLider :: (Num a, Eq a) => Polinomio a -> Polinomio a

1	termLider :: (Num a, Eq a) => Polinomio a -> Polinomio a

tal que termLider p es el término líder del polinomio p. Por ejemplo,

   λ> ejPol = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))
   λ> ejPol
   x^5 + 5*x^2 + 4*x
   λ> termLider ejPol
   x^5

λ> ejPol = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))

λ> ejPol

x^5 + 5*x^2 + 4*x

λ> termLider ejPol

x^5

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, coefLider, grado, polCero, consPol)
import Pol_Crea_termino (creaTermino)

termLider :: (Num a, Eq a) => Polinomio a -> Polinomio a
termLider p = creaTermino (grado p) (coefLider p)

-- La función creaTermino está definida en el ejercicio
-- "Construcción de términos" que se encuentra en
-- https://bit.ly/3GXteuH

import TAD.Polinomio (Polinomio, coefLider, grado, polCero, consPol)

import Pol_Crea_termino (creaTermino)

termLider :: (Num a, Eq a) => Polinomio a -> Polinomio a

termLider p = creaTermino (grado p) (coefLider p)

-- La función creaTermino está definida en el ejercicio

-- "Construcción de términos" que se encuentra en

-- https://bit.ly/3GXteuH

Soluciones en Python

from typing import TypeVar

from hypothesis import given

from src.Pol_Crea_termino import creaTermino
from src.TAD.Polinomio import (Polinomio, coefLider, consPol, grado, polCero,
                               polinomioAleatorio)

A = TypeVar('A', int, float, complex)

# 1ª solución
# ===========

def termLider(p: Polinomio[A]) -> Polinomio[A]:
    return creaTermino(grado(p), coefLider(p))

# 2ª solución
# ===========

def termLider2(p: Polinomio[A]) -> Polinomio[A]:
    return creaTermino(p.grado(), p.coefLider())

# La función creaTermino está definida en el ejercicio
# "Construcción de términos" que se encuentra en
# https://bit.ly/3GXteuH

# Equivalencia de las definiciones
# ================================

# La propiedad es
@given(p=polinomioAleatorio())
def test_termLider(p: Polinomio[int]) -> None:
    assert termLider(p) == termLider2(p)

# La comprobación es
#    > poetry run pytest -q Pol_Termino_lider.py
#    1 passed in 0.21s

from typing import TypeVar

from hypothesis import given

from src.Pol_Crea_termino import creaTermino

from src.TAD.Polinomio import (Polinomio, coefLider, consPol, grado, polCero,

polinomioAleatorio)

A = TypeVar('A', int, float, complex)

# 1ª solución

# ===========

def termLider(p: Polinomio[A]) -> Polinomio[A]:

return creaTermino(grado(p), coefLider(p))

# 2ª solución

# ===========

def termLider2(p: Polinomio[A]) -> Polinomio[A]:

return creaTermino(p.grado(), p.coefLider())

# La función creaTermino está definida en el ejercicio

# "Construcción de términos" que se encuentra en

# https://bit.ly/3GXteuH

# Equivalencia de las definiciones

# ================================

# La propiedad es

@given(p=polinomioAleatorio())

def test_termLider(p: Polinomio[int]) -> None:

assert termLider(p) == termLider2(p)

# La comprobación es

# > poetry run pytest -q Pol_Termino_lider.py

# 1 passed in 0.21s

TAD de los polinomios: Construcción de términos

PorJosé A. Alonso 24-abril-202318-abril-2023

Usando el tipo abstracto de los polinomios, definir la función

   creaTermino :: (Num a, Eq a) => Int -> a -> Polinomio a

1	creaTermino :: (Num a, Eq a) => Int -> a -> Polinomio a

tal que (creaTermino n a) es el término a*x^n. Por ejemplo,

   creaTermino 2 5  ==  5*x^2

1	creaTermino 2 5 == 5*x^2

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, polCero, consPol)

creaTermino :: (Num a, Eq a) => Int -> a -> Polinomio a
creaTermino n a = consPol n a polCero

import TAD.Polinomio (Polinomio, polCero, consPol)

creaTermino :: (Num a, Eq a) => Int -> a -> Polinomio a

creaTermino n a = consPol n a polCero

Soluciones en Python

from typing import TypeVar

from hypothesis import given
from hypothesis import strategies as st

from src.TAD.Polinomio import (Polinomio, consPol, polCero)

A = TypeVar('A', int, float, complex)

# 1ª solución
# ===========

def creaTermino(n: int, a: A) -> Polinomio[A]:
    return consPol(n, a, polCero())

# 2ª solución
# ===========

def creaTermino2(n: int, a: A) -> Polinomio[A]:
    r: Polinomio[A] = polCero()
    return r.consPol(n, a)

# Equivalencia de las definiciones
# ================================

# La propiedad es
@given(st.integers(min_value=0, max_value=9),
       st.integers(min_value=-9, max_value=9))
def test_creaTermino(n: int, a: int) -> None:
    assert creaTermino(n, a) == creaTermino2(n, a)

# La comprobación es
#    > poetry run pytest -q Pol_Crea_termino.py
#    1 passed in 0.21s

from typing import TypeVar

from hypothesis import given

from hypothesis import strategies as st

from src.TAD.Polinomio import (Polinomio, consPol, polCero)

A = TypeVar('A', int, float, complex)

# 1ª solución

# ===========

def creaTermino(n: int, a: A) -> Polinomio[A]:

return consPol(n, a, polCero())

# 2ª solución

# ===========

def creaTermino2(n: int, a: A) -> Polinomio[A]:

r: Polinomio[A] = polCero()

return r.consPol(n, a)

# Equivalencia de las definiciones

# ================================

# La propiedad es

@given(st.integers(min_value=0, max_value=9),

st.integers(min_value=-9, max_value=9))

def test_creaTermino(n: int, a: int) -> None:

assert creaTermino(n, a) == creaTermino2(n, a)

# La comprobación es

# > poetry run pytest -q Pol_Crea_termino.py

# 1 passed in 0.21s

TAD de los polinomios: Transformaciones entre polinomios y listas densas

PorJosé A. Alonso 21-abril-202318-abril-2023

Utilizando el tipo abstracto de datos de los polinomios definir las funciones

   densaApolinomio :: (Num a, Eq a) => [a] -> Polinomio a
   polinomioAdensa :: (Num a, Eq a) => Polinomio a -> [a]

1 2	densaApolinomio :: (Num a, Eq a) => [a] -> Polinomio a polinomioAdensa :: (Num a, Eq a) => Polinomio a -> [a]

tales que

densaApolinomio xs es el polinomio cuya representación densa es xs. Por ejemplo,

     λ> densaApolinomio [9,0,0,5,0,4,7]
     9*x^6 + 5*x^3 + 4*x + 7

1 2	λ> densaApolinomio [9,0,0,5,0,4,7] 9x^6 + 5x^3 + 4*x + 7

polinomioAdensa p es la representación densa del polinomio p. Por ejemplo,

     λ> ejPol = consPol 6 9 (consPol 3 5 (consPol 1 4 (consPol 0 7 polCero)))
     λ> ejPol
     9*x^6 + 5*x^3 + 4*x + 7
     λ> polinomioAdensa ejPol
     [9,0,0,5,0,4,7]

λ> ejPol = consPol 6 9 (consPol 3 5 (consPol 1 4 (consPol 0 7 polCero)))

λ> ejPol

9*x^6 + 5*x^3 + 4*x + 7

λ> polinomioAdensa ejPol

[9,0,0,5,0,4,7]

Comprobar con QuickCheck que ambas funciones son inversas.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, polCero, esPolCero, consPol, grado,
                      coefLider, restoPol)
import Polinomios_Transformaciones_dispersa_y_densa (densaAdispersa,
                                                     dispersaAdensa)
import Polinomios_Transformaciones_polinomios_dispersas (dispersaApolinomio,
                                                         polinomioAdispersa)
import Polinomios_Coeficiente (coeficiente)
import Data.List (sort, nub)
import Test.QuickCheck

-- 1ª definición de densaApolinomio
-- ================================

densaApolinomio :: (Num a, Eq a) => [a] -> Polinomio a
densaApolinomio []     = polCero
densaApolinomio (x:xs) = consPol (length xs) x (densaApolinomio xs)

-- 2ª definición de densaApolinomio
-- ================================

densaApolinomio2 :: (Num a, Eq a) => [a] -> Polinomio a
densaApolinomio2 = dispersaApolinomio . densaAdispersa

-- La función densaAdispersa está definida en el ejercicio
-- "Transformaciones entre las representaciones dispersa y densa" que se
-- encuentra en https://bit.ly/3GTyIqe

-- La función dispersaApolinomio se encuentra en el ejercicio
-- "Transformaciones entre polinomios y listas dispersas" que se
-- encuentra en https://bit.ly/41GgQaB

-- Comprobación de equivalencia de densaApolinomio
-- ===============================================

-- La propiedad es
prop_densaApolinomio :: [Int] -> Bool
prop_densaApolinomio xs =
  densaApolinomio xs == densaApolinomio2 xs

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

-- 1ª definición de polinomioAdensa
-- ================================

polinomioAdensa :: (Num a, Eq a) => Polinomio a -> [a]
polinomioAdensa p
  | esPolCero p = []
  | otherwise   = [coeficiente k p | k <- [n,n-1..0]]
  where n = grado p

-- La función coeficiente está definida en el ejercicio
-- "Coeficiente del término de grado k" que se encuentra en
-- https://bit.ly/413l3oQ

-- 2ª definición de polinomioAdensa
-- ================================

polinomioAdensa2 :: (Num a, Eq a) => Polinomio a -> [a]
polinomioAdensa2 = dispersaAdensa . polinomioAdispersa

-- La función dispersaAdensa está definida en el ejercicio
-- "Transformaciones entre las representaciones dispersa y densa" que se
-- encuentra en https://bit.ly/3GTyIqe

-- La función polinomioAdispersa se encuentra en el ejercicio
-- "Transformaciones entre polinomios y listas dispersas" que se
-- encuentra en https://bit.ly/41GgQaB

-- Comprobación de equivalencia de polinomioAdensa
-- ===============================================

-- La propiedad es
prop_polinomioAdensa :: Polinomio Int -> Bool
prop_polinomioAdensa p =
  polinomioAdensa p == polinomioAdensa2 p

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

-- Propiedades de inversa
-- ======================

-- La primera propiedad es
prop_polinomioAdensa_densaApolinomio :: [Int] -> Bool
prop_polinomioAdensa_densaApolinomio xs =
  polinomioAdensa (densaApolinomio xs') == xs'
  where xs' = dropWhile (== 0) xs

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

-- La segunda propiedad es
prop_densaApolinomio_polinomioAdensa :: Polinomio Int -> Bool
prop_densaApolinomio_polinomioAdensa p =
   densaApolinomio (polinomioAdensa p) == p

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

100

101

102

103

import TAD.Polinomio (Polinomio, polCero, esPolCero, consPol, grado,

coefLider, restoPol)

import Polinomios_Transformaciones_dispersa_y_densa (densaAdispersa,

dispersaAdensa)

import Polinomios_Transformaciones_polinomios_dispersas (dispersaApolinomio,

polinomioAdispersa)

import Polinomios_Coeficiente (coeficiente)

import Data.List (sort, nub)

import Test.QuickCheck

-- 1ª definición de densaApolinomio

-- ================================

densaApolinomio :: (Num a, Eq a) => [a] -> Polinomio a

densaApolinomio [] = polCero

densaApolinomio (x:xs) = consPol (length xs) x (densaApolinomio xs)

-- 2ª definición de densaApolinomio

-- ================================

densaApolinomio2 :: (Num a, Eq a) => [a] -> Polinomio a

densaApolinomio2 = dispersaApolinomio . densaAdispersa

-- La función densaAdispersa está definida en el ejercicio

-- "Transformaciones entre las representaciones dispersa y densa" que se

-- encuentra en https://bit.ly/3GTyIqe

-- La función dispersaApolinomio se encuentra en el ejercicio

-- "Transformaciones entre polinomios y listas dispersas" que se

-- encuentra en https://bit.ly/41GgQaB

-- Comprobación de equivalencia de densaApolinomio

-- ===============================================

-- La propiedad es

prop_densaApolinomio :: [Int] -> Bool

prop_densaApolinomio xs =

densaApolinomio xs == densaApolinomio2 xs

-- La comprobación es

-- λ> quickCheck prop_densaApolinomio

-- +++ OK, passed 100 tests.

-- 1ª definición de polinomioAdensa

-- ================================

polinomioAdensa :: (Num a, Eq a) => Polinomio a -> [a]

polinomioAdensa p

| esPolCero p = []

| otherwise = [coeficiente k p | k <- [n,n-1..0]]

where n = grado p

-- La función coeficiente está definida en el ejercicio

-- "Coeficiente del término de grado k" que se encuentra en

-- https://bit.ly/413l3oQ

-- 2ª definición de polinomioAdensa

-- ================================

polinomioAdensa2 :: (Num a, Eq a) => Polinomio a -> [a]

polinomioAdensa2 = dispersaAdensa . polinomioAdispersa

-- La función dispersaAdensa está definida en el ejercicio

-- "Transformaciones entre las representaciones dispersa y densa" que se

-- encuentra en https://bit.ly/3GTyIqe

-- La función polinomioAdispersa se encuentra en el ejercicio

-- "Transformaciones entre polinomios y listas dispersas" que se

-- encuentra en https://bit.ly/41GgQaB

-- Comprobación de equivalencia de polinomioAdensa

-- ===============================================

-- La propiedad es

prop_polinomioAdensa :: Polinomio Int -> Bool

prop_polinomioAdensa p =

polinomioAdensa p == polinomioAdensa2 p

-- La comprobación es

-- λ> quickCheck prop_polinomioAdensa

-- +++ OK, passed 100 tests.

-- Propiedades de inversa

-- ======================

-- La primera propiedad es

prop_polinomioAdensa_densaApolinomio :: [Int] -> Bool

prop_polinomioAdensa_densaApolinomio xs =

polinomioAdensa (densaApolinomio xs') == xs'

where xs' = dropWhile (== 0) xs

-- La comprobación es

-- λ> quickCheck prop_polinomioAdensa_densaApolinomio

-- +++ OK, passed 100 tests.

-- La segunda propiedad es

prop_densaApolinomio_polinomioAdensa :: Polinomio Int -> Bool

prop_densaApolinomio_polinomioAdensa p =

densaApolinomio (polinomioAdensa p) == p

-- La comprobación es

-- λ> quickCheck prop_densaApolinomio_polinomioAdensa

-- +++ OK, passed 100 tests.

Soluciones en Python

from typing import TypeVar

from hypothesis import given

from src.Polinomios_Coeficiente import coeficiente
from src.Polinomios_Transformaciones_dispersa_y_densa import (densaAdispersa,
                                                              densaAleatoria,
                                                              dispersaAdensa)
from src.Polinomios_Transformaciones_polinomios_dispersas import (
    dispersaApolinomio, polinomioAdispersa)
from src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,
                               polCero, polinomioAleatorio, restoPol)

A = TypeVar('A', int, float, complex)

# 1ª definición de densaApolinomio
# ================================

def densaApolinomio(xs: list[A]) -> Polinomio[A]:
    if not xs:
        return polCero()
    return consPol(len(xs[1:]), xs[0], densaApolinomio(xs[1:]))

# 2ª definición de densaApolinomio
# ================================

def densaApolinomio2(xs: list[A]) -> Polinomio[A]:
    return dispersaApolinomio(densaAdispersa(xs))

# La función densaAdispersa está definida en el ejercicio
# "Transformaciones entre las representaciones dispersa y densa" que se
# encuentra en https://bit.ly/3GTyIqe

# La función dispersaApolinomio se encuentra en el ejercicio
# "Transformaciones entre polinomios y listas dispersas" que se
# encuentra en https://bit.ly/41GgQaB

# Comprobación de equivalencia de densaApolinomio
# ===============================================

# La propiedad es
@given(xs=densaAleatoria())
def test_densaApolinomio(xs: list[int]) -> None:
    assert densaApolinomio(xs) == densaApolinomio2(xs)

# La función densaAleatoria está definida en el ejercicio
# "Transformaciones entre las representaciones dispersa y densa" que se
# encuentra en https://bit.ly/3GTyIqe

# 1ª definición de polinomioAdensa
# ================================

def polinomioAdensa(p: Polinomio[A]) -> list[A]:
    if esPolCero(p):
        return []
    n = grado(p)
    return [coeficiente(k, p) for k in range(n, -1, -1)]

# La función coeficiente está definida en el ejercicio
# "Coeficiente del término de grado k" que se encuentra en
# https://bit.ly/413l3oQ

# 2ª definición de polinomioAdensa
# ================================

def polinomioAdensa2(p: Polinomio[A]) -> list[A]:
    return dispersaAdensa(polinomioAdispersa(p))

# La función dispersaAdensa está definida en el ejercicio
# "Transformaciones entre las representaciones dispersa y densa" que se
# encuentra en https://bit.ly/3GTyIqe

# La función polinomioAdispersa se encuentra en el ejercicio
# "Transformaciones entre polinomios y listas dispersas" que se
# encuentra en https://bit.ly/41GgQaB

# Comprobación de equivalencia de polinomioAdensa
# ===============================================

# La propiedad es
@given(p=polinomioAleatorio())
def test_polinomioAdensa(p: Polinomio[int]) -> None:
    assert polinomioAdensa(p) == polinomioAdensa2(p)

# Propiedades de inversa
# ======================

# La primera propiedad es
@given(xs=densaAleatoria())
def test_polinomioAdensa_densaApolinomio(xs: list[int]) -> None:
    assert polinomioAdensa(densaApolinomio(xs)) == xs

# La segunda propiedad es
@given(p=polinomioAleatorio())
def test_densaApolinomio_polinomioAdensa(p: Polinomio[int]) -> None:
    assert densaApolinomio(polinomioAdensa(p)) == p

# La comprobación es
#    > poetry run pytest -v Polinomios_Transformaciones_polinomios_densas.py
#    test_densaApolinomio PASSED
#    test_polinomioAdensa PASSED
#    test_polinomioAdensa_densaApolinomio PASSED
#    test_densaApolinomio_polinomioAdensa PASSED

100

101

102

103

from typing import TypeVar

from hypothesis import given

from src.Polinomios_Coeficiente import coeficiente

from src.Polinomios_Transformaciones_dispersa_y_densa import (densaAdispersa,

densaAleatoria,

dispersaAdensa)

from src.Polinomios_Transformaciones_polinomios_dispersas import (

dispersaApolinomio, polinomioAdispersa)

from src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,

polCero, polinomioAleatorio, restoPol)

A = TypeVar('A', int, float, complex)

# 1ª definición de densaApolinomio

# ================================

def densaApolinomio(xs: list[A]) -> Polinomio[A]:

if not xs:

return polCero()

return consPol(len(xs[1:]), xs[0], densaApolinomio(xs[1:]))

# 2ª definición de densaApolinomio

# ================================

def densaApolinomio2(xs: list[A]) -> Polinomio[A]:

return dispersaApolinomio(densaAdispersa(xs))

# La función densaAdispersa está definida en el ejercicio

# "Transformaciones entre las representaciones dispersa y densa" que se

# encuentra en https://bit.ly/3GTyIqe

# La función dispersaApolinomio se encuentra en el ejercicio

# "Transformaciones entre polinomios y listas dispersas" que se

# encuentra en https://bit.ly/41GgQaB

# Comprobación de equivalencia de densaApolinomio

# ===============================================

# La propiedad es

@given(xs=densaAleatoria())

def test_densaApolinomio(xs: list[int]) -> None:

assert densaApolinomio(xs) == densaApolinomio2(xs)

# La función densaAleatoria está definida en el ejercicio

# "Transformaciones entre las representaciones dispersa y densa" que se

# encuentra en https://bit.ly/3GTyIqe

# 1ª definición de polinomioAdensa

# ================================

def polinomioAdensa(p: Polinomio[A]) -> list[A]:

if esPolCero(p):

return []

n = grado(p)

return [coeficiente(k, p) for k in range(n, -1, -1)]

# La función coeficiente está definida en el ejercicio

# "Coeficiente del término de grado k" que se encuentra en

# https://bit.ly/413l3oQ

# 2ª definición de polinomioAdensa

# ================================

def polinomioAdensa2(p: Polinomio[A]) -> list[A]:

return dispersaAdensa(polinomioAdispersa(p))

# La función dispersaAdensa está definida en el ejercicio

# "Transformaciones entre las representaciones dispersa y densa" que se

# encuentra en https://bit.ly/3GTyIqe

# La función polinomioAdispersa se encuentra en el ejercicio

# "Transformaciones entre polinomios y listas dispersas" que se

# encuentra en https://bit.ly/41GgQaB

# Comprobación de equivalencia de polinomioAdensa

# ===============================================

# La propiedad es

@given(p=polinomioAleatorio())

def test_polinomioAdensa(p: Polinomio[int]) -> None:

assert polinomioAdensa(p) == polinomioAdensa2(p)

# Propiedades de inversa

# ======================

# La primera propiedad es

@given(xs=densaAleatoria())

def test_polinomioAdensa_densaApolinomio(xs: list[int]) -> None:

assert polinomioAdensa(densaApolinomio(xs)) == xs

# La segunda propiedad es

@given(p=polinomioAleatorio())

def test_densaApolinomio_polinomioAdensa(p: Polinomio[int]) -> None:

assert densaApolinomio(polinomioAdensa(p)) == p

# La comprobación es

# > poetry run pytest -v Polinomios_Transformaciones_polinomios_densas.py

# test_densaApolinomio PASSED

# test_polinomioAdensa PASSED

# test_polinomioAdensa_densaApolinomio PASSED

# test_densaApolinomio_polinomioAdensa PASSED

TAD de los polinomios: Coeficiente del término de grado k

PorJosé A. Alonso 20-abril-202313-abril-2023

Utilizando el tipo abstracto de datos de los polinomios definir la función

   coeficiente :: (Num a, Eq a) => Int -> Polinomio a -> a

1	coeficiente :: (Num a, Eq a) => Int -> Polinomio a -> a

tal que coeficiente k p es el coeficiente del término de grado k del polinomio p. Por ejemplo,

   λ> ejPol = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))
   λ> ejPol
   x^5 + 5*x^2 + 4*x
   λ> coeficiente 2 ejPol
   5
   λ> coeficiente 3 ejPol
   0

λ> ejPol = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))

λ> ejPol

x^5 + 5*x^2 + 4*x

λ> coeficiente 2 ejPol

λ> coeficiente 3 ejPol

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, coefLider, grado, restoPol,
                      consPol, polCero)

coeficiente :: (Num a, Eq a) => Int -> Polinomio a -> a
coeficiente k p | k == n                 = coefLider p
                | k > grado (restoPol p) = 0
                | otherwise              = coeficiente k (restoPol p)
  where n = grado p

import TAD.Polinomio (Polinomio, coefLider, grado, restoPol,

consPol, polCero)

coeficiente :: (Num a, Eq a) => Int -> Polinomio a -> a

coeficiente k p | k == n = coefLider p

| k > grado (restoPol p) = 0

| otherwise = coeficiente k (restoPol p)

where n = grado p

Soluciones en Python

from typing import TypeVar

from src.TAD.Polinomio import (Polinomio, coefLider, consPol, grado, polCero,
                               restoPol)

A = TypeVar('A', int, float, complex)

def coeficiente(k: int, p: Polinomio[A]) -> A:
    if k == grado(p):
        return coefLider(p)
    if k > grado(restoPol(p)):
        return 0
    return coeficiente(k, restoPol(p))

from typing import TypeVar

from src.TAD.Polinomio import (Polinomio, coefLider, consPol, grado, polCero,

restoPol)

A = TypeVar('A', int, float, complex)

def coeficiente(k: int, p: Polinomio[A]) -> A:

if k == grado(p):

return coefLider(p)

if k > grado(restoPol(p)):

return 0

return coeficiente(k, restoPol(p))

TAD de los polinomios: Transformaciones entre polinomios y listas dispersas

PorJosé A. Alonso 19-abril-202313-abril-2023

Utilizando el tipo abstracto de datos de los polinomios definir las funciones

   dispersaApolinomio :: (Num a, Eq a) => [(Int,a)] -> Polinomio a
   polinomioAdispersa :: (Num a, Eq a) => Polinomio a -> [(Int,a)]

1 2	dispersaApolinomio :: (Num a, Eq a) => [(Int,a)] -> Polinomio a polinomioAdispersa :: (Num a, Eq a) => Polinomio a -> [(Int,a)]

tales que

dispersaApolinomio ps es el polinomiocuya representación dispersa es ps. Por ejemplo,

     λ> dispersaApolinomio [(6,9),(3,5),(1,4),(0,7)]
     9*x^6 + 5*x^3 + 4*x + 7

1 2	λ> dispersaApolinomio [(6,9),(3,5),(1,4),(0,7)] 9x^6 + 5x^3 + 4*x + 7

polinomioAdispersa p es la representación dispersa del polinomio p. Por ejemplo,

     λ> ejPol = consPol 6 9 (consPol 3 5 (consPol 1 4 (consPol 0 7 polCero)))
     λ> ejPol
     9*x^6 + 5*x^3 + 4*x + 7
     λ> polinomioAdispersa ejPol
     [(6,9),(3,5),(1,4),(0,7)]

λ> ejPol = consPol 6 9 (consPol 3 5 (consPol 1 4 (consPol 0 7 polCero)))

λ> ejPol

9*x^6 + 5*x^3 + 4*x + 7

λ> polinomioAdispersa ejPol

[(6,9),(3,5),(1,4),(0,7)]

Comprobar con QuickCheck que ambas funciones son inversas.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Polinomio (Polinomio, polCero, esPolCero, consPol, grado,
                      coefLider, restoPol)
import Data.List (sort, nub)
import Test.QuickCheck

-- 1ª definición de dispersaApolinomio
-- ===================================

dispersaApolinomio :: (Num a, Eq a) => [(Int,a)] -> Polinomio a
dispersaApolinomio []         = polCero
dispersaApolinomio ((n,a):ps) = consPol n a (dispersaApolinomio ps)

-- 2ª definición de dispersaApolinomio
-- ===================================

dispersaApolinomio2 :: (Num a, Eq a) => [(Int,a)] -> Polinomio a
dispersaApolinomio2 = foldr (\(x,y) -> consPol x y) polCero


-- 3ª definición de dispersaApolinomio
-- ===================================

dispersaApolinomio3 :: (Num a, Eq a) => [(Int,a)] -> Polinomio a
dispersaApolinomio3 = foldr (uncurry consPol) polCero

-- Comprobación de equivalencia
-- ============================

-- Tipo de las representaciones dispersas de polinomios.
newtype Dispersa = Dis [(Int,Int)]
  deriving Show

-- dispersaArbitraria es un generador de representaciones dispersas de
-- polinomios. Por ejemplo,
--    λ> sample dispersaArbitraria
--    Dis []
--    Dis []
--    Dis [(3,-2),(2,0),(0,3)]
--    Dis [(6,1),(4,-2),(3,4),(2,-4)]
--    Dis []
--    Dis [(5,-7)]
--    Dis [(12,5),(11,-8),(10,3),(8,-10),(7,-5),(4,12),(3,6),(2,-8),(1,11)]
--    Dis [(7,-2),(2,-8)]
--    Dis [(14,-15)]
--    Dis [(17,5),(16,1),(15,-1),(14,10),(13,5),(12,-15),(9,12),(6,14)]
--    Dis [(19,17),(12,7),(8,-3),(7,13),(5,-2),(4,7)]
dispersaArbitraria :: Gen Dispersa
dispersaArbitraria = do
  (xs, ys) <- arbitrary
  let xs' = nub (reverse (sort (map abs xs)))
      ys' = filter (/= 0) ys
  return (Dis (zip xs' ys'))

-- Dispersa está contenida en Arbitrary
instance Arbitrary Dispersa where
  arbitrary = dispersaArbitraria

-- La propiedad es
prop_dispersaApolinomio :: Dispersa -> Bool
prop_dispersaApolinomio (Dis ps) =
  all (== dispersaApolinomio ps)
      [dispersaApolinomio2 ps,
       dispersaApolinomio3 ps]

-- Definición de polinomioAdispersa
-- ================================

polinomioAdispersa :: (Num a, Eq a) => Polinomio a -> [(Int,a)]
polinomioAdispersa p
  | esPolCero p = []
  | otherwise   = (grado p, coefLider p) : polinomioAdispersa (restoPol p)

-- Propiedad de ser inversas
-- =========================

-- La primera propiedad es
prop_polinomioAdispersa_dispersaApolinomio :: Dispersa -> Bool
prop_polinomioAdispersa_dispersaApolinomio (Dis ps) =
  polinomioAdispersa (dispersaApolinomio ps) == ps

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

-- La segunda propiedad es
prop_dispersaApolinomio_polinomioAdispersa :: Polinomio Int -> Bool
prop_dispersaApolinomio_polinomioAdispersa p =
  dispersaApolinomio (polinomioAdispersa p) == p

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

import TAD.Polinomio (Polinomio, polCero, esPolCero, consPol, grado,

coefLider, restoPol)

import Data.List (sort, nub)

import Test.QuickCheck

-- 1ª definición de dispersaApolinomio

-- ===================================

dispersaApolinomio :: (Num a, Eq a) => [(Int,a)] -> Polinomio a

dispersaApolinomio [] = polCero

dispersaApolinomio ((n,a):ps) = consPol n a (dispersaApolinomio ps)

-- 2ª definición de dispersaApolinomio

-- ===================================

dispersaApolinomio2 :: (Num a, Eq a) => [(Int,a)] -> Polinomio a

dispersaApolinomio2 = foldr (\(x,y) -> consPol x y) polCero

-- 3ª definición de dispersaApolinomio

-- ===================================

dispersaApolinomio3 :: (Num a, Eq a) => [(Int,a)] -> Polinomio a

dispersaApolinomio3 = foldr (uncurry consPol) polCero

-- Comprobación de equivalencia

-- ============================

-- Tipo de las representaciones dispersas de polinomios.

newtype Dispersa = Dis [(Int,Int)]

deriving Show

-- dispersaArbitraria es un generador de representaciones dispersas de

-- polinomios. Por ejemplo,

-- λ> sample dispersaArbitraria

-- Dis []

-- Dis [(3,-2),(2,0),(0,3)]

-- Dis [(6,1),(4,-2),(3,4),(2,-4)]

-- Dis []

-- Dis [(5,-7)]

-- Dis [(12,5),(11,-8),(10,3),(8,-10),(7,-5),(4,12),(3,6),(2,-8),(1,11)]

-- Dis [(7,-2),(2,-8)]

-- Dis [(14,-15)]

-- Dis [(17,5),(16,1),(15,-1),(14,10),(13,5),(12,-15),(9,12),(6,14)]

-- Dis [(19,17),(12,7),(8,-3),(7,13),(5,-2),(4,7)]

dispersaArbitraria :: Gen Dispersa

dispersaArbitraria = do

(xs, ys) <- arbitrary

let xs' = nub (reverse (sort (map abs xs)))

ys' = filter (/= 0) ys

return (Dis (zip xs' ys'))

-- Dispersa está contenida en Arbitrary

instance Arbitrary Dispersa where

arbitrary = dispersaArbitraria

-- La propiedad es

prop_dispersaApolinomio :: Dispersa -> Bool

prop_dispersaApolinomio (Dis ps) =

all (== dispersaApolinomio ps)

[dispersaApolinomio2 ps,

dispersaApolinomio3 ps]

-- Definición de polinomioAdispersa

-- ================================

polinomioAdispersa :: (Num a, Eq a) => Polinomio a -> [(Int,a)]

polinomioAdispersa p

| esPolCero p = []

| otherwise = (grado p, coefLider p) : polinomioAdispersa (restoPol p)

-- Propiedad de ser inversas

-- =========================

-- La primera propiedad es

prop_polinomioAdispersa_dispersaApolinomio :: Dispersa -> Bool

prop_polinomioAdispersa_dispersaApolinomio (Dis ps) =

polinomioAdispersa (dispersaApolinomio ps) == ps

-- La comprobación es

-- λ> quickCheck prop_polinomioAdispersa_dispersaApolinomio

-- +++ OK, passed 100 tests.

-- La segunda propiedad es

prop_dispersaApolinomio_polinomioAdispersa :: Polinomio Int -> Bool

prop_dispersaApolinomio_polinomioAdispersa p =

dispersaApolinomio (polinomioAdispersa p) == p

-- La comprobación es

-- λ> quickCheck prop_dispersaApolinomio_polinomioAdispersa

-- +++ OK, passed 100 tests.

Soluciones en Python

from typing import TypeVar

from hypothesis import given

from src.Polinomios_Transformaciones_dispersa_y_densa import dispersaAleatoria
from src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,
                               polCero, polinomioAleatorio, restoPol)

A = TypeVar('A', int, float, complex)


# 1ª definición de dispersaApolinomio
# ===================================

def dispersaApolinomio(ps: list[tuple[int, A]]) -> Polinomio[A]:
    if not ps:
        return polCero()
    (n, a) = ps[0]
    return consPol(n, a, dispersaApolinomio(ps[1:]))

# 2ª definición de dispersaApolinomio
# ===================================

def dispersaApolinomio2(ps: list[tuple[int, A]]) -> Polinomio[A]:
    r: Polinomio[A] = polCero()
    for (n, a) in reversed(ps):
        r = consPol(n, a, r)
    return r

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(ps=dispersaAleatoria())
def test_dispersaApolinomio(ps: list[tuple[int, int]]) -> None:
    assert dispersaApolinomio(ps) == dispersaApolinomio2(ps)

# El generador dispersaAleatoria está definido en el ejercicio
# "Transformaciones entre las representaciones dispersa y densa" que se
# encuentra en https://bit.ly/402UpuT

# Definición de polinomioAdispersa
# ================================

def polinomioAdispersa(p: Polinomio[A]) -> list[tuple[int, A]]:
    if esPolCero(p):
        return []
    return [(grado(p), coefLider(p))] + polinomioAdispersa(restoPol(p))

# Propiedad de ser inversas
# =========================

# La primera propiedad es
@given(ps=dispersaAleatoria())
def test_polinomioAdispersa_dispersaApolinomio(ps: list[tuple[int,
                                                              int]]) -> None:
    assert polinomioAdispersa(dispersaApolinomio(ps)) == ps

# La segunda propiedad es
@given(p=polinomioAleatorio())
def test_dispersaApolinomio_polinomioAdispersa(p: Polinomio[int]) -> None:
    assert dispersaApolinomio(polinomioAdispersa(p)) == p

# La comprobación es
#    > poetry run pytest -v Polinomios_Transformaciones_polinomios_dispersas.py
#    test_dispersaApolinomio PASSED
#    test_polinomioAdispersa_dispersaApolinomio PASSED
#    test_dispersaApolinomio_polinomioAdispersa PASSED

from typing import TypeVar

from hypothesis import given

from src.Polinomios_Transformaciones_dispersa_y_densa import dispersaAleatoria

from src.TAD.Polinomio import (Polinomio, coefLider, consPol, esPolCero, grado,

polCero, polinomioAleatorio, restoPol)

A = TypeVar('A', int, float, complex)

# 1ª definición de dispersaApolinomio

# ===================================

def dispersaApolinomio(ps: list[tuple[int, A]]) -> Polinomio[A]:

if not ps:

return polCero()

(n, a) = ps[0]

return consPol(n, a, dispersaApolinomio(ps[1:]))

# 2ª definición de dispersaApolinomio

# ===================================

def dispersaApolinomio2(ps: list[tuple[int, A]]) -> Polinomio[A]:

r: Polinomio[A] = polCero()

for (n, a) in reversed(ps):

r = consPol(n, a, r)

return r

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(ps=dispersaAleatoria())

def test_dispersaApolinomio(ps: list[tuple[int, int]]) -> None:

assert dispersaApolinomio(ps) == dispersaApolinomio2(ps)

# El generador dispersaAleatoria está definido en el ejercicio

# "Transformaciones entre las representaciones dispersa y densa" que se

# encuentra en https://bit.ly/402UpuT

# Definición de polinomioAdispersa

# ================================

def polinomioAdispersa(p: Polinomio[A]) -> list[tuple[int, A]]:

if esPolCero(p):

return []

return [(grado(p), coefLider(p))] + polinomioAdispersa(restoPol(p))

# Propiedad de ser inversas

# =========================

# La primera propiedad es

@given(ps=dispersaAleatoria())

def test_polinomioAdispersa_dispersaApolinomio(ps: list[tuple[int,

int]]) -> None:

assert polinomioAdispersa(dispersaApolinomio(ps)) == ps

# La segunda propiedad es

@given(p=polinomioAleatorio())

def test_dispersaApolinomio_polinomioAdispersa(p: Polinomio[int]) -> None:

assert dispersaApolinomio(polinomioAdispersa(p)) == p

# La comprobación es

# > poetry run pytest -v Polinomios_Transformaciones_polinomios_dispersas.py

# test_dispersaApolinomio PASSED

# test_polinomioAdispersa_dispersaApolinomio PASSED

# test_dispersaApolinomio_polinomioAdispersa PASSED

TAD de los polinomios: Transformaciones entre las representaciones dispersa y densa

PorJosé A. Alonso 18-abril-202313-abril-2023

Definir las funciones

   densaAdispersa :: (Num a, Eq a) => [a] -> [(Int,a)]
   dispersaAdensa :: (Num a, Eq a) => [(Int,a)] -> [a]

1 2	densaAdispersa :: (Num a, Eq a) => [a] -> [(Int,a)] dispersaAdensa :: (Num a, Eq a) => [(Int,a)] -> [a]

tales que

densaAdispersa xs es la representación dispersa del polinomio cuya representación densa es xs. Por ejemplo,

     λ> densaAdispersa [9,0,0,5,0,4,7]
     [(6,9),(3,5),(1,4),(0,7)]

1 2	λ> densaAdispersa [9,0,0,5,0,4,7] [(6,9),(3,5),(1,4),(0,7)]

dispersaAdensa ps es la representación densa del polinomio cuya representación dispersa es ps. Por ejemplo,

     λ> dispersaAdensa [(6,9),(3,5),(1,4),(0,7)]
     [9,0,0,5,0,4,7]

1 2	λ> dispersaAdensa [(6,9),(3,5),(1,4),(0,7)] [9,0,0,5,0,4,7]

Comprobar con QuickCheck que las funciones densaAdispersa y dispersaAdensa son inversas.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Data.List (nub, sort)
import Test.QuickCheck

-- 1ª definición de densaAdispersa
-- ===============================

densaAdispersa :: (Num a, Eq a) => [a] -> [(Int,a)]
densaAdispersa xs = [(m,a) | (m,a) <- zip [n-1,n-2..] xs, a /= 0]
  where n  = length xs

-- 2ª definición de densaAdispersa
-- ===============================

densaAdispersa2 :: (Num a, Eq a) => [a] -> [(Int,a)]
densaAdispersa2 xs = reverse (aux (reverse xs) 0)
  where aux [] _ = []
        aux (0:ys) n = aux ys (n+1)
        aux (y:ys) n = (n,y) : aux ys (n+1)

-- Comprobación de equivalencia de densaAdispersa
-- ==============================================

-- La propiedad es
prop_densaAdispersa :: [Int] -> Bool
prop_densaAdispersa xs =
  densaAdispersa xs == densaAdispersa2 xs

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

-- Comparación de eficiencia
-- =========================

-- La comparación es
--    λ> densaAdispersa (5 : replicate (10^7) 0)
--    [(10000000,5)]
--    (4.54 secs, 3,280,572,504 bytes)
--    λ> densaAdispersa2 (5 : replicate (10^7) 0)
--    [(10000000,5)]
--    (7.35 secs, 3,696,968,576 bytes)

-- 1ª definición de dispersaAdensa
-- ===============================

dispersaAdensa :: (Num a, Eq a) => [(Int,a)] -> [a]
dispersaAdensa []      = []
dispersaAdensa [(n,a)] = a : replicate n 0
dispersaAdensa ((n,a):(m,b):ps) =
  a : replicate (n-m-1) 0 ++ dispersaAdensa ((m,b):ps)

-- 2ª definición de dispersaAdensa
-- ===============================

dispersaAdensa2 :: (Num a, Eq a) => [(Int,a)] -> [a]
dispersaAdensa2 []           = []
dispersaAdensa2 ps@((n,_):_) =
  [coeficiente ps m | m <- [n,n-1..0]]

-- (coeficiente ps n) es el coeficiente del término de grado n en el
-- polinomio cuya representación densa es ps. Por ejemplo,
--    coeficiente [(6,9),(3,5),(1,4),(0,7)] 3  ==  5
--    coeficiente [(6,9),(3,5),(1,4),(0,7)] 4  ==  0
coeficiente :: (Num a, Eq a) => [(Int,a)] -> Int -> a
coeficiente [] _                     = 0
coeficiente ((m,a):ps) n | n > m     = 0
                         | n == m    = a
                         | otherwise = coeficiente ps n

-- Comprobación de equivalencia de dispersaAdensa
-- ==============================================

-- Tipo de las representaciones dispersas de polinomios.
newtype Dispersa = Dis [(Int,Int)]
  deriving Show

-- dispersaArbitraria es un generador de representaciones dispersas de
-- polinomios. Por ejemplo,
--    λ> sample dispersaArbitraria
--    Dis []
--    Dis []
--    Dis [(3,-2),(2,0),(0,3)]
--    Dis [(6,1),(4,-2),(3,4),(2,-4)]
--    Dis []
--    Dis [(5,-7)]
--    Dis [(12,5),(11,-8),(10,3),(8,-10),(7,-5),(4,12),(3,6),(2,-8),(1,11)]
--    Dis [(7,-2),(2,-8)]
--    Dis [(14,-15)]
--    Dis [(17,5),(16,1),(15,-1),(14,10),(13,5),(12,-15),(9,12),(6,14)]
--    Dis [(19,17),(12,7),(8,-3),(7,13),(5,-2),(4,7)]
dispersaArbitraria :: Gen Dispersa
dispersaArbitraria = do
  (xs, ys) <- arbitrary
  let xs' = nub (reverse (sort (map abs xs)))
      ys' = filter (/= 0) ys
  return (Dis (zip xs' ys'))

-- Dispersa está contenida en Arbitrary
instance Arbitrary Dispersa where
  arbitrary = dispersaArbitraria

-- La propiedad es
prop_dispersaAdensa :: Dispersa -> Bool
prop_dispersaAdensa (Dis xs) =
  dispersaAdensa xs == dispersaAdensa2 xs

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

-- Comparación de eficiencia de dispersaAdensa
-- ===========================================

-- La comparación es
--    λ> length (dispersaAdensa [(10^7,5)])
--    10000001
--    (0.11 secs, 560,566,848 bytes)
--    λ> length (dispersaAdensa2 [(10^7,5)])
--    10000001
--    (2.51 secs, 2,160,567,112 bytes)

-- Propiedad
-- =========

-- Tipo de las representaciones densas de polinomios.
newtype Densa = Den [Int]
  deriving Show

-- densaArbitraria es un generador de representaciones dispersas de
-- polinomios. Por ejemplo,
--    λ> sample densaArbitraria
--    Den []
--    Den []
--    Den []
--    Den [-6,6,5,-3]
--    Den []
--    Den [8,-7,-10,8,-10,-4,10,6,10]
--    Den [-6,2,11,-4,-9,-5,9,2,2,9]
--    Den [-6,9,-2]
--    Den [-1,-7,15,1,5,-2,13,16,8,7,2,16,-2,16,-7,4]
--    Den [8,13,-4,-2,-10,3,5,-4,-6,13,-9,-12,8,11,9,-18,12,10]
--    Den [-1,-2,11,17,-7,13,-12,-19,16,-10,-18,-19,1,-4,-17,10,1,10]
densaArbitraria :: Gen Densa
densaArbitraria = do
  ys <- arbitrary
  let ys' = dropWhile (== 0) ys
  return (Den ys')

-- Dispersa está contenida en Arbitrary
instance Arbitrary Densa where
  arbitrary = densaArbitraria

-- La primera propiedad es
prop_dispersaAdensa_densaAdispersa :: Densa -> Bool
prop_dispersaAdensa_densaAdispersa (Den xs) =
  dispersaAdensa (densaAdispersa xs) == xs

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

-- La segunda propiedad es
prop_densaAdispersa_dispersaAdensa :: Dispersa -> Bool
prop_densaAdispersa_dispersaAdensa (Dis ps) =
  densaAdispersa (dispersaAdensa ps) == ps

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

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

import Data.List (nub, sort)

import Test.QuickCheck

-- 1ª definición de densaAdispersa

-- ===============================

densaAdispersa :: (Num a, Eq a) => [a] -> [(Int,a)]

densaAdispersa xs = [(m,a) | (m,a) <- zip [n-1,n-2..] xs, a /= 0]

where n = length xs

-- 2ª definición de densaAdispersa

-- ===============================

densaAdispersa2 :: (Num a, Eq a) => [a] -> [(Int,a)]

densaAdispersa2 xs = reverse (aux (reverse xs) 0)

where aux [] _ = []

aux (0:ys) n = aux ys (n+1)

aux (y:ys) n = (n,y) : aux ys (n+1)

-- Comprobación de equivalencia de densaAdispersa

-- ==============================================

-- La propiedad es

prop_densaAdispersa :: [Int] -> Bool

prop_densaAdispersa xs =

densaAdispersa xs == densaAdispersa2 xs

-- La comprobación es

-- λ> quickCheck prop_densaAdispersa

-- +++ OK, passed 100 tests.

-- Comparación de eficiencia

-- =========================

-- La comparación es

-- λ> densaAdispersa (5 : replicate (10^7) 0)

-- [(10000000,5)]

-- (4.54 secs, 3,280,572,504 bytes)

-- λ> densaAdispersa2 (5 : replicate (10^7) 0)

-- [(10000000,5)]

-- (7.35 secs, 3,696,968,576 bytes)

-- 1ª definición de dispersaAdensa

-- ===============================

dispersaAdensa :: (Num a, Eq a) => [(Int,a)] -> [a]

dispersaAdensa [] = []

dispersaAdensa [(n,a)] = a : replicate n 0

dispersaAdensa ((n,a):(m,b):ps) =

a : replicate (n-m-1) 0 ++ dispersaAdensa ((m,b):ps)

-- 2ª definición de dispersaAdensa

-- ===============================

dispersaAdensa2 :: (Num a, Eq a) => [(Int,a)] -> [a]

dispersaAdensa2 [] = []

dispersaAdensa2 ps@((n,_):_) =

[coeficiente ps m | m <- [n,n-1..0]]

-- (coeficiente ps n) es el coeficiente del término de grado n en el

-- polinomio cuya representación densa es ps. Por ejemplo,

-- coeficiente [(6,9),(3,5),(1,4),(0,7)] 3 == 5

-- coeficiente [(6,9),(3,5),(1,4),(0,7)] 4 == 0

coeficiente :: (Num a, Eq a) => [(Int,a)] -> Int -> a

coeficiente [] _ = 0

coeficiente ((m,a):ps) n | n > m = 0

| n == m = a

| otherwise = coeficiente ps n

-- Comprobación de equivalencia de dispersaAdensa

-- ==============================================

-- Tipo de las representaciones dispersas de polinomios.

newtype Dispersa = Dis [(Int,Int)]

deriving Show

-- dispersaArbitraria es un generador de representaciones dispersas de

-- polinomios. Por ejemplo,

-- λ> sample dispersaArbitraria

-- Dis []

-- Dis [(3,-2),(2,0),(0,3)]

-- Dis [(6,1),(4,-2),(3,4),(2,-4)]

-- Dis []

-- Dis [(5,-7)]

-- Dis [(12,5),(11,-8),(10,3),(8,-10),(7,-5),(4,12),(3,6),(2,-8),(1,11)]

-- Dis [(7,-2),(2,-8)]

-- Dis [(14,-15)]

-- Dis [(17,5),(16,1),(15,-1),(14,10),(13,5),(12,-15),(9,12),(6,14)]

-- Dis [(19,17),(12,7),(8,-3),(7,13),(5,-2),(4,7)]

dispersaArbitraria :: Gen Dispersa

dispersaArbitraria = do

(xs, ys) <- arbitrary

let xs' = nub (reverse (sort (map abs xs)))

ys' = filter (/= 0) ys

return (Dis (zip xs' ys'))

-- Dispersa está contenida en Arbitrary

instance Arbitrary Dispersa where

arbitrary = dispersaArbitraria

-- La propiedad es

prop_dispersaAdensa :: Dispersa -> Bool

prop_dispersaAdensa (Dis xs) =

dispersaAdensa xs == dispersaAdensa2 xs

-- La comprobación es

-- λ> quickCheck prop_dispersaAdensa

-- +++ OK, passed 100 tests.

-- Comparación de eficiencia de dispersaAdensa

-- ===========================================

-- La comparación es

-- λ> length (dispersaAdensa [(10^7,5)])

-- 10000001

-- (0.11 secs, 560,566,848 bytes)

-- λ> length (dispersaAdensa2 [(10^7,5)])

-- 10000001

-- (2.51 secs, 2,160,567,112 bytes)

-- Propiedad

-- =========

-- Tipo de las representaciones densas de polinomios.

newtype Densa = Den [Int]

deriving Show

-- densaArbitraria es un generador de representaciones dispersas de

-- polinomios. Por ejemplo,

-- λ> sample densaArbitraria

-- Den []

-- Den [-6,6,5,-3]

-- Den []

-- Den [8,-7,-10,8,-10,-4,10,6,10]

-- Den [-6,2,11,-4,-9,-5,9,2,2,9]

-- Den [-6,9,-2]

-- Den [-1,-7,15,1,5,-2,13,16,8,7,2,16,-2,16,-7,4]

-- Den [8,13,-4,-2,-10,3,5,-4,-6,13,-9,-12,8,11,9,-18,12,10]

-- Den [-1,-2,11,17,-7,13,-12,-19,16,-10,-18,-19,1,-4,-17,10,1,10]

densaArbitraria :: Gen Densa

densaArbitraria = do

ys <- arbitrary

let ys' = dropWhile (== 0) ys

return (Den ys')

-- Dispersa está contenida en Arbitrary

instance Arbitrary Densa where

arbitrary = densaArbitraria

-- La primera propiedad es

prop_dispersaAdensa_densaAdispersa :: Densa -> Bool

prop_dispersaAdensa_densaAdispersa (Den xs) =

dispersaAdensa (densaAdispersa xs) == xs

-- La comprobación es

-- λ> quickCheck prop_dispersaAdensa_densaAdispersa

-- +++ OK, passed 100 tests.

-- La segunda propiedad es

prop_densaAdispersa_dispersaAdensa :: Dispersa -> Bool

prop_densaAdispersa_dispersaAdensa (Dis ps) =

densaAdispersa (dispersaAdensa ps) == ps

-- La comprobación es

-- λ> quickCheck prop_densaAdispersa_dispersaAdensa

-- +++ OK, passed 100 tests.

Soluciones en Python

from itertools import dropwhile
from typing import TypeVar

from hypothesis import given
from hypothesis import strategies as st

A = TypeVar('A', int, float, complex)

# 1ª definición de densaAdispersa
# ===============================

def densaAdispersa(xs: list[A]) -> list[tuple[int, A]]:
    n = len(xs)
    return [(m, a) for (m, a) in zip(range(n-1, -1, -1),  xs) if a != 0]

# 2ª definición de densaAdispersa
# ===============================

def densaAdispersa2(xs: list[A]) -> list[tuple[int, A]]:
    def aux(xs: list[A], n: int) -> list[tuple[int, A]]:
        if not xs:
            return []
        if xs[0] == 0:
            return aux(xs[1:], n + 1)
        return [(n, xs[0])] + aux(xs[1:], n + 1)

    return list(reversed(aux(list(reversed(xs)), 0)))

# 3ª definición de densaAdispersa
# ===============================

def densaAdispersa3(xs: list[A]) -> list[tuple[int, A]]:
    r = []
    n = len(xs) - 1
    for x in xs:
        if x != 0:
            r.append((n, x))
        n -= 1
    return r

# Comprobación de equivalencia de densaAdispersa
# ==============================================

# normalDensa(ps) es la representación dispersa de un polinomio.
def normalDensa(xs: list[A]) -> list[A]:
    return list(dropwhile(lambda x: x == 0, xs))

# densaAleatoria() genera representaciones densas de polinomios
# aleatorios. Por ejemplo,
#    >>> densaAleatoria().example()
#    [-5, 9, -6, -5, 7, -5, -1, 9]
#    >>> densaAleatoria().example()
#    [-4, 9, -3, -3, -5, 0, 6, -8, 8, 6, 0, -9]
#    >>> densaAleatoria().example()
#    [-3, -1, 2, 0, -9]
def densaAleatoria() -> st.SearchStrategy[list[int]]:
    return st.lists(st.integers(min_value=-9, max_value=9))\
             .map(normalDensa)

# La propiedad es
@given(xs=densaAleatoria())
def test_densaADispersa(xs: list[int]) -> None:
    r = densaAdispersa(xs)
    assert densaAdispersa2(xs) == r
    assert densaAdispersa3(xs) == r

# 1ª definición de dispersaAdensa
# ===============================

def dispersaAdensa(ps: list[tuple[int, A]]) -> list[A]:
    if not ps:
        return []
    if len(ps) == 1:
        return [ps[0][1]] + [0] * ps[0][0]
    (n, a) = ps[0]
    (m, _) = ps[1]
    return [a] + [0] * (n-m-1) + dispersaAdensa(ps[1:])

# 2ª definición de dispersaAdensa
# ===============================

# coeficiente(ps, n) es el coeficiente del término de grado n en el
# polinomio cuya representación densa es ps. Por ejemplo,
#    coeficiente([(6, 9), (3, 5), (1, 4), (0, 7)], 3)  ==  5
#    coeficiente([(6, 9), (3, 5), (1, 4), (0, 7)], 4)  ==  0
def coeficiente(ps: list[tuple[int, A]], n: int) -> A:
    if not ps:
        return 0
    (m, a) = ps[0]
    if n > m:
        return 0
    if n == m:
        return a
    return coeficiente(ps[1:], n)

def dispersaAdensa2(ps: list[tuple[int, A]]) -> list[A]:
    if not ps:
        return []
    n = ps[0][0]
    return [coeficiente(ps, m) for m in range(n, -1, -1)]

# 3ª definición de dispersaAdensa
# ===============================

def dispersaAdensa3(ps: list[tuple[int, A]]) -> list[A]:
    if not ps:
        return []
    n = ps[0][0]
    r: list[A] = [0] * (n + 1)
    for (m, a) in ps:
        r[n-m] = a
    return r

# Comprobación de equivalencia de dispersaAdensa
# ==============================================

# normalDispersa(ps) es la representación dispersa de un polinomio.
def normalDispersa(ps: list[tuple[int, A]]) -> list[tuple[int, A]]:
    xs = sorted(list({p[0] for p in ps}), reverse=True)
    ys = [p[1] for p in ps]
    return [(x, y) for (x, y) in zip(xs, ys) if y != 0]

# dispersaAleatoria() genera representaciones densas de polinomios
# aleatorios. Por ejemplo,
#    >>> dispersaAleatoria().example()
#    [(5, -6), (2, -1), (0, 2)]
#    >>> dispersaAleatoria().example()
#    [(6, -7)]
#    >>> dispersaAleatoria().example()
#    [(7, 2), (4, 9), (3, 3), (0, -2)]
def dispersaAleatoria() -> st.SearchStrategy[list[tuple[int, int]]]:
    return st.lists(st.tuples(st.integers(min_value=0, max_value=9),
                              st.integers(min_value=-9, max_value=9)))\
             .map(normalDispersa)

# La propiedad es
@given(ps=dispersaAleatoria())
def test_dispersaAdensa(ps: list[tuple[int, int]]) -> None:
    r = dispersaAdensa(ps)
    assert dispersaAdensa2(ps) == r
    assert dispersaAdensa3(ps) == r

# Propiedad
# =========

# La primera propiedad es
@given(xs=densaAleatoria())
def test_dispersaAdensa_densaAdispersa(xs: list[int]) -> None:
    assert dispersaAdensa(densaAdispersa(xs)) == xs

# La segunda propiedad es
@given(ps=dispersaAleatoria())
def test_densaAdispersa_dispersaAdensa(ps: list[tuple[int, int]]) -> None:
    assert densaAdispersa(dispersaAdensa(ps)) == ps

# La comprobación es
#    > poetry run pytest -v Polinomios_Transformaciones_dispersa_y_densa.py
#    test_densaADispersa PASSED
#    test_dispersaAdensa PASSED
#    test_dispersaAdensa_densaAdispersa PASSED
#    test_densaAdispersa_dispersaAdensa PASSED

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

from itertools import dropwhile

from typing import TypeVar

from hypothesis import given

from hypothesis import strategies as st

A = TypeVar('A', int, float, complex)

# 1ª definición de densaAdispersa

# ===============================

def densaAdispersa(xs: list[A]) -> list[tuple[int, A]]:

n = len(xs)

return [(m, a) for (m, a) in zip(range(n-1, -1, -1), xs) if a != 0]

# 2ª definición de densaAdispersa

# ===============================

def densaAdispersa2(xs: list[A]) -> list[tuple[int, A]]:

def aux(xs: list[A], n: int) -> list[tuple[int, A]]:

if not xs:

return []

if xs[0] == 0:

return aux(xs[1:], n + 1)

return [(n, xs[0])] + aux(xs[1:], n + 1)

return list(reversed(aux(list(reversed(xs)), 0)))

# 3ª definición de densaAdispersa

# ===============================

def densaAdispersa3(xs: list[A]) -> list[tuple[int, A]]:

r = []

n = len(xs) - 1

for x in xs:

if x != 0:

r.append((n, x))

n -= 1

return r

# Comprobación de equivalencia de densaAdispersa

# ==============================================

# normalDensa(ps) es la representación dispersa de un polinomio.

def normalDensa(xs: list[A]) -> list[A]:

return list(dropwhile(lambda x: x == 0, xs))

# densaAleatoria() genera representaciones densas de polinomios

# aleatorios. Por ejemplo,

# >>> densaAleatoria().example()

# [-5, 9, -6, -5, 7, -5, -1, 9]

# >>> densaAleatoria().example()

# [-4, 9, -3, -3, -5, 0, 6, -8, 8, 6, 0, -9]

# >>> densaAleatoria().example()

# [-3, -1, 2, 0, -9]

def densaAleatoria() -> st.SearchStrategy[list[int]]:

return st.lists(st.integers(min_value=-9, max_value=9))\

.map(normalDensa)

# La propiedad es

@given(xs=densaAleatoria())

def test_densaADispersa(xs: list[int]) -> None:

r = densaAdispersa(xs)

assert densaAdispersa2(xs) == r

assert densaAdispersa3(xs) == r

# 1ª definición de dispersaAdensa

# ===============================

def dispersaAdensa(ps: list[tuple[int, A]]) -> list[A]:

if not ps:

return []

if len(ps) == 1:

return [ps[0][1]] + [0] * ps[0][0]

(n, a) = ps[0]

(m, _) = ps[1]

return [a] + [0] * (n-m-1) + dispersaAdensa(ps[1:])

# 2ª definición de dispersaAdensa

# ===============================

# coeficiente(ps, n) es el coeficiente del término de grado n en el

# polinomio cuya representación densa es ps. Por ejemplo,

# coeficiente([(6, 9), (3, 5), (1, 4), (0, 7)], 3) == 5

# coeficiente([(6, 9), (3, 5), (1, 4), (0, 7)], 4) == 0

def coeficiente(ps: list[tuple[int, A]], n: int) -> A:

if not ps:

return 0

(m, a) = ps[0]

if n > m:

return 0

if n == m:

return a

return coeficiente(ps[1:], n)

def dispersaAdensa2(ps: list[tuple[int, A]]) -> list[A]:

if not ps:

return []

n = ps[0][0]

return [coeficiente(ps, m) for m in range(n, -1, -1)]

# 3ª definición de dispersaAdensa

# ===============================

def dispersaAdensa3(ps: list[tuple[int, A]]) -> list[A]:

if not ps:

return []

n = ps[0][0]

r: list[A] = [0] * (n + 1)

for (m, a) in ps:

r[n-m] = a

return r

# Comprobación de equivalencia de dispersaAdensa

# ==============================================

# normalDispersa(ps) es la representación dispersa de un polinomio.

def normalDispersa(ps: list[tuple[int, A]]) -> list[tuple[int, A]]:

xs = sorted(list({p[0] for p in ps}), reverse=True)

ys = [p[1] for p in ps]

return [(x, y) for (x, y) in zip(xs, ys) if y != 0]

# dispersaAleatoria() genera representaciones densas de polinomios

# aleatorios. Por ejemplo,

# >>> dispersaAleatoria().example()

# [(5, -6), (2, -1), (0, 2)]

# >>> dispersaAleatoria().example()

# [(6, -7)]

# >>> dispersaAleatoria().example()

# [(7, 2), (4, 9), (3, 3), (0, -2)]

def dispersaAleatoria() -> st.SearchStrategy[list[tuple[int, int]]]:

return st.lists(st.tuples(st.integers(min_value=0, max_value=9),

st.integers(min_value=-9, max_value=9)))\

.map(normalDispersa)

# La propiedad es

@given(ps=dispersaAleatoria())

def test_dispersaAdensa(ps: list[tuple[int, int]]) -> None:

r = dispersaAdensa(ps)

assert dispersaAdensa2(ps) == r

assert dispersaAdensa3(ps) == r

# Propiedad

# =========

# La primera propiedad es

@given(xs=densaAleatoria())

def test_dispersaAdensa_densaAdispersa(xs: list[int]) -> None:

assert dispersaAdensa(densaAdispersa(xs)) == xs

# La segunda propiedad es

@given(ps=dispersaAleatoria())

def test_densaAdispersa_dispersaAdensa(ps: list[tuple[int, int]]) -> None:

assert densaAdispersa(dispersaAdensa(ps)) == ps

# La comprobación es

# > poetry run pytest -v Polinomios_Transformaciones_dispersa_y_densa.py

# test_densaADispersa PASSED

# test_dispersaAdensa PASSED

# test_dispersaAdensa_densaAdispersa PASSED

# test_densaAdispersa_dispersaAdensa PASSED

El tipo abstracto de datos de los polinomios

PorJosé A. Alonso 17-abril-20232-mayo-2023

1. El tipo abstracto de datos de los polinomios

Un polinomio es una expresión matemática compuesta por una suma de términos, donde cada término es el producto de un coeficiente y una variable elevada a una potencia. Por ejemplo, el polinomio 3x^2+2x-1 tiene un término de segundo grado (3x^2), un término de primer grado (2x) y un término constante (-1).

Las operaciones que definen al tipo abstracto de datos (TAD) de los polinomios (cuyos coeficientes son del tipo a) son las siguientes:

   polCero   :: Polinomio a
   esPolCero :: Polinomio a -> Bool
   consPol   :: (Num a, Eq a) => Int -> a -> Polinomio a -> Polinomio a
   grado     :: Polinomio a -> Int
   coefLider :: Num a => Polinomio a -> a
   restoPol  :: (Num a, Eq a) => Polinomio a -> Polinomio a

polCero :: Polinomio a

esPolCero :: Polinomio a -> Bool

consPol :: (Num a, Eq a) => Int -> a -> Polinomio a -> Polinomio a

grado :: Polinomio a -> Int

coefLider :: Num a => Polinomio a -> a

restoPol :: (Num a, Eq a) => Polinomio a -> Polinomio a

tales que

polCero es el polinomio cero.
(esPolCero p) se verifica si p es el polinomio cero.
(consPol n b p) es el polinomio bx^n+p
(grado p) es el grado del polinomio p.
(coefLider p) es el coeficiente líder del polinomio p.
(restoPol p) es el resto del polinomio p.

Por ejemplo, el polinomio

   3*x^4 + -5*x^2 + 3

1	3x^4 + -5x^2 + 3

se representa por

   consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))

1	consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))

Las operaciones tienen que verificar las siguientes propiedades:

esPolCero polCero
n > grado p && b /= 0 ==> not (esPolCero (consPol n b p))
consPol (grado p) (coefLider p) (restoPol p) == p
n > grado p && b /= 0 ==> grado (consPol n b p) == n
n > grado p && b /= 0 ==> coefLider (consPol n b p) == b
n > grado p && b /= 0 ==> restoPol (consPol n b p) == p

2. Los polinomios en Haskell

2.1. El tipo abstracto de datos de los polinomios en Haskell

El TAD de los polinomios se encuentra en el módulo Polinomio.hs cuyo contenido es el siguiente:

module TAD.Polinomio
  ( Polinomio,
    polCero,   -- Polinomio a
    esPolCero, -- Polinomio a -> Bool
    consPol,   -- (Num a, Eq a) => Int -> a -> Polinomio a -> Polinomio a
    grado,     -- Polinomio a -> Int
    coefLider, -- Num a => Polinomio a -> a
    restoPol   -- (Num a, Eq a) => Polinomio a -> Polinomio a
  ) where

import TAD.PolRepTDA
-- import TAD.PolRepDensa
-- import TAD.PolRepDispersa

module TAD.Polinomio

( Polinomio,

polCero, -- Polinomio a

esPolCero, -- Polinomio a -> Bool

consPol, -- (Num a, Eq a) => Int -> a -> Polinomio a -> Polinomio a

grado, -- Polinomio a -> Int

coefLider, -- Num a => Polinomio a -> a

restoPol -- (Num a, Eq a) => Polinomio a -> Polinomio a

) where

import TAD.PolRepTDA

-- import TAD.PolRepDensa

-- import TAD.PolRepDispersa

Para usar el TAD hay que usar una implementación concreta. En principio, consideraremos las siguientes:

mediante tipo de dato algebraico,
mediante listas densas y
mediante listas dispersas.

Hay que elegir la que se desee utilizar, descomentándola y comentando las otras.

2.2. Implementación de los polinomios mediante tipos de datos algebraicos

Representamos un polinomio mediante los constructores ConsPol y
PolCero. Por ejemplo, el polinomio

   6x^4 -5x^2 + 4x -7

1	6x^4 -5x^2 + 4x -7

se representa por

   ConsPol 4 6 (ConsPol 2 (-5) (ConsPol 1 4 (ConsPol 0 (-7) PolCero)))

1	ConsPol 4 6 (ConsPol 2 (-5) (ConsPol 1 4 (ConsPol 0 (-7) PolCero)))

La implementación se encuentra en el módulo PolRepTDA.hs cuyo contenido es el siguiente:

{-# LANGUAGE TemplateHaskell #-}
{-# OPTIONS_GHC -fno-warn-unused-top-binds #-}

module TAD.PolRepTDA
  ( Polinomio,
    polCero,   -- Polinomio a
    esPolCero, -- Polinomio a -> Bool
    consPol,   -- (Num a, Eq a)) => Int -> a -> Polinomio a -> Polinomio a
    grado,     -- Polinomio a -> Int
    coefLider, -- Num t => Polinomio t -> t
    restoPol   -- Polinomio t -> Polinomio t
  ) where

import Test.QuickCheck

-- Polinomio como tipo de dato algebra
data Polinomio a = PolCero
                 | ConsPol Int a (Polinomio a)
  deriving Eq

-- (escribePol p) es la cadena correspondiente al polinomio p. Por
-- ejemplo,
--    λ> escribePol (consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero)))
--    "3*x^4 + -5*x^2 + 3"
escribePol :: (Num a, Show a, Eq a) => Polinomio a -> String
escribePol PolCero               = "0"
escribePol (ConsPol 0 b PolCero) = show b
escribePol (ConsPol 0 b p)       = concat [show b, " + ", escribePol p]
escribePol (ConsPol 1 b PolCero) = show b ++ "*x"
escribePol (ConsPol 1 b p)       = concat [show b, "*x + ", escribePol p]
escribePol (ConsPol n 1 PolCero) = "x^" ++ show n
escribePol (ConsPol n b PolCero) = concat [show b, "*x^", show n]
escribePol (ConsPol n 1 p)       = concat ["x^", show n, " + ", escribePol p]
escribePol (ConsPol n b p)       = concat [show b, "*x^", show n, " + ", escribePol p]

-- Procedimiento de escritura de polinomios.
instance (Num a, Show a, Eq a) => Show (Polinomio a) where
  show = escribePol

-- Ejemplos de polinomios con coeficientes enteros:
ejPol1, ejPol2, ejPol3 :: Polinomio Int
ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))
ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))
ejPol3 = consPol 4 6 (consPol 1 2 polCero)

-- Comprobación de escritura:
--    > ejPol1
--    3*x^4 + -5*x^2 + 3
--    > ejPol2
--    x^5 + 5*x^2 + 4*x
--    > ejPol3
--    6*x^4 + 2*x

-- polCero es el polinomio cero. Por ejemplo,
--    > polCero
--    0
polCero :: Polinomio a
polCero = PolCero

-- (esPolCero p) se verifica si p es el polinomio cero. Por ejemplo,
--    esPolCero polCero  ==  True
--    esPolCero ejPol1   ==  False
esPolCero :: Polinomio a -> Bool
esPolCero PolCero = True
esPolCero _       = False

-- (consPol n b p) es el polinomio bx^n+p. Por ejemplo,
--    ejPol2               ==  x^5 + 5*x^2 + 4*x
--    consPol 3 0 ejPol2   ==  x^5 + 5*x^2 + 4*x
--    consPol 3 2 polCero  ==  2*x^3
--    consPol 6 7 ejPol2   ==  7*x^6 + x^5 + 5*x^2 + 4*x
--    consPol 4 7 ejPol2   ==  x^5 + 7*x^4 + 5*x^2 + 4*x
--    consPol 5 7 ejPol2   ==  8*x^5 + 5*x^2 + 4*x
consPol :: (Num a, Eq a) => Int -> a -> Polinomio a -> Polinomio a
consPol _ 0 p = p
consPol n b PolCero = ConsPol n b PolCero
consPol n b (ConsPol m c p)
  | n > m      = ConsPol n b (ConsPol m c p)
  | n < m      = ConsPol m c (consPol n b p)
  | b+c == 0   = p
  | otherwise  = ConsPol n (b+c) p

-- (grado p) es el grado del polinomio p. Por ejemplo,
--    ejPol3        ==  6*x^4 + 2*x
--    grado ejPol3  ==  4
grado :: Polinomio a -> Int
grado PolCero         = 0
grado (ConsPol n _ _) = n

-- (coefLider p) es el coeficiente líder del polinomio p. Por ejemplo,
--    ejPol3            ==  6*x^4 + 2*x
--    coefLider ejPol3  ==  6
coefLider :: Num t => Polinomio t -> t
coefLider PolCero         = 0
coefLider (ConsPol _ b _) = b

-- (restoPol p) es el resto del polinomio p. Por ejemplo,
--    ejPol3           ==  6*x^4 + 2*x
--    restoPol ejPol3  ==  2*x
--    ejPol2           ==  x^5 + 5*x^2 + 4*x
--    restoPol ejPol2  ==  5*x^2 + 4*x
restoPol :: Polinomio t -> Polinomio t
restoPol PolCero         = PolCero
restoPol (ConsPol _ _ p) = p

-- Generador de polinomios                                          --
-- =======================

-- genPolinomio es un generador de polinomios. Por ejemplo,
--    λ> sample (genPol 1)
--    7*x^9 + 9*x^8 + 10*x^7 + -14*x^5 + -15*x^2 + -10
--    -4*x^8 + 2*x
--    -8*x^9 + 4*x^8 + 2*x^6 + 4*x^5 + -6*x^4 + 5*x^2 + -8*x
--    -9*x^9 + x^5 + -7
--    8*x^10 + -9*x^7 + 7*x^6 + 9*x^5 + 10*x^3 + -1*x^2
--    7*x^10 + 5*x^9 + -5
--    -8*x^10 + -7
--    -5*x
--    5*x^10 + 4*x^4 + -3
--    3*x^3 + -4
--    10*x
genPol :: (Num a, Arbitrary a, Eq a) => Int -> Gen (Polinomio a)
genPol 0 = return polCero
genPol _ = do
  n <- choose (0,10)
  b <- arbitrary
  p <- genPol (div n 2)
  return (consPol n b p)

instance (Num a, Arbitrary a, Eq a) => Arbitrary (Polinomio a) where
  arbitrary = sized genPol

-- Propiedades de los polinomios
-- =============================

-- polCero es el polinomio cero.
prop_polCero_es_cero :: Bool
prop_polCero_es_cero =
  esPolCero polCero

-- Si n es mayor que el grado de p y b no es cero, entonces
-- (consPol n b p) es un polinomio distinto del cero.
prop_consPol_no_cero :: Int -> Int -> Polinomio Int -> Property
prop_consPol_no_cero n b p =
  n > grado p && b /= 0  ==>
  not (esPolCero (consPol n b p))

-- (consPol (grado p) (coefLider p) (restoPol p)) es igual a p.
prop_consPol :: Polinomio Int -> Bool
prop_consPol p =
  consPol (grado p) (coefLider p) (restoPol p) == p

-- Si n es mayor que el grado de p y b no es cero, entonces
-- el grado de (consPol n b p) es n.
prop_grado :: Int -> Int -> Polinomio Int -> Property
prop_grado n b p =
  n > grado p && b /= 0 ==>
  grado (consPol n b p) == n

-- Si n es mayor que el grado de p y b no es cero, entonces
-- el coeficiente líder de (consPol n b p) es b.
prop_coefLider :: Int -> Int -> Polinomio Int -> Property
prop_coefLider n b p =
  n > grado p && b /= 0 ==>
  coefLider (consPol n b p) == b

-- Si n es mayor que el grado de p y b no es cero, entonces
-- el resto de (consPol n b p) es p.
prop_restoPol :: Int -> Int -> Polinomio Int -> Property
prop_restoPol n b p =
  n > grado p && b /= 0 ==>
  restoPol (consPol n b p) == p

-- Verificación
-- ============

return []

verificaPol :: IO Bool
verificaPol = $quickCheckAll

-- La verificación es
--    λ> verificaPol
--    === prop_polCero_es_cero from PolPropiedades.hs:53 ===
--    +++ OK, passed 1 test.
--
--    === prop_consPol_no_cero from PolPropiedades.hs:63 ===
--    +++ OK, passed 100 tests; 251 discarded.
--
--    === prop_consPol from PolPropiedades.hs:73 ===
--    +++ OK, passed 100 tests.
--
--    === prop_grado from PolPropiedades.hs:83 ===
--    +++ OK, passed 100 tests; 321 discarded.
--
--    === prop_coefLider from PolPropiedades.hs:94 ===
--    +++ OK, passed 100 tests; 340 discarded.
--
--    === prop_restoPol from PolPropiedades.hs:105 ===
--    +++ OK, passed 100 tests; 268 discarded.
--
--    True

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

{-# LANGUAGE TemplateHaskell #-}

{-# OPTIONS_GHC -fno-warn-unused-top-binds #-}

module TAD.PolRepTDA

( Polinomio,

polCero, -- Polinomio a

esPolCero, -- Polinomio a -> Bool

consPol, -- (Num a, Eq a)) => Int -> a -> Polinomio a -> Polinomio a

grado, -- Polinomio a -> Int

coefLider, -- Num t => Polinomio t -> t

restoPol -- Polinomio t -> Polinomio t

) where

import Test.QuickCheck

-- Polinomio como tipo de dato algebra

data Polinomio a = PolCero

| ConsPol Int a (Polinomio a)

deriving Eq

-- (escribePol p) es la cadena correspondiente al polinomio p. Por

-- ejemplo,

-- λ> escribePol (consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero)))

-- "3*x^4 + -5*x^2 + 3"

escribePol :: (Num a, Show a, Eq a) => Polinomio a -> String

escribePol PolCero = "0"

escribePol (ConsPol 0 b PolCero) = show b

escribePol (ConsPol 0 b p) = concat [show b, " + ", escribePol p]

escribePol (ConsPol 1 b PolCero) = show b ++ "*x"

escribePol (ConsPol 1 b p) = concat [show b, "*x + ", escribePol p]

escribePol (ConsPol n 1 PolCero) = "x^" ++ show n

escribePol (ConsPol n b PolCero) = concat [show b, "*x^", show n]

escribePol (ConsPol n 1 p) = concat ["x^", show n, " + ", escribePol p]

escribePol (ConsPol n b p) = concat [show b, "*x^", show n, " + ", escribePol p]

-- Procedimiento de escritura de polinomios.

instance (Num a, Show a, Eq a) => Show (Polinomio a) where

show = escribePol

-- Ejemplos de polinomios con coeficientes enteros:

ejPol1, ejPol2, ejPol3 :: Polinomio Int

ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))

ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))

ejPol3 = consPol 4 6 (consPol 1 2 polCero)

-- Comprobación de escritura:

-- > ejPol1

-- 3*x^4 + -5*x^2 + 3

-- > ejPol2

-- x^5 + 5*x^2 + 4*x

-- > ejPol3

-- 6*x^4 + 2*x

-- polCero es el polinomio cero. Por ejemplo,

-- > polCero

-- 0

polCero :: Polinomio a

polCero = PolCero

-- (esPolCero p) se verifica si p es el polinomio cero. Por ejemplo,

-- esPolCero polCero == True

-- esPolCero ejPol1 == False

esPolCero :: Polinomio a -> Bool

esPolCero PolCero = True

esPolCero _ = False

-- (consPol n b p) es el polinomio bx^n+p. Por ejemplo,

-- ejPol2 == x^5 + 5*x^2 + 4*x

-- consPol 3 0 ejPol2 == x^5 + 5*x^2 + 4*x

-- consPol 3 2 polCero == 2*x^3

-- consPol 6 7 ejPol2 == 7*x^6 + x^5 + 5*x^2 + 4*x

-- consPol 4 7 ejPol2 == x^5 + 7*x^4 + 5*x^2 + 4*x

-- consPol 5 7 ejPol2 == 8*x^5 + 5*x^2 + 4*x

consPol :: (Num a, Eq a) => Int -> a -> Polinomio a -> Polinomio a

consPol _ 0 p = p

consPol n b PolCero = ConsPol n b PolCero

consPol n b (ConsPol m c p)

| n > m = ConsPol n b (ConsPol m c p)

| n < m = ConsPol m c (consPol n b p)

| b+c == 0 = p

| otherwise = ConsPol n (b+c) p

-- (grado p) es el grado del polinomio p. Por ejemplo,

-- ejPol3 == 6*x^4 + 2*x

-- grado ejPol3 == 4

grado :: Polinomio a -> Int

grado PolCero = 0

grado (ConsPol n _ _) = n

-- (coefLider p) es el coeficiente líder del polinomio p. Por ejemplo,

-- ejPol3 == 6*x^4 + 2*x

-- coefLider ejPol3 == 6

coefLider :: Num t => Polinomio t -> t

coefLider PolCero = 0

coefLider (ConsPol _ b _) = b

-- (restoPol p) es el resto del polinomio p. Por ejemplo,

-- ejPol3 == 6*x^4 + 2*x

-- restoPol ejPol3 == 2*x

-- ejPol2 == x^5 + 5*x^2 + 4*x

-- restoPol ejPol2 == 5*x^2 + 4*x

restoPol :: Polinomio t -> Polinomio t

restoPol PolCero = PolCero

restoPol (ConsPol _ _ p) = p

-- Generador de polinomios --

-- =======================

-- genPolinomio es un generador de polinomios. Por ejemplo,

-- λ> sample (genPol 1)

-- 7*x^9 + 9*x^8 + 10*x^7 + -14*x^5 + -15*x^2 + -10

-- -4*x^8 + 2*x

-- -8*x^9 + 4*x^8 + 2*x^6 + 4*x^5 + -6*x^4 + 5*x^2 + -8*x

-- -9*x^9 + x^5 + -7

-- 8*x^10 + -9*x^7 + 7*x^6 + 9*x^5 + 10*x^3 + -1*x^2

-- 7*x^10 + 5*x^9 + -5

-- -8*x^10 + -7

-- -5*x

-- 5*x^10 + 4*x^4 + -3

-- 3*x^3 + -4

-- 10*x

genPol :: (Num a, Arbitrary a, Eq a) => Int -> Gen (Polinomio a)

genPol 0 = return polCero

genPol _ = do

n <- choose (0,10)

b <- arbitrary

p <- genPol (div n 2)

return (consPol n b p)

instance (Num a, Arbitrary a, Eq a) => Arbitrary (Polinomio a) where

arbitrary = sized genPol

-- Propiedades de los polinomios

-- =============================

-- polCero es el polinomio cero.

prop_polCero_es_cero :: Bool

prop_polCero_es_cero =

esPolCero polCero

-- Si n es mayor que el grado de p y b no es cero, entonces

-- (consPol n b p) es un polinomio distinto del cero.

prop_consPol_no_cero :: Int -> Int -> Polinomio Int -> Property

prop_consPol_no_cero n b p =

n > grado p && b /= 0 ==>

not (esPolCero (consPol n b p))

-- (consPol (grado p) (coefLider p) (restoPol p)) es igual a p.

prop_consPol :: Polinomio Int -> Bool

prop_consPol p =

consPol (grado p) (coefLider p) (restoPol p) == p

-- Si n es mayor que el grado de p y b no es cero, entonces

-- el grado de (consPol n b p) es n.

prop_grado :: Int -> Int -> Polinomio Int -> Property

prop_grado n b p =

n > grado p && b /= 0 ==>

grado (consPol n b p) == n

-- Si n es mayor que el grado de p y b no es cero, entonces

-- el coeficiente líder de (consPol n b p) es b.

prop_coefLider :: Int -> Int -> Polinomio Int -> Property

prop_coefLider n b p =

n > grado p && b /= 0 ==>

coefLider (consPol n b p) == b

-- Si n es mayor que el grado de p y b no es cero, entonces

-- el resto de (consPol n b p) es p.

prop_restoPol :: Int -> Int -> Polinomio Int -> Property

prop_restoPol n b p =

n > grado p && b /= 0 ==>

restoPol (consPol n b p) == p

-- Verificación

-- ============

return []

verificaPol :: IO Bool

verificaPol = $quickCheckAll

-- La verificación es

-- λ> verificaPol

-- === prop_polCero_es_cero from PolPropiedades.hs:53 ===

-- +++ OK, passed 1 test.

-- === prop_consPol_no_cero from PolPropiedades.hs:63 ===

-- +++ OK, passed 100 tests; 251 discarded.

-- === prop_consPol from PolPropiedades.hs:73 ===

-- +++ OK, passed 100 tests.

-- === prop_grado from PolPropiedades.hs:83 ===

-- +++ OK, passed 100 tests; 321 discarded.

-- === prop_coefLider from PolPropiedades.hs:94 ===

-- +++ OK, passed 100 tests; 340 discarded.

-- === prop_restoPol from PolPropiedades.hs:105 ===

-- +++ OK, passed 100 tests; 268 discarded.

-- True

2.3. Implementación de polinomios mediante listas densas

Representaremos un polinomio por la lista de sus coeficientes ordenados en orden decreciente según el grado. Por ejemplo, el polinomio

   6x^4 -5x^2 + 4x -7

1	6x^4 -5x^2 + 4x -7

se representa por

   [6,0,-2,4,-7]

1	[6,0,-2,4,-7]

En la representación se supone que, si la lista no es vacía, su primer elemento es distinto de cero.

La implementación se encuentra en el módulo PolRepDensa.hs cuyo contenido es el siguiente:

{-# LANGUAGE TemplateHaskell #-}
{-# OPTIONS_GHC -fno-warn-unused-top-binds #-}

module TAD.PolRepDensa
  ( Polinomio,
    polCero,   -- Polinomio a
    esPolCero, -- Polinomio a -> Bool
    consPol,   -- (Num a, Eq a) => Int -> a -> Polinomio a -> Polinomio a
    grado,     -- Polinomio a -> Int
    coefLider, -- Num a => Polinomio a -> a
    restoPol   -- (Num a, Eq a) => Polinomio a -> Polinomio a
  ) where

import Test.QuickCheck

newtype Polinomio a = Pol [a]
  deriving Eq

-- (escribePol p) es la cadena correspondiente al polinomio p. Por
-- ejemplo,
--    λ> escribePol (consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero)))
--    "3*x^4 + -5*x^2 + 3"
escribePol :: (Num a, Show a, Eq a) => Polinomio a -> String
escribePol pol
  | esPolCero pol         = "0"
  | n == 0 && esPolCero p = show a
  | n == 0                = concat [show a, " + ", escribePol p]
  | n == 1 && esPolCero p = show a ++ "*x"
  | n == 1                = concat [show a, "*x + ", escribePol p]
  | a == 1 && esPolCero p = "x^" ++ show n
  | esPolCero p           = concat [show a, "*x^", show n]
  | a == 1                = concat ["x^", show n, " + ", escribePol p]
  | otherwise             = concat [show a, "*x^", show n, " + ", escribePol p]
  where n = grado pol
        a = coefLider pol
        p = restoPol pol

-- Procedimiento de escritura de polinomios.
instance (Num a, Show a, Eq a) => Show (Polinomio a) where
  show = escribePol

-- Ejemplos de polinomios con coeficientes enteros:
ejPol1, ejPol2, ejPol3 :: Polinomio Int
ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))
ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))
ejPol3 = consPol 4 6 (consPol 1 2 polCero)

-- Comprobación de escritura:
--    > ejPol1
--    3*x^4 + -5*x^2 + 3
--    > ejPol2
--    x^5 + 5*x^2 + 4*x
--    > ejPol3
--    6*x^4 + 2*x

-- polCero es el polinomio cero. Por ejemplo,
--    λ> polCero
--    0
polCero :: Polinomio a
polCero = Pol []

-- (esPolCero p) se verifica si p es el polinomio cero. Por ejemplo,
--    esPolCero polCero  ==  True
--    esPolCero ejPol1   ==  False
esPolCero :: Polinomio a -> Bool
esPolCero (Pol []) = True
esPolCero _        = False

-- (consPol n b p) es el polinomio bx^n+p. Por ejemplo,
--    ejPol2               ==  x^5 + 5*x^2 + 4*x
--    consPol 3 0 ejPol2   ==  x^5 + 5*x^2 + 4*x
--    consPol 3 2 polCero  ==  2*x^3
--    consPol 6 7 ejPol2   ==  7*x^6 + x^5 + 5*x^2 + 4*x
--    consPol 4 7 ejPol2   ==  x^5 + 7*x^4 + 5*x^2 + 4*x
--    consPol 5 7 ejPol2   ==  8*x^5 + 5*x^2 + 4*x
consPol :: (Num a, Eq a) => Int -> a -> Polinomio a -> Polinomio a
consPol _ 0 p = p
consPol n b p@(Pol xs)
    | esPolCero p = Pol (b : replicate n 0)
    | n > m       = Pol (b : replicate (n-m-1) 0 ++ xs)
    | n < m       = consPol m c (consPol n b (restoPol p))
    | b+c == 0    = Pol (dropWhile (==0) (tail xs))
    | otherwise   = Pol ((b+c):tail xs)
    where
      c = coefLider p
      m = grado p

-- (grado p) es el grado del polinomio p. Por ejemplo,
--    ejPol3        ==  6*x^4 + 2*x
--    grado ejPol3  ==  4
grado :: Polinomio a -> Int
grado (Pol []) = 0
grado (Pol xs) = length xs - 1

-- (coefLider p) es el coeficiente líder del polinomio p. Por ejemplo,
--    ejPol3            ==  6*x^4 + 2*x
--    coefLider ejPol3  ==  6
coefLider :: Num t => Polinomio t -> t
coefLider (Pol [])    = 0
coefLider (Pol (a:_)) = a

-- (restoPol p) es el resto del polinomio p. Por ejemplo,
--    ejPol3           ==  6*x^4 + 2*x
--    restoPol ejPol3  ==  2*x
--    ejPol2           ==  x^5 + 5*x^2 + 4*x
--    restoPol ejPol2  ==  5*x^2 + 4*x
restoPol :: (Num t, Eq t) => Polinomio t -> Polinomio t
restoPol (Pol [])     = polCero
restoPol (Pol [_])    = polCero
restoPol (Pol (_:b:as))
  | b == 0    = Pol (dropWhile (==0) as)
  | otherwise = Pol (b:as)

-- Generador de polinomios
-- =======================

-- genPolinomio es un generador de polinomios. Por ejemplo,
--    λ> sample (genPol 1)
--    7*x^9 + 9*x^8 + 10*x^7 + -14*x^5 + -15*x^2 + -10
--    -4*x^8 + 2*x
--    -8*x^9 + 4*x^8 + 2*x^6 + 4*x^5 + -6*x^4 + 5*x^2 + -8*x
--    -9*x^9 + x^5 + -7
--    8*x^10 + -9*x^7 + 7*x^6 + 9*x^5 + 10*x^3 + -1*x^2
--    7*x^10 + 5*x^9 + -5
--    -8*x^10 + -7
--    -5*x
--    5*x^10 + 4*x^4 + -3
--    3*x^3 + -4
--    10*x
genPol :: (Num a, Arbitrary a, Eq a) => Int -> Gen (Polinomio a)
genPol 0 = return polCero
genPol _ = do
  n <- choose (0,10)
  b <- arbitrary
  p <- genPol (div n 2)
  return (consPol n b p)

instance (Num a, Arbitrary a, Eq a) => Arbitrary (Polinomio a) where
  arbitrary = sized genPol

-- Propiedades de los polinomios
-- =============================

-- polCero es el polinomio cero.
prop_polCero_es_cero :: Bool
prop_polCero_es_cero =
  esPolCero polCero

-- Si n es mayor que el grado de p y b no es cero, entonces
-- (consPol n b p) es un polinomio distinto del cero.
prop_consPol_no_cero :: Int -> Int -> Polinomio Int -> Property
prop_consPol_no_cero n b p =
  n > grado p && b /= 0  ==>
  not (esPolCero (consPol n b p))

-- (consPol (grado p) (coefLider p) (restoPol p)) es igual a p.
prop_consPol :: Polinomio Int -> Bool
prop_consPol p =
  consPol (grado p) (coefLider p) (restoPol p) == p

-- Si n es mayor que el grado de p y b no es cero, entonces
-- el grado de (consPol n b p) es n.
prop_grado :: Int -> Int -> Polinomio Int -> Property
prop_grado n b p =
  n > grado p && b /= 0 ==>
  grado (consPol n b p) == n

-- Si n es mayor que el grado de p y b no es cero, entonces
-- el coeficiente líder de (consPol n b p) es b.
prop_coefLider :: Int -> Int -> Polinomio Int -> Property
prop_coefLider n b p =
  n > grado p && b /= 0 ==>
  coefLider (consPol n b p) == b

-- Si n es mayor que el grado de p y b no es cero, entonces
-- el resto de (consPol n b p) es p.
prop_restoPol :: Int -> Int -> Polinomio Int -> Property
prop_restoPol n b p =
  n > grado p && b /= 0 ==>
  restoPol (consPol n b p) == p

-- Verificación
-- ============

return []

verificaPol :: IO Bool
verificaPol = $quickCheckAll

-- La verificación es
--    λ> verificaPol
--    === prop_polCero_es_cero from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDensa.hs:157 ===
--    +++ OK, passed 1 test.
--
--    === prop_consPol_no_cero from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDensa.hs:163 ===
--    +++ OK, passed 100 tests; 274 discarded.
--
--    === prop_consPol from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDensa.hs:169 ===
--    +++ OK, passed 100 tests.
--
--    === prop_grado from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDensa.hs:175 ===
--    +++ OK, passed 100 tests; 297 discarded.
--
--    === prop_coefLider from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDensa.hs:182 ===
--    +++ OK, passed 100 tests; 248 discarded.
--
--    === prop_restoPol from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDensa.hs:189 ===
--    +++ OK, passed 100 tests; 322 discarded.
--
--    True

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

{-# LANGUAGE TemplateHaskell #-}

{-# OPTIONS_GHC -fno-warn-unused-top-binds #-}

module TAD.PolRepDensa

( Polinomio,

polCero, -- Polinomio a

esPolCero, -- Polinomio a -> Bool

consPol, -- (Num a, Eq a) => Int -> a -> Polinomio a -> Polinomio a

grado, -- Polinomio a -> Int

coefLider, -- Num a => Polinomio a -> a

restoPol -- (Num a, Eq a) => Polinomio a -> Polinomio a

) where

import Test.QuickCheck

newtype Polinomio a = Pol [a]

deriving Eq

-- (escribePol p) es la cadena correspondiente al polinomio p. Por

-- ejemplo,

-- λ> escribePol (consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero)))

-- "3*x^4 + -5*x^2 + 3"

escribePol :: (Num a, Show a, Eq a) => Polinomio a -> String

escribePol pol

| esPolCero pol = "0"

| n == 0 && esPolCero p = show a

| n == 0 = concat [show a, " + ", escribePol p]

| n == 1 && esPolCero p = show a ++ "*x"

| n == 1 = concat [show a, "*x + ", escribePol p]

| a == 1 && esPolCero p = "x^" ++ show n

| esPolCero p = concat [show a, "*x^", show n]

| a == 1 = concat ["x^", show n, " + ", escribePol p]

| otherwise = concat [show a, "*x^", show n, " + ", escribePol p]

where n = grado pol

a = coefLider pol

p = restoPol pol

-- Procedimiento de escritura de polinomios.

instance (Num a, Show a, Eq a) => Show (Polinomio a) where

show = escribePol

-- Ejemplos de polinomios con coeficientes enteros:

ejPol1, ejPol2, ejPol3 :: Polinomio Int

ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))

ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))

ejPol3 = consPol 4 6 (consPol 1 2 polCero)

-- Comprobación de escritura:

-- > ejPol1

-- 3*x^4 + -5*x^2 + 3

-- > ejPol2

-- x^5 + 5*x^2 + 4*x

-- > ejPol3

-- 6*x^4 + 2*x

-- polCero es el polinomio cero. Por ejemplo,

-- λ> polCero

-- 0

polCero :: Polinomio a

polCero = Pol []

-- (esPolCero p) se verifica si p es el polinomio cero. Por ejemplo,

-- esPolCero polCero == True

-- esPolCero ejPol1 == False

esPolCero :: Polinomio a -> Bool

esPolCero (Pol []) = True

esPolCero _ = False

-- (consPol n b p) es el polinomio bx^n+p. Por ejemplo,

-- ejPol2 == x^5 + 5*x^2 + 4*x

-- consPol 3 0 ejPol2 == x^5 + 5*x^2 + 4*x

-- consPol 3 2 polCero == 2*x^3

-- consPol 6 7 ejPol2 == 7*x^6 + x^5 + 5*x^2 + 4*x

-- consPol 4 7 ejPol2 == x^5 + 7*x^4 + 5*x^2 + 4*x

-- consPol 5 7 ejPol2 == 8*x^5 + 5*x^2 + 4*x

consPol :: (Num a, Eq a) => Int -> a -> Polinomio a -> Polinomio a

consPol _ 0 p = p

consPol n b p@(Pol xs)

| esPolCero p = Pol (b : replicate n 0)

| n > m = Pol (b : replicate (n-m-1) 0 ++ xs)

| n < m = consPol m c (consPol n b (restoPol p))

| b+c == 0 = Pol (dropWhile (==0) (tail xs))

| otherwise = Pol ((b+c):tail xs)

where

c = coefLider p

m = grado p

-- (grado p) es el grado del polinomio p. Por ejemplo,

-- ejPol3 == 6*x^4 + 2*x

-- grado ejPol3 == 4

grado :: Polinomio a -> Int

grado (Pol []) = 0

grado (Pol xs) = length xs - 1

-- (coefLider p) es el coeficiente líder del polinomio p. Por ejemplo,

-- ejPol3 == 6*x^4 + 2*x

-- coefLider ejPol3 == 6

coefLider :: Num t => Polinomio t -> t

coefLider (Pol []) = 0

coefLider (Pol (a:_)) = a

-- (restoPol p) es el resto del polinomio p. Por ejemplo,

-- ejPol3 == 6*x^4 + 2*x

-- restoPol ejPol3 == 2*x

-- ejPol2 == x^5 + 5*x^2 + 4*x

-- restoPol ejPol2 == 5*x^2 + 4*x

restoPol :: (Num t, Eq t) => Polinomio t -> Polinomio t

restoPol (Pol []) = polCero

restoPol (Pol [_]) = polCero

restoPol (Pol (_:b:as))

| b == 0 = Pol (dropWhile (==0) as)

| otherwise = Pol (b:as)

-- Generador de polinomios

-- =======================

-- genPolinomio es un generador de polinomios. Por ejemplo,

-- λ> sample (genPol 1)

-- 7*x^9 + 9*x^8 + 10*x^7 + -14*x^5 + -15*x^2 + -10

-- -4*x^8 + 2*x

-- -8*x^9 + 4*x^8 + 2*x^6 + 4*x^5 + -6*x^4 + 5*x^2 + -8*x

-- -9*x^9 + x^5 + -7

-- 8*x^10 + -9*x^7 + 7*x^6 + 9*x^5 + 10*x^3 + -1*x^2

-- 7*x^10 + 5*x^9 + -5

-- -8*x^10 + -7

-- -5*x

-- 5*x^10 + 4*x^4 + -3

-- 3*x^3 + -4

-- 10*x

genPol :: (Num a, Arbitrary a, Eq a) => Int -> Gen (Polinomio a)

genPol 0 = return polCero

genPol _ = do

n <- choose (0,10)

b <- arbitrary

p <- genPol (div n 2)

return (consPol n b p)

instance (Num a, Arbitrary a, Eq a) => Arbitrary (Polinomio a) where

arbitrary = sized genPol

-- Propiedades de los polinomios

-- =============================

-- polCero es el polinomio cero.

prop_polCero_es_cero :: Bool

prop_polCero_es_cero =

esPolCero polCero

-- Si n es mayor que el grado de p y b no es cero, entonces

-- (consPol n b p) es un polinomio distinto del cero.

prop_consPol_no_cero :: Int -> Int -> Polinomio Int -> Property

prop_consPol_no_cero n b p =

n > grado p && b /= 0 ==>

not (esPolCero (consPol n b p))

-- (consPol (grado p) (coefLider p) (restoPol p)) es igual a p.

prop_consPol :: Polinomio Int -> Bool

prop_consPol p =

consPol (grado p) (coefLider p) (restoPol p) == p

-- Si n es mayor que el grado de p y b no es cero, entonces

-- el grado de (consPol n b p) es n.

prop_grado :: Int -> Int -> Polinomio Int -> Property

prop_grado n b p =

n > grado p && b /= 0 ==>

grado (consPol n b p) == n

-- Si n es mayor que el grado de p y b no es cero, entonces

-- el coeficiente líder de (consPol n b p) es b.

prop_coefLider :: Int -> Int -> Polinomio Int -> Property

prop_coefLider n b p =

n > grado p && b /= 0 ==>

coefLider (consPol n b p) == b

-- Si n es mayor que el grado de p y b no es cero, entonces

-- el resto de (consPol n b p) es p.

prop_restoPol :: Int -> Int -> Polinomio Int -> Property

prop_restoPol n b p =

n > grado p && b /= 0 ==>

restoPol (consPol n b p) == p

-- Verificación

-- ============

return []

verificaPol :: IO Bool

verificaPol = $quickCheckAll

-- La verificación es

-- λ> verificaPol

-- === prop_polCero_es_cero from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDensa.hs:157 ===

-- +++ OK, passed 1 test.

-- === prop_consPol_no_cero from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDensa.hs:163 ===

-- +++ OK, passed 100 tests; 274 discarded.

-- === prop_consPol from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDensa.hs:169 ===

-- +++ OK, passed 100 tests.

-- === prop_grado from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDensa.hs:175 ===

-- +++ OK, passed 100 tests; 297 discarded.

-- === prop_coefLider from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDensa.hs:182 ===

-- +++ OK, passed 100 tests; 248 discarded.

-- === prop_restoPol from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDensa.hs:189 ===

-- +++ OK, passed 100 tests; 322 discarded.

-- True

2.4. Implementación de polinomios mediante listas dispersas

Representaremos un polinomio mediante una lista de pares (grado,coef),
ordenados en orden decreciente según el grado. Por ejemplo, el polinomio

   6x^4 -5x^2 + 4x -7

1	6x^4 -5x^2 + 4x -7

se representa por

   [(4,6),(2,-5),(1,4),(0,-7)]

1	[(4,6),(2,-5),(1,4),(0,-7)]

En la representación se supone que los primeros elementos de los pares forman una sucesión estrictamente decreciente y que los segundos elementos son distintos de cero.

La implementación se encuentra en el módulo PolRepDispersa.hs cuyo contenido es el siguiente:

{-# LANGUAGE TemplateHaskell #-}
{-# OPTIONS_GHC -fno-warn-unused-top-binds #-}

module TAD.PolRepDispersa
  ( Polinomio,
    polCero,   -- Polinomio a
    esPolCero, -- Num a =>  Polinomio a -> Bool
    consPol,   -- Num a => Int -> a -> Polinomio a -> Polinomio a
    grado,     -- Polinomio a -> Int
    coefLider, -- Num a => Polinomio a -> a
    restoPol   -- Polinomio a -> Polinomio a
  ) where

import Test.QuickCheck

newtype Polinomio a = Pol [(Int,a)]
  deriving Eq

-- (escribePol p) es la cadena correspondiente al polinomio p. Por
-- ejemplo,
--    λ> escribePol (consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero)))
--    "3*x^4 + -5*x^2 + 3"
escribePol :: (Num a, Show a, Eq a) => Polinomio a -> String
escribePol pol
  | esPolCero pol         = "0"
  | n == 0 && esPolCero p = show a
  | n == 0                = concat [show a, " + ", escribePol p]
  | n == 1 && esPolCero p = show a ++ "*x"
  | n == 1                = concat [show a, "*x + ", escribePol p]
  | a == 1 && esPolCero p = "x^" ++ show n
  | esPolCero p           = concat [show a, "*x^", show n]
  | a == 1                = concat ["x^", show n, " + ", escribePol p]
  | otherwise             = concat [show a, "*x^", show n, " + ", escribePol p]
  where n = grado pol
        a = coefLider pol
        p = restoPol pol

-- Procedimiento de escritura de polinomios.
instance (Num a, Show a, Eq a) => Show (Polinomio a) where
  show = escribePol

-- Ejemplos de polinomios con coeficientes enteros:
ejPol1, ejPol2, ejPol3 :: Polinomio Int
ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))
ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))
ejPol3 = consPol 4 6 (consPol 1 2 polCero)

-- Comprobación de escritura:
--    > ejPol1
--    3*x^4 + -5*x^2 + 3
--    > ejPol2
--    x^5 + 5*x^2 + 4*x
--    > ejPol3
--    6*x^4 + 2*x

-- polCero es el polinomio cero. Por ejemplo,
--    λ> polCero
--    0
polCero :: Num a => Polinomio a
polCero = Pol []

-- (esPolCero p) se verifica si p es el polinomio cero. Por ejemplo,
--    esPolCero polCero  ==  True
--    esPolCero ejPol1   ==  False
esPolCero :: Num a => Polinomio a -> Bool
esPolCero (Pol []) = True
esPolCero _        = False

-- (consPol n b p) es el polinomio bx^n+p. Por ejemplo,
--    ejPol2               ==  x^5 + 5*x^2 + 4*x
--    consPol 3 0 ejPol2   ==  x^5 + 5*x^2 + 4*x
--    consPol 3 2 polCero  ==  2*x^3
--    consPol 6 7 ejPol2   ==  7*x^6 + x^5 + 5*x^2 + 4*x
--    consPol 4 7 ejPol2   ==  x^5 + 7*x^4 + 5*x^2 + 4*x
--    consPol 5 7 ejPol2   ==  8*x^5 + 5*x^2 + 4*x
consPol :: (Num a, Eq a) => Int -> a -> Polinomio a -> Polinomio a
consPol _ 0 p = p
consPol n b p@(Pol xs)
    | esPolCero p = Pol [(n,b)]
    | n > m       = Pol ((n,b):xs)
    | n < m       = consPol m c (consPol n b (Pol (tail xs)))
    | b+c == 0    = Pol (tail xs)
    | otherwise   = Pol ((n,b+c) : tail xs)
    where
      c = coefLider p
      m = grado p

-- (grado p) es el grado del polinomio p. Por ejemplo,
--    ejPol3        ==  6*x^4 + 2*x
--    grado ejPol3  ==  4
grado :: Polinomio a -> Int
grado (Pol [])        = 0
grado (Pol ((n,_):_)) = n

-- (coefLider p) es el coeficiente líder del polinomio p. Por ejemplo,
--    ejPol3            ==  6*x^4 + 2*x
--    coefLider ejPol3  ==  6
coefLider :: Num t => Polinomio t -> t
coefLider (Pol [])        = 0
coefLider (Pol ((_,b):_)) = b

-- (restoPol p) es el resto del polinomio p. Por ejemplo,
--    ejPol3           ==  6*x^4 + 2*x
--    restoPol ejPol3  ==  2*x
--    ejPol2           ==  x^5 + 5*x^2 + 4*x
--    restoPol ejPol2  ==  5*x^2 + 4*x
restoPol :: Num t => Polinomio t -> Polinomio t
restoPol (Pol [])     = polCero
restoPol (Pol [_])    = polCero
restoPol (Pol (_:xs)) = Pol xs

-- Generador de polinomios                                          --
-- =======================

-- genPolinomio es un generador de polinomios. Por ejemplo,
--    λ> sample (genPol 1)
--    7*x^9 + 9*x^8 + 10*x^7 + -14*x^5 + -15*x^2 + -10
--    -4*x^8 + 2*x
--    -8*x^9 + 4*x^8 + 2*x^6 + 4*x^5 + -6*x^4 + 5*x^2 + -8*x
--    -9*x^9 + x^5 + -7
--    8*x^10 + -9*x^7 + 7*x^6 + 9*x^5 + 10*x^3 + -1*x^2
--    7*x^10 + 5*x^9 + -5
--    -8*x^10 + -7
--    -5*x
--    5*x^10 + 4*x^4 + -3
--    3*x^3 + -4
--    10*x
genPol :: (Num a, Arbitrary a, Eq a) => Int -> Gen (Polinomio a)
genPol 0 = return polCero
genPol _ = do
  n <- choose (0,10)
  b <- arbitrary
  p <- genPol (div n 2)
  return (consPol n b p)

instance (Num a, Arbitrary a, Eq a) => Arbitrary (Polinomio a) where
  arbitrary = sized genPol

-- Propiedades de los polinomios
-- =============================

-- polCero es el polinomio cero.
prop_polCero_es_cero :: Bool
prop_polCero_es_cero =
  esPolCero polCero

-- Si n es mayor que el grado de p y b no es cero, entonces
-- (consPol n b p) es un polinomio distinto del cero.
prop_consPol_no_cero :: Int -> Int -> Polinomio Int -> Property
prop_consPol_no_cero n b p =
  n > grado p && b /= 0  ==>
  not (esPolCero (consPol n b p))

-- (consPol (grado p) (coefLider p) (restoPol p)) es igual a p.
prop_consPol :: Polinomio Int -> Bool
prop_consPol p =
  consPol (grado p) (coefLider p) (restoPol p) == p

-- Si n es mayor que el grado de p y b no es cero, entonces
-- el grado de (consPol n b p) es n.
prop_grado :: Int -> Int -> Polinomio Int -> Property
prop_grado n b p =
  n > grado p && b /= 0 ==>
  grado (consPol n b p) == n

-- Si n es mayor que el grado de p y b no es cero, entonces
-- el coeficiente líder de (consPol n b p) es b.
prop_coefLider :: Int -> Int -> Polinomio Int -> Property
prop_coefLider n b p =
  n > grado p && b /= 0 ==>
  coefLider (consPol n b p) == b

-- Si n es mayor que el grado de p y b no es cero, entonces
-- el resto de (consPol n b p) es p.
prop_restoPol :: Int -> Int -> Polinomio Int -> Property
prop_restoPol n b p =
  n > grado p && b /= 0 ==>
  restoPol (consPol n b p) == p

-- Verificación
-- ============

return []

verificaPol :: IO Bool
verificaPol = $quickCheckAll

-- La verificación es
--    λ> verificaPol
--    === prop_polCero_es_cero from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDispersa.hs:156 ===
--    +++ OK, passed 1 test.
--
--    === prop_consPol_no_cero from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDispersa.hs:162 ===
--    +++ OK, passed 100 tests; 264 discarded.
--
--    === prop_consPol from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDispersa.hs:168 ===
--    +++ OK, passed 100 tests.
--
--    === prop_grado from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDispersa.hs:174 ===
--    +++ OK, passed 100 tests; 266 discarded.
--
--    === prop_coefLider from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDispersa.hs:181 ===
--    +++ OK, passed 100 tests; 251 discarded.
--
--    === prop_restoPol from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDispersa.hs:188 ===
--    +++ OK, passed 100 tests; 254 discarded.
--
--    True

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

{-# LANGUAGE TemplateHaskell #-}

{-# OPTIONS_GHC -fno-warn-unused-top-binds #-}

module TAD.PolRepDispersa

( Polinomio,

polCero, -- Polinomio a

esPolCero, -- Num a => Polinomio a -> Bool

consPol, -- Num a => Int -> a -> Polinomio a -> Polinomio a

grado, -- Polinomio a -> Int

coefLider, -- Num a => Polinomio a -> a

restoPol -- Polinomio a -> Polinomio a

) where

import Test.QuickCheck

newtype Polinomio a = Pol [(Int,a)]

deriving Eq

-- (escribePol p) es la cadena correspondiente al polinomio p. Por

-- ejemplo,

-- λ> escribePol (consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero)))

-- "3*x^4 + -5*x^2 + 3"

escribePol :: (Num a, Show a, Eq a) => Polinomio a -> String

escribePol pol

| esPolCero pol = "0"

| n == 0 && esPolCero p = show a

| n == 0 = concat [show a, " + ", escribePol p]

| n == 1 && esPolCero p = show a ++ "*x"

| n == 1 = concat [show a, "*x + ", escribePol p]

| a == 1 && esPolCero p = "x^" ++ show n

| esPolCero p = concat [show a, "*x^", show n]

| a == 1 = concat ["x^", show n, " + ", escribePol p]

| otherwise = concat [show a, "*x^", show n, " + ", escribePol p]

where n = grado pol

a = coefLider pol

p = restoPol pol

-- Procedimiento de escritura de polinomios.

instance (Num a, Show a, Eq a) => Show (Polinomio a) where

show = escribePol

-- Ejemplos de polinomios con coeficientes enteros:

ejPol1, ejPol2, ejPol3 :: Polinomio Int

ejPol1 = consPol 4 3 (consPol 2 (-5) (consPol 0 3 polCero))

ejPol2 = consPol 5 1 (consPol 2 5 (consPol 1 4 polCero))

ejPol3 = consPol 4 6 (consPol 1 2 polCero)

-- Comprobación de escritura:

-- > ejPol1

-- 3*x^4 + -5*x^2 + 3

-- > ejPol2

-- x^5 + 5*x^2 + 4*x

-- > ejPol3

-- 6*x^4 + 2*x

-- polCero es el polinomio cero. Por ejemplo,

-- λ> polCero

-- 0

polCero :: Num a => Polinomio a

polCero = Pol []

-- (esPolCero p) se verifica si p es el polinomio cero. Por ejemplo,

-- esPolCero polCero == True

-- esPolCero ejPol1 == False

esPolCero :: Num a => Polinomio a -> Bool

esPolCero (Pol []) = True

esPolCero _ = False

-- (consPol n b p) es el polinomio bx^n+p. Por ejemplo,

-- ejPol2 == x^5 + 5*x^2 + 4*x

-- consPol 3 0 ejPol2 == x^5 + 5*x^2 + 4*x

-- consPol 3 2 polCero == 2*x^3

-- consPol 6 7 ejPol2 == 7*x^6 + x^5 + 5*x^2 + 4*x

-- consPol 4 7 ejPol2 == x^5 + 7*x^4 + 5*x^2 + 4*x

-- consPol 5 7 ejPol2 == 8*x^5 + 5*x^2 + 4*x

consPol :: (Num a, Eq a) => Int -> a -> Polinomio a -> Polinomio a

consPol _ 0 p = p

consPol n b p@(Pol xs)

| esPolCero p = Pol [(n,b)]

| n > m = Pol ((n,b):xs)

| n < m = consPol m c (consPol n b (Pol (tail xs)))

| b+c == 0 = Pol (tail xs)

| otherwise = Pol ((n,b+c) : tail xs)

where

c = coefLider p

m = grado p

-- (grado p) es el grado del polinomio p. Por ejemplo,

-- ejPol3 == 6*x^4 + 2*x

-- grado ejPol3 == 4

grado :: Polinomio a -> Int

grado (Pol []) = 0

grado (Pol ((n,_):_)) = n

-- (coefLider p) es el coeficiente líder del polinomio p. Por ejemplo,

-- ejPol3 == 6*x^4 + 2*x

-- coefLider ejPol3 == 6

coefLider :: Num t => Polinomio t -> t

coefLider (Pol []) = 0

coefLider (Pol ((_,b):_)) = b

-- (restoPol p) es el resto del polinomio p. Por ejemplo,

-- ejPol3 == 6*x^4 + 2*x

-- restoPol ejPol3 == 2*x

-- ejPol2 == x^5 + 5*x^2 + 4*x

-- restoPol ejPol2 == 5*x^2 + 4*x

restoPol :: Num t => Polinomio t -> Polinomio t

restoPol (Pol []) = polCero

restoPol (Pol [_]) = polCero

restoPol (Pol (_:xs)) = Pol xs

-- Generador de polinomios --

-- =======================

-- genPolinomio es un generador de polinomios. Por ejemplo,

-- λ> sample (genPol 1)

-- 7*x^9 + 9*x^8 + 10*x^7 + -14*x^5 + -15*x^2 + -10

-- -4*x^8 + 2*x

-- -8*x^9 + 4*x^8 + 2*x^6 + 4*x^5 + -6*x^4 + 5*x^2 + -8*x

-- -9*x^9 + x^5 + -7

-- 8*x^10 + -9*x^7 + 7*x^6 + 9*x^5 + 10*x^3 + -1*x^2

-- 7*x^10 + 5*x^9 + -5

-- -8*x^10 + -7

-- -5*x

-- 5*x^10 + 4*x^4 + -3

-- 3*x^3 + -4

-- 10*x

genPol :: (Num a, Arbitrary a, Eq a) => Int -> Gen (Polinomio a)

genPol 0 = return polCero

genPol _ = do

n <- choose (0,10)

b <- arbitrary

p <- genPol (div n 2)

return (consPol n b p)

instance (Num a, Arbitrary a, Eq a) => Arbitrary (Polinomio a) where

arbitrary = sized genPol

-- Propiedades de los polinomios

-- =============================

-- polCero es el polinomio cero.

prop_polCero_es_cero :: Bool

prop_polCero_es_cero =

esPolCero polCero

-- Si n es mayor que el grado de p y b no es cero, entonces

-- (consPol n b p) es un polinomio distinto del cero.

prop_consPol_no_cero :: Int -> Int -> Polinomio Int -> Property

prop_consPol_no_cero n b p =

n > grado p && b /= 0 ==>

not (esPolCero (consPol n b p))

-- (consPol (grado p) (coefLider p) (restoPol p)) es igual a p.

prop_consPol :: Polinomio Int -> Bool

prop_consPol p =

consPol (grado p) (coefLider p) (restoPol p) == p

-- Si n es mayor que el grado de p y b no es cero, entonces

-- el grado de (consPol n b p) es n.

prop_grado :: Int -> Int -> Polinomio Int -> Property

prop_grado n b p =

n > grado p && b /= 0 ==>

grado (consPol n b p) == n

-- Si n es mayor que el grado de p y b no es cero, entonces

-- el coeficiente líder de (consPol n b p) es b.

prop_coefLider :: Int -> Int -> Polinomio Int -> Property

prop_coefLider n b p =

n > grado p && b /= 0 ==>

coefLider (consPol n b p) == b

-- Si n es mayor que el grado de p y b no es cero, entonces

-- el resto de (consPol n b p) es p.

prop_restoPol :: Int -> Int -> Polinomio Int -> Property

prop_restoPol n b p =

n > grado p && b /= 0 ==>

restoPol (consPol n b p) == p

-- Verificación

-- ============

return []

verificaPol :: IO Bool

verificaPol = $quickCheckAll

-- La verificación es

-- λ> verificaPol

-- === prop_polCero_es_cero from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDispersa.hs:156 ===

-- +++ OK, passed 1 test.

-- === prop_consPol_no_cero from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDispersa.hs:162 ===

-- +++ OK, passed 100 tests; 264 discarded.

-- === prop_consPol from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDispersa.hs:168 ===

-- +++ OK, passed 100 tests.

-- === prop_grado from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDispersa.hs:174 ===

-- +++ OK, passed 100 tests; 266 discarded.

-- === prop_coefLider from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDispersa.hs:181 ===

-- +++ OK, passed 100 tests; 251 discarded.

-- === prop_restoPol from /home/jalonso/alonso/estudio/Exercitium/Exercitium/src/TAD/PolRepDispersa.hs:188 ===

-- +++ OK, passed 100 tests; 254 discarded.

-- True

3. Los polinomios en Python

3.1. El tipo abstracto de los polinomios en Python

La implementación se encuentra en el módulo Polinomio.py cuyo contenido es el siguiente:

__all__ = [
    'Polinomio',
    'polCero',
    'esPolCero',
    'consPol',
    'grado',
    'coefLider',
    'restoPol',
    'polinomioAleatorio'
]

from src.TAD.PolRepDensa import (Polinomio, coefLider, consPol, esPolCero,
                                 grado, polCero, polinomioAleatorio, restoPol)

# from src.TAD.PolRepDispersa import (Polinomio, polCero, esPolCero,
#                                     consPol, grado, coefLider,
#                                     restoPol, polinomioAleatorio)

__all__ = [

'Polinomio',

'polCero',

'esPolCero',

'consPol',

'grado',

'coefLider',

'restoPol',

'polinomioAleatorio'

]

from src.TAD.PolRepDensa import (Polinomio, coefLider, consPol, esPolCero,

grado, polCero, polinomioAleatorio, restoPol)

# from src.TAD.PolRepDispersa import (Polinomio, polCero, esPolCero,

# consPol, grado, coefLider,

# restoPol, polinomioAleatorio)

Para usar el TAD hay que usar una implementación concreta. En principio, consideraremos las siguientes:

mediante listas densas y
mediante listas dispersas.

3.2. Implementación de los polinomios mediante listas densas

Representaremos un polinomio por la lista de sus coeficientes ordenados en orden decreciente según el grado. Por ejemplo, el polinomio

   6x^4 -5x^2 + 4x -7

1	6x^4 -5x^2 + 4x -7

se representa por

   [6,0,-2,4,-7]

1	[6,0,-2,4,-7]

En la representación se supone que, si la lista no es vacía, su primer elemento es distinto de cero.

Se define la clase Polinomio con los siguientes métodos:

esPolCero() se verifica si es el polinomio cero.
consPol(n, b) es el polinomio obtenido añadiendo el térmiono bx^n
grado() es el grado del polinomio.
coefLider() es el coeficiente líder del polinomio.
restoPol() es el resto del polinomio.

Por ejemplo,

   >>> Polinomio()
   0
   >>> ejPol1 = Polinomio().consPol(0,3).consPol(2,-5).consPol(4,3)
   >>> ejPol1
   3*x^4 + -5*x^2 + 3
   >>> ejPol2 = Polinomio().consPol(1,4).consPol(2,5).consPol(5,1)
   >>> ejPol2
   x^5 + 5*x^2 + 4*x
   >>> ejPol3 = Polinomio().consPol(1,2).consPol(4,6)
   >>> ejPol3
   6*x^4 + 2*x
   >>> Polinomio().esPolCero()
   True
   >>> ejPol1.esPolCero()
   False
   >>> ejPol2
   x^5 + 5*x^2 + 4*x
   >>> ejPol2.consPol(3,0)
   x^5 + 5*x^2 + 4*x
   >>> Polinomio().consPol(3,2)
   2*x^3
   >>> ejPol2.consPol(6,7)
   7*x^6 + x^5 + 5*x^2 + 4*x
   >>> ejPol2.consPol(4,7)
   x^5 + 7*x^4 + 5*x^2 + 4*x
   >>> ejPol2.consPol(5,7)
   8*x^5 + 5*x^2 + 4*x
   >>> ejPol3
   6*x^4 + 2*x
   >>> ejPol3.grado()
   4
   >>> ejPol3.restoPol()
   2*x
   >>> ejPol2
   x^5 + 5*x^2 + 4*x
   >>> ejPol2.restoPol()
   5*x^2 + 4*x

>>> Polinomio()

>>> ejPol1 = Polinomio().consPol(0,3).consPol(2,-5).consPol(4,3)

>>> ejPol1

3*x^4 + -5*x^2 + 3

>>> ejPol2 = Polinomio().consPol(1,4).consPol(2,5).consPol(5,1)

>>> ejPol2

x^5 + 5*x^2 + 4*x

>>> ejPol3 = Polinomio().consPol(1,2).consPol(4,6)

>>> ejPol3

6*x^4 + 2*x

>>> Polinomio().esPolCero()

True

>>> ejPol1.esPolCero()

False

>>> ejPol2

x^5 + 5*x^2 + 4*x

>>> ejPol2.consPol(3,0)

x^5 + 5*x^2 + 4*x

>>> Polinomio().consPol(3,2)

2*x^3

>>> ejPol2.consPol(6,7)

7*x^6 + x^5 + 5*x^2 + 4*x

>>> ejPol2.consPol(4,7)

x^5 + 7*x^4 + 5*x^2 + 4*x

>>> ejPol2.consPol(5,7)

8*x^5 + 5*x^2 + 4*x

>>> ejPol3

6*x^4 + 2*x

>>> ejPol3.grado()

>>> ejPol3.restoPol()

2*x

>>> ejPol2

x^5 + 5*x^2 + 4*x

>>> ejPol2.restoPol()

5*x^2 + 4*x

Además se definen las correspondientes funciones. Por ejemplo,

   >>> polCero()
   0
   >>> ejPol1a = consPol(4,3,consPol(2,-5,consPol(0,3,polCero())))
   >>> ejPol1a
   3*x^4 + -5*x^2 + 3
   >>> ejPol2a = consPol(5,1,consPol(2,5,consPol(1,4,polCero())))
   >>> ejPol2a
   x^5 + 5*x^2 + 4*x
   >>> ejPol3a = consPol(4,6,consPol(1,2,polCero()))
   >>> ejPol3a
   6*x^4 + 2*x
   >>> esPolCero(polCero())
   True
   >>> esPolCero(ejPol1a)
   False
   >>> ejPol2a
   x^5 + 5*x^2 + 4*x
   >>> consPol(3,9,ejPol2a)
   x^5 + 9*x^3 + 5*x^2 + 4*x
   >>> consPol(3,2,polCero())
   2*x^3
   >>> consPol(6,7,ejPol2a)
   7*x^6 + x^5 + 5*x^2 + 4*x
   >>> consPol(4,7,ejPol2a)
   x^5 + 7*x^4 + 5*x^2 + 4*x
   >>> consPol(5,7,ejPol2a)
   8*x^5 + 5*x^2 + 4*x
   >>> ejPol3a
   6*x^4 + 2*x
   >>> grado(ejPol3a)
   4
   >>> restoPol(ejPol3a)
   2*x
   >>> ejPol2a
   x^5 + 5*x^2 + 4*x
   >>> restoPol(ejPol2a)
   5*x^2 + 4*x

>>> polCero()

>>> ejPol1a = consPol(4,3,consPol(2,-5,consPol(0,3,polCero())))

>>> ejPol1a

3*x^4 + -5*x^2 + 3

>>> ejPol2a = consPol(5,1,consPol(2,5,consPol(1,4,polCero())))

>>> ejPol2a

x^5 + 5*x^2 + 4*x

>>> ejPol3a = consPol(4,6,consPol(1,2,polCero()))

>>> ejPol3a

6*x^4 + 2*x

>>> esPolCero(polCero())

True

>>> esPolCero(ejPol1a)

False

>>> ejPol2a

x^5 + 5*x^2 + 4*x

>>> consPol(3,9,ejPol2a)

x^5 + 9*x^3 + 5*x^2 + 4*x

>>> consPol(3,2,polCero())

2*x^3

>>> consPol(6,7,ejPol2a)

7*x^6 + x^5 + 5*x^2 + 4*x

>>> consPol(4,7,ejPol2a)

x^5 + 7*x^4 + 5*x^2 + 4*x

>>> consPol(5,7,ejPol2a)

8*x^5 + 5*x^2 + 4*x

>>> ejPol3a

6*x^4 + 2*x

>>> grado(ejPol3a)

>>> restoPol(ejPol3a)

2*x

>>> ejPol2a

x^5 + 5*x^2 + 4*x

>>> restoPol(ejPol2a)

5*x^2 + 4*x

Finalmente, se define un generador aleatorio de polinomios y se comprueba que los polinomios cumplen las propiedades de su especificación.

La implementación se encuentra en el módulo PolRepDensa.py en el que se define la clase Conj con los siguientes métodos:

from __future__ import annotations

__all__ = [
    'Polinomio',
    'polCero',
    'esPolCero',
    'consPol',
    'grado',
    'coefLider',
    'restoPol',
    'polinomioAleatorio'
]

from dataclasses import dataclass, field
from itertools import dropwhile
from typing import Generic, TypeVar

from hypothesis import assume, given
from hypothesis import strategies as st

A = TypeVar('A', int, float, complex)

# Clase de los polinomios mediante listas densas
# ==============================================

@dataclass
class Polinomio(Generic[A]):
    _coeficientes: list[A] = field(default_factory=list)

    def esPolCero(self) -> bool:
        return not self._coeficientes

    def grado(self) -> int:
        if self.esPolCero():
            return 0
        return len(self._coeficientes) - 1

    def coefLider(self) -> A:
        if self.esPolCero():
            return 0
        return self._coeficientes[0]

    def restoPol(self) -> Polinomio[A]:
        xs = self._coeficientes
        if len(xs) <= 1:
            return Polinomio([])
        if xs[1] == 0:
            return Polinomio(list(dropwhile(lambda x: x == 0, xs[2:])))
        return Polinomio(xs[1:])

    def consPol(self, n: int, b: A) -> Polinomio[A]:
        m = self.grado()
        c = self.coefLider()
        xs = self._coeficientes
        if b == 0:
            return self
        if self.esPolCero():
            return Polinomio([b] + ([0] * n))
        if n > m:
            return Polinomio([b] + ([0] * (n-m-1)) + xs)
        if n < m:
            return self.restoPol().consPol(n, b).consPol(m, c)
        if b + c == 0:
            return Polinomio(list(dropwhile(lambda x: x == 0, xs[1:])))
        return Polinomio([b + c] + xs[1:])

    def __repr__(self) -> str:
        n = self.grado()
        a = self.coefLider()
        p = self.restoPol()
        if self.esPolCero():
            return "0"
        if n == 0 and p.esPolCero():
            return str(a)
        if n == 0:
            return str(a) + " + " + str(p)
        if n == 1 and p.esPolCero():
            return str(a) + "*x"
        if n == 1:
            return str(a) + "*x + " + str(p)
        if a == 1 and p.esPolCero():
            return "x^" + str(n)
        if p.esPolCero():
            return str(a) + "*x^" + str(n)
        if a == 1:
            return "x^" + str(n) + " + " + str(p)
        return str(a) + "*x^" + str(n) + " + " + str(p)

# Funciones del tipo polinomio
# ============================

def polCero() -> Polinomio[A]:
    return Polinomio([])

def esPolCero(p: Polinomio[A]) -> bool:
    return p.esPolCero()

def grado(p: Polinomio[A]) -> int:
    return p.grado()

def coefLider(p: Polinomio[A]) -> A:
    return p.coefLider()

def restoPol(p: Polinomio[A]) -> Polinomio[A]:
    return p.restoPol()

def consPol(n: int, b: A, p: Polinomio[A]) -> Polinomio[A]:
    return p.consPol(n, b)

# Generador de polinomios
# =======================

# normal(xs) es la lista obtenida eliminando los ceros iniciales de
# xs. Por ejmplo,
#    >>> normal([0,0,5,0])
#    [5, 0]
#    >>> normal([0,0,0,0])
#    []
def normal(xs: list[A]) -> list[A]:
    return list(dropwhile(lambda x: x == 0, xs))

# polinomioAleatorio() genera polinomios aleatorios. Por ejemplo,
#    >>> polinomioAleatorio().example()
#    9*x^6 + -7*x^5 + 7*x^3 + x^2 + 7
#    >>> polinomioAleatorio().example()
#    -3*x^7 + 8*x^6 + 2*x^5 + x^4 + -1*x^3 + -6*x^2 + 8*x + -6
#    >>> polinomioAleatorio().example()
#    x^2 + 7*x + -1
def polinomioAleatorio() -> st.SearchStrategy[Polinomio[int]]:
    return st.lists(st.integers(min_value=-9, max_value=9), max_size=10)\
             .map(lambda xs: normal(xs))\
             .map(Polinomio)

# Comprobación de las propiedades de los polinomios
# =================================================

# Las propiedades son
def test_esPolCero1() -> None:
    assert esPolCero(polCero())

@given(p=polinomioAleatorio(),
       n=st.integers(min_value=0, max_value=10),
       b=st.integers())
def test_esPolCero2(p: Polinomio[int], n: int, b: int) -> None:
    assume(n > grado(p) and b != 0)
    assert not esPolCero(consPol(n, b, p))

@given(p=polinomioAleatorio())
def test_consPol(p: Polinomio[int]) -> None:
    assume(not esPolCero(p))
    assert consPol(grado(p), coefLider(p), restoPol(p)) == p

@given(p=polinomioAleatorio(),
       n=st.integers(min_value=0, max_value=10),
       b=st.integers())
def test_grado(p: Polinomio[int], n: int, b: int) -> None:
    assume(n > grado(p) and b != 0)
    assert grado(consPol(n, b, p)) == n

@given(p=polinomioAleatorio(),
       n=st.integers(min_value=0, max_value=10),
       b=st.integers())
def test_coefLider(p: Polinomio[int], n: int, b: int) -> None:
    assume(n > grado(p) and b != 0)
    assert coefLider(consPol(n, b, p)) == b

@given(p=polinomioAleatorio(),
       n=st.integers(min_value=0, max_value=10),
       b=st.integers())
def test_restoPol(p: Polinomio[int], n: int, b: int) -> None:
    assume(n > grado(p) and b != 0)
    assert restoPol(consPol(n, b, p)) == p

# La comprobación es
#    > poetry run pytest -v PolRepDensa.py
#
#    PolRepDensa.py::test_esPolCero1 PASSED
#    PolRepDensa.py::test_esPolCero2 PASSED
#    PolRepDensa.py::test_consPol PASSED
#    PolRepDensa.py::test_grado PASSED
#    PolRepDensa.py::test_coefLider PASSED
#    PolRepDensa.py::test_restoPol PASSED
#
#    === 6 passed in 1.64s ===

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

from __future__ import annotations

__all__ = [

'Polinomio',

'polCero',

'esPolCero',

'consPol',

'grado',

'coefLider',

'restoPol',

'polinomioAleatorio'

]

from dataclasses import dataclass, field

from itertools import dropwhile

from typing import Generic, TypeVar

from hypothesis import assume, given

from hypothesis import strategies as st

A = TypeVar('A', int, float, complex)

# Clase de los polinomios mediante listas densas

# ==============================================

@dataclass

class Polinomio(Generic[A]):

_coeficientes: list[A] = field(default_factory=list)

def esPolCero(self) -> bool:

return not self._coeficientes

def grado(self) -> int:

if self.esPolCero():

return 0

return len(self._coeficientes) - 1

def coefLider(self) -> A:

if self.esPolCero():

return 0

return self._coeficientes[0]

def restoPol(self) -> Polinomio[A]:

xs = self._coeficientes

if len(xs) <= 1:

return Polinomio([])

if xs[1] == 0:

return Polinomio(list(dropwhile(lambda x: x == 0, xs[2:])))

return Polinomio(xs[1:])

def consPol(self, n: int, b: A) -> Polinomio[A]:

m = self.grado()

c = self.coefLider()

xs = self._coeficientes

if b == 0:

return self

if self.esPolCero():

return Polinomio([b] + ([0] * n))

if n > m:

return Polinomio([b] + ([0] * (n-m-1)) + xs)

if n < m:

return self.restoPol().consPol(n, b).consPol(m, c)

if b + c == 0:

return Polinomio(list(dropwhile(lambda x: x == 0, xs[1:])))

return Polinomio([b + c] + xs[1:])

def __repr__(self) -> str:

n = self.grado()

a = self.coefLider()

p = self.restoPol()

if self.esPolCero():

return "0"

if n == 0 and p.esPolCero():

return str(a)

if n == 0:

return str(a) + " + " + str(p)

if n == 1 and p.esPolCero():

return str(a) + "*x"

if n == 1:

return str(a) + "*x + " + str(p)

if a == 1 and p.esPolCero():

return "x^" + str(n)

if p.esPolCero():

return str(a) + "*x^" + str(n)

if a == 1:

return "x^" + str(n) + " + " + str(p)

return str(a) + "*x^" + str(n) + " + " + str(p)

# Funciones del tipo polinomio

# ============================

def polCero() -> Polinomio[A]:

return Polinomio([])

def esPolCero(p: Polinomio[A]) -> bool:

return p.esPolCero()

def grado(p: Polinomio[A]) -> int:

return p.grado()

def coefLider(p: Polinomio[A]) -> A:

return p.coefLider()

def restoPol(p: Polinomio[A]) -> Polinomio[A]:

return p.restoPol()

def consPol(n: int, b: A, p: Polinomio[A]) -> Polinomio[A]:

return p.consPol(n, b)

# Generador de polinomios

# =======================

# normal(xs) es la lista obtenida eliminando los ceros iniciales de

# xs. Por ejmplo,

# >>> normal([0,0,5,0])

# [5, 0]

# >>> normal([0,0,0,0])

# []

def normal(xs: list[A]) -> list[A]:

return list(dropwhile(lambda x: x == 0, xs))

# polinomioAleatorio() genera polinomios aleatorios. Por ejemplo,

# >>> polinomioAleatorio().example()

# 9*x^6 + -7*x^5 + 7*x^3 + x^2 + 7

# >>> polinomioAleatorio().example()

# -3*x^7 + 8*x^6 + 2*x^5 + x^4 + -1*x^3 + -6*x^2 + 8*x + -6

# >>> polinomioAleatorio().example()

# x^2 + 7*x + -1

def polinomioAleatorio() -> st.SearchStrategy[Polinomio[int]]:

return st.lists(st.integers(min_value=-9, max_value=9), max_size=10)\

.map(lambda xs: normal(xs))\

.map(Polinomio)

# Comprobación de las propiedades de los polinomios

# =================================================

# Las propiedades son

def test_esPolCero1() -> None:

assert esPolCero(polCero())

@given(p=polinomioAleatorio(),

n=st.integers(min_value=0, max_value=10),

b=st.integers())

def test_esPolCero2(p: Polinomio[int], n: int, b: int) -> None:

assume(n > grado(p) and b != 0)

assert not esPolCero(consPol(n, b, p))

@given(p=polinomioAleatorio())

def test_consPol(p: Polinomio[int]) -> None:

assume(not esPolCero(p))

assert consPol(grado(p), coefLider(p), restoPol(p)) == p

@given(p=polinomioAleatorio(),

n=st.integers(min_value=0, max_value=10),

b=st.integers())

def test_grado(p: Polinomio[int], n: int, b: int) -> None:

assume(n > grado(p) and b != 0)

assert grado(consPol(n, b, p)) == n

@given(p=polinomioAleatorio(),

n=st.integers(min_value=0, max_value=10),

b=st.integers())

def test_coefLider(p: Polinomio[int], n: int, b: int) -> None:

assume(n > grado(p) and b != 0)

assert coefLider(consPol(n, b, p)) == b

@given(p=polinomioAleatorio(),

n=st.integers(min_value=0, max_value=10),

b=st.integers())

def test_restoPol(p: Polinomio[int], n: int, b: int) -> None:

assume(n > grado(p) and b != 0)

assert restoPol(consPol(n, b, p)) == p

# La comprobación es

# > poetry run pytest -v PolRepDensa.py

# PolRepDensa.py::test_esPolCero1 PASSED

# PolRepDensa.py::test_esPolCero2 PASSED

# PolRepDensa.py::test_consPol PASSED

# PolRepDensa.py::test_grado PASSED

# PolRepDensa.py::test_coefLider PASSED

# PolRepDensa.py::test_restoPol PASSED

# === 6 passed in 1.64s ===

3.3. Implementación de los polinomios mediante listas dispersas

Representaremos un polinomio mediante una lista de pares (grado,coef), ordenados en orden decreciente según el grado. Por ejemplo, el polinomio

   6x^4 -5x^2 + 4x -7

1	6x^4 -5x^2 + 4x -7

se representa por

   [(4,6),(2,-5),(1,4),(0,-7)]

1	[(4,6),(2,-5),(1,4),(0,-7)]

En la representación se supone que los primeros elementos de los pares forman una sucesión estrictamente decreciente y que los segundos elementos son distintos de cero.

La implementación se encuentra en el módulo PolRepDispersa.py cuyo contenido es

from __future__ import annotations

__all__ = [
    'Polinomio',
    'polCero',
    'esPolCero',
    'consPol',
    'grado',
    'coefLider',
    'restoPol',
    'polinomioAleatorio'
]

from dataclasses import dataclass, field
from typing import Generic, TypeVar

from hypothesis import assume, given
from hypothesis import strategies as st

A = TypeVar('A', int, float, complex)

# Clase de los polinomios mediante listas densas
# ==============================================

@dataclass
class Polinomio(Generic[A]):
    _terminos: list[tuple[int, A]] = field(default_factory=list)

    def esPolCero(self) -> bool:
        return not self._terminos

    def grado(self) -> int:
        if self.esPolCero():
            return 0
        return self._terminos[0][0]

    def coefLider(self) -> A:
        if self.esPolCero():
            return 0
        return self._terminos[0][1]

    def restoPol(self) -> Polinomio[A]:
        xs = self._terminos
        if len(xs) <= 1:
            return Polinomio([])
        return Polinomio(xs[1:])

    def consPol(self, n: int, b: A) -> Polinomio[A]:
        m = self.grado()
        c = self.coefLider()
        xs = self._terminos
        if b == 0:
            return self
        if self.esPolCero():
            return Polinomio([(n, b)])
        if n > m:
            return Polinomio([(n, b)] + xs)
        if n < m:
            return Polinomio(xs[1:]).consPol(n, b).consPol(m, c)
        if b + c == 0:
            return Polinomio(xs[1:])
        return Polinomio([(n, b + c)] + xs[1:])

    def __repr__(self) -> str:
        n = self.grado()
        a = self.coefLider()
        p = self.restoPol()
        if self.esPolCero():
            return "0"
        if n == 0 and p.esPolCero():
            return str(a)
        if n == 0:
            return str(a) + " + " + str(p)
        if n == 1 and p.esPolCero():
            return str(a) + "*x"
        if n == 1:
            return str(a) + "*x + " + str(p)
        if a == 1 and p.esPolCero():
            return "x^" + str(n)
        if p.esPolCero():
            return str(a) + "*x^" + str(n)
        if a == 1:
            return "x^" + str(n) + " + " + str(p)
        return str(a) + "*x^" + str(n) + " + " + str(p)

# Funciones del tipo polinomio
# ============================

def polCero() -> Polinomio[A]:
    return Polinomio([])

def esPolCero(p: Polinomio[A]) -> bool:
    return p.esPolCero()

def grado(p: Polinomio[A]) -> int:
    return p.grado()

def coefLider(p: Polinomio[A]) -> A:
    return p.coefLider()

def restoPol(p: Polinomio[A]) -> Polinomio[A]:
    return p.restoPol()

def consPol(n: int, b: A, p: Polinomio[A]) -> Polinomio[A]:
    return p.consPol(n, b)

# Generador de polinomios
# =======================

# normal(ps) es la representación dispersa de un polinomio.
def normal(ps: list[tuple[int, A]]) -> list[tuple[int, A]]:
    xs = sorted(list({p[0] for p in ps}), reverse=True)
    ys = [p[1] for p in ps]
    return [(x, y) for (x, y) in zip(xs, ys) if y != 0]

# polinomioAleatorio() genera polinomios aleatorios. Por ejemplo,
#    >>> polinomioAleatorio().example()
#    -4*x^8 + -5*x^7 + -4*x^6 + -4*x^5 + -8*x^3
#    >>> polinomioAleatorio().example()
#    -7*x^9 + -8*x^6 + -8*x^3 + 2*x^2 + -1*x + 4
def polinomioAleatorio() -> st.SearchStrategy[Polinomio[int]]:
    return st.lists(st.tuples(st.integers(min_value=0, max_value=9),
                              st.integers(min_value=-9, max_value=9)))\
             .map(lambda ps: normal(ps))\
             .map(Polinomio)

# Comprobación de las propiedades de los polinomios
# =================================================

# Las propiedades son
def test_esPolCero1() -> None:
    assert esPolCero(polCero())

@given(p=polinomioAleatorio(),
       n=st.integers(min_value=0, max_value=10),
       b=st.integers())
def test_esPolCero2(p: Polinomio[int], n: int, b: int) -> None:
    assume(n > grado(p) and b != 0)
    assert not esPolCero(consPol(n, b, p))

@given(p=polinomioAleatorio())
def test_consPol(p: Polinomio[int]) -> None:
    assume(not esPolCero(p))
    assert consPol(grado(p), coefLider(p), restoPol(p)) == p

@given(p=polinomioAleatorio(),
       n=st.integers(min_value=0, max_value=10),
       b=st.integers())
def test_grado(p: Polinomio[int], n: int, b: int) -> None:
    assume(n > grado(p) and b != 0)
    assert grado(consPol(n, b, p)) == n

@given(p=polinomioAleatorio(),
       n=st.integers(min_value=0, max_value=10),
       b=st.integers())
def test_coefLider(p: Polinomio[int], n: int, b: int) -> None:
    assume(n > grado(p) and b != 0)
    assert coefLider(consPol(n, b, p)) == b

@given(p=polinomioAleatorio(),
       n=st.integers(min_value=0, max_value=10),
       b=st.integers())
def test_restoPol(p: Polinomio[int], n: int, b: int) -> None:
    assume(n > grado(p) and b != 0)
    assert restoPol(consPol(n, b, p)) == p

# La comprobación es
#    > poetry run pytest -v PolRepDispersa.py
#
#    PolRepDispersa.py::test_esPolCero1 PASSED
#    PolRepDispersa.py::test_esPolCero2 PASSED
#    PolRepDispersa.py::test_consPol PASSED
#    PolRepDispersa.py::test_grado PASSED
#    PolRepDispersa.py::test_coefLider PASSED
#    PolRepDispersa.py::test_restoPol PASSED
#
#    === 6 passed in 1.74s ===

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

from __future__ import annotations

__all__ = [

'Polinomio',

'polCero',

'esPolCero',

'consPol',

'grado',

'coefLider',

'restoPol',

'polinomioAleatorio'

]

from dataclasses import dataclass, field

from typing import Generic, TypeVar

from hypothesis import assume, given

from hypothesis import strategies as st

A = TypeVar('A', int, float, complex)

# Clase de los polinomios mediante listas densas

# ==============================================

@dataclass

class Polinomio(Generic[A]):

_terminos: list[tuple[int, A]] = field(default_factory=list)

def esPolCero(self) -> bool:

return not self._terminos

def grado(self) -> int:

if self.esPolCero():

return 0

return self._terminos[0][0]

def coefLider(self) -> A:

if self.esPolCero():

return 0

return self._terminos[0][1]

def restoPol(self) -> Polinomio[A]:

xs = self._terminos

if len(xs) <= 1:

return Polinomio([])

return Polinomio(xs[1:])

def consPol(self, n: int, b: A) -> Polinomio[A]:

m = self.grado()

c = self.coefLider()

xs = self._terminos

if b == 0:

return self

if self.esPolCero():

return Polinomio([(n, b)])

if n > m:

return Polinomio([(n, b)] + xs)

if n < m:

return Polinomio(xs[1:]).consPol(n, b).consPol(m, c)

if b + c == 0:

return Polinomio(xs[1:])

return Polinomio([(n, b + c)] + xs[1:])

def __repr__(self) -> str:

n = self.grado()

a = self.coefLider()

p = self.restoPol()

if self.esPolCero():

return "0"

if n == 0 and p.esPolCero():

return str(a)

if n == 0:

return str(a) + " + " + str(p)

if n == 1 and p.esPolCero():

return str(a) + "*x"

if n == 1:

return str(a) + "*x + " + str(p)

if a == 1 and p.esPolCero():

return "x^" + str(n)

if p.esPolCero():

return str(a) + "*x^" + str(n)

if a == 1:

return "x^" + str(n) + " + " + str(p)

return str(a) + "*x^" + str(n) + " + " + str(p)

# Funciones del tipo polinomio

# ============================

def polCero() -> Polinomio[A]:

return Polinomio([])

def esPolCero(p: Polinomio[A]) -> bool:

return p.esPolCero()

def grado(p: Polinomio[A]) -> int:

return p.grado()

def coefLider(p: Polinomio[A]) -> A:

return p.coefLider()

def restoPol(p: Polinomio[A]) -> Polinomio[A]:

return p.restoPol()

def consPol(n: int, b: A, p: Polinomio[A]) -> Polinomio[A]:

return p.consPol(n, b)

# Generador de polinomios

# =======================

# normal(ps) es la representación dispersa de un polinomio.

def normal(ps: list[tuple[int, A]]) -> list[tuple[int, A]]:

xs = sorted(list({p[0] for p in ps}), reverse=True)

ys = [p[1] for p in ps]

return [(x, y) for (x, y) in zip(xs, ys) if y != 0]

# polinomioAleatorio() genera polinomios aleatorios. Por ejemplo,

# >>> polinomioAleatorio().example()

# -4*x^8 + -5*x^7 + -4*x^6 + -4*x^5 + -8*x^3

# >>> polinomioAleatorio().example()

# -7*x^9 + -8*x^6 + -8*x^3 + 2*x^2 + -1*x + 4

def polinomioAleatorio() -> st.SearchStrategy[Polinomio[int]]:

return st.lists(st.tuples(st.integers(min_value=0, max_value=9),

st.integers(min_value=-9, max_value=9)))\

.map(lambda ps: normal(ps))\

.map(Polinomio)

# Comprobación de las propiedades de los polinomios

# =================================================

# Las propiedades son

def test_esPolCero1() -> None:

assert esPolCero(polCero())

@given(p=polinomioAleatorio(),

n=st.integers(min_value=0, max_value=10),

b=st.integers())

def test_esPolCero2(p: Polinomio[int], n: int, b: int) -> None:

assume(n > grado(p) and b != 0)

assert not esPolCero(consPol(n, b, p))

@given(p=polinomioAleatorio())

def test_consPol(p: Polinomio[int]) -> None:

assume(not esPolCero(p))

assert consPol(grado(p), coefLider(p), restoPol(p)) == p

@given(p=polinomioAleatorio(),

n=st.integers(min_value=0, max_value=10),

b=st.integers())

def test_grado(p: Polinomio[int], n: int, b: int) -> None:

assume(n > grado(p) and b != 0)

assert grado(consPol(n, b, p)) == n

@given(p=polinomioAleatorio(),

n=st.integers(min_value=0, max_value=10),

b=st.integers())

def test_coefLider(p: Polinomio[int], n: int, b: int) -> None:

assume(n > grado(p) and b != 0)

assert coefLider(consPol(n, b, p)) == b

@given(p=polinomioAleatorio(),

n=st.integers(min_value=0, max_value=10),

b=st.integers())

def test_restoPol(p: Polinomio[int], n: int, b: int) -> None:

assume(n > grado(p) and b != 0)

assert restoPol(consPol(n, b, p)) == p

# La comprobación es

# > poetry run pytest -v PolRepDispersa.py

# PolRepDispersa.py::test_esPolCero1 PASSED

# PolRepDispersa.py::test_esPolCero2 PASSED

# PolRepDispersa.py::test_consPol PASSED

# PolRepDispersa.py::test_grado PASSED

# PolRepDispersa.py::test_coefLider PASSED

# PolRepDispersa.py::test_restoPol PASSED

# === 6 passed in 1.74s ===

Clausura transitiva

PorJosé A. Alonso 14-abril-202314-abril-2023

Usando el tipo de las relaciones binarias, definir la función

   clausuraTransitiva :: Eq a => Rel a -> Rel a

1	clausuraTransitiva :: Eq a => Rel a -> Rel a

tal que clausuraTransitiva r es la clausura transitiva de r; es decir, la menor relación transitiva que contiene a r. Por ejemplo,

   λ> clausuraTransitiva (R ([1..6],[(1,2),(2,5),(5,6)]))
   R ([1,2,3,4,5,6],[(1,2),(2,5),(5,6),(1,5),(2,6),(1,6)])

1 2	λ> clausuraTransitiva (R ([1..6],[(1,2),(2,5),(5,6)])) R ([1,2,3,4,5,6],[(1,2),(2,5),(5,6),(1,5),(2,6),(1,6)])

Comprobar con QuickCheck que clausuraTransitiva es transitiva.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Relaciones_binarias (Rel(R))
import Relaciones_transitivas (transitiva)
import Data.List (union)
import Test.QuickCheck

--  1ª solución
--  ===========

clausuraTransitiva :: Ord a => Rel a -> Rel a
clausuraTransitiva (R (u,g)) = R (u, aux g)
  where
    aux u' | cerradoTr u' = u'
           | otherwise    = aux (u' `union` comp u' u')
    cerradoTr r       = subconjunto (comp r r) r
    comp r s          = [(x,z) | (x,y) <- r, (y',z) <- s, y == y']
    subconjunto xs ys = all (`elem` ys) xs

-- 2ª solución
-- ===========

clausuraTransitiva2 :: Ord a => Rel a -> Rel a
clausuraTransitiva2 (R (u,g)) =
  R (u, until cerradoTr (\r -> r `union` comp r r) g)
  where
    cerradoTr r       = subconjunto (comp r r) r
    comp r s          = [(x,z) | (x,y) <- r, (y',z) <- s, y == y']
    subconjunto xs ys = all (`elem` ys) xs


-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_clausuraTransitiva :: Rel Int -> Bool
prop_clausuraTransitiva r =
  clausuraTransitiva r == clausuraTransitiva2 r

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

-- Propiedad
-- =========

-- La propiedad es
prop_clausuraTransitivaEsTransitiva :: Rel Int -> Bool
prop_clausuraTransitivaEsTransitiva r =
  transitiva (clausuraTransitiva r)

-- La función transitiva está definida en el ejercicio
-- "Relaciones transitivas" que se encuentra en
-- https://bit.ly/42WRPJv

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

import Relaciones_binarias (Rel(R))

import Relaciones_transitivas (transitiva)

import Data.List (union)

import Test.QuickCheck

-- 1ª solución

-- ===========

clausuraTransitiva :: Ord a => Rel a -> Rel a

clausuraTransitiva (R (u,g)) = R (u, aux g)

where

aux u' | cerradoTr u' = u'

| otherwise = aux (u' `union` comp u' u')

cerradoTr r = subconjunto (comp r r) r

comp r s = [(x,z) | (x,y) <- r, (y',z) <- s, y == y']

subconjunto xs ys = all (`elem` ys) xs

-- 2ª solución

-- ===========

clausuraTransitiva2 :: Ord a => Rel a -> Rel a

clausuraTransitiva2 (R (u,g)) =

R (u, until cerradoTr (\r -> r `union` comp r r) g)

where

cerradoTr r = subconjunto (comp r r) r

comp r s = [(x,z) | (x,y) <- r, (y',z) <- s, y == y']

subconjunto xs ys = all (`elem` ys) xs

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_clausuraTransitiva :: Rel Int -> Bool

prop_clausuraTransitiva r =

clausuraTransitiva r == clausuraTransitiva2 r

-- La comprobación es

-- λ> quickCheck prop_clausuraTransitiva

-- +++ OK, passed 100 tests.

-- Propiedad

-- =========

-- La propiedad es

prop_clausuraTransitivaEsTransitiva :: Rel Int -> Bool

prop_clausuraTransitivaEsTransitiva r =

transitiva (clausuraTransitiva r)

-- La función transitiva está definida en el ejercicio

-- "Relaciones transitivas" que se encuentra en

-- https://bit.ly/42WRPJv

-- La comprobación es

-- λ> quickCheck prop_clausuraTransitivaEsTransitiva

-- +++ OK, passed 100 tests.

Soluciones en Python

from typing import TypeVar

from hypothesis import given
from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria
from src.Relaciones_transitivas import transitiva

A = TypeVar('A')

# 1ª solución
# ===========

def clausuraTransitiva(r: Rel[A]) -> Rel[A]:
    (u, g) = r

    def subconjunto(xs: list[tuple[A, A]], ys: list[tuple[A, A]]) -> bool:
        return set(xs) <= set(ys)

    def comp(r: list[tuple[A, A]], s: list[tuple[A, A]]) -> list[tuple[A, A]]:
        return list({(x, z) for (x, y) in r for (y1, z) in s if y == y1})

    def cerradoTr(r: list[tuple[A, A]]) -> bool:
        return subconjunto(comp(r, r), r)

    def union(xs: list[tuple[A, A]], ys: list[tuple[A, A]]) -> list[tuple[A, A]]:
        return xs + [y for y in ys if y not in xs]

    def aux(u1: list[tuple[A, A]]) -> list[tuple[A, A]]:
        if cerradoTr(u1):
            return u1
        return aux(union(u1, comp(u1, u1)))

    return (u, aux(g))

# 2ª solución
# ===========

def clausuraTransitiva2(r: Rel[A]) -> Rel[A]:
    (u, g) = r

    def subconjunto(xs: list[tuple[A, A]], ys: list[tuple[A, A]]) -> bool:
        return set(xs) <= set(ys)

    def comp(r: list[tuple[A, A]], s: list[tuple[A, A]]) -> list[tuple[A, A]]:
        return list({(x, z) for (x, y) in r for (y1, z) in s if y == y1})

    def cerradoTr(r: list[tuple[A, A]]) -> bool:
        return subconjunto(comp(r, r), r)

    def union(xs: list[tuple[A, A]], ys: list[tuple[A, A]]) -> list[tuple[A, A]]:
        return xs + [y for y in ys if y not in xs]

    def aux(u1: list[tuple[A, A]]) -> list[tuple[A, A]]:
        if cerradoTr(u1):
            return u1
        return aux(union(u1, comp(u1, u1)))

    g1: list[tuple[A, A]] = g
    while not cerradoTr(g1):
        g1 = union(g1, comp(g1, g1))
    return (u, g1)

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(st.integers(min_value=0, max_value=10))
def test_clausuraTransitiva(n: int) -> None:
    r = relacionArbitraria(n)
    assert clausuraTransitiva(r) == clausuraTransitiva2(r)

# Propiedad
# =========

# La propiedad es
@given(st.integers(min_value=0, max_value=10))
def test_cla(n: int) -> None:
    r = relacionArbitraria(n)
    assert transitiva(clausuraTransitiva(r))

# La función transitiva está definida en el ejercicio
# "Relaciones transitivas" que se encuentra en
# https://bit.ly/42WRPJv

# La comprobación es
#    > poetry run pytest -q Clausura_transitiva.py
#    2 passed in 0.16s

from typing import TypeVar

from hypothesis import given

from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria

from src.Relaciones_transitivas import transitiva

A = TypeVar('A')

# 1ª solución

# ===========

def clausuraTransitiva(r: Rel[A]) -> Rel[A]:

(u, g) = r

def subconjunto(xs: list[tuple[A, A]], ys: list[tuple[A, A]]) -> bool:

return set(xs) <= set(ys)

def comp(r: list[tuple[A, A]], s: list[tuple[A, A]]) -> list[tuple[A, A]]:

return list({(x, z) for (x, y) in r for (y1, z) in s if y == y1})

def cerradoTr(r: list[tuple[A, A]]) -> bool:

return subconjunto(comp(r, r), r)

def union(xs: list[tuple[A, A]], ys: list[tuple[A, A]]) -> list[tuple[A, A]]:

return xs + [y for y in ys if y not in xs]

def aux(u1: list[tuple[A, A]]) -> list[tuple[A, A]]:

if cerradoTr(u1):

return u1

return aux(union(u1, comp(u1, u1)))

return (u, aux(g))

# 2ª solución

# ===========

def clausuraTransitiva2(r: Rel[A]) -> Rel[A]:

(u, g) = r

def subconjunto(xs: list[tuple[A, A]], ys: list[tuple[A, A]]) -> bool:

return set(xs) <= set(ys)

def comp(r: list[tuple[A, A]], s: list[tuple[A, A]]) -> list[tuple[A, A]]:

return list({(x, z) for (x, y) in r for (y1, z) in s if y == y1})

def cerradoTr(r: list[tuple[A, A]]) -> bool:

return subconjunto(comp(r, r), r)

def union(xs: list[tuple[A, A]], ys: list[tuple[A, A]]) -> list[tuple[A, A]]:

return xs + [y for y in ys if y not in xs]

def aux(u1: list[tuple[A, A]]) -> list[tuple[A, A]]:

if cerradoTr(u1):

return u1

return aux(union(u1, comp(u1, u1)))

g1: list[tuple[A, A]] = g

while not cerradoTr(g1):

g1 = union(g1, comp(g1, g1))

return (u, g1)

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(st.integers(min_value=0, max_value=10))

def test_clausuraTransitiva(n: int) -> None:

r = relacionArbitraria(n)

assert clausuraTransitiva(r) == clausuraTransitiva2(r)

# Propiedad

# =========

# La propiedad es

@given(st.integers(min_value=0, max_value=10))

def test_cla(n: int) -> None:

r = relacionArbitraria(n)

assert transitiva(clausuraTransitiva(r))

# La función transitiva está definida en el ejercicio

# "Relaciones transitivas" que se encuentra en

# https://bit.ly/42WRPJv

# La comprobación es

# > poetry run pytest -q Clausura_transitiva.py

# 2 passed in 0.16s

Clausura simétrica

PorJosé A. Alonso 13-abril-202330-marzo-2023

Usando el tipo de las relaciones binarias, definir la función

   clausuraSimetrica :: Eq a => Rel a -> Rel a

1	clausuraSimetrica :: Eq a => Rel a -> Rel a

tal que clausuraSimetrica r es la clausura simétrica de r; es decir, la menor relación simétrica que contiene a r. Por ejemplo,

   λ> clausuraSimetrica (R ([1,3,5],[(1,1),(3,1),(1,5)]))
   R ([1,3,5],[(1,1),(3,1),(1,5),(1,3),(5,1)])

1 2	λ> clausuraSimetrica (R ([1,3,5],[(1,1),(3,1),(1,5)])) R ([1,3,5],[(1,1),(3,1),(1,5),(1,3),(5,1)])

Comprobar con QuickCheck que clausuraSimetrica es simétrica.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Relaciones_binarias (Rel(R))
import Data.List (union)
import Relaciones_simetricas (simetrica)
import Test.QuickCheck

clausuraSimetrica :: Eq a => Rel a -> Rel a
clausuraSimetrica (R (u,g)) =
  R (u, g `union` [(y,x) | (x,y) <- g])

-- La propiedad es
prop_ClausuraSimetrica :: Rel Int -> Bool
prop_ClausuraSimetrica r =
  simetrica (clausuraSimetrica r)

-- La función simetrica está definida en el ejercicio
-- "Relaciones simétricas" que se encuentra en
-- https://bit.ly/3zlO2rH

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

import Relaciones_binarias (Rel(R))

import Data.List (union)

import Relaciones_simetricas (simetrica)

import Test.QuickCheck

clausuraSimetrica :: Eq a => Rel a -> Rel a

clausuraSimetrica (R (u,g)) =

R (u, g `union` [(y,x) | (x,y) <- g])

-- La propiedad es

prop_ClausuraSimetrica :: Rel Int -> Bool

prop_ClausuraSimetrica r =

simetrica (clausuraSimetrica r)

-- La función simetrica está definida en el ejercicio

-- "Relaciones simétricas" que se encuentra en

-- https://bit.ly/3zlO2rH

-- La comprobación es

-- λ> quickCheck prop_ClausuraSimetrica

-- +++ OK, passed 100 tests.

Soluciones en Python

from typing import TypeVar

from hypothesis import given
from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria
from src.Relaciones_simetricas import simetrica

A = TypeVar('A')

def clausuraSimetrica(r: Rel[A]) -> Rel[A]:
    (u, g) = r
    return (u, list(set(g) | {(y, x) for (x,y) in g}))

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(st.integers(min_value=0, max_value=10))
def test_irreflexiva(n: int) -> None:
    r = relacionArbitraria(n)
    assert simetrica(clausuraSimetrica(r))

# La función simetrica está definida en el ejercicio
# "Relaciones simétricas" que se encuentra en
# https://bit.ly/3zlO2rH

# La comprobación es
#    > poetry run pytest -q Clausura_simetrica.py
#    1 passed in 0.12s

from typing import TypeVar

from hypothesis import given

from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria

from src.Relaciones_simetricas import simetrica

A = TypeVar('A')

def clausuraSimetrica(r: Rel[A]) -> Rel[A]:

(u, g) = r

return (u, list(set(g) | {(y, x) for (x,y) in g}))

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(st.integers(min_value=0, max_value=10))

def test_irreflexiva(n: int) -> None:

r = relacionArbitraria(n)

assert simetrica(clausuraSimetrica(r))

# La función simetrica está definida en el ejercicio

# "Relaciones simétricas" que se encuentra en

# https://bit.ly/3zlO2rH

# La comprobación es

# > poetry run pytest -q Clausura_simetrica.py

# 1 passed in 0.12s

1. El tipo abstracto de datos de los grafos

2. Los grafos en Haskell

2.1. El tipo abstracto de datos de los grafos en Haskell

2.2. Implementación de los grafos mediante listas de adyacencia

2.3. Implementación de los grafos mediante vectores de adyacencia

2.3. Implementación de los grafos mediante vectores de adyacencia

3. Los grafos en Python

3.1. El tipo abstracto de los grafos en Python

3.2. Implementación de los grafos mediante listas

1. El tipo abstracto de datos de los polinomios

2. Los polinomios en Haskell

2.1. El tipo abstracto de datos de los polinomios en Haskell

2.2. Implementación de los polinomios mediante tipos de datos algebraicos

2.3. Implementación de polinomios mediante listas densas

2.4. Implementación de polinomios mediante listas dispersas

3. Los polinomios en Python

3.1. El tipo abstracto de los polinomios en Python

3.2. Implementación de los polinomios mediante listas densas

3.3. Implementación de los polinomios mediante listas dispersas

Entradas recientes

Buscar

Correo electrónico