¿Cómo manipular funciones?

Me ha encantado la tranquilidad y empatia que transmite este prof

Escribí un código para poder comparar mejor las modificaciones que realiza el profesor en la clase. Dejo el script para que lo puedan realizar. Junto con el output. El de reflexión se deja de tarea.

N = 1000

def f(x):
  return x**2

c = 4

x = np.linspace(-10,10, num=N)

y1 = f(x + c)
y2 = f(x - c)
y3 = f(x) - c
y4 = f(x) + c

fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(10,10))
axs[0,0].plot(x,y1)
axs[0,0].set_title("f(x + c)")

axs[0,1].plot(x,y2)
axs[0,1].set_title("f(x - c)")

axs[1,0].plot(x,y3)
axs[1,0].set_title("f(x)-c")

axs[1,1].plot(x,y4)
axs[1,1].set_title("f(x) + c")
fig.suptitle('Desplazamientos verticales y horizontales')
for ax in axs.flat:
  ax.grid()
  ax.axhline(y=0, color='r')
  ax.axvline(x=0, color='r')

![](

N = 1000

def f(x):
  return np.sin(x);

c = 2

x = np.linspace(-15,15, num=N)

y1 = f(x)*c
y2 = f(x)*(1/c)
y3 = f(c*x)
y4 = f((1/c)*x)

fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(10,10))
axs[0,0].plot(x,y1)

axs[0,1].plot(x,y2)

axs[1,0].plot(x,y3)

axs[1,1].plot(x,y4)

axs[0,0].set_title("f(x)*c")
axs[0,1].set_title("f(x)*(1/c)")
axs[1,0].set_title("f(c*x)")
axs[1,1].set_title("f((1/c)*x)")

fig.suptitle('Alargamientos y compresiones')
for ax in axs.flat:
  ax.grid()
  ax.axhline(y=0, color='r')
  ax.axvline(x=0, color='r')

