Funciones Afines: Propiedades y Ejercicios Prácticos

Clase 15 de 28 • Curso de Introducción al Álgebra Lineal: Vectores

Resumen

¿Qué son las funciones afines?

Las funciones afines son un concepto crucial en matemáticas, particularmente en el estudio del álgebra lineal. Se definen como funciones que pueden expresarse utilizando la fórmula ( f(x) = a^T x + b ), donde:

( a ) y ( x ) son vectores.
( b ) es un escalar, conocido como el offset o el bias.

Estas funciones cumplen propiedades específicas de superposición solo cuando los coeficientes de una combinación lineal suman uno. Por ejemplo, una función dada por ( 3 + x_0 + x_1 + x_2 ) puede representarse como ( a^T x + b ), donde ( a = [1, 1, 1] ) y ( 3 ) es el offset.

¿Cómo se demuestra la propiedad de superposición en funciones afines?

Para verificar si una función afín cumple la propiedad de superposición, debemos confirmar que:

[ \alpha f(x) + \beta f(y) = f(\alpha x + \beta y) ]

solo cuando ( \alpha + \beta = 1 ). La demostración sigue estos pasos:

Partimos de la definición de la función afín: [ f(\alpha x + \beta y) = a^T (\alpha x + \beta y) + b ]
Distribuimos y utilizamos que ( \alpha + \beta = 1 ): [ = a^T \alpha x + a^T \beta y + b ]
Agregamos el escalar utilizando que ( (\alpha + \beta) b = b ) gracias a que ( \alpha + \beta ) es uno: [ = a^T \alpha x + a^T \beta y + (\alpha + \beta)b ]
Finalmente, reagrupamos los términos: [ = \alpha(a^T x + b) + \beta(a^T y + b) ] Ambos términos demuestran la propiedad de superposición, validando así que nuestra función es afín.

Ejercicios propuestos: ¿Cómo aplicar el concepto de funciones afines?

A continuación, te propongo algunos ejercicios para aplicar lo aprendido sobre funciones afines.

Tipos de funciones:
- Determina si las funciones dadas son lineales o no.
- Comprueba si cumplen la propiedad de superposición.
Desempeño en clusters:
- Tenemos un problema basado en sistemas de control:
  - Imagina un clúster con tres procesadores. Midiendo la potencia y temperatura en diferentes estados operativos, deduce el comportamiento de la temperatura.
  - Calcula la temperatura cuando los tres procesadores están a máxima potencia.
  - Asegúrate de que la temperatura no supere los 150 grados.

Recuerda, estos ejercicios están diseñados para reforzar tu comprensión de las funciones afines y su aplicabilidad en problemas reales. Sumérgete en ellos y no dudes en compartir tus soluciones y dudas con la comunidad. ¡Sigue aprendiendo y profundizando en temas matemáticos!

Robin Angel Romero

student•

Aquí mi aporte del ultimo problema, me llevo algo de rato, ya que es un tema que tenia rato de no ver, tuve que repasar algunos conceptos de matrices, hacer varias preguntas... XD, lo que explicare será la forma de obtener los valores de a y b:

hay distintas formas de ver este problema para llegar a la solución, una vez terminé de ver la clase, lo primero hice fue tratar de implementar algún código para encontrar los vectores a y b, como no llegaba a nada, toco plantear el sistema de ecuaciones

35 = [a0 a1 a2][10 10 10] + b 60 = [a0 a1 a2][100 10 10] + b 75 = [a0 a1 a2][10 100 10] + b 65 = [a0 a1 a2][10 10 100] + b

cada ecuación representa las situaciones descritas en el problemas

operando las matrices a y p como indica la función, se obtiene lo siguiente 35 = 10 a0 + 10 a1 + 10 a2 + b 60 = 100 a0 + 10 a1 + 10 a2 + b 75 = 10 a0 + 100 a1 + 10 a2 + b 65 = 10 a0 + 10 a1 + 100 a2 + b así tenemos un sistema de 4 ecuaciones y 4 incógnitas, que es posible resolver de distintas formas, una de ellas es escribir el sistema en su forma matricial, el termino "matricial" no se ha usado mucho hasta ahora en el curso, pero es como si habláramos de stacks de vectores. este sistema se puede resolver con la función linalg.solve de Numpy, la cual nos devolvera en un array con los valores de a0, a1, a2 y b, aqui les dejo un video con explicacion y el codigo implementado https://www.youtube.com/watch?v=G28bJYdqOFQ

