septiembre 2022 – Página 4

Raíces de la ecuación de segundo grado

PorJosé A. Alonso 12-septiembre-202214-diciembre-2022

Definir la función

   raices :: Double -> Double -> Double -> [Double]

1	raices :: Double -> Double -> Double -> [Double]

tal que (raices a b c) es la lista de las raíces reales de la ecuación $ax^2 + bx + c = 0$ . Por ejemplo,

   raices 1 3 2    ==  [-1.0,-2.0]
   raices 1 (-2) 1 ==  [1.0,1.0]
   raices 1 0 1    ==  []

raices 1 3 2 == [-1.0,-2.0]

raices 1 (-2) 1 == [1.0,1.0]

raices 1 0 1 == []

Comprobar con QuickCheck que la suma de las raíces de la ecuación $ax^2 + bx + c = 0$ (con $a$ no nulo) es $\dfrac{-b}{a}$ y su producto es $\dfrac{c}{a}$ .

Soluciones

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

Soluciones en Haskell

import Test.QuickCheck

raices :: Double -> Double -> Double -> [Double]
raices a b c
    | d >= 0    = [(-b+e)/t,(-b-e)/t]
    | otherwise = []
    where d = b^2 - 4*a*c
          e = sqrt d
          t = 2*a

-- Para comprobar la propiedad se usará el operador
--    (~=) :: (Fractional a, Ord a) => a -> a -> Bool
-- tal que (x ~= y) se verifica si x e y son casi iguales; es decir si
-- el valor absoluto de su diferencia es menor que una milésima. Por
-- ejemplo,
--    12.3457 ~= 12.3459  ==  True
--    12.3457 ~= 12.3479  ==  False
(~=) :: (Fractional a, Ord a) => a -> a -> Bool
x ~= y  = abs (x-y) < 0.001

-- La propiedad es
prop_raices :: Double -> Double -> Double -> Property
prop_raices a b c =
    a /= 0 && not (null xs) ==> sum xs ~= (-b/a) && product xs ~= (c/a)
    where xs = raices a b c

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

import Test.QuickCheck

raices :: Double -> Double -> Double -> [Double]

raices a b c

| d >= 0 = [(-b+e)/t,(-b-e)/t]

| otherwise = []

where d = b^2 - 4*a*c

e = sqrt d

t = 2*a

-- Para comprobar la propiedad se usará el operador

-- (~=) :: (Fractional a, Ord a) => a -> a -> Bool

-- tal que (x ~= y) se verifica si x e y son casi iguales; es decir si

-- el valor absoluto de su diferencia es menor que una milésima. Por

-- ejemplo,

-- 12.3457 ~= 12.3459 == True

-- 12.3457 ~= 12.3479 == False

(~=) :: (Fractional a, Ord a) => a -> a -> Bool

x ~= y = abs (x-y) < 0.001

-- La propiedad es

prop_raices :: Double -> Double -> Double -> Property

prop_raices a b c =

a /= 0 && not (null xs) ==> sum xs ~= (-b/a) && product xs ~= (c/a)

where xs = raices a b c

-- La comprobación es

-- λ> quickCheck prop_raices

-- +++ OK, passed 100 tests.

El código se encuentra en GitHub.

Soluciones en Python

from math import sqrt
from hypothesis import given, assume, strategies as st

def raices(a: float, b: float, c: float) -> list[float]:
    d = b**2 - 4*a*c
    if d >= 0:
        e = sqrt(d)
        t = 2*a
        return [(-b+e)/t, (-b-e)/t]
    return []

# Para comprobar la propiedad se usará la función
#    casiIguales : (float, float) -> bool
# tal que casiIguales(x, y) se verifica si x e y son casi iguales; es
# decir si el valor absoluto de su diferencia es menor que una
# milésima. Por  ejemplo,
#    casiIguales(12.3457, 12.3459)  ==  True
#    casiIguales(12.3457, 12.3479)  ==  False
def casiIguales(x: float, y: float) -> bool:
    return abs(x - y) < 0.001

# La propiedad es
@given(st.floats(min_value=-100, max_value=100),
       st.floats(min_value=-100, max_value=100),
       st.floats(min_value=-100, max_value=100))
def test_prop_raices(a, b, c):
    assume(abs(a) > 0.1)
    xs = raices(a, b, c)
    assume(xs)
    [x1, x2] = xs
    assert casiIguales(x1 + x2, -b / a)
    assert casiIguales(x1 * x2, c / a)

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

from math import sqrt

from hypothesis import given, assume, strategies as st

def raices(a: float, b: float, c: float) -> list[float]:

d = b**2 - 4*a*c

if d >= 0:

e = sqrt(d)

t = 2*a

return [(-b+e)/t, (-b-e)/t]

return []

