Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

¿Cómo manipular funciones?

8/30
Recursos

Aportes 32

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Resumen Fast:
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.
y=c⋅f(x) alarga la gráfica verticalmente en un factor de c .
y=1/c⋅f(x) comprime la gráfica verticalmente en un factor de c .
y=f(c⋅x) comprime la gráfica horizontelmente en un factor de c .
y=f(1/c⋅x) alarga la gráfica horizontelmente en un factor de c .
y=−f(x) refleja la gráfica respecto al eje x.
y=f(−x) refleja la gráfica respecto al eje y.

Es todo lo que tienes que saber de esta clase, si se te hace difícil solo imagina que son direcciones/un chicle/un espejo, un chicle se puede estirar y comprimir; un espejo, dependiendo dónde lo pongas te reflejará en X o Y

Considero que en términos de igualdad puede ser bienvenidas y bienvenidos todos, en cualquier orden, pero no solo bienvenida, es el n-esimo video y no se me hace correcto, es una observación.

Traslación se hace sumando o restando. Compresion o alargamiento se hace multiplicando por un positivo. Reflexión se hace multiplicando por -1. Si se multiplica por un negativo, se esta reflejando y alargando (o contrayendo) al.mismo tiempo.

¿De que forma puede ser útil este tema de manipulación en Data Science?

Manipulación de funciones
Podemos “manipular” las funciones mediante la transformación por medio de constantes, de esta manera no se pierde la estructura de la función.

Aplicación de las constantes

  • A toda la función → transformamos la función con respecto a su rango (eje y)
  • Directamente a la variable → transformamos la función con respecto a su dominio (eje x)

Transormación por suma de constantes

  • A la función: f(x) ± c
    • Suma f(x) + c → desplaza la función hacia arriba
    • Resta f(x) - c → desplaza la función hacia abajo
  • A la variable: f(x± c)
    • Suma f(x+c) → desplaza la función a la izquierda
    • Resta f(x-c) → desplaza la función a la derecha

Transormación por multiplicacion de constantes

  • A la función: f(x)*c
    • c>0 f(x)*c → alarga la función verticalmente (con respecto al eje y)
    • Resta f(x) - c → comprime la función verticalmente
  • A la variable: f(x± c)
    • Suma f(x+c) → comprime la función horizontalmente (con respecto al eje x)
    • Resta f(x-c) → alarga la función horizontalmente

Desplazamientos

import numpy as np
import matplotlib.pyplot as plt

N = 1000

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

c = 5

x = np.linspace(-10,10, num=N)
y_1 = f(x)+c
y_2 = f(x)-c
y_3 = f(x+c)
y_4 = f(x-c)

fig,ax = plt.subplots(1,1,figsize=(10,10),dpi=60)

ax.plot(x,y_1, label="F(X) + C")
ax.plot(x,y_2, label="F(X) - C")
ax.plot(x,y_3, label="F(X + C)")
ax.plot(x,y_4, label="F(X - C)")
#SCATTER(X,Y):DISPERSION
ax.scatter([-5,0,0,5],[0,-5,5,0], color='red', s=100)
ax.grid()

#LEGEND(LOC=POSICION, FONTSIZE=TAMAÑO)
ax.legend(loc=3, fontsize='x-large')
ax.axhline(y=0, color='y')
ax.axvline(x=0, color='y')
ax.set_xlim(-10,10)
ax.set_ylim(-6, 14)

plt.show()