import numpy as np

def run():
    
    ecuacion1="10*a0+10*a1+10*a2+b=35"
    ecuacion2="100*a0+10*a1+10*a2+b=60"
    ecuacion3="10*a0+100*a1+10*a2+b=70"
    ecuacion4="10*a0+10*a1+100*a2+b=65"

    p=np.array([[10,10,10,1],[100,10,10,1],[10,100,10,1],[10,10,100,1]]) #matrix de coeficientes, potencias de los controladores
    t=np.array([35,60,70,65]) #matriz de soluciones, temperaturas
    
    a=np.linalg.solve(p,t) #obtengo los valores de a y b

    print(a)

if __name__ == "__main__":
    run()

ejecutando, tenemos el siguiente output:

por lo tanto a0=0.2777778, a1=0.3888889, a2=0.33333 y b=25 así ya hemos encontrado las entradas del vector a y el valor de b, y podemos escribir nuestra función T(P)=a*P+b

ahora bien, si vienen siguiendo la ruta de aprendizaje de escuela de Data Science, habrán pasado por algunos cursos del profesor David Aroesti o el curso de matemáticas para data Science: probabilidad. https://platzi.com/clases/ds-probabilidad/ del profesor Francisco Camacho, que fue agregado recientemente. en ellos se nos ha hablado de la regresión lineal o el metodo de minimos cuadrados, los cuales son altamente aplicables en este problema.

si usamos otro enfoque, lo que tenemos son una serie de datos experimentales que corresponden las temperaturas obtenidas según la configuración de los procesadores, entonces requerimos una función o polinomio que se ajuste al comportamiento de los datos, para nuestra suerte, el ejercicio nos dice que esta función es afín, T(P)=aP+b lo que nos indica que buscamos un polinomio de grado 1 de la forma y=ax+b, una funcion lineal, y benditas sean las librerías como numpy o Scikitlearn que nos brindan métodos para lograr esto, les comparto mi código, en donde se aplican varias formas de obtener los coeficientes a y el valor de b:

import numpy as np
from sklearn.linear_model import LinearRegression

def datos_experimentales():
    p_0=np.array([10,10,10]) #en reposo
    p_1=np.array([100,10,10])
    p_2=np.array([10,100,10])
    p_3=np.array([10,10,100])
    
    p=np.array([p_0,p_1,p_2,p_3])
    t=np.array([35,60,75,65])
    
    return p, t

def solucion_metodo1(): #resolvinedo el sistema de ecuaciones
    ecuacion1="10*a0+10*a1+10*a2+b=35"
    ecuacion2="100*a0+10*a1+10*a2+b=60"
    ecuacion3="10*a0+100*a1+10*a2+b=70"
    ecuacion4="10*a0+10*a1+100*a2+b=65"
    
    p=np.array([[10,10,10,1],[100,10,10,1],[10,100,10,1],[10,10,100,1]]) #matrix de coeficientes, potencias de los controladores
    t=np.array([35,60,70,65]) #matriz de soluciones, temperaturas
    
    a=np.linalg.solve(p,t) #obtengo los valores de a y b
    return a

def solucion_metodo2(): #usando minimos cuadrados, numpy.linalg.lstsq
    # Experimental data:
    p,t=datos_experimentales()
    
    A = np.column_stack([p, np.ones(len(p))])
    coefs = np.linalg.lstsq(A, t, rcond=-1)[0]
    
    return coefs

def solucion_metodo3(): #regresion lineal con sklearn.linear_model
    model = LinearRegression()
    
    # Experimental data:
    p,t=datos_experimentales()

    model.fit(X=p, y=t)

    print("coeff: ", *model.coef_)
    print("intercept: ", model.intercept_)
    
def run():
    print("********metodo1, resolvinedo el sistema de ecuaciones*******")
    print(solucion_metodo1())
    print("********metodo2, usando minimos cuadrados, numpy.linalg.lstsq*******")
    print(solucion_metodo2())
    print("********metodo3, regresion lineal con sklearn.linear_model*******")
    solucion_metodo3()
if __name__ == "__main__":
    run()

Output:

Espero que esto ayude, hare otro aporte respondiendo a los incisos usando los resultados obtenidos aquí

Jorge Urrea

student•

Excelente contrubución! Muchas gracias!