# Para comprobar la propiedad se usará la función

# casiIguales : (float, float) -> bool

# tal que casiIguales(x, y) se verifica si x e y son casi iguales; es

# decir si el valor absoluto de su diferencia es menor que una

# milésima. Por ejemplo,

# casiIguales(12.3457, 12.3459) == True

# casiIguales(12.3457, 12.3479) == False

def casiIguales(x: float, y: float) -> bool:

return abs(x - y) < 0.001

# La propiedad es

@given(st.floats(min_value=-100, max_value=100),

st.floats(min_value=-100, max_value=100),

st.floats(min_value=-100, max_value=100))

def test_prop_raices(a, b, c):

assume(abs(a) > 0.1)

xs = raices(a, b, c)

assume(xs)

[x1, x2] = xs

assert casiIguales(x1 + x2, -b / a)

assert casiIguales(x1 * x2, c / a)

# La comprobación es

# src> poetry run pytest -q raices_de_la_ecuacion_de_segundo_grado.py

# 1 passed in 0.35s

El código se encuentra en GitHub.

Número de raíces de la ecuación de segundo grado

PorJosé A. Alonso 9-septiembre-202214-diciembre-2022

Definir la función

   numeroDeRaices :: (Num t, Ord t) => t -> t -> t -> Int

1	numeroDeRaices :: (Num t, Ord t) => t -> t -> t -> Int

tal que (numeroDeRaices a b c) es el número de raíces reales de la ecuación $ax^2 + bx + c = 0$ . Por ejemplo,

   numeroDeRaices 2 0 3    ==  0
   numeroDeRaices 4 4 1    ==  1
   numeroDeRaices 5 23 12  ==  2

numeroDeRaices 2 0 3 == 0

numeroDeRaices 4 4 1 == 1

numeroDeRaices 5 23 12 == 2

Soluciones

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

Soluciones en Haskell

numeroDeRaices :: (Num t, Ord t) => t -> t -> t -> Int
numeroDeRaices a b c | d < 0     = 0
                     | d == 0    = 1
                     | otherwise = 2
  where d = b^2-4*a*c

numeroDeRaices :: (Num t, Ord t) => t -> t -> t -> Int

numeroDeRaices a b c | d < 0 = 0

| d == 0 = 1

| otherwise = 2

where d = b^2-4*a*c

El código se encuentra en GitHub.

Soluciones en Python

def numeroDeRaices(a: float, b: float, c: float) -> float:
    d = b ** 2 - 4 * a * c
    if d < 0:
        return 0
    if d == 0:
        return 1
    return 2

def numeroDeRaices(a: float, b: float, c: float) -> float:

d = b ** 2 - 4 * a * c

if d < 0:

return 0

if d == 0:

return 1

return 2

El código se encuentra en GitHub.

Comentarios

En Haskell se usa un entorno local con where d = b^2-4*a*c y en Python se usa la asignación d = b ** 2 - 4 * a * c.

Mayor número con dos dígitos dados

PorJosé A. Alonso 8-septiembre-202214-diciembre-2022

Definir la función

   numeroMayor :: Int -> Int -> Int

1	numeroMayor :: Int -> Int -> Int

tal que (numeroMayor x y) es el mayor número de dos cifras que puede construirse con los dígitos x e y. Por ejemplo,

   numeroMayor 2 5 ==  52
   numeroMayor 5 2 ==  52

1 2	numeroMayor 2 5 == 52 numeroMayor 5 2 == 52

Soluciones

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

Soluciones en Haskell

-- 1ª definición:
numeroMayor1 :: Int -> Int -> Int
numeroMayor1 x y = 10 * max x y + min x y

-- 2ª definición:
numeroMayor2 :: Int -> Int -> Int
numeroMayor2 x y | x > y     = 10*x+y
                 | otherwise = 10*y+x

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

-- La propiedad es
prop_numeroMayor :: Bool
prop_numeroMayor =
  and [numeroMayor1 x y == numeroMayor2 x y | x <- [0..9], y <- [0..9]]

-- La comprobación es
--    λ> prop_numeroMayor
--    True

-- 1ª definición:

numeroMayor1 :: Int -> Int -> Int

numeroMayor1 x y = 10 * max x y + min x y

-- 2ª definición:

numeroMayor2 :: Int -> Int -> Int

numeroMayor2 x y | x > y = 10*x+y

| otherwise = 10*y+x

-- Comprobación de equivalencia

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

-- La propiedad es

prop_numeroMayor :: Bool

prop_numeroMayor =

and [numeroMayor1 x y == numeroMayor2 x y | x <- [0..9], y <- [0..9]]

-- La comprobación es

-- λ> prop_numeroMayor

-- True

El código se encuentra en GitHub.

Soluciones en Python

