Funciones seccionadas

mi forma favorita de implementar esto es:

import numpy as np

def f(x):
    # np.int0 es un cast a números enteros
    return np.int0(x >= 0) 

Según yo así:

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

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

y=f(x)

plt.plot(x, y)

Así lo hice yo 🤔

Dejo una lectura adicional de las funciones seccionadas acá

Información resumida de esta clase
#EstudiantesDePlatzi

• Las funciones seccionadas son funciones que se comportan de manera diferente dependiendo de los trozos o secciones

• Las funciones seccionadas se definen H (x)

• enumerate es una función en Python que nos permite tener el índice y el elemento de un arreglo

• Existen muchas funciones seccionadas

• La función real valor absoluto se define sobre el conjunto de todos los números reales asignando a cada número real su respectivo valor absoluto

este es el aporte del reto>

![](

#Valor absoluto:

def f(x):

    lista = []

    for value in x:
        if value > 0:
            value = value
            lista.append(value)

        elif value < 0:
            value = value*-1
            lista.append(value)

        else:
            value = 0
            lista.append(value)
    
    return lista

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

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()

Tambien se puede hacer con np.absolute

Hay una función muy interesante llamada “sigmoide”. La función que representa una sigmoide es la siguiente:

f(x) = (1 + e^(-x))^(-1)

Donde e es el número de Euler.

Esta función tiene propiedades muy interesantes. Por ejemplo, se puede demostrar que su derivada es igual a:

f’(x) = f(x)*[1 - f(x)]

Pero lo que quiero resaltar es su comportamiento, el cual es muy similar al de la función escalón de Heaviside, ya que solo toma valores entre 0 y 1, es decir, su rango es (0, 1).

Esta función es muy usada cuando se trabaja con redes neuronales.

Si quieren implementar la función sigmoide en Python, aquí les dejo el código:

import numpy as np

def f(x):
    return (1 + np.exp(-x))**(-1)

Así se ve la gráfica de la función:

Acerca de las funciones de valor absoluto
https://www.varsitytutors.com/hotmath/hotmath_help/spanish/topics/absolute-value-functions

La gráfica de la función H(x) que se realizo en google colab en el minuto 7:30 no es la más precisa en términos matemáticos, el segmento de recta vertical no debe ir en la gráfica, es solo un detalle pero no menos importante.

Escalón de Heaviside, siguiendo la metodolia de las anteriores

def H(x):

    lista = []

    for value in x:
        if value >= 0:
            value = 1
            lista.append(value)
        else:
            value = 0
            lista.append(value)

    return lista

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

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()

Esta clase es un preambulo de lo que podemos ver en una función logistica para modelos de ML para regresiones logísticas. Importante repasar bien esta clase.

La función escalón se ocupa en redes neuronales

Así realice la solución al problema propuesto

def Abs_value(x):
    Y=np.zeros(len(x))
    for idx,x in enumerate(x):
        if x >= 0:
            Y[idx]=x
        else:
            Y[idx]=-x
    return Y

A=1000
x=np.linspace(-5, 5, num=A)
y=Abs_value(x)

fig,ax = plt.subplots()
ax.plot(x,y)
ax.grid(linestyle='--')
plt.title("Funciones a trozos - Valor Abs")

![](

Sé que se puede utilizar la función abs() para hacerlo de forma más fácil pero definiendo una función absoluta como una función seccionada sería así.

def f(x):
    y = np.zeros_like(x)
    for i,v in enumerate(x):
        if v < 0:
            y[i] = -v
        elif v >= 0:
            y[i] = v
    return y
    
x = np.linspace(-10,10, num=100)
y = f(x)
plt.plot(x,y)

Según yo, así funciona para sacar la gráfica de la función de valor absoluto. Si estoy bien o mal, muchas gracias por los comentarios y tomaré nota.

def Abs(x):
  Y = np.zeros(len(x))
  for idx,x in enumerate(x):
    if x<0:
      Y[idx]=x*-1
    else:
      Y[idx]=x
  return Y
    

N=1000

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

y = Abs(x)

plt.plot(x,y)

Interesante el desarrollo de funciones seccionada. Ma el reto de valor absolute. Era casi el mismo valor solo que con numpy se cambia el valor a absolute.
![](

Esta fue mi forma de resolverlo, sin embargo, he notado que numpy tiene una función especifica para esto jajaja

Por cierto, un dato curioso, si escriben un “;” despues del comando para graficar no será necesario escribir la linea de codigo “plt.show()”

def f(x):
  Y = np.zeros(len(x))
  for index, x in enumerate(x):
    if x < 0:
      Y[index] = x * -1
    elif x > 0:
      Y[index] = x
  return Y

x = np.linspace(-10,10, num=1000)
y = f(x)

plt.plot(x,y);

Me encantó que para esta sesión del curso pasaran los apuntes de clase, deberían hacerlo en todas las clases de platzi.

Función Absoluta

La función absoluta, denotada comúnmente como |x|, es una función que toma un número real x como entrada y devuelve el valor absoluto de ese número como resultado. El valor absoluto de un número es la distancia entre ese número y el cero en la recta numérica, siempre siendo positivo o igual a cero. La función absoluta se puede definir como:

| x | = { x, si x >= 0, -x, si x < 0 }

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

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

y=f(x)

plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('|x|')
plt.title('Gráfica de la Función Absoluta')
plt.grid(True)
plt.show()

se puede usar esto:

<import numpy as np
import matplotlib.pyplot as plt

def H(x):
    if x < 0:
        return 0
    else:
        return 1

N = 1000
x = np.linspace(-10, 10, num=N)
y = [H(xi) for xi in x]

plt.plot(x, y)
plt.show()
> 

también esto

<y = np.vectorize(H)(x)> 

Mi aporte:

def h(x):
    return 1 * (x >= 0)

x = np.linspace(-10, 10, 1000)
y = h(x)

plt.plot(x, y);

De esta manera se pueden hacer mas “escalones”, simplemente agregando mas condicionales o “secciones” a la función.

def H(x):
  Y = np.zeros(len(x))
  for idx,x in enumerate(x):
    if x > 0 and x < 10:
      Y[idx] = 1
    elif x >10:
      Y[idx] = 2 
  return Y

x = np.linspace(-20,20, num=1000)
y = H(x)

plt.plot(x,y)
plt.grid()

Encontre otra forma de resolver el problema que es vectorizar la funcion con np.vectorize(H)
se los dejo aqui 😃

import numpy as np

def H(x):
    if x < 0:
        return 0
    return 1

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

H_vectorized = np.vectorize(H)  # Vectorizamos la función H

result = H_vectorized(x)  # Aplicamos la función vectorizada a todo el array x
plt.plot(x,result)

Comparto con ustedes la función de Heaviside.
Debemos tomar en cuenta que el segmento de recta vertical no debe ir en la gráfica como lo hace Google Colab en el video.

Yo así le hice, veo que hay muchas formas de hacerlo, no duden en compartir su forma 😃

Función de valor absoluto

Por definición, el valor absoluto de x siempre será mayor o igual que cero y nunca negativo.

def f_abs (x):
  return np.abs(x)

y = f_abs(x)
plt.plot(x,y)

<code> 
def valorab(x):
Y = np.zeros(len(x))
for idx,x in enumerate(x):
	if x < 0:
	Y[idx]=x*-1
else:
	Y[idx]=x
return Y

x = np.linspace(-100,100,num=200)
y = valorab(x)
plt.plot(x,y)

Una forma fácil y rápida para crear el valor absoluto

def f(x):
    return abs(x) 
y=f(x)
plt.plot(x,y)
plt.grid()
plt.axhline(0,color='gray', alpha=0.5 )
plt.axvline(0,color='gray',alpha=0.5 )
plt.show()

Pongo el codigo identico en COLAB y me sale una linea a una altura de 1 siempre 😦

<def f(x):
  Y= np.zeros(len(x))
  for idx, x in enumerate(x):
    if x>=0:
      Y[idx]=x
    else:
      Y[idx]=-x
  return Y
N=1000
x=np.linspace(-10,10,num=N)
y=f(x)    
plt.plot(x,y)> 

Fue confuso el codigo de ejemplo en Google colab.

import numpy as np
import matplotlib.pyplot as plt

N = 1000


def H(x):
    Y = np.zeros(len(x))
    for idx, x in enumerate(x):
        if x >= 0:
            Y[idx]=1
    return Y

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

plt.plot(x, y)

import matplotlib.pyplot as plt
import numpy as np

def f(x):
    Y=np.zeros(len(x))
    for idx, b in enumerate(x):
        if b >= 0:
            Y[idx]=b
        else:
            Y[idx]=-b
    return Y

N=11
x =np.linspace(-10,10, num = N)
y = f(x)
plt.plot(x,y)

3 formas de hacer la función valor absoluto :

1. la chipi

def f(x):
    return np.abs(x)
    
x=np.linspace(-5,5,150)
plt.plot(x,f(x))

1. la python de puro

def f(x):
    lista=[]
    for i ,j in enumerate(x):
        if j <0:
            lista.append(j*-1)
        else:
            lista.append(j)
    return lista

x=np.linspace(-5,5,100)
y=f(x)
plt.plot(x,y)

3.con numpy(copia de profe)

def f(x):
    lista=np.zeros(len(x))
    for i ,j in enumerate(x):
        if j <0:
            lista[i]=j*-1
        else:
            lista[i]=j
    return lista

x=np.linspace(-5,5,100)
y=f(x)
plt.plot(x,y)

import matplotlib.pyplot as plt   
import numpy as np                
def f(x):
  return np.absolute(x)
x = np.linspace(-10,10, num=1000)
y=f(x)
fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid(".")
plt.axvline(x=0, color='grey')
plt.axhline(y=0, color='grey')

Para el caso de la primera funcion, lo hice de la siguiente manera:

import numpy as np
import matplotlib.pyplot as plt

def H(x):
    if x<0:
        return 0
    else:
        return 1

x = np.linspace(-10,10,100)

lista = list(map(H,x)) 
y = np.array(lista)

plt.plot(x,y)
plt.grid()
plt.show()

reto

Veámosla en acción para dibujar la función campana de Gauss:

Elegiremos 1000 valores en el intervalo para una distribución normal de media y desviación estándar .

import matplotlib.pyplot as plt
import numpy as np
import math

num_puntos = 1000
x_min = -5
x_max = 5
lista_x = np.linspace(x_min, x_max, num_puntos)

media = 0
desviacion_estandar = 1
factor = 1./(desviacion_estandar*math.sqrt(2*math.pi))
den = 2*desviacion_estandar**2

lista_y = [0]*num_puntos
for i, x in enumerate(lista_x):
    lista_y[i] = factor*math.exp((-(x-media)**2)/den)

plt.plot(lista_x, lista_y)
plt.title('Distribución de Gauss')
plt.xlabel('$x$')
plt.ylabel('$N({},{})$'.format(media, desviacion_estandar))
plt.show()

crea una tira de ceros de la misma longitud que la entrada X y solo cambia a 1 las mismas posiciones en las que X es >=0

Otra forma de hacerlo:

import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

def f(x):
  y= x.copy()
  y[y>=0], y[y<0] = 1, 0
  return y

x = np.linspace(-10, 10, num=1000)
y = f(x)

#Graphic
fig = plt.figure()
axes = fig.add_axes([0, 0, 1, 1])
axes.plot(x, y, linewidth=3, color=c_1)
axes.set_title('Función escalón de Headivise\n')
axes.set_xlabel('x')
axes.set_ylabel('y')
fig.set_facecolor(color=c_2)
fig.show()

import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
#RETO: FUNCIÓN VALOR ABSOLUTO
#Dos maneras de hacerlo:
#1
def f(x):
  Y = x.copy()
  for idx, num in enumerate(x):
    if num < 0:
      Y[idx] *= -1
  return Y
#2
def f(x):
  y = x.copy()
  y[y<0] *= -1
  return y

x = np.linspace(-10, 10, num=1000)
y = f(x)

#Graphic
sns.set_theme(style='darkgrid')
fig = plt.figure()
axes = fig.add_axes([0, 0, 1, 1])
axes.plot(x, y, linewidth=3, color='#000080')
axes.set_xlabel('x')
axes.set_ylabel('y')
axes.set_title('Función de valor absoluto\n')
fig.set_facecolor('#AAA662')
fig.show()

algo me dice que nuestro querido teacher se complico un poco.

Pd. es la primera ves que veo estas cosas.

Mi forma de implementar la función de valor absoluto

plt.plot(x, np.absolute(x))

Adicionalmente la clase me sirvió para repasar la función enumerate.

Adjunto mi reto

Reto, parte 1:

.abs(): Lo que hace esta función, como su nombre lo indica, es pasar a su valor absoluto. El valor absoluto es el valor positivo de este (-3 → 3). Cuándo el valor es positivo, se deja positivo (3→3)

Puedes entender más sobre el tema en este Artículo (Está en inglés, aprovecha para practicar tu reading)

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

y = f(x)

plt.title('Abs Value')
plt.plot(x,y);
plt.grid()

Mi aporte!

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

def H(x):
  Y = np.zeros(len(x))
  for idx, x in enumerate(x):
    if x <= 0:
      Y[idx] = -x
    else:
      Y[idx] = x  
  return Y    

plt.plot(x,H(x));

Funciones absolutas

Las Funciones absolutas son aquellas que se encuentran dentro de el valor absoluto es decir tenemos una función algebráica y para que sea una función absoluta esta se tiene que meter dentro de los símbolos del valor absoluto

Mi Código para solucionarlo es este

<code> 

def f(x):
  return abs(4 + 2*x)

n = 1000

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

y = f(x)

plt.plot(x,y)
plt.grid()

El resultado de esto es

FUNCIÓN ABSOLUTO

N = 1000

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

plt.plot(x, np.absolute(x))
plt.grid()

Dejo mi implementación de la función absoluta

def f(x):
  return np.absolute(x)
N = 1000
x = np.linspace(-10,10,num=N)
y = f(x)

fig, ax = plt.subplots()
ax.plot(x,y)
ax.grid()

https://prezi.com/x4wwr2ygy7ey/funcion-seccionada/ dejpoo aqui unas dias positivas