Anthony Jean Paul Blaz Lazo

student•

Muy buen enfoque

Angel Estrada

student•

Solución al problema 2:

Angel Estrada

student•

También les dejo el link a mi notebook

Daniel Pérez

student•

Mas claro imposible

Angel Estrada

student•

Primer ejercicio:

Daniel Camilo Velez Malagon

student•

Anges una duda. En el segundo ejercicio en la validacion de la linealidad por que da alpha(x^3(x^3 - x^2)) = alpha(2x^3 - x^2) Mi duda radica en que X^3 * (-X^2) no deberia dar otro resultado?

Angel Estrada

student•

Como tu lo planteas el X_3 estaría miltiplicando al (X_3 - X_2), sin embargo, si te das cuenta, existe un signo de '+' entre estos términos,

lo que significa que no se está multiplicando, sino sumando.

Entonces el párentesis indica únicamente agrupación, como no podemos sumar el X_3 - X_2, pasamos al siguiente término que se debe operar, que es sumar el X_3 de afuera.

Quedaría algo como:

alpha(X_3 + X_3 - X_2) = alpha(2*X_3 -X_2)

Espero que haya despejado tu duda c:

Jorge Cruz Perez

student•

Estuvo complejo el ejercicio mas que nada por la cantidad de datos, de hecho mi solución solo es aproximada, y bueno estos son mis datos:

Y la temperatura a la que los 3 procesadores trabajan al 100% (126.94) no rebasa la temperatura limite de 150:

Saludos :)

Abel Camacho

student•

Excelente aporte, tienes un resumen de la metodología aplicada?

Axel Díaz

student•

Ejercicio 1

def p(x):
  long=len(x)
  ret= x[long-1] - x [0]
  return ret

v_a = np.array([1,9,12])
v_b = np.array([4,3,4])
x ,y = 1 , 9
print('p(x*v_a + y*v_b) = ',p(x*v_a + y*v_b))
print('x*f(v_a) + y*f(v_b) =',x*p(v_a) + y*p(v_b))

#output
p(x*v_a + y*v_b) =  11
x*f(v_a) + y*f(v_b) = 11

Por lo tanto si es lineal

Ejercicio 2

#funcion
def f_4(x):
    res = x[2] + (x [2] - x [1])
    return res
# main 
v_a = np.array([1,9,12,2])
v_b = np.array([4,3,4,9])
x ,y = 1 , 9
print('p(x*v_a + y*v_b) = ',f_4(x*v_a + y*v_b))
print('x*f(v_a) + y*f(v_b) =',x*f_4(v_a) + y*f_4(v_b))

#output
p(x*v_a + y*v_b) =  60
x*f(v_a) + y*f(v_b) = 60

La segunda función es lineal

Rafael Rivera

student•

Gran aporte, gracias por explicar.

Daniel Felipe Montenegro

student•

¿Que temperatura se alcanza? Para resolver esta pregunta tenemos que encontrar el vector a y el escalar b que satisfacen la ecuación: T( P ) = aT . P + b El procedimiento es plantear y resolver el siguiente sistema de ecuaciones lineales donde a0, a1 y a2 son las componentes del vector a encontrar: 35 = 10 a0 + 10 a1 + 10 a2 + b 60 = 100 a0 + 10 a1 + 10 a2 + b 75 = 10 a0 + 100 a1 + 10 a2 + b 65 = 10 a0 + 10 a1 + 100 a2 + b El vector resultante sería a = [5/18, 4/9, 1/3] y el escalar b = 220/9, de esta manera la ecuación del problema sería esta: T( P ) = [5/18, 4/9, 1/3]T . [P0, P1, P2] + 220/9. La máxima potencia de cada procesador es 100 por lo que P = [100, 100, 100], al resolver la ecuación T( P ) = [5/18, 4/9, 1/3]T . [100, 100, 100] + 220/9 el resultado de la temperatura es 130. . ¿Cual es la potencia máxima que pueden alcanzar los procesadores para que T <= 150? Reescribamos la ecuación T( P ) = [5/18, 4/9, 1/3]T . [P0, P1, P2] + 220/9: 150 = [5/18, 4/9, 1/3]T . [P0, P1, P2] + 220/9 150 = 5/18 P0 + 4/9 P1 + 1/3 P2 + 220/9 150 = 5/18 P0 + 8/18 P1 + 6/18 P2 + 440/18 150 = (5 P0 + 8 P1 + 6 P2 + 440)/18 2700 = 5 P0 + 8 P1 + 6 P2 + 440 2260 = 5 P0 + 8 P1 + 6 P2 La potencia máxima puede ser descrita como una ecuación de dos variables donde las variables independientes serán la potencia de dos de los tres procesadores y la variable dependiente nos indicará la potencia máxima del procesador restante. Para hallar la potencia máxima se puede utilizar cualquiera de las siguientes tres ecuaciones: P0max = ( 2260 - 8 P1 - 6 P2 )/5 P1max = ( 2260 - 5 P0 - 6 P2 )/8 P2max = ( 2260 - 5 P0 - 8 P1 )/6

