[BACK]Return to calcul_integral.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/calcul_integral.c between versions 1.13 and 1.75

version 1.13, 2010/08/26 19:07:34 version 1.75, 2025/04/15 10:17:49
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.19    RPL/2 (R) version 4.1.36
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2025 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 55  integrale_romberg(struct_processus *s_et Line 55  integrale_romberg(struct_processus *s_et
   
     struct_variable             s_variable;      struct_variable             s_variable;
   
     unsigned long               i;      integer8                    i;
     unsigned long               j;      integer8                    j;
     unsigned long               k;      integer8                    k;
     unsigned long               n;      integer8                    n;
     unsigned long               p;      integer8                    p;
     unsigned long               nombre_elements;      integer8                    nombre_elements;
     unsigned long               nombre_termes;      integer8                    nombre_termes;
     unsigned long               taille_vecteur_precedent;      integer8                    taille_vecteur_precedent;
   
       erreur = 0;
   
     /*      /*
      * Création d'une variable locale représentant la variable d'intégration       * Création d'une variable locale représentant la variable d'intégration
Line 137  integrale_romberg(struct_processus *s_et Line 139  integrale_romberg(struct_processus *s_et
   
     do      do
     {      {
         h = (b - a) / (nombre_elements = (1ULL << (++n)));          h = (b - a) / ((real8) (nombre_elements = (((integer8) 1) << (++n))));
   
           if (nombre_elements == 0)
           {
               // Dépassement de capacité
               n--;
               break;
           }
   
         x = a;          x = a;
   
         /*          /*
Line 146  integrale_romberg(struct_processus *s_et Line 156  integrale_romberg(struct_processus *s_et
   
         t_tampon = t;          t_tampon = t;
   
         if ((t = (real8 **) malloc((n + 1) * sizeof(real8 *))) == NULL)          if ((t = (real8 **) malloc((((size_t) n) + 1) * sizeof(real8 *)))
                   == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 154  integrale_romberg(struct_processus *s_et Line 165  integrale_romberg(struct_processus *s_et
   
         for(i = 0; i <= n; i++)          for(i = 0; i <= n; i++)
         {          {
             if ((t[i] = (real8 *) malloc((n + 1) * sizeof(real8))) == NULL)              if ((t[i] = (real8 *) malloc((((size_t) n) + 1) * sizeof(real8)))
                       == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 180  integrale_romberg(struct_processus *s_et Line 192  integrale_romberg(struct_processus *s_et
          * Boucle principale           * Boucle principale
          */           */
   
         if ((vecteur = (real8 *) malloc((nombre_elements + 1) *          if ((vecteur = (real8 *) malloc((((size_t) nombre_elements) + 1) *
                 sizeof(real8))) == NULL)                  sizeof(real8))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
   
   
         if (vecteur_precedent == NULL)          if (vecteur_precedent == NULL)
         {          {
             /*              /*
Line 258  integrale_romberg(struct_processus *s_et Line 269  integrale_romberg(struct_processus *s_et
         for(p = 1; p <= n; p++)          for(p = 1; p <= n; p++)
         {          {
             k = n - p;              k = n - p;
             t[p][k] = ((pow(4, p) * t[p - 1][k + 1]) - t[p - 1][k]) /              t[p][k] = ((pow(4, (real8) p) * t[p - 1][k + 1]) - t[p - 1][k]) /
                     ((real8) (pow(4, p) - 1));                      ((real8) (pow(4, (real8) p) - 1));
         }          }
     } while(((erreur = fabs(t[n][0] - t[n - 1][0])) > precision) &&      } while(((erreur = fabs(t[n][0] - t[n - 1][0])) > precision) &&
             ((*s_etat_processus).var_volatile_requete_arret == 0));              ((*s_etat_processus).var_volatile_requete_arret == 0));
Line 340  evaluation_romberg(struct_processus *s_e Line 351  evaluation_romberg(struct_processus *s_e
         struct_objet *s_expression, unsigned char *variable, real8 *point,          struct_objet *s_expression, unsigned char *variable, real8 *point,
         real8 *valeur, logical1 *validite)          real8 *valeur, logical1 *validite)
 {  {
     long                                hauteur_pile;      integer8                            hauteur_pile;
   
     struct_liste_pile_systeme           *l_position_normale;      struct_liste_pile_systeme           *l_position_normale;
   
Line 355  evaluation_romberg(struct_processus *s_e Line 366  evaluation_romberg(struct_processus *s_e
   
     if (recherche_variable(s_etat_processus, variable) == d_vrai)      if (recherche_variable(s_etat_processus, variable) == d_vrai)
     {      {
         if (((*s_etat_processus).s_liste_variables[(*s_etat_processus)          if ((*(*s_etat_processus).pointeur_variable_courante)
                 .position_variable_courante]).variable_verrouillee == d_vrai)                  .variable_verrouillee == d_vrai)
         {          {
             (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;              (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
             return;              return;
         }          }
   
         if ((*((*s_etat_processus).s_liste_variables          if ((*(*(*s_etat_processus).pointeur_variable_courante)
                 [(*s_etat_processus).position_variable_courante])  
                 .objet).type != REL)                  .objet).type != REL)
         {          {
             liberation(s_etat_processus, ((*s_etat_processus).s_liste_variables              liberation(s_etat_processus, (*(*s_etat_processus)
                     [(*s_etat_processus).position_variable_courante]).objet);                      .pointeur_variable_courante).objet);
   
             if ((((*s_etat_processus).s_liste_variables              if (((*(*s_etat_processus).pointeur_variable_courante).objet =
                     [(*s_etat_processus).position_variable_courante]).objet =  
                     allocation(s_etat_processus, REL)) == NULL)                      allocation(s_etat_processus, REL)) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 378  evaluation_romberg(struct_processus *s_e Line 387  evaluation_romberg(struct_processus *s_e
             }              }
         }          }
   
         (*((real8 *) (*((*s_etat_processus).s_liste_variables          (*((real8 *) (*(*(*s_etat_processus).pointeur_variable_courante)
                 [(*s_etat_processus).position_variable_courante])  
                 .objet).objet)) = (*point);                  .objet).objet)) = (*point);
     }      }
     else      else
Line 418  evaluation_romberg(struct_processus *s_e Line 426  evaluation_romberg(struct_processus *s_e
              */               */
   
             while((*s_etat_processus).hauteur_pile_operationnelle >              while((*s_etat_processus).hauteur_pile_operationnelle >
                     (unsigned long) hauteur_pile)                      hauteur_pile)
             {              {
                 if (depilement(s_etat_processus, &((*s_etat_processus)                  if (depilement(s_etat_processus, &((*s_etat_processus)
                         .l_base_pile), &s_objet) == d_erreur)                          .l_base_pile), &s_objet) == d_erreur)
Line 469  evaluation_romberg(struct_processus *s_e Line 477  evaluation_romberg(struct_processus *s_e
   
         if ((*s_objet).type == INT)          if ((*s_objet).type == INT)
         {          {
             (*valeur) = (*((integer8 *) (*s_objet).objet));              (*valeur) = (real8) (*((integer8 *) (*s_objet).objet));
             (*validite) = d_vrai;              (*validite) = d_vrai;
         }          }
         else if ((*s_objet).type == REL)          else if ((*s_objet).type == REL)
Removed from v.1.13  
changed lines
  Added in v.1.75

CVSweb interface <joel.bertrand@systella.fr>