![](

Las manipulaciones en las funciones son de dos tipos vertical y horizontal:

• Vertical: Ya sea para generar un desplazamiento o deformación el factor c va a afectar a la imagen de la función, es decir y = f(x).
  Aquí podemos aplicar directamente c a f(x) dependiendo de lo que se quiera hacer, por ejemplo:
  -> f(x) + 5 para desplazar hacia arriba la función 5 unidades.
  -> (1/2)*f(x) para reducir a la mitad su altura.

• Horizontal: Para generar un desplazamiento o deformación el factor c va a afectar el dominio de la función, es decir lo que se encuentra dentro del argumento de f.
  -> Por lo tanto si tenemos f(x + c) podemos hacer u = x + c
  donde x = u - c, así es más fácil ver porque en el eje horizontal se genera un desplazamiento a la izquierda.
  -> Igual si tenemos f(cx) podemos hacer u = cx y despejando x tenemos x= u/c donde es más claro ver porque se comprime el eje horizontal.

Información resumida de esta clase
#EstudiantesDePlatzi

• Es importante aprender a manipular las funciones

• y = F (x) + c : Si sumamos una constante ‘c’ fuera del argumento, la gráfica se moverá ‘c’ unidades hacia arriba

• y = F (x) - c : Si restamos una constante ‘c’ fuera del argumento, la gráfica se moverá ‘c’ unidades hacia abajo

• Y = F (x-c) : Si restamos una constante ‘c’ dentro del argumento, la gráfica se moverá ‘c’ unidades a la derecha

• Y = F (x+c) : Si sumamos una constante ‘c’ dentro del argumento, la gráfica se moverá ‘c’ unidades a la izquierda

• Con la función ax.axhline puedo crear una línea horizontal y ubicarla dentro del plano, definiendo en sus parámetros la posición y el color

• Con la función ax.axvline puedo crear una línea vertical y ubicarla dentro del plano, definiendo en sus parámetros la posición y el color

• y = c * F (x) : Si multiplicamos una constante ‘c’ fuera del argumento, la gráfica se alargará verticalmente en un factor de ‘c’

• y = 1/c * F (x) : Si dividimos una constante ‘c’ fuera del argumento, la gráfica se comprimirá verticalmente en un factor de ‘c’

• y = F (x*c) : Si multiplicamos una constate ‘c’ dentro del argumento, la gráfica se comprimirá horizontalmente en un factor de ‘c’

• Y = F (1/c * x) : Si dividimos una constante ‘c’ dentro del argumento, la gráfica se alargará horizontalmente en un factor de ‘c’

• y = -F (x) : Si multiplicamos por un número negativo fuera del argumento, la gráfica se va a reflejar en el eje x

• y = F (-x) : Si multiplicamos por un número negativo dentro del argumento, la gráfica se va a reflejar en el eje y

Que buena clase!

Reflexiones
No puedo cargar las imágenes, pero si lo grafican se ve claramente el desplazamiento

-y=-f(x) refleja la gráfica respecto al eje x.

N = 1000

def f(x):
  return x**3;

x = np.linspace(-10,10, num=N)
y = f(x);
y1 = -f(x); 

fig, ax = plt.subplots()
ax.plot(x,y,label="f(x)", color='g', linestyle='-')
ax.plot(x,y1, label="-f(x)", color='b', linestyle='--')
ax.legend(loc=9)
plt.title('Refleja la gráfica respecto al eje x')
ax.grid()
ax.axhline(y=0, color='r')
ax.axvline(x=0, color='r');

• y=f(-x) refleja la gráfica respecto al eje y. Los datos que tengo a la izquierda pasan a la derecha y los que están a la derecha pasan a la izquierda.

N = 1000

def f(x):
  return x**3;

x = np.linspace(-10,10, num=N)
y = f(x);
y1 = f(-x); 

fig, ax = plt.subplots()
ax.plot(x,y,label="f(x)", color='g', linestyle='-')
ax.plot(x,y1, label="f(-x)", color='b', linestyle='--')
ax.legend(loc=9)
plt.title('Refleja la gráfica respecto al eje y')
ax.grid()
ax.axhline(y=0, color='r')
ax.axvline(x=0, color='r');

acabo de entender en 10 min la matemática de los amplificadores sin darme cuenta 😛

La clase es maravillosa y nos llena de conocimientos. Creo que la verdadera maestría de estos conceptos se ven en la práctica.

Con set_ylim() podemos darles el tamaño a los ejes y para que se note más la compresión y el alargamiento

Me parece genial que se abarque este tema desde el punto de vista de los casos generales y no solo los específicos. Puede que cueste un poco más entender así, pero se aprende y se avanza más.

Mil gracias por los apuntes, me ayudaron un monton.

Construyendo sobre el aporte de Jazma Mesa y utilizando la sugerencia de Juan Manuel Betancur, para ver la gráfica de f(x) y las 2 gráficas de Reflexiones:

N = 1000
def f(x):
  return x**2.5

x = np.linspace(-10,10, num= N)
y = f(x)
functions = [y, -f(x), f(-x)] 
titles = ['f(x)', '-f(x)', 'f(-x)'] 
# -f(x) Lo graficado con f(x) en el cuadrante III pasa al cuadrante II y lo graficado en el cuadrante I pasa al cuadrante IV
# f(-x) Lo graficado con f(x) en el cuadrante I pasa al cuadrante II y lo graficado en el cuadrante III pasa al cuadrante IV
fig, ax = plt.subplots(1,3, figsize=(12,4))
for i in range(3):
  y = functions[i]
  ax[i].plot(x,y)
  ax[i].set_title(titles[i])
  ax[i].grid()
  ax[i].axhline(y=0, color='r')
  ax[i].axvline(x=0, color='r')
  ax[i].set_ylim((-400, 400))
  ax[i].set_xlim((-12, 12))

Me di a la tarea de gráficarlos juntos.

y = f(x)           
y0 = f(x) + c  # Hacia arriba
y1 = f(x) - c   # Hacia abajo
y2 = f(x - c)   # Hacia la izquierda
y3 = f(x + c)  # Hacia la derecha

fig, ax = plt.subplots(figsize=(6.9,3.5))
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color='r')
ax.axvline(x=0, color='r')
ax.set_title('f(x)')