Valenttina Cardozo

student•

Por si alguien no entendió bien los dos puntos del Ejercicio: En el primero, la propiedad de homogeneidad, por ende es lineal. En el segundo, se cumple superposición porque la suma de los escalares (los indices del vector) es 1.

Rafael Rivera

student•

Gracias por el aporte Valentina

Carlos Felipe Saldarriaga Bejarano

student•

Esta fue la aproximación que encontré, la A transpuesta está definida en la función.


import numpy as np

def T(p):
    return np.array([112275/405449, 179925/405449, 134825/405449]).T@p + 24.468

print("Cuando están en reposo T=", T(np.array([10,10,10])),
      "\nCuando el procesador 1 está al máximo T=", T(np.array([100,10,10])),
      "\nCuando el procesador 2 está al máximo T=", T(np.array([10,100,10])),
      "\nCuando el procesador 3 está al máximo T=", T(np.array([10,10,100])),
      "\nCuando el todos los procesadores están al máximo T=", T(np.array([100,100,100])))

OUTPUT

Cuando están en reposo T= 35.00015077605322 
Cuando el procesador 1 está al máximo T= 59.922520790530996 
Cuando el procesador 2 está al máximo T= 74.9392059963152 
Cuando el procesador 3 está al máximo T= 64.9280825257924 
Cuando el todos los procesadores están al máximo T= 129.78950776053216

Ulises Rayon

teacher•

¡Buenísimo Carlos! Gran solución.

Sergio Alejandro Martínez

student•

Disculpa @Carlos, me podría explicar por favor la razón de los valores del arreglo que define en la función T(p)

(112275/405449, 179925/405449, 134825/405449) Muchas Gracias

Axel Díaz

student•

Este es el código que use para encontrar el vector a

Estas fueron las operaciones que use para enontrar los valores de el vector a

import numpy as np
T = np.array([35, 60, 75, 65]).T
P = np.array([[10, 100, 10, 10],[10, 10, 100, 10],[10, 10, 10, 100],[1,1,1,1]])
P_inv= np.linalg.inv(P)
a_vec = T @ P_inv
print(a_vec)

Esta es la función que hice

def funcion_de_temperatura(x):
  return f'T = {a @ x+ b} con P_1 = {x[0]}, P2= {x[1]}, P3 = {x[2]} '
#Para probar
v = np.array([10,10,10])
print(funcion_de_temperatura(v))
#Temperatura maxima potencia
max_p = np.array([100, 100 ,100])
print(funcion_de_temperatura(max_p))

Y el output

T = 35.00000000000001 con P_1 = 10, P2= 10, P3 = 10 
T = 130.0 con P_1 = 100, P2= 100, P3 = 100

Con este algoritmo calcule los valores donde se aproximaba a 150 Primero puse una delta grande de .01 y después que ya sabia que era cercano a 18 empecé a contar desde 18

resultado = 0
potencia = 118
delta = 0.000001
while (1):
  v_c = np.array([potencia,potencia,potencia])
  resultado = funcion_de_temperatura_n(v_c)
  if resultado ==150 or resultado > 150:
    break
  potencia = potencia + delta
print(resultado , potencia)

output : 150 , 118.94736899760812 Ejecuntando lo

max_p = np.array([118.94736899760812, 118.94736899760812,118.94736899760812])
print(funcion_de_temperatura(max_p))

Output

T = 150.00000060858633 con P_1 = 118.94736899760812, P2= 118.94736899760812, P3 = 118.94736899760812

Robin Angel Romero

student•

aqui les compartto mi codigo final:

import numpy as np
from sklearn.linear_model import LinearRegression

