mayo 2023 – Página 3

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))

Meses: mayo 2023

TAD de los polinomios: Regla de Ruffini

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

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

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

TAD de los polinomios: Divisibilidad de polinomios

Entradas recientes

Buscar

Correo electrónico