fig, ax = plt.subplots(2,2)
ax[0,0].plot(x,y0)
ax[0,0].grid()
ax[0,0].axhline(y=0, color='r')
ax[0,0].axvline(x=0, color='r')
ax[0,0].set_title('f(x) + c "Arriba"')

ax[0,1].plot(x,y1)
ax[0,1].grid()
ax[0,1].axhline(y=0, color='r')
ax[0,1].axvline(x=0, color='r')
ax[0,1].set_title('f(x) - c "Abajo"')

ax[1,0].plot(x,y2)
ax[1,0].grid()
ax[1,0].axhline(y=0, color='r')
ax[1,0].axvline(x=0, color='r')
ax[1,0].set_title('f(x - c) "Izq"')

ax[1,1].plot(x,y3)
ax[1,1].grid()
ax[1,1].axhline(y=0, color='r')
ax[1,1].axvline(x=0, color='r')
ax[1,1].set_title('f(x + c) "Der"')

fig.tight_layout()

muy buena clase, espero poner en practica toda esta teoria con algun ejemplo y muchos datos

Excelente PROFESOR !!!

Para seguir complementando con la última parte de la clase, podemos hablar de la paridad de las funciones. Una función par es aquella que comple que f(x) = f(-x) un ejemplo es x^2 porque (2)^2 = (-2)^2 = 4 y así con cualquier número de su dominio y la función impar es aquella que cumple con f(-x) = -f(x) y el ejemplo básico es x^3 como lo usó el profesor

Excelente explicación!

gracias tenia mal el concepto

Excelente el profe Devars como siempre!

Código para ver en 4 gráficas los desplazamientos verticales y horizontales:

import numpy as np
import matplotlib.pyplot as plt

N = 1000

def f(x):
  return x**2;

c = 4

x = np.linspace(-10,10, num=N)

y1 = f(x - c)
y2 = f(x + c)
y3 = f(x) + c
y4 = f(x) - c

fig,axes = plt.subplots(nrows=1,ncols=4, figsize=(18,5))
for ax in axes:
    ax.grid(True)
    ax.axhline(y=0, color='r')
    ax.axvline(x=0, color='r')
axes[0].plot(x,y1)
axes[1].plot(x,y2)
axes[2].plot(x,y3)
axes[3].plot(x,y4)

la razon por la que se va a la derecha o izquierda es que para hallar el punto de inflexion de “x”, se tiene que igualar a “0”, lo dentro del parentesis.

Este tema tambien es bastante recurrente en el curso de Procesamiento digital de señales.

Gracias profe por aterrizar y ver esto facil, solo agrege las siguientes lineas para entender los valores de la cuarta opción y fue aun mas sencillo

N = 1000

c = 2

print("Este es y:", y)
print("Este es x:", x)
print("Este es f(x):", f(x))
print("Este es c", c)
print("Este es (x - c):", (x-c))

Hasta este punto, lo que se ha visto en el curso es la matemática del preuniversitario en Cuba, solo que usando Google Colab y Python en vez de lápiz y papel.

Fue mal ejemplo tomar la función x***3 ya que esta es una función impar ( f(-x) = -f(x) ) por lo que al cambiar o “jugar” con ella se verá igual de ambas formas y no se notará la diferencia de las simetrías con los ejes en ambos casos.

Que buena explicacion, gracias.

Me encantó la clase, muy clara.
Agradecida de los profesores que no son mezquinos con el conocimiento 😄

N = 1000

def f(x):
  return x**3;

x = np.linspace(-10,10, num=N)

y = f(-x)

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color='r')
ax.axvline(x=0, color='r')

