Matlab "Unable to convert expression containing symbolic variables into ddouble array"

[turbulent]

Bonjour tout le monde. Merci de m'aider à corriger "Unable to convert expression containing symbolic variables into ddouble array"

%Root of linear or nonlinear function
% Root-Finding in Matlab of function
%defined on interval [a,b]
clc
%format short
%format long
% Find all roots of function real.
% Solve Eq f(x)=0 on interval [a,b].
L=3;
A=1.08;
f=@(x) tan(L*x)+2*x;
a=-5;
b=5;
fplot(f,[a,b]),grid on;
zero=fzero(@(x)f(x),a);
oldzero=zero;
zerotot=zero;
eps=1e-6;
nRoots=100;
for i=a:0.01:b
zero=fzero(@(x)f(x),i);
long=length(zerotot);
if abs(zero - zerotot)> eps & (a<= zero) & (zero <= b)
zerotot=[zerotot;zero];
long=long+1;
end
oldzero=zerotot(long);
end
index=find(zerotot<a);
zerotot(index)=[];
index=find(zerotot>b);
zerotot(index)=[];

%Check:
froots=f(zerotot); % equal to 0?
index=find(abs(froots)<=eps);
Roots=sort(zerotot(index))
z=0:.1:L;%L;%
%dt =.1;
for i=1:6
  if i==1
  T=0;
  end
  if i==2
  T= .25;
  end
  if i==3
  T=1;%.2;%*60;% Après 15 min;%1500;
  end
  if i==4
   T=3;%.2;%*60;% Après 20  min;%0.1;
  end
  if i==5
  T=7;%.2;%*60;% Après 30  heure;%
  end
  if i==6
  T=10;%.2;%*60;% Après 40 minutes; 
  end
  
    n=length(Roots);
syms n
%Roots=sort(zerotot(index));
%Roots=subs(sort(zerotot(index)));
Roots=sym(sort(zerotot(index)));
% symsum(sin(Roots(i )*z).*sin(Roots(i )*L).*exp(-(Roots(i ).^2).*t )./(1+...
%         L /2+2*L*Roots(i ).^2),1,length(Roots));
symsum(sin(Roots.*sym(z)).*sin(Roots*L).*exp(-(Roots.^2).*sym(T) )./(1+...
        L /2+2*L*Roots.^2),1,n);
fsum=symsum(sin(Roots.*sym(z)).*sin(Roots*L).*exp(-(Roots.^2).*sym(T) )./(1+...
        L /2+2*L*Roots.^2),1,n);
f=log(A -(A-1)*exp(-sym(z))-4*(A)*exp(L-...
         sym(z)).*exp(-sym(T) ).*fsum); %subs

   % fplot(double(f),z)
end
F=subs(f)
% plot(double(f),z)
plot(double(F),z)
%end

-----

[Biname]

Salut,
Je n'utilise jamais Matlab. Curieux de tester GPT sur le sujet, je lui copie ton msg, il me répond ceci que je ne comprends pas/peu :

 Cliquez pour afficher

Ce code semble être une tentative de résoudre une équation non linéaire à l'aide de la méthode de recherche de racines sur l'intervalle [a, b]. Cependant, il semble y avoir quelques problèmes dans le code.

L'erreur "Unable to convert expression containing symbolic variables into double array" se produit lorsque vous essayez de convertir une expression symbolique en un tableau de nombres doubles. Cela se produit probablement lors de l'utilisation de la fonction fplot ou de la tentative de tracer le graphique de f à la fin du code.

Pour résoudre ce problème, vous pouvez utiliser la fonction double pour convertir les expressions symboliques en nombres doubles avant de les utiliser dans des fonctions qui nécessitent des entrées numériques. Par exemple, vous pouvez modifier la ligne où vous définissez F comme suit :

matlab

F = double(subs(f));

De plus, il y a une boucle for où vous essayez d'itérer de a à b avec un pas de 0,01. Cependant, a et b sont définis comme des entiers (a = -5 et b = 5). Il est recommandé d'utiliser des valeurs en virgule flottante (par exemple, a = -5.0 et b = 5.0) pour éviter des problèmes d'itération.