def datos_experimentales():
    p_0=np.array([10,10,10]) #en reposo
    p_1=np.array([100,10,10])
    p_2=np.array([10,100,10])
    p_3=np.array([10,10,100])
    
    p=np.array([p_0,p_1,p_2,p_3])
    t=np.array([35,60,75,65])
    
    return p, t

def solucion_metodo1(): #resolvinedo el sistema de ecuaciones
    ecuacion1="10*a0+10*a1+10*a2+b=35"
    ecuacion2="100*a0+10*a1+10*a2+b=60"
    ecuacion3="10*a0+100*a1+10*a2+b=70"
    ecuacion4="10*a0+10*a1+100*a2+b=65"
    
    p=np.array([[10,10,10,1],[100,10,10,1],[10,100,10,1],[10,10,100,1]]) #matrix de coeficientes, potencias de los controladores
    t=np.array([35,60,70,65]) #matriz de soluciones, temperaturas
    
    a=np.linalg.solve(p,t) #obtengo los valores de a y b
    return a

def solucion_metodo2(): #usando minimos cuadrados, numpy.linalg.lstsq
    # Experimental data:
    p,t=datos_experimentales()
    
    A = np.column_stack([p, np.ones(len(p))])
    coefs = np.linalg.lstsq(A, t, rcond=-1)[0]
    
    return coefs

def solucion_metodo3(): #regresion lineal con sklearn.linear_model
    # Experimental data:
    p,t=datos_experimentales()
    
    #primera forma:
    model = LinearRegression()

    model.fit(X=p, y=t)

    # print("coeff: ", *model.coef_)
    # print("intercept: ", model.intercept_)
    
    #segunda forma:
    reg = LinearRegression().fit(p, t)
    # print (reg.coef_, reg.intercept_)
    
    return reg.coef_, reg.intercept_
    
def T(p):
    a,b=solucion_metodo3()
    return a@p+b

    
def run():
    print("********metodo1, resolvinedo el sistema de ecuaciones*******")
    print(solucion_metodo1())
    print("")
    print("********metodo2, usando minimos cuadrados, numpy.linalg.lstsq*******")
    print(solucion_metodo2())
    print("")
    print("********metodo3, regresion lineal con sklearn.linear_model*******")
    print("coeff, intercept: ", solucion_metodo3())
    print("")
    
    p_max_capacity=np.array([100,100,100])
    print(f'la temperatura que se alcanza cuando los todos los procesadores estan a su maxima capacidad es de {T(p_max_capacity)}°C')

Output:

Siendo la temperatura de fusión de los procesadores 150°C, los 3 podrían operar a su máxima capacidad sin que se derritan

Miguel Angel Reyes Moreno

student•

