Comment utiliser une variable globale (expression dérivée) dans une fonction

Question

Ce script fonctionne parfaitement pour ce que je veux. C'est une fonction de poids que je veux minimiser. Je l'ai écrit dans une fonction et dans le monde et j'ai remarqué que l'impression globale (W) est mon expression et l'impression (W) à l'intérieur de la fonction est le tableau de valeurs à tracer:

import numpy as np 
from sympy import * 
import matplotlib.pyplot as plt 

#Weight function 

tf = Symbol('tf') 
l = 50/(0.54*tf) - tf 
d = (tf*(2*l+2*(l-tf)/2))/(2*l*(l+tf)/2) 
W = 15.7*tf-7.85*tf*d+7.85*d*50/(0.54*tf) 
print(W) 

def func(tf): 
    l = 50/(0.54*tf) - tf 
    d = (tf*(2*l+2*(l-tf)/2))/(2*l*(l+tf)/2) 
    W = 15.7*tf-7.85*tf*d+7.85*d*50/(0.54*tf) 
    print(W) 
    return W 

b = np.linspace(1, 10, 201) 
plt.plot(b, func(b)) 
plt.xlabel("tf", fontsize=18) 
plt.ylabel("Weight", fontsize=18) 
plt.grid() 
plt.show() 

Mon problème se produit maintenant. Je veux aussi que le dérivé de fonction de poids soit tracé. Mais je ne peux pas le faire à l'intérieur de la fonction car il reconnaît un nombre (premier élément du tableau). La première impression me donne l'expression que je veux tracer, mais je ne peux pas envoyer cette expression à l'intérieur de la fonction. Comment puis-je appeler une variable globale (expression dérivée) à utiliser dans la fonction?

dW_dtf = W.diff(tf) 
print(dW_dtf) 

def funcd(tf): 
    l = M/(a*tf) - tf 
    tw = tf 
    d = (tw*(2*l+2*(l-tw)/2))/(2*l*(l+tw)/2) 
    W = 15.7*tf-7.85*tf*d+7.85*d*M/(a*tf) 
    dW_dtf = W.diff(tf) 
    return dW_dtf 

AttributeError: 'numpy.ndarray' objet n'a pas d'attribut 'diff'

Je suis ouvert à d'autres options pour faire ce que je veux. Je vais en lire plus sur les algorithmes d'optimisation en utilisant python car je vais devoir résoudre des problèmes plus difficiles mais je voudrais faire ce genre de problèmes de base sans utiliser de méthodes itératives. Je vous remercie. Luis

Answer 1

Dans votre code, vous substituez essentiellement votre définition globale. À l'heure actuelle, lorsque vous appelez le func, vous redéfinissez W en utilisant la valeur que vous avez indiquée tf. Dans votre cas, un tableau. De cette façon, W n'est plus une expression symbolique mais simplement un tableau. Ce que vous voulez est quelque chose comme ça au lieu de func:

def func(x): 
    w_evaluator=lambdify(tf,W) 
    return w_evaluator(x) 

Et analogue:

def funcd(x): 
    dwdt_evaluator=lambdify(tf,W.diff(tf)) 
    return dwdt_evaluator(x)