# 1ª definición
def numeroMayor1(x: int, y: int) -> int:
    return 10 * max(x, y) + min(x, y)

# 2ª definición
def numeroMayor2(x: int, y: int) -> int:
    if x > y:
        return 10 * x + y
    return 10 * y + x

# La propiedad de equivalencia de las definiciones es
def test_equiv_numeroMayor():
    # type: () -> bool
    return all(numeroMayor1(x, y) == numeroMayor2(x, y)
               for x in range(10) for y in range(10))

# La comprobación es
#    >>> test_equiv_numeroMayor()
#    True

# 1ª definición

def numeroMayor1(x: int, y: int) -> int:

return 10 * max(x, y) + min(x, y)

# 2ª definición

def numeroMayor2(x: int, y: int) -> int:

if x > y:

return 10 * x + y

return 10 * y + x

# La propiedad de equivalencia de las definiciones es

def test_equiv_numeroMayor():

# type: () -> bool

return all(numeroMayor1(x, y) == numeroMayor2(x, y)

for x in range(10) for y in range(10))

# La comprobación es

# >>> test_equiv_numeroMayor()

# True

El código se encuentra en GitHub.

Permutación cíclica

PorJosé A. Alonso 7-septiembre-202214-diciembre-2022

Definir la función

   ciclo :: [a] -> [a]

1	ciclo :: [a] -> [a]

tal que (ciclo xs) es la lista obtenida permutando cíclicamente los elementos de la lista xs, pasando el último elemento al principio de la lista. Por ejemplo,

   ciclo [2,5,7,9]  == [9,2,5,7]
   ciclo []         == []
   ciclo [2]        == [2]

ciclo [2,5,7,9] == [9,2,5,7]

ciclo [] == []

ciclo [2] == [2]

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

Soluciones

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

Soluciones en Haskell

import Test.QuickCheck

ciclo :: [a] -> [a]
ciclo [] = []
ciclo xs = last xs : init xs

-- La propiedad es
prop_ciclo :: [Int] -> Bool
prop_ciclo xs = length (ciclo xs) == length xs

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

import Test.QuickCheck

ciclo :: [a] -> [a]

ciclo [] = []

ciclo xs = last xs : init xs

-- La propiedad es

prop_ciclo :: [Int] -> Bool

prop_ciclo xs = length (ciclo xs) == length xs

-- La comprobación es

-- λ> quickCheck prop_ciclo

-- +++ OK, passed 100 tests.

El código se encuentra en GitHub

Soluciones en Python

from typing import TypeVar
from hypothesis import given, strategies as st

A = TypeVar('A')

def ciclo(xs: list[A]) -> list[A]:
    if xs:
        return [xs[-1]] + xs[:-1]
    return []

# La propiedad de es
@given(st.lists(st.integers()))
def test_equiv_ciclo(xs):
    assert len(ciclo(xs)) == len(xs)

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

from typing import TypeVar

from hypothesis import given, strategies as st

A = TypeVar('A')

def ciclo(xs: list[A]) -> list[A]:

if xs:

return [xs[-1]] + xs[:-1]

return []

# La propiedad de es

@given(st.lists(st.integers()))

def test_equiv_ciclo(xs):

assert len(ciclo(xs)) == len(xs)

# La comprobación es

# src> poetry run pytest -q permutacion_ciclica.py

# 1 passed in 0.39s

El código se encuentra en GitHub.

Distancia entre dos puntos

PorJosé A. Alonso 6-septiembre-202214-diciembre-2022

Definir la función

   distancia :: (Double,Double) -> (Double,Double) -> Double

1	distancia :: (Double,Double) -> (Double,Double) -> Double

tal que (distancia p1 p2) es la distancia entre los puntos p1 y p2. Por ejemplo,

   distancia (1,2) (4,6)  ==  5.0

1	distancia (1,2) (4,6) == 5.0

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

Soluciones

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

Soluciones en Haskell

import Test.QuickCheck

distancia :: (Double,Double) -> (Double,Double) -> Double
distancia (x1,y1) (x2,y2) = sqrt((x1-x2)^2+(y1-y2)^2)

-- La propiedad es
prop_triangular :: (Double,Double) -> (Double,Double) -> (Double,Double)
                -> Property
prop_triangular p1 p2 p3 =
    all acotado [p1, p2, p3] ==>
    distancia p1 p3 <= distancia p1 p2 + distancia p2 p3
    where acotado (x, y) = abs x < cota && abs y < cota
          cota = 2^30

-- La comprobación es
--    ghci> quickCheck prop_triangular
--    +++ OK, passed 100 tests.

