Niveau école ingénieur

test algorithme résolution équa diff ne fonctionne pas sur algob

Posté par
cambdt 01-05-20 à 18:03

Bonjour à tous !

J'ai écrit un algorithme permettant de résoudre des équations différentielles de premier et second ordre. Je l'ai écrit en utilisant algobox.

Cependant, lorsque je tente de l'exécuter ("tester algorithme"), le message ***Lancement de l'algorithme*** apparaît indéfiniment et l'algo ne s'exécute jamais. Le logiciel ne m'a remonté aucune erreur de syntaxe. Voici mon algorithme, si ça peut être utile (désolé, il est très long):


FONCTIONS_UTILISEES
VARIABLES
  A EST_DU_TYPE NOMBRE
  B EST_DU_TYPE NOMBRE
  C EST_DU_TYPE NOMBRE
  Yc EST_DU_TYPE NOMBRE
  hx EST_DU_TYPE NOMBRE
  ED EST_DU_TYPE NOMBRE
  Yh EST_DU_TYPE NOMBRE
  Yp EST_DU_TYPE NOMBRE
  k EST_DU_TYPE NOMBRE
  D EST_DU_TYPE NOMBRE
  E EST_DU_TYPE NOMBRE
  F EST_DU_TYPE NOMBRE
  G EST_DU_TYPE NOMBRE
  H EST_DU_TYPE NOMBRE
  I EST_DU_TYPE NOMBRE
  J EST_DU_TYPE NOMBRE
  U1 EST_DU_TYPE NOMBRE
  U2 EST_DU_TYPE NOMBRE
  V1 EST_DU_TYPE NOMBRE
  V2 EST_DU_TYPE NOMBRE
  u EST_DU_TYPE NOMBRE
  v EST_DU_TYPE NOMBRE
  w EST_DU_TYPE NOMBRE
  x EST_DU_TYPE NOMBRE
  K1 EST_DU_TYPE NOMBRE
  K2 EST_DU_TYPE NOMBRE
  K3 EST_DU_TYPE NOMBRE
  K4 EST_DU_TYPE NOMBRE
  delta EST_DU_TYPE NOMBRE
  P1 EST_DU_TYPE NOMBRE
  P2 EST_DU_TYPE NOMBRE
  P3 EST_DU_TYPE NOMBRE
  P4 EST_DU_TYPE NOMBRE
  r1 EST_DU_TYPE NOMBRE
  r2 EST_DU_TYPE NOMBRE
  r0 EST_DU_TYPE NOMBRE
  m EST_DU_TYPE NOMBRE
  t1 EST_DU_TYPE NOMBRE
  t2 EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
  AFFICHER* "Entrez les valeurs de A, B et C telles que Ay''+By'+Cy=h(x)"
  LIRE A
  LIRE B
  LIRE C
  LIRE m
  ED PREND_LA_VALEUR Ay''+By'+Cy
  P3 PREND_LA_VALEUR pow(x,t1)(K1cos(u*x)+K2sin(u*x))
  P4 PREND_LA_VALEUR pow(x,t2)(K3cos(v*x)+K4sin(v*x))
  SI (B=0) ALORS
    DEBUT_SI
    delta PREND_LA_VALEUR -4*A*C
    P1 PREND_LA_VALEUR (D*pow(x,2)+E*x+F)
    SI (delta>0) ALORS
      DEBUT_SI
      r1 PREND_LA_VALEUR (-B+sqrt(delta))/2A
      r2 PREND_LA_VALEUR (-B-sqrt(delta))/2A
      Yh PREND_LA_VALEUR w*exp(r1*x)+z*exp(r2*x)
      t1 PREND_LA_VALEUR 0
      t2 PREND_LA_VALEUR 0
      SI (r1==m OU r2==m) ALORS
        DEBUT_SI
        P2 PREND_LA_VALEUR (G3*pow(x,3)+G2*pow(x,2)+H*x+I)*exp(mx)
        FIN_SI
      SI (r1!=m ET r2!=m) ALORS
        DEBUT_SI
        P2 PREND_LA_VALEUR (G*pow(x,2)+H*x+I)*exp(mx)
        FIN_SI
      FIN_SI
    SI (delta==0) ALORS
      DEBUT_SI
      r0 PREND_LA_VALEUR -B/2A
      t1 PREND_LA_VALEUR 0
      t2 PREND_LA_VALEUR 0
      Yh PREND_LA_VALEUR (w+z)*exp(r0*x)
      SI (r0==m) ALORS
        DEBUT_SI
        P2 PREND_LA_VALEUR (G4*pow(x,4)+G3*pow(x,3)+G2*pow(x,2)+H*x+I)*exp(mx)
        FIN_SI
      FIN_SI
    SI (delta<0) ALORS
      DEBUT_SI
      r1 PREND_LA_VALEUR (-B/2A)+(sqrt(delta)*i/(2A))
      r2 PREND_LA_VALEUR (-B/2A)-(sqrt(delta)*i/(2A))
      Yh PREND_LA_VALEUR exp((-B/2*A)*x)*(w*cos(sqrt(abs(pow(B,2)-4*A*C)))+z*sin(sqrt(abs(pow(B,2)-4*A*C))))
      SI (-B/2A==0 ET ((-sqrt(delta)/(2A)==u OU (sqrt(delta)/(2A)==u)) ALORS
        DEBUT_SI
        t1 PREND_LA_VALEUR 1
        FIN_SI
        SINON
          DEBUT_SINON
          t1 PREND_LA_VALEUR 0
          FIN_SINON
      SI (-B/2A==0 ET ((-sqrt(delta)/(2A)==v OU (sqrt(delta)/(2A)==v)) ALORS
        DEBUT_SI
        t2 PREND_LA_VALEUR 1
        FIN_SI
        SINON
          DEBUT_SINON
          t2 PREND_LA_VALEUR 0
          FIN_SINON
      SI (r0==m) ALORS
        DEBUT_SI
        P2 PREND_LA_VALEUR (G4*pow(x,4)+G3*pow(x,3)+G2*pow(x,2)+H*x+I)*exp(mx)
        FIN_SI
      FIN_SI
    FIN_SI
  SI (C=0) ALORS
    DEBUT_SI
    delta PREND_LA_VALEUR pow(B,2)-4*A*C
    P1 PREND_LA_VALEUR (D3*pow(x,3)+D2*pow(x,2)+E*x+F)
    SI (delta>0) ALORS
      DEBUT_SI
      r1 PREND_LA_VALEUR (-B+sqrt(delta))/2A
      r2 PREND_LA_VALEUR (-B-sqrt(delta))/2A
      t1 PREND_LA_VALEUR 0
      t2 PREND_LA_VALEUR 0
      SI (r1==m OU r2==m) ALORS
        DEBUT_SI
        P2 PREND_LA_VALEUR (G3*pow(x,3)+G2*pow(x,2)+H*x+I)*exp(m*x)
        FIN_SI
      SI (r1!=m ET r2!=m) ALORS
        DEBUT_SI
        P2 PREND_LA_VALEUR (G*pow(x,2)+H*x+I)*exp(mx)
        FIN_SI
      FIN_SI
    SI (delta==0) ALORS
      DEBUT_SI
      r0 PREND_LA_VALEUR -B/2A
      t1 PREND_LA_VALEUR 0
      t2 PREND_LA_VALEUR 0
      Yh PREND_LA_VALEUR (w+z)*exp(r0*x)
      SI (r0==m) ALORS
        DEBUT_SI
        P2 PREND_LA_VALEUR (G4*pow(x,4)+G3*pow(x,3)+G2*pow(x,2)+H*x+I)*exp(mx)
        FIN_SI
      FIN_SI
    SI (delta<0) ALORS
      DEBUT_SI
      r1 PREND_LA_VALEUR (-B/2A)+(sqrt(delta)*i/(2A))
      r2 PREND_LA_VALEUR (-B/2A)-(sqrt(delta)*i/(2A))
      SI (-B/2A==0 ET ((-sqrt(delta)/(2A)==u OU (sqrt(delta)/(2A)==u)) ALORS
        DEBUT_SI
        t1 PREND_LA_VALEUR 1
        FIN_SI
        SINON
          DEBUT_SINON
          t1 PREND_LA_VALEUR 0
          FIN_SINON
      SI (-B/2A==0 ET ((-sqrt(delta)/(2A)==v OU (sqrt(delta)/(2A)==v)) ALORS
        DEBUT_SI
        t2 PREND_LA_VALEUR 1
        FIN_SI
        SINON
          DEBUT_SINON
          t2 PREND_LA_VALEUR 0
          FIN_SINON
      SI (r0==m) ALORS
        DEBUT_SI
        P2 PREND_LA_VALEUR (G4*pow(x,4)+G3*pow(x,3)+G2*pow(x,2)+H*x+I)*exp(mx)
        FIN_SI
        SINON
          DEBUT_SINON
          P2 PREND_LA_VALEUR (G2*pow(x,2)+H*x+I)*exp(mx)
          FIN_SINON
      FIN_SI
    Yp PREND_LA_VALEUR P1+P2+P3+P4
    Yc PREND_LA_VALEUR Yh+Yp
    AFFICHER Yc
    FIN_SI
  SI (A!=0 ET B!=0 ET C!=0) ALORS
    DEBUT_SI
    delta PREND_LA_VALEUR pow(B,2)-4*A*C
    P1 PREND_LA_VALEUR (D2*pow(x,2)+E*x+F)
    SI (delta>0) ALORS
      DEBUT_SI
      r1 PREND_LA_VALEUR (-B+sqrt(delta))/2A
      r2 PREND_LA_VALEUR (-B-sqrt(delta))/2A
      t1 PREND_LA_VALEUR 0
      t2 PREND_LA_VALEUR 0
      SI (r1==m OU r2==m) ALORS
        DEBUT_SI
        P2 PREND_LA_VALEUR (G3*pow(x,3)+G2*pow(x,2)+H*x+I)*exp(mx)
        FIN_SI
      SI (r1!=m ET r2!=m) ALORS
        DEBUT_SI
        P2 PREND_LA_VALEUR (G*pow(x,2)+H*x+I)*exp(mx)
        FIN_SI
      FIN_SI
    SI (delta==0) ALORS
      DEBUT_SI
      r0 PREND_LA_VALEUR -B/2A
      t1 PREND_LA_VALEUR 0
      t2 PREND_LA_VALEUR 0
      Yh PREND_LA_VALEUR (w+z)*exp(r0*x)
      SI (r0==m) ALORS
        DEBUT_SI
        P2 PREND_LA_VALEUR (G4*pow(x,4)+G3*pow(x,3)+G2*pow(x,2)+H*x+I)*exp(mx)
        FIN_SI
      FIN_SI
    SI (delta<0) ALORS
      DEBUT_SI
      r1 PREND_LA_VALEUR (-B/2A)+(sqrt(delta)*i/(2A))
      r2 PREND_LA_VALEUR (-B/2A)-(sqrt(delta)*i/(2A))
      SI (-B/2A==0 ET ((-sqrt(delta)/(2A)==u OU (sqrt(delta)/(2A)==u)) ALORS
        DEBUT_SI
        t1 PREND_LA_VALEUR 1
        FIN_SI
        SINON
          DEBUT_SINON
          t1 PREND_LA_VALEUR 0
          FIN_SINON
      SI (-B/2A==0 ET ((-sqrt(delta)/(2A)==v OU (sqrt(delta)/(2A)==v)) ALORS
        DEBUT_SI
        t2 PREND_LA_VALEUR 1
        FIN_SI
        SINON
          DEBUT_SINON
          t2 PREND_LA_VALEUR 0
          FIN_SINON
      SI (r0==m) ALORS
        DEBUT_SI
        P2 PREND_LA_VALEUR (G4*pow(x,4)+G3*pow(x,3)+G2*pow(x,2)+H*x+I)*exp(mx)
        FIN_SI
        SINON
          DEBUT_SINON
          P2 PREND_LA_VALEUR (G2*pow(x,2)+H*x+I)*exp(mx)
          FIN_SINON
      FIN_SI
    Yp PREND_LA_VALEUR P1+P2+P3+P4
    Yc PREND_LA_VALEUR Yh+Yp
    AFFICHER Yc
    FIN_SI
  SI (A=0 & B=0 & C=0) ALORS
    DEBUT_SI
    Yc PREND_LA_VALEUR 0
    AFFICHER Yc
    FIN_SI
  SI (A=0 & B=0) ALORS
    DEBUT_SI
    Yh PREND_LA_VALEUR 0
    P1 PREND_LA_VALEUR (D*pow(x,2)+E*x+F)
    P2 PREND_LA_VALEUR (G2*pow(x,2)+H*x+I)*exp(mx)
    t1 PREND_LA_VALEUR 0
    t2 PREND_LA_VALEUR 0
    Yp PREND_LA_VALEUR P1+P2+P3+P4
    Yc PREND_LA_VALEUR Yh+Yp
    AFFICHER Yc
    FIN_SI
  SI (A=0 & C=0) ALORS
    DEBUT_SI
    Yh PREND_LA_VALEUR k*exp(prim(B))
    P1 PREND_LA_VALEUR (D*pow(x,2)+E*x+F)
    P2 PREND_LA_VALEUR (G2*pow(x,2)+H*x+I)*exp(mx)
    t1 PREND_LA_VALEUR 0
    t2 PREND_LA_VALEUR 0
    Yp PREND_LA_VALEUR P1+P2+P3+P4
    Yc PREND_LA_VALEUR Yh+Yp
    AFFICHER Yc
    FIN_SI
  SI (A=0) ALORS
    DEBUT_SI
    Yh PREND_LA_VALEUR k*exp(prim(C/B))
    P1 PREND_LA_VALEUR (D*pow(x,2)+E*x+F)
    P2 PREND_LA_VALEUR (G2*pow(x,2)+H*x+I)*exp(mx)
    t1 PREND_LA_VALEUR 0
    t2 PREND_LA_VALEUR 0
    Yp PREND_LA_VALEUR P1+P2+P3+P4
    Yc PREND_LA_VALEUR Yh+Yp
    AFFICHER Yc
    FIN_SI
  SI (B=0 & C=0) ALORS
    DEBUT_SI
    delta PREND_LA_VALEUR 0
    r0 PREND_LA_VALEUR -B/2A
    t1 PREND_LA_VALEUR 0
    t2 PREND_LA_VALEUR 0
    P1 PREND_LA_VALEUR (D4*pow(x,4)+D3*pow(x,3)+D2*pow(x,2)+E*x+F)
    Yh PREND_LA_VALEUR (w+z)*exp(r0*x)
    SI (r0==m) ALORS
      DEBUT_SI
      P2 PREND_LA_VALEUR (G4*pow(x,4)+G3*pow(x,3)+G2*pow(x,2)+H*x+I)*exp(mx)
      FIN_SI
      SINON
        DEBUT_SINON
        P2 PREND_LA_VALEUR (G2*pow(x,2)+H*x+I)*exp(mx)
        FIN_SINON
    Yp PREND_LA_VALEUR P1+P2+P3+P4
    Yc PREND_LA_VALEUR Yh+Yp
    AFFICHER Yc
    FIN_SI
FIN_ALGORITHME

Posté par re : test algorithme résolution équa diff ne fonctionne pas sur 01-05-20 à 18:48

salut,
ce serait plus lisible en python avec des fonctions et des commentaires.
C'est quoi mx ?

Posté par re : test algorithme résolution équa diff ne fonctionne pas sur 01-05-20 à 19:05

salut

Citation :
DEBUT_ALGORITHME
  AFFICHER* "Entrez les valeurs de A, B et C telles que Ay''+By'+Cy=h(x)"
  LIRE A
  LIRE B
  LIRE C
  LIRE m        que représente m?
  ED PREND_LA_VALEUR Ay''+By'+Cy           A, B et C sont définies ok ... mais y'' et y' et y ?
  P3 PREND_LA_VALEUR pow(x,t1)(K1cos(u*x)+K2sin(u*x))    idem pour ces deux lignes : quelle est la valeur de x ? de u ? de t1 ? de K1 ? de K2 ?
  P4 PREND_LA_VALEUR pow(x,t2)(K3cos(v*x)+K4sin(v*x))

Posté par re : test algorithme résolution équa diff ne fonctionne pas sur 01-05-20 à 19:08

PS : et algobox est effectivement très pénible ... peut-être pour le collège ...

mais comme le dit alb12 en python ce serait autrement plus agréable ... à lire ...

Posté par re : test algorithme résolution équa diff ne fonctionne pas sur 01-05-20 à 20:13

Oui je pense le faire après en python.

Voici le sujet du devoir, pour que vous compreniez mieux à quoi correspondent les variables.

Le but est d'automatiser la résolution d'équations différentielles de cette forme :

a*y"(x)+b*y'(x)+c*y(x)=h(x) avec a, b, c constantes réelles à traiter dans la gestion du problème ( 8 cas à priori)

Avec h(x) de la forme :
h(x)= P1(x) + P2(x)*e(m*x) + U*cos(u*x) + V*sin(v*x)
P1(x) = d*x2 + e*x + f avec d, e, f constantes réelles P2(x) = g*x2 + h*x + l avec g, h et l constantes réelles

On peut imaginer "factoriser" l'affichage final sur un certain nombre de cas amenant des développement longs et complexes :
Y_complet = y_h + y_p

Avec
Yp= Q1(x)*((x+K1)^V2) + Q2(x)*((x+K3)^V4)*e(m*x) + (x^V5)*(K6*cos(u*x) + K7*sin(u*x)) + (x^V8)*(K9*cos(v*x) + K10*sin(v*x))

Avec
- ∀𝑖,𝐾𝑖 ∈ ℝ, constantes dont vous ne pouvez pas fournir la valeur
- ∀𝑖,𝑉 𝑖 ∈ ℕ, variables pour lesquelles votre algorithme devra trouver la valeur
- Les fonctions suivantes prédéfinies : exp(x), sin(x), cos(x)
- Q1(x) et Q2(x) ont respectivement la même forme (le même degré) que P1(x) et P2(x), avec d'autres constantes que d, e, f et g, h, l.

Le souci avec algobox est qu'il demande une valeur pour chaque variable de type "nombre". Il ne veut par exemple pas m'afficher V*sin(v*x) car pour lui ce n'est pas un nombre.
J'envisage donc bien d'écrire tout ça en python, mais encore une fois, le typage me pose problème car j'aimerai retourner à l'utilisateur la forme générale de la solution (avec des constantes comme D,E, F écrites telles quel mais certaines d'autres, comme m, écrites avec la valeur donnée par l'utilisateur.)