Contents

LAB Polinomios

!wget --no-cache -O init.py -q https://raw.githubusercontent.com/rramosp/20192.L3/master/init.py
import init; init.init(force_download=False); init.get_weblink()

import init
from local.lib.rlxmoocapi import submit, session
import inspect
student = session.Session(init.endpoint).login( course_id=init.course_id, 
                                                session_id="UDEA", 
                                                lab_id="lab_02" )

LAB Polinomios

Ejercicio 1

Implementación TAD polinomio v1. Completa la implementación siguiente de manera que:

  • mantenga dos listas, una con los coeficientes y otra con los exponentes

  • cada vez que se añada un término con add_term ambas listas han de mantenerse compactas y ordenadas

  • compacta se refiere a que no debe de haber términos con exponentes duplicados

  • ordenada se refiere a que ambas listas estén en orden ascendente de exponentes

Sugerencia: usa numpy.searchsorted e implementa el siguiente pseudocódigo

k = np.searchsorted(self.exps,e)
si k > el número de términos actual:
   añadir c,e al final de sus respectivas listas
si self.exps[k]==e:
   sumar c al término correspondiente
en otro caso:
   insertar c y e en la posición k en sus respectivas listas

juega primero con np.searchsorted para entender su funcionamiento

import numpy as np
a = [2, 5, 6, 10]
print(np.searchsorted(a, 2))
print(np.searchsorted(a, 7))
print(np.searchsorted(a, 0))
print(np.searchsorted(a, 6))
print(np.searchsorted(a, 12))

fíjate también cómo se inserta un elemento en una lista

k = [1, 4, 10, 3, 5]
i = 3
element = 89

k_updated = k[:i] + [element] + k[i:]

print(k)
print(k_updated)

def Pol1(**kwargs):
    import numpy as np

    class Pol1__class:

        def __init__(self):
            self.exps = []
            self.coefs = []

        def len(self):
            return len(self.exps)

        def add_term(self, c, e):

            <... TU CODIGO AQUI ...>

            assert len(self.exps)==len(self.coefs), "must have the same number of exps and coefs"
            return self

        def show(self):
            from IPython.display import Math, HTML, display
            display(HTML("<script src='https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.3/latest.js?config=default'></script>"))          
            s = "+".join(["%s^{%s}"%(str(c) if e==0 else str(c)+"x" if c!=1 else "x", str(e) if e not in [0,1] else "") for e,c in zip(self.exps, self.coefs) if c!=0])
            s = s.replace("+-", "-")
            return Math(s)
        
    return Pol1__class(**kwargs)

comprueba tu código, la siguiente ejecución debería de dar:

\[-1+2x+9x^2+4x^5\]
p = Pol1()
p.add_term(3,2).add_term(2,1).add_term(2,0).add_term(4,5).add_term(6,2).add_term(-3,0).show()

registra tu solución en línea

student.submit_task(globals(), task_id="task_01");

Ejercicio 2

implementa la operación suma para la clase del polinomio anterior. El resultado ha de ser una instancia de la misma clase en la que self.exps y self.coefs se mantengan compactos y ordenados.

Sugerencia: realiza una implementación que:

  1. cree un polinomio vacío

  2. recorra los términos de q y p y los vaya añadiendo al polinomio creado inicialmente vacío

  3. devuelva el polinomio construido de esta manera

def Pol2(**kwargs):
    import numpy as np
    class Pol2__class:

        def __init__(self):
            self.exps = []
            self.coefs = []

        def len(self):
            return len(self.exps)

        def add_term(self, c, e):
            <... TU CODIGO AQUI ...>

            assert len(self.exps)==len(self.coefs), "must have the same number of exps and coefs"
            return self

        def sum(self, q):
            r = self.__class__()

            <... TU CODIGO AQUI ...>

            return r

        def show(self):
            from IPython.display import Math, HTML, display
            display(HTML("<script src='https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.3/latest.js?config=default'></script>"))          
            s = "+".join(["%s^{%s}"%(str(c) if e==0 else str(c)+"x" if c!=1 else "x", str(e) if e not in [0,1] else "") for e,c in zip(self.exps, self.coefs) if c!=0])
            s = s.replace("+-", "-")
            return Math(s)

    return Pol2__class(**kwargs)

comprueba tu código manualmente

p = Pol2()
p.add_term(3,2).add_term(2,1).add_term(4,5).add_term(6,2)
p.show()

q = Pol2()
q.add_term(1,5).add_term(4,1).add_term(3,3)
q.show()

p.sum(q).show()

registra tu solución en línea

student.submit_task(globals(), task_id="task_02");

Ejercicio 3

Implementación TAD Polinomio v2 con una única lista de coeficientes. En esta implementación un polinomio lo representaremos con una lista en la que:

  • la posición de la lista indica el coeficiente del término exponencial correspondiente a la posición.

  • los coeficientes intermedios que no existan en la lista se establecen a 0.

por ejemplo, el polinomio \(2+3x^2+6x^5\) viene representado por la siguiente lista:

[2, 0, 3, 0, 0, 6]

Observa que cuando se le añade un término a un polinomio con exponente mayor que el máximo hay que añadir 0’s intermedios. P.ej. si añadimos el término \(x^8\) al polinomio anterior, hay que:

  • añadirle tres ceros la lista anterior. De manera general hay que añadir e-max_exp ceros a la lista.

  • establecer el último elemento a 1

para que dé el resultado siguiente:

[2, 0, 3, 0, 0, 6, 0, 0, 1]

en cambio si le añadimos un término con exponente igual o menor al máximo, simplemente hay que añadir el coeficiente a la posición correspondiente de la lista. Por ejemplo:

  • al añadir el término 3x^5 hay que sumarle 3 a la posición 5: [2, 0, 3, 0, 0, 9, 0, 0, 1]

  • al añadir el término 13x^1 hay que sumarle 13 a la posición 1: [2, 13, 3, 0, 0, 6, 0, 0, 1]