-- Nota: Por problemas de redondeo, la propiedad no se cumple en
-- general. Por ejemplo,
--    λ> p1 = (0, 9147936743096483)
--    λ> p2 = (0, 3)
--    λ> p3 = (0, 2)
--    λ> distancia p1 p3 <= distancia p1 p2 + distancia p2 p3
--    False
--    λ> distancia p1 p3
--    9.147936743096482e15
--    λ> distancia p1 p2 + distancia p2 p3
--    9.14793674309648e15

import Test.QuickCheck

distancia :: (Double,Double) -> (Double,Double) -> Double

distancia (x1,y1) (x2,y2) = sqrt((x1-x2)^2+(y1-y2)^2)

-- La propiedad es

prop_triangular :: (Double,Double) -> (Double,Double) -> (Double,Double)

-> Property

prop_triangular p1 p2 p3 =

all acotado [p1, p2, p3] ==>

distancia p1 p3 <= distancia p1 p2 + distancia p2 p3

where acotado (x, y) = abs x < cota && abs y < cota

cota = 2^30

-- La comprobación es

-- ghci> quickCheck prop_triangular

-- +++ OK, passed 100 tests.

-- Nota: Por problemas de redondeo, la propiedad no se cumple en

-- general. Por ejemplo,

-- λ> p1 = (0, 9147936743096483)

-- λ> p2 = (0, 3)

-- λ> p3 = (0, 2)

-- λ> distancia p1 p3 <= distancia p1 p2 + distancia p2 p3

-- False

-- λ> distancia p1 p3

-- 9.147936743096482e15

-- λ> distancia p1 p2 + distancia p2 p3

-- 9.14793674309648e15

El código se encuentra en GitHub.

Soluciones en Python

from math import sqrt
from hypothesis import given, strategies as st

def distancia(p1: tuple[float, float],
              p2: tuple[float, float]) -> float:
    (x1, y1) = p1
    (x2, y2) = p2
    return sqrt((x1-x2)**2+(y1-y2)**2)

# La propiedad es
cota = 2 ** 30

@given(st.tuples(st.integers(min_value=0, max_value=cota),
                 st.integers(min_value=0, max_value=cota)),
       st.tuples(st.integers(min_value=0, max_value=cota),
                 st.integers(min_value=0, max_value=cota)),
       st.tuples(st.integers(min_value=0, max_value=cota),
                 st.integers(min_value=0, max_value=cota)))
def test_triangular(p1, p2, p3):
    assert distancia(p1, p3) <= distancia(p1, p2) + distancia(p2, p3)

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

# Nota: Por problemas de redondeo, la propiedad no se cumple en
# general. Por ejemplo,
#    λ> p1 = (0, 9147936743096483)
#    λ> p2 = (0, 3)
#    λ> p3 = (0, 2)
#    λ> distancia(p1, p3) <= distancia(p1, p2) + distancia (p2. p3)
#    False
#    λ> distancia(p1, p3)
#    9147936743096482.0
#    λ> distancia(p1, p2) + distancia(p2, p3)
#    9147936743096480.05

from math import sqrt

from hypothesis import given, strategies as st

def distancia(p1: tuple[float, float],

p2: tuple[float, float]) -> float:

(x1, y1) = p1

(x2, y2) = p2

return sqrt((x1-x2)**2+(y1-y2)**2)

# La propiedad es

cota = 2 ** 30

@given(st.tuples(st.integers(min_value=0, max_value=cota),

st.integers(min_value=0, max_value=cota)),

st.tuples(st.integers(min_value=0, max_value=cota),

st.integers(min_value=0, max_value=cota)),

st.tuples(st.integers(min_value=0, max_value=cota),

st.integers(min_value=0, max_value=cota)))

def test_triangular(p1, p2, p3):

assert distancia(p1, p3) <= distancia(p1, p2) + distancia(p2, p3)

# La comprobación es

# src> poetry run pytest -q distancia_entre_dos_puntos.py

# 1 passed in 0.38s

# Nota: Por problemas de redondeo, la propiedad no se cumple en

# general. Por ejemplo,

# λ> p1 = (0, 9147936743096483)

# λ> p2 = (0, 3)

# λ> p3 = (0, 2)

# λ> distancia(p1, p3) <= distancia(p1, p2) + distancia (p2. p3)

# False

# λ> distancia(p1, p3)

# 9147936743096482.0

# λ> distancia(p1, p2) + distancia(p2, p3)

# 9147936743096480.05

El código se encuentra en GitHub.

Comentarios

La raíz cuadrada de x se escribe
- en Haskell, como sqrt x y
- en Python, como sqrt(x) y hay que importarla del módulo math.

Meses: septiembre 2022

Raíces de la ecuación de segundo grado

Número de raíces de la ecuación de segundo grado

Mayor número con dos dígitos dados

Permutación cíclica

Distancia entre dos puntos

Entradas recientes

Buscar

Correo electrónico