Dependencias
________________________________________
[1]
0 s
import numpy as np
import matplotlib.pyplot as plt
________________________________________
Desplazamientos verticales y horizontales
Siendo c una constante mayor que cero, entonces la gráfica:
•	$y=f(x)+c se desplaza c unidades hacia arriba.
•	$y=f(x)−c se desplaza c unidades hacia abajo.
•	$y=f(x−c) se desplaza c unidades hacia la derecha.
•	$y=f(x+c) se desplaza c unidades hacia la izquierda.
________________________________________
[2]
0 s
N = 2000
def f(x):
  return x**4
c = 500 
x = np.linspace(-5,5, num=N)

y = f(x) + c

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color="r")
ax.axvline(x=0, color="r")
# aca estamos uacando la reglas de desplazamiento hacia el eje posistivo 
________________________________________
[3]
0 s
N = 2000
def f(x):
  return x**4
c = 100 
x = np.linspace(-5,5, num=N)

y = f(x) - c

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color="r")
ax.axvline(x=0, color="r")
#en esta grafica esta hacia el eje negativo 
________________________________________
[4]
0 s
N = 2000
def f(x):
  return x**4
c = 8 
x = np.linspace(-5,5, num=N)

y = f(x - c)

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color="r")
ax.axvline(x=0, color="r")
#aca estamos desplazando nuestra grafica hacia la derecha 
________________________________________
[5]
1 s
N = 2000
def f(x):
  return x**4
c = 12
x = np.linspace(-5,5, num=N)

y = f(x + c)

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color="r")
ax.axvline(x=0, color="r")
#aca estamos desplazando la grafica hacia la izquierda 
________________________________________
argumentos
debemos tener en cuenta que cuando es fuera del argumento y = f(x) + c y lo sumo la gráfica es hacia arriba y si los resto es hacia abajo
cuando es dentro del argumento y = f(x + c) los valores de la gráfica se corren hacia la izquierda cuando es positiva y hacia la derecha cuando es negativo
________________________________________
[ ]
N = 1000

def f(x):
  return x**2;

c = 4

x = np.linspace(-10,10, num=N)

y = f(x + c)

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color='r')
ax.axvline(x=0, color='r')
________________________________________
Alargamientos y compresiones
Siendo c una constante mayor que cero, entonces la gráfica:
•	y=c⋅f(x) alarga la gráfica verticalmente en un factor de c.
•	y=1c⋅f(x) comprime la gráfica verticalmente en un factor de c.
•	y=f(c⋅x) comprime la gráfica horizontalmente en un factor de c.
•	y=f(1c⋅x) alarga la gráfica horizontalmente en un factor de c.
________________________________________
[15]
N = 2000

def f(x):
  return np.sin(x);

c = 2

x = np.linspace(-30,30, num=N)

y = c*f(x)

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color="r")
ax.axvline(x=0, color="r")
plt.show()
#eaca estamos multiplicando por (c = 2) nuetra funcion y duplicaremos su tamaño de -2 a 2 
________________________________________
[17]
N = 1000

def f(x):
  return np.sin(x);

c = 2

x = np.linspace(-15,15, num=N)

y = (1/c)*f(x)

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color="r")
ax.axvline(x=0, color="r")
plt.show()
#aca la estamos comprimiendo esto se debe a que lo estamos dividiendo la funcion
#la grafica va de -5  
________________________________________
[18]
N = 1000

def f(x):
  return np.sin(x);

c = 2

x = np.linspace(-15,15, num=N)

y = f(c*x)

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color="r")
ax.axvline(x=0, color="r")
plt.show()
#aca estamos multiplicando la funcion dentro del argumento de f y = f(c*x)
#como podemos notar es la inversa, osea la ondulacion se comprime y esta aproximadamente en 2,5
________________________________________
[19]
N = 1000

def f(x):
  return np.sin(x);

c = 2

x = np.linspace(-15,15, num=N)