Así fue como resolví los primeros 2 ejercicios, con ejemplos. Estoy abierto a feedback (:

Para el tercer ejercicio tuve que ver ejemplos de algunos comentarios y noté que iba en la misma dirección, dejo mi código en python:

import numpy as np
P = np.array([[10,10,10,1] , [100,10,10,1] , [10,100,10,1] , [10,10,100,1]])
T = np.array([35,60,75,65])
x = np.linalg.solve(P,T)
print(f"La solución para el sistema de ecuaciones lineales es {x}")

Resultado: La solución para el sistema de ecuaciones lineales es [ 0.27777778 0.44444444 0.33333333 24.44444444]

Marco Carmona

student•

Veo que en tu hipótesis pones que vas a realizar una demostración para algún vector perteneciente al campo R^n que va hacia R. Entonces, te recomiendo que utilices el siguiente vector:

\vec{x} = (x_0,x_1,...,x_{n-1}, x_n)

Puede que sea un poco pretencioso el dar una demostración con un vector de tal tamaño, pero cualquier duda que tengas, no dudes en dejar tu comentario, me mantengo muy al pendiente.

Jorge Cruz Perez

student•

Otra solución, por el gusanito de estar mas aproximada,

Axel Díaz

student•

Podrían explicar un poco como trabajaron con las matrices para llegar a el vector a y la variable b

CRISTIAN BARBERO PÉREZ

student•

Hola compañero,

Tienes la ecuación: T(P) = a P + b Donde a y P son vectores a = [a1 a2 a3] y P = [P1 P2 P3], y se multiplican escalarmente: a1*P1 + a2*P2 + a3*P3

Entonces tienes 4 incógnitas que son a1, a2, a3 y b, y 4 ecuaciones, que son:

35 = [a1 a2 a3][10 10 10] + b 60 = [a1 a2 a3][100 10 10] + b 75 = [a1 a2 a3][10 100 10] + b 65 = [a1 a2 a3][10 10 100] + b

Resolviendo ese sistema obtienes a y b, y podrás responder entonces a las siguientes preguntas 😀

Axel Díaz

student•

Gracias

CARLOS JAVIER ANZOLA CASTELLANOS

student•

Método ++simplificado++ para el problema de los procesadores: .

Una función afín cumplirá la superposición si y solo si la suma de de los coeficientes de la combinación lineal es uno. Es decir, si f es una función afín entonces f(αx+βy)=αf(x)+βf(y) si y solo si α+β=1 .

. En este caso tenemos la función T( P), que puede expresarse como T(1*P), donde 1 es el único coeficiente de la función T. Como sólo hay un coeficiente (que equivale a 1), entonces la suma de coeficientes es igual a 1. Como la suma de coeficientes es igual a 1, podemos aplicar el principio de superposición. .

If input A produces response X and input B produces response Y then input (A + B) produces response (X + Y).

. Por lo que podemos calcular el efecto en la temperatura producido por cada procesador por separado y sumarlos para hallar el ++efecto total en el sistema:++ . T(P1) = 60° - 35° = 25° T(P2) = 75° - 35° = 40° T(P3) = 65° - 35° = 30° T( P) = T(P1) + T(P2) + T(P3) = 95° . Ya teniendo el efecto total de los procesadores en la temperatura del sistema, sólo debemos sumarlo a la ++condición inicial T = 35°:++ . Tmax = 95° + 35° Tmax = 130° . ++Finalmente, podemos concluir que:++ .

Si los procesadores operan a máxima potencia, el sistema tendría una temperatura de 130°
No hay riesgo de que los procesadores se derritan si operan a máxima potencia, ya que 130° < 150°

Alejandro López

student•

La única respuesta cuyo planteamiento concuerda con lo visto en la clase. El Principio de Superposición. Gracias Maestro

Mariano Gobea Alcoba

student•

Estoy realmente muy contento de decirle que pude resolver el problema. Tardé unas horas, pero me ha apasionado resolverlo. Me sirvió mucho retomar otros cursos, fundamentalmente el otro que hay sobre Algebra Lineal donde nos enseñan a resolver un sistema de ecuaciones lineales usando matrices y vectores. Gracias a este ejercicio termine de entender su utilidad.

Les dejo mi trabajo final:

https://github.com/Mgobeaalcoba/proyectos_platzi/blob/main/Ejercicios_de_Funciones_Lineales.ipynb

jesus Encinas

student•

Hay otro curso de algebra lineal aqui ?

Mariano Gobea Alcoba

student•

Hola jencinasc. ¿Como estás? Claro que sí. Hay varios. Si usas la luta vas a encontrar al menos 3 o 4 mas de algebra lineal. En mí caso me refería a este otro curso de Algebra Lineal:

https://platzi.com/cursos/algebra-lineal/

Brayan David

student•

import numpy as np
import sympy as sym
#en reposo
p_0=np.array([10,10,10,1]) 
#1 activado
p_1=np.array([100,10,10,1])
#2 activado
p_2=np.array([10,100,10,1])
#3 activado
p_3=np.array([10,10,100,1])

#coeficientes de la matriz
coef=np.array([p_0,p_1,p_2,p_3])
#soluciones
sol=np.array([35,60,75,65])
#solucionamos el sistema de ecuaciones
a=np.linalg.solve(coef,sol)

#miramos cuando la temperatura es igual a 150 
x = sym.symbols('x')
expr =a[0]*x+a[1]*x+a[2]*x+(a[3])-150
print(f'la potencia maxima que pueden alcanzar antes de que la temperatura sea superior a 150° es: {sym.solve(expr)[0]}')
#miramos la temperatura con los 3 procesadores funcionando
print(f'la temperatura con todos los procesadores encendidos es: {a[0]*100+a[1]*100+a[2]*100+(a[3])}°')

la potencia maxima que pueden alcanzar antes de que la temperatura sea superior a 150° es: 118.947368421053 la temperatura con todos los procesadores encendidos es: 130.0°

JAVIER SANTIAGO SALGADO

student•

Samuel José Moreno

student•

import numpy as np vectorA = np.array([5/18,4/9, 1/3])

bias = 24.4444444444

def T(vectorA, bias = 24.4444444444):

P0 = float(input("p0 = "))

P1 = float(input("p1 = "))

P2 = float(input("p2 = "))

vectorP = np.array([P0,P1,P2])

return vectorP@vectorA.T + bias

T(vectorA, bias = 24.4444444444)

Jeinfferson Bernal G

student•

Ejercicios Resueltos

Probar que las siguientes funciones sean lineales

# Definimos la funcion
def f(x):
    return x[-1] - x[0]

# elementos a utilizar
a = np.array([1,1,1,1])
b = np.array([1,0,1,0])
x,y = 1,-2

# principio de superposicion
print('f(a*x + b*y) = ', f(a*x + b*y))
--> f(a*x + b*y) =  2

# principio de superposicion
print('x*f(a) + y*f(b) = ', x*f(a) + y*f(b))
--> x*f(a) + y*f(b) =  2

Como ambos resultados son correctos, la funcion f(x) es lineal

# definimos la funcion
def f4(x):
    return x[3] + (x[3] - x[2])

# elementos a utilizar
a = np.array([0,1,1,0])
b = np.array([1,0,1,0])
x,y = 1,-2

# principio de superposicion
print('f(a*x + b*y) = ', f4(a*x + b*y))
--> f(a*x + b*y) =  1

# principio de superposicion
print('f(a*x + b*y) = ', f4(a*x + b*y))
--> f(a*x + b*y) =  1
```Como ambos resultado son iguales indica que cumple con el principio de superposición, por tanto, es lineal.



1. Resolver:

![](https://static.platzi.com/media/user_upload/Untitled%20%2822%29-f13d1189-a340-4aea-9069-ce082732a753.jpg)

&#x20;![](https://static.platzi.com/media/user_upload/Untitled%20%2823%29-984ceeb2-c8c0-4fc4-b644-dd523babff37.jpg)

```python
# construimos una matriz con los coeficientes del sistema de ecuacion
A = np.array([[10,10,10,1], [100,10,10,1], [10,100,10,1], [10,10,100,1]])

# vector con las soluciones del sistema de ecuacion
b = np.array([35,60,75,65])

# vectos solucion. Primer parametro la matriz, segundo parametro las soluciones
a = np.linalg.solve(A,b)

# los primeros 3 elementos corresponden a los coeficientes de 'a^T' 
# el ultimo elemento corresponde a 'b'
a

--> array([ 0.27777778,  0.44444444,  0.33333333, 24.44444444])

# asignamos los elementos de la lista 'a' a nuevas variables
b = a[3]
a = a[:3]
print(a)
print(b)

--> [0.27777778 0.44444444 0.33333333]
		24.444444444444443

# ahora, definimos una funcion que resuma la formula anterior
def T(P):
    return a.dot(P) + b

# Validamos que los resultados encontrados sean correctos al pasarlos
# a la formula y ver que las soluciones sean las mismas
print('T([10,10,10]) = ',T(np.array([10,10,10])))
print('T([100,10,10]) = ',T(np.array([100,10,10])))
print('T([10,100,10]) = ',T(np.array([10,100,10])))
print('T([10,10,100]) = ',T(np.array([10,10,100])))

-->
T([10,10,10]) =  35.0
T([100,10,10]) =  60.0
T([10,100,10]) =  75.0
T([10,10,100]) =  65.0

Supongamos que los tres procesadores operan a máxima potencia ¿Qué temperatura se alcanza?

print('T([100,100,100]) = ', a.dot(np.array([100,100,100])) + b)

--> T([100,100,100]) =  130.0

La temperatura de fusión de los procesadores (a la que los procesadores se derriten) es cerca de 150 ¿Cuál es la potencia máxima que pueden alcanzar los procesadores para que T≤150?

# Asumimos que la temperatura maxima de los 3 procesadores 
# es la misma con una tolerancia es de 0.01 y que la potencia minima es de 100
tol = 0.01
min = float(100)
max = 150

# definimos la potencia de inicio
P = np.array([min,min,min])

# buscamos los valores de Potencia que no superen los 150 de temperatura
while T(P) <= max:
    max_potencia = P
    P += tol

max_potencia
--> array([118.95, 118.95, 118.95])

Alejandro López

student•