![](

Que maravilla poder tener el material ya listo y que las clases no solo sean tomar apuntes. La educación tradicional tiene mucho que aprender de Platzi

Solo como aporte,
|
Cuando en una función se cumple que:
|
$f(-x) = f(x)$
|
Se le llama función par, y estas son simétricas respecto a eje y.
|
Y en el caso de que
|
$f(-x) = -f(x)$
|
Se llama función impar, y estas son simétricas respecto al origen.
|

Funciones trigonométricas

Desplazamientos horizontales

Desplazamientos vericales

Reflexiones

Para visualizar mejor, podemos graficar una función original y la otra función la trasformamos.

def f(x): 
  return x

c = 5 

resolution = 1000  

x = np.linspace(-10.0, 10.0, num=resolution) 

y = f(np.cos(x))  
z = f(np.cos(x * c)) 

fig, ax = plt.subplots() 

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

excelente, gracias

No me gustan las clases de este profesor, explica terrible. (en mi opinion)

Hola les dejo mi codigo para graficar los primeros cuatro desplazamientos

<
import numpy as np
import matplotlib.pyplot as plt

N : int = 1000

def fun_desplazamiento_vertical_horizontal(x : float) -> float:
    return x**2

c : int = 10

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

y_arriba = fun_desplazamiento_vertical_horizontal(x) + c
y_abajo = fun_desplazamiento_vertical_horizontal(x) - c

c = 2

y_derecha = fun_desplazamiento_vertical_horizontal(x - c)
y_izquierda = fun_desplazamiento_vertical_horizontal(x + c)


fig = plt.figure(figsize=(15,15))
fig.tight_layout()
i : int = 1
for j in [[y_arriba, 'Desplazamiento hacia arriba'], 
          [y_abajo, 'Desplazamiento hacia abajo'], 
          [y_derecha, 'Desplazamiento hacia la derecha'], 
          [y_izquierda, 'Desplazamiento hacia la izquierda']]:
    y = j[0]
    title = j[1]
    ax = plt.subplot(2,2,i)
    ax.plot(x,y)
    ax.grid()
    ax.axhline(y=0, color='r')
    ax.axvline(x=0, color='r')
    ax.set_title(title)
    i += 1

> 

Para percibir mejor cada una de las manipulaciones, decidí graficar la original junto con la modificada. Se los recomiendo. 😄

import matplotlib.pyplot as plt  
import numpy as np

N = 1000      # N es la resolución

def f(x):
  return x**3

c = 10

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

y = f(x)


v = np.linspace(-1000,100, num=N)

w = f(-x)


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

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

Vale aclarar que y=cf(x) la alargará verticalmente un factor de c si y solo si, c>1, de lo contrario, la comprimirá.
Y que y=1/c
f(x) la comprimirá verticalmente si y solo si, c>1, de lo contrario la alargará.

Muy interesante la clase

Alargamientos y compresiones

Desplazamientos de funciones
Podemos pensar el desplazamiento de la siguiente manera con la función lineal
f(x) = mx +b, donde m es la pendiente, x representa el valor de entrada y b es el valor donde corta la función en el eje y, al sumar o restar, estaríamos asignando un valor b y por ende, subiendo o bajando la función.

  • Al restar un número a la función (f(x)=x-c), se desplaza hacia abajo

  • Al sumar un número a la función (f(x)=x+c), se desplaza hacia arriba

  • Al restar un número al valor de entrada(f(x-c)=x), se desplaza hacia la derecha

  • Al sumar un número al valor de entrada(f(+c)=x), se desplaza hacia la izquierda

Alargamiento y compresión

  • Al multiplicar un número c a la función, nos la comprime.

  • Al dividir por un número c a la función, nos la alarga.

Inversión de funciones

  • Al multiplicar por -1 (es lo que significa el -), invertimos la función.

Ejemplo de todo esto sería que nos dieran una función así, f(x) = x, y nos pidieran que la invirtamos, la alarguemos, que la corramos un espacio a la derecha y 3 espacios hacia abajo, suena complicado pero con todo lo visto, resultará intuitivo.
Terminamos aplicando todo lo que vimos en este módulo en un simple ejercicio.

Cuando tengan problemas para visualizar la función en sus mentes, recurran a geogebra excelente herramienta que nos puede ayudar mucho a ver las funciones o apliquen el método de la tabla de valores.

Creo que la manera más práctica es graficar los puntos en el diagrama cartesiano para que le quede claro a uno.

Hola [email protected] quería compartir con uds una funcion queria meter los 4 casos de alargamiento y compresion de cualquier funcion, entonces cree una funcion que toma como parametros un (kwargs) con dos keys : 1) comportamiento =“alargar || comprimir” y la 2da es la key modo = “natural || antinatural” y dependiendo de cualquier caso que digite el usuario como parametro dentro de **la funcion mostrara la grafica correspondiente **comparto el codigo y un caso ejemplo :

Código:

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

def graficar(**kwargs):
  print(kwargs)
  if kwargs["comportamiento"] == "alargar" or kwargs["comportamiento"] == "comprimir" and kwargs["modo"] == "natural" or kwargs["modo"] == "antinatural":  
    constante = 4
    x = np.linspace(4*(-np.pi), 4*(np.pi), 1000)
    y = f(x)
    string= ""
    if kwargs["comportamiento"] == "alargar" and kwargs["modo"] == "antinatural":
      string = "y2 = f((1/constante) * x)"
      y2 = f((1/constante) * x)
    else:
      string = "y2 = constante * f(x)"
      y2 = constante * f(x)
      if kwargs["comportamiento"] == "comprimir":
        if kwargs["modo"] == "natural":
          string = "y2 = 1/constante * f(x)"
          y2 = (1/constante) * f(x)
        elif kwargs["modo"] == "antinatural":
          print("entree")
          string = "y2 = f(c * x)"
          y2 = f(constante * x)
    [grafica1, grafica2] = plt.plot(x, y, x, y2)
    plt.xlabel('Angulo en [rad]')
    plt.ylabel('sin(x)')
    plt.grid()
    plt.legend([grafica1, grafica2], ["f(x) = sin(x)", f"{string}"])
    plt.axhline(y=0, color="g")
    plt.axvline(x=0, color="g")
    return plt.show()
  else:
    print("Los valores que puede tomar como máximo dos llaves respectivamente son:\n \t 1) comportamiento = comprimir ó  alargar\n \t 2) modo = natural ó antinatural")

graficar(comportamiento="alargar", modo="antinatural")

Gráfica del ejemplo con comportamiento == “alargar” y modo == “antinatural”

cuando la constante está fuera de f(x) el comportamiento sera natural y en sentido vertical mientras que si la constante esta dentro de f(x) el comportamiento sera antinatural y en sentido horizontal (así fue como lo entendí espero les sirva salu2)

Algo que no menciono el profesor es que la “reflexión” no siempre se da en todas las funciones, ya que, en las funciones pares la grafica es igual a su reflejo en el eje y.
f(x) = f(-x), donde f : R —> R y f es una función par, es decir que el argumento “x” es de la forma x^2n.
Se puede comprobar con el siguiente script:

N = 1000

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

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

y1 = f(-x)

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

Por otra parte, las funciones impares tienen la propiedad de que:
f(-x) = -f(x)

Realice unas pequeñas modificaciones sobre la función original del notebook

N = 1000

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

c = 4

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

y = f(x)
y_arr = f(x) + c
y_abj = f(x) - c
y_der = f(x - c)
y_izq = f(x + c)


fig, ax = plt.subplots()


ax.plot(x,y, 'g-', label='original', linewidth=2)
ax.plot(x,y_arr, 'y-', label='arr', linewidth=2)
ax.plot(x,y_abj, 'b-', label='abj', linewidth=2)
ax.plot(x,y_der, 'c--', label='Der', linewidth=2)
ax.plot(x,y_izq, 'm--', label='Izq', linewidth=2)
ax.grid()
ax.legend()
ax.axhline(y=0, color='r')
ax.axvline(x=0, color='r')