y = f(1/c*x)

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color="r")
ax.axvline(x=0, color="r")
plt.show()
#cuando hacemos la division dentro del argumento y = f(1/c*x), este se espande como si fuera un resorte
#notamos que la primera bajada esta aproximadamete en 10. asi es como se ven las compreciones de funciones 
________________________________________
Reflexiones
•	y=−f(x) refleja la gráfica respecto al eje x.
•	y=f(−x) refleja la gráfica respecto al eje y.
________________________________________
[24]
0 s
N = 1000

def f(x):
  return x**3;

x = np.linspace(-10,10, num=N)

y = f(x)

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color="r")
ax.axvline(x=0, color="r")
plt.show()
________________________________________
[25]
0 s
N = 1000

def f(x):
  return x**3;

x = np.linspace(-10,10, num=N)

y = -f(x)

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color="r")
ax.axvline(x=0, color="r")
plt.show()
________________________________________
[26]
0 s
N = 1000

def f(x):
  return x**3;

x = np.linspace(-10,10, num=N)

y = f(-x)

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color="r")
ax.axvline(x=0, color="r")
plt.show()
________________________________________
en esta clase aprendimos como manipular funciones, alárgalas, comprimirlas, es bastante útil para el análisis de datos, estos tipos de reglas te van a ayudar incluso que está pasando con tus gráficas, que nos dan una idea de cuál es el comportamiento de nuestros datos, y obviamente si estas tienen variaciones alargamientos, compresiones esa grafica esta siendo modifica por un factor de 2x que ocurre en tal punto con tales variaciones y esto nos será de mucha utilidad

No entiendo como en la universidad no me pudieron dar una explicación asi de sencilla de este tema. Eres grande Enrique

Reflexion de la funcion cubica

N = 1000

def f(x):
  return np.sin(x)

c = 2

x = np.linspace(-15, 15, num= N)

y1 = f(x)*c      #alraga la grafica un factor c
y2 = f(x)*(1/c)  #comprime la grafica un factor c
y3 = f(x*c)      #comprime la grafica horizontalmente
y4 = f((1/c)*x)  #alarga la grafica horizontalmente

fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(10,10))
fig.suptitle('Alargamineto y Compresiones')

ax[0,0].plot(x,y1)
ax[0,0].set_title('f(x)*c')
ax[0,1].plot(x,y2)
ax[0,1].set_title('f(x)*1/c')
ax[1,0].plot(x,y3)
ax[1,0].set_title('f(x*c)')
ax[1,1].plot(x,y4)
ax[1,1].set_title('f(x*(1/c))')

for graph in ax.flat:
  graph.grid()
  graph.axhline(y=0, color = 'r')
  graph.axvline(x=0, color = 'r')

Resumiendo los desplazamientos verticales y horizontales

N = 1000

def f(x):
  return x**2;

c = 2
x = np.linspace(-5,5, num=N)

y = f(x)
y1 = f(x)+c
y2 = f(x)-c
y3 = f(x-c)
y4 = f(x+c)

fig, ax = plt.subplots()
ax.plot(x,y,label="f(x)", color='g', linestyle='-')
ax.plot(x,y1, label="f(x) + c", color='b', linestyle='--')
ax.plot(x,y2, label="f(x) - c", color='c', linestyle='--')
ax.plot(x,y3, label="f(x - c)", color='m', linestyle='--')
ax.plot(x,y4, label="f(x + c)", color='y', linestyle='--')
ax.legend(loc=9)
plt.title('Desplazamientos verticales y horizontales')
ax.grid()
ax.axhline(y=0, color='r')
ax.axvline(x=0, color='r');

Para ver todos los gráficos juntos:

N = 1000
def f(x):
  return x**3

x = np.linspace(-10,10, num= N)
y = f(x)
functions = [y, -f(x), f(-x)] 
titles = ['f(x)', '-f(x)', 'f(-x)'] 
fig, ax = plt.subplots(1,3, figsize=(10,10))
for i in range(3):
  y = functions[i]
  ax[i].plot(x,y)
  ax[i].set_title(titles[i])
  ax[i].grid()
  ax[i].axhline(y=0, color='r')
  ax[i].axvline(x=0, color='r');