Enfin, je remarque que la variable n est définie comme une variable symbole (syms n) mais elle est ensuite utilisée comme une variable numérique (n = length(Roots)). Cela peut entraîner des résultats inattendus. Il serait préférable de changer le nom de la variable symbole pour éviter les conflits.

Assurez-vous également d'avoir la boîte à outils Symbolic Math installée, car le code utilise des variables et des fonctions symboliques de MATLAB.

Si vous avez des problèmes spécifiques ou des questions supplémentaires concernant le code, n'hésitez pas à demander.

A-t-il raison ?

Biname

[turbulent]

Merci infiniment Biname.
Effectivement, le problème résidait dans la définition de n. Le code marche bien, malheureusement, il n'aboutit pas aux bons résultats. L'essentiel pour moi c'est qu'il marche. Le reste, c'est à moi de le régler.

[Biname]

Merci infiniment Biname.
Effectivement, le problème résidait dans la définition de n. Le code marche bien, malheureusement, il n'aboutit pas aux bons résultats. L'essentiel pour moi c'est qu'il marche. Le reste, c'est à moi de le régler.

C'est GPT qu'il faut remercier, pas moi !
Merci, pour le retour.
Biname

[A voir en vidéo sur Futura]

[umfred]

Pour une prochaine fois, en plus du message d'erreur lui-même, il serait bien aussi d'indiquer la ligne où cette erreur est survenue, ça permet de directement cibler la bonne ligne à corriger/analyser.

[turbulent]

C'est promis

[MissJenny]

Le code marche bien, malheureusement, il n'aboutit pas aux bons résultats.

j'aime beaucoup cette phrase...

[turbulent]

Je veux dire qu'il n y a pas d'erreurs de programmation, mais ça n'aboutit pas aux résultats attendus.

[MissJenny]

tu t'enfonces...

[turbulent]

Merci, c'est gentil. Pourriez-vous ne pas commenter à mes questions, même si vous avez la bonne réponse.

[Biname]

Salut,
J'ai demandé à GPT de trouver une éventuelle erreur dans la formulation

 Cliquez pour afficher

Biname
Tu ne vois pas l'erreur dans la formulation ? Matlab, je lis à grand peine et il faudrait en plus comprendre la démarche suivie.
ChatGPT

Je m'excuse si je n'ai pas identifié immédiatement l'erreur dans la formulation. Je vais essayer de l'examiner plus attentivement.

Après avoir revu attentivement le code, il semble y avoir une erreur dans la ligne suivante :

matlab

f=log(A -(A-1)*exp(-sym(z))-4*(A)*exp(L-sym(z)).*exp(-sym(T)).*fsum);

Dans cette ligne, il semble y avoir une utilisation incohérente des fonctions log, exp et sym. Les variables z et T sont déjà définies en tant que tableaux de nombres réels (z=0:.1:L), et donc l'utilisation de sym(z) et sym(T) pour les convertir en variables symboliques semble incorrecte.

Pour résoudre ce problème, vous pouvez modifier cette ligne en utilisant les fonctions réelles plutôt que les fonctions symboliques, comme ceci :

matlab

f = log(A - (A - 1) * exp(-z) - 4 * A * exp(L - z) .* exp(-T) .* fsum);

En remplaçant sym(z) par z et sym(T) par T, vous utilisez les valeurs réelles des variables plutôt que leur représentation symbolique.

J'espère que cela résout l'erreur de formulation dans le code. N'hésitez pas à me faire savoir si vous avez d'autres questions ou si vous avez besoin d'une assistance supplémentaire.

Je n'ai pas fait l'effort d'essayer comprendre. Est-ce pertinent ?

Biname

[turbulent]

En fait, j'ai déjà remplacé les variables sym par les variables réelles et j'ai même modifié le code. Maintenant, le problème réside dans fsum, à propos duquel, ce matin, j'ai posté dans ce forum mon message intitulé "Fzero all roots". Merci Biname pour l'effort déployé même si GPT qui s'en occupait.

[Biname]

Salut,

En fait, j'ai déjà remplacé les variables sym par les variables réelles et j'ai même modifié le code. Maintenant, le problème réside dans fsum, à propos duquel, ce matin, j'ai posté dans ce forum mon message intitulé "Fzero all roots". Merci Biname pour l'effort déployé même si GPT qui s'en occupait.