Completa el método add_term de la clase siguiente para implementar esta especificiación. Sugerencia: guíate por el siguiente pseudocódigo:

1.   if e > max_exp:
2.       añadir e-max_exp ceros a la lista
3.   añadir c al elemento en la posición e de la lista

Ten en cuenta que el primer elemento de la lista corresponde al exponente 0 (\(x^0=1\)) como en el ejemplo anterior, por tanto max_exp es la longitud de la lista menos 1.

def Pol3(**kwargs):
    import numpy as np

    class Pol3__class:

        def __init__(self):
            self.coefs = [0]

        def add_term(self, c, e):
            <... TU CODIGO AQUI ...>
            return self

        def show(self):
            from IPython.display import Math, HTML, display
            display(HTML("<script src='https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.3/latest.js?config=default'></script>"))          
            s = "+".join(["%s^{%s}"%(str(c) if e==0 else str(c)+"x" if c!=1 else "x", str(e) if e not in [0,1] else "") for e,c in enumerate(self.coefs) if c!=0])
            s = s.replace("+-", "-")
            return Math(s)
    
    return Pol3__class(**kwargs)

p = Pol3()
p.add_term(2,0).add_term(1,5).add_term(3,2).add_term(5,5)
print(p.coefs)
p.show()

p.add_term(1,8)
print(p.coefs)
p.show()

registra tu solución en línea

student.submit_task(globals(), task_id="task_03");

Ejercicio 4

completa la siguiente función para que, dadas dos listas, las sume elemento a elemento. Ten en cuenta que:

  • las listas pueden tener distinta longitud.

  • el resultado ha de tener la longitud de la lista más grande.

Sugerencia de implementación:

  1. completa la lista más pequeña con ceros hasta la longitud de la lista más grande

  2. convierte ambas listas a np.array

  3. utiliza el operador + sobre los np.array creados

  4. convierte el resultado a una lista antes de devolverlo

Fíjate cómo se hacen las conversiones entre listas y np.array

import numpy as np

a = [1,10,2,3,20]
print(a)
na = np.array(a)
print(na)
la = list(na)
print(la)

def add_lists(a,b):
    import numpy as np
    <...>
    return <... TU CODIGO AQUI ...>

comprueba manualmente tu código. las siguientes tres sumas han de dar, respectivamente:

[3, 6, 5]
[3, 6, 7]
[3, 6, 7, 2]

print(add_lists([1,4,5], [2,2]))
print(add_lists([1,4,5], [2,2,2]))
print(add_lists([1,4,5], [2,2,2,2]))

registra tu solución en línea

student.submit_task(globals(), task_id="task_04");

Ejercicio 5

usa la función add_lists para implementar el método sum del polinomio anterior

def Pol5(**kwargs):
    import numpy as np
    def add_lists(a,b):
        <...>
        return <... TU CODIGO AQUI ...>

    class Pol5__class:

        def __init__(self):
            self.coefs = [0]

        def add_term(self, c, e):
            <... TU CODIGO AQUI ...>

            return self

        def sum(self, q):
            <... TU CODIGO AQUI ...>
            return r

        def show(self):
            from IPython.display import Math, HTML, display
            display(HTML("<script src='https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.3/latest.js?config=default'></script>"))          
            s = "+".join(["%s^{%s}"%(str(c) if e==0 else str(c)+"x" if c!=1 else "x", str(e) if e not in [0,1] else "") for e,c in enumerate(self.coefs) if c!=0])
            s = s.replace("+-", "-")
            return Math(s)
        
    return Pol5__class(**kwargs)

p = Pol5()
p.add_term(3,2).add_term(2,1).add_term(4,5).add_term(6,2)
p.show()

q = Pol5()
q.add_term(1,5).add_term(4,1).add_term(3,8)
q.show()

s = p.sum(q)
print(s.coefs)
s.show()

registra tu solución en línea

student.submit_task(globals(), task_id="task_05");

Ejercicio 6

Implementa la multiplicación de polinomios sobre el TAD Polinomio v2. Sugerencia: guíate por el siguiente pseudocódigo:

r = nuevo polinomio
for i in 0..self max coef
   for j in 0..q max coef
       añade a r el término correspondiente a la multiplicación del término i de self con el j de q

def Pol6(**kwargs):
    import numpy as np

    class Pol6__class:

        def __init__(self):
            self.coefs = []

        def add_term(self, c, e):

            <... TU CODIGO AQUI ...>

            return self

        def sum(self, q):
            r = self.__class__()

            <... TU CODIGO AQUI ...>

            return r

        def mult(self, q):
            r = self.__class__()

            <... TU CODIGO AQUI ...>

            return r

        def show(self):
            from IPython.display import Math, HTML, display
            display(HTML("<script src='https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.3/latest.js?config=default'></script>"))          
            s = "+".join(["%s^{%s}"%(str(c) if e==0 else str(c)+"x" if c!=1 else "x", str(e) if e not in [0,1] else "") for e,c in enumerate(self.coefs) if c!=0])
            s = s.replace("+-", "-")
            return Math(s)
        
    return Pol6__class(**kwargs)

comprueba manualmente tu código

p = Pol6()
p.add_term(3,2).add_term(2,1).add_term(4,5).add_term(6,2)
p.show()

q = Pol6()
q.add_term(2,5).add_term(4,1).add_term(3,8)
q.show()

p.mult(q).show()

registra tu solución en línea

student.submit_task(globals(), task_id="task_06");

previous

Representación en memoria

next

LAB 03 Matrices dispersas