Je viens de passer une heure agréable avec GPT qui, grâce à toi, m'a initié à la programmation symbolique, il m'a traduit ton code en Python et là, j'ai compris ... pas rien ça

 Cliquez pour afficher

Python

import sympy as sp

L = 3
A = 1.08
x = sp.Symbol('x')
f = sp.tan(L*x) + 2*x

a = -5
b = 5

sp.plot(f, (x, a, b), grid=True)

zero = sp.nsolve(f, a)
oldzero = zero
zerotot = [zero]
eps = 1e-6
nRoots = 100

for i in sp.arange(a, b, 0.01):
    zero = sp.nsolve(f, i)
    if abs(zero - zerotot[-1]) > eps and a <= zero <= b:
        zerotot.append(zero)
        oldzero = zerotot[-1]

zerotot = [z for z in zerotot if a <= z <= b]

froots = [f.subs(x, z) for z in zerotot]
Roots = sorted([z for z, f in zip(zerotot, froots) if abs(f) <= eps])

z = sp.Symbol('z')
T_values = [0, 0.25, 1, 3, 7, 10]

for T in T_values:
    n = len(Roots)
    fsum = sp.summation(sp.sin(Roots[z]*z)*sp.sin(Roots[z]*L)*sp.exp(-(Roots[z]**2)*T)/(1+L/2+2*L*Roots[z]**2), (z, 1, n))
    F = sp.log(A - (A - 1)*sp.exp(-z) - 4*A*sp.exp(L - z)*sp.exp(-T)*fsum)
    F = F.subs(z, z/10)
    sp.plot(F, (z, 0, L), xlabel='z', ylabel='F(z)', title='T = {}'.format(T))

Biname

[turbulent]

C'est intérresant, mais comme je l'ai cité dans mon message précédent, mon problème, maintenant réside dans le calcul des Roots. Le code (modifié) que j'ai appliqué me donne des racines bizarres:

f=@(x) tan(100*x)+2*x;
a=-5.0;
b=5.0;
%fplot(f,[a,b]),grid on;
zero=fzero(@(x)f(x),a);
oldzero=zero;
zerotot=zero;
eps=1e-9;
for i=a:0.01:b
zero=fzero(@(x)f(x),i);
long=length(zerotot);
if abs(zero - zerotot)> eps & (a<= zero) & (zero <= b)
zerotot=[zerotot;zero];
long=long+1;
end
oldzero=zerotot(long);
end
index=find(zerotot<a);
zerotot(index)=[];
index=find(zerotot>b);
zerotot(index)=[];
froots=f(zerotot); % equal to 0?
index=find(abs(froots)<=eps);
Roots=sort(zerotot(index))

En testant par exemple la dernière valeur affichée Roots(231)= 4.6663 et f(4.6663)=-0.2956 et pourtant eps=1e-9. Est-ce que avec Pyton, on obtient les mêmes résultats ou c'est différent ?

[Paraboloide_Hyperbolique]

Bonjour,

Voir ma réponse dans: https://forums.futura-sciences.com/p...all-roots.html

[Biname]

Salut,
A la calculette on trouve f(4.6663) = -0.29556...
Tu voudrais trouver zéro ? , je comprends mieux miss Jenny.

 Cliquez pour afficher

Python généré par GPT

import numpy as np

x = np.linspace(4.6662, 4.6664, 20)
y = np.tan(100*x) + 2*x

# Configuration de l'affichage
np.set_printoptions(precision=8, floatmode='fixed')

# Impression des valeurs de x et y
for i in range(len(x)):
    print(f"{x[i]:>12.8f} {y[i]:>12.8f}")

Résultats (4.6662, 4.6664, 20)
4.66620000 -1.33264157
4.66621053 -1.21317914
4.66622105 -1.09633935
4.66623158 -0.98203651
4.66624211 -0.87018861
4.66625263 -0.76071715
4.66626316 -0.65354695
4.66627368 -0.54860594
4.66628421 -0.44582505
4.66629474 -0.34513804
4.66630526 -0.24648133
4.66631579 -0.14979390
4.66632632 -0.05501715
4.66633684 0.03790522
4.66634737 0.12902731
4.66635789 0.21840116
4.66636842 0.30607679
4.66637895 0.39210236
4.66638947 0.47652420
4.66640000 0.55938695

Résultats (4.66632, 4.66634, 20)
4.66632000 -0.11165712
4.66632105 -0.10217026
4.66632211 -0.09270222
4.66632316 -0.08325294
4.66632421 -0.07382238
4.66632526 -0.06441046
4.66632632 -0.05501715
4.66632737 -0.04564237
4.66632842 -0.03628609
4.66632947 -0.02694823
4.66633053 -0.01762875
4.66633158 -0.00832760
4.66633263 0.00095529
4.66633368 0.01021996
4.66633474 0.01946647
4.66633579 0.02869487
4.66633684 0.03790522
4.66633789 0.04709757
4.66633895 0.05627197
4.66634000 0.06542847

Biname

[turbulent]

Je n'ai pas besoin de "calculette" !!!!
Moi, je cherche à vérifier la condition:

froots=f(zerotot); % equal to 0?
index=find(abs(froots)<=eps);
Roots=sort(zerotot(index))

[Biname]

Salut,

Je n'ai pas besoin de "calculette" !!!!
Moi, je cherche à vérifier la condition:

froots=f(zerotot); % equal to 0?
index=find(abs(froots)<=eps);
Roots=sort(zerotot(index))

A l'endroit de la racine en x=~4.66... la courbe est quasi verticale, d'où la difficulté de trouver la racine avec précision, même pour dx = 1e-9

Pour f(x) = tg(100x) + 2x, racine entre 4.66 et 4.67
Bounds: x=4.66000000 y=11.04046803, x =4.67000000 y = 7.38826799
Root found at x = 4.66526509 (eps = 1e-9)
Derivative at the root: f'(x) = 563.06569550
Arctan of the derivative: arctan(f'(x)) = 89.89824328 degrees

 Cliquez pour afficher

GPT python

import numpy as np

def derivative(x):
    return 100 * (1 + np.tan(100*x)**2) + 2

def find_root_and_derivative():
    x_start = 4.66
    x_end = 4.67
    tolerance = 1e-6
    
    a = x_start
    b = x_end
    
    fa = np.tan(100*a) + 2*a
    fb = np.tan(100*b) + 2*b
    
    print(f"Bounds: {a:.8f} {fa:.8f}, {b:.8f} {fb:.8f}")
    
    while np.abs(b - a) > tolerance:
        c = (a + b) / 2
        f_a = np.tan(100*a) + 2*a
        f_c = np.tan(100*c) + 2*c
        
        if np.sign(f_a) != np.sign(f_c):
            b = c
            fb = f_c
        else:
            a = c
            fa = f_c
    
    root = (a + b) / 2
    f_prime = derivative(root)
    f_prime_deg = np.degrees(np.arctan(f_prime))
    
    print(f"Root found at x = {root:.8f}")
    print(f"Derivative at the root: f'(x) = {f_prime:.8f}")
    print(f"Arctan of the derivative: arctan(f'(x)) = {f_prime_deg:.8f} degrees")

find_root_and_derivative()

Biname

[turbulent]

Merci comme même, le problème est déjà résolu.

[umfred]

la réponse a été donnée sur son autre post https://forums.futura-sciences.com/p...all-roots.html
c'est le format d'affichage du résultat qui biaise la valeur (affichée)
on peut forcer l'affichage long via l'instruction matlab "format long" , ou mieux, passer directement la valeur retournée dans la fonction f(Roots(231)) et ça donne bien une valeur inférieure à l'epsilon définie

[Biname]

Salut,
Est-ce que la courbe est bien très verticale en la racine ?231, x=4.66... ?
Je me demande si 'mon' code ne trouve pas l'infini (pi/2) de la tangente ?
Biname

[turbulent]

La vérité, ce qui m'importait, c'est les courbes f(z, T), c'est parfait.

[Biname]

Salut,

La vérité, ce qui m'importait, c'est les courbes f(z, T), c'est parfait.

La valeur ___minimale___ de la dérivée de tg(bx) est b pour x = N * pi
Ajouter 2 x augmente encore la pente.
Si b=100, dx=1 >> dy=100 ... au moins
Biname