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

Diff for /rpl/src/algebre_lineaire4.c between versions 1.1.1.1 and 1.72

version 1.1.1.1, 2010/01/26 15:22:45 version 1.72, 2025/04/15 10:17:49
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.9    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 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 38 Line 38
 static integer4  static integer4
 calcul_cond(struct_processus *s_etat_processus, void *matrice_f77,  calcul_cond(struct_processus *s_etat_processus, void *matrice_f77,
         integer4 nombre_lignes_a, integer4 nombre_colonnes_a,          integer4 nombre_lignes_a, integer4 nombre_colonnes_a,
         integer4 *pivot, integer4 dimension_vecteur_pivot,          integer4 *pivot, unsigned char type, real8 *cond)
         unsigned char type, real8 *cond)  
 {  {
     integer4                    erreur;      integer4                    erreur;
     integer4                    *iwork;      integer4                    *iwork;
Line 75  calcul_cond(struct_processus *s_etat_pro Line 74  calcul_cond(struct_processus *s_etat_pro
             return(-1);              return(-1);
         }          }
   
         if ((iwork = malloc(nombre_colonnes_a * sizeof(integer4))) == NULL)          if ((iwork = malloc(((size_t) nombre_colonnes_a) *
                   sizeof(integer4))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return(-1);              return(-1);
         }          }
   
         if ((work = malloc(4 * nombre_colonnes_a * sizeof(real8))) == NULL)          if ((work = malloc(4 * ((size_t) nombre_colonnes_a) *
                   sizeof(real8))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return(-1);              return(-1);
Line 124  calcul_cond(struct_processus *s_etat_pro Line 125  calcul_cond(struct_processus *s_etat_pro
             return(-1);              return(-1);
         }          }
   
         if ((rwork = malloc(2 * nombre_colonnes_a * sizeof(real8))) == NULL)          if ((rwork = malloc(2 * ((size_t) nombre_colonnes_a) * sizeof(real8)))
                   == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return(-1);              return(-1);
         }          }
   
         if ((work = malloc(2 * nombre_colonnes_a * sizeof(complex16))) == NULL)          if ((work = malloc(2 * ((size_t) nombre_colonnes_a) *
                   sizeof(complex16))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return(-1);              return(-1);
Line 174  cond(struct_processus *s_etat_processus, Line 177  cond(struct_processus *s_etat_processus,
   
     real8                       cond;      real8                       cond;
   
     unsigned long               i;      integer8                    i;
     unsigned long               j;      integer8                    j;
     unsigned long               k;      integer8                    k;
   
     void                        *matrice_f77;      void                        *matrice_f77;
   
Line 186  cond(struct_processus *s_etat_processus, Line 189  cond(struct_processus *s_etat_processus,
             ? nombre_lignes_a : nombre_colonnes_a;              ? nombre_lignes_a : nombre_colonnes_a;
     taille_matrice_f77 = nombre_lignes_a * nombre_colonnes_a;      taille_matrice_f77 = nombre_lignes_a * nombre_colonnes_a;
   
     if ((pivot = (integer4 *) malloc(dimension_vecteur_pivot *      if ((pivot = (integer4 *) malloc(((size_t) dimension_vecteur_pivot) *
             sizeof(integer4))) == NULL)              sizeof(integer4))) == NULL)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 197  cond(struct_processus *s_etat_processus, Line 200  cond(struct_processus *s_etat_processus,
     {      {
         case 'I' :          case 'I' :
         {          {
             if ((matrice_f77 = (void *) malloc(taille_matrice_f77 *              if ((matrice_f77 = malloc(((size_t) taille_matrice_f77) *
                     sizeof(real8))) == NULL)                      sizeof(real8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 208  cond(struct_processus *s_etat_processus, Line 211  cond(struct_processus *s_etat_processus,
             {              {
                 for(j = 0; j < (*s_matrice).nombre_lignes; j++)                  for(j = 0; j < (*s_matrice).nombre_lignes; j++)
                 {                  {
                     ((real8 *) matrice_f77)[k++] = ((integer8 **)                      ((real8 *) matrice_f77)[k++] = (real8) ((integer8 **)
                             (*s_matrice).tableau)[j][i];                              (*s_matrice).tableau)[j][i];
                 }                  }
             }              }
   
             if ((rang = calcul_cond(s_etat_processus, matrice_f77,              if ((rang = calcul_cond(s_etat_processus, matrice_f77,
                     nombre_lignes_a, nombre_colonnes_a, pivot,                      nombre_lignes_a, nombre_colonnes_a, pivot,
                     dimension_vecteur_pivot, 'R', &cond)) < 0)                      'R', &cond)) < 0)
             {              {
                 free(pivot);                  free(pivot);
                 free(matrice_f77);                  free(matrice_f77);
Line 229  cond(struct_processus *s_etat_processus, Line 232  cond(struct_processus *s_etat_processus,
   
         case 'R' :          case 'R' :
         {          {
             if ((matrice_f77 = (void *) malloc(taille_matrice_f77 *              if ((matrice_f77 = malloc(((size_t) taille_matrice_f77) *
                     sizeof(real8))) == NULL)                      sizeof(real8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 247  cond(struct_processus *s_etat_processus, Line 250  cond(struct_processus *s_etat_processus,
   
             if ((rang = calcul_cond(s_etat_processus, matrice_f77,              if ((rang = calcul_cond(s_etat_processus, matrice_f77,
                     nombre_lignes_a, nombre_colonnes_a, pivot,                      nombre_lignes_a, nombre_colonnes_a, pivot,
                     dimension_vecteur_pivot, 'R', &cond)) < 0)                      'R', &cond)) < 0)
             {              {
                 free(pivot);                  free(pivot);
                 free(matrice_f77);                  free(matrice_f77);
Line 261  cond(struct_processus *s_etat_processus, Line 264  cond(struct_processus *s_etat_processus,
   
         case 'C' :          case 'C' :
         {          {
             if ((matrice_f77 = (void *) malloc(taille_matrice_f77 *              if ((matrice_f77 = malloc(((size_t) taille_matrice_f77) *
                     sizeof(complex16))) == NULL)                      sizeof(complex16))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 279  cond(struct_processus *s_etat_processus, Line 282  cond(struct_processus *s_etat_processus,
   
             if ((rang = calcul_cond(s_etat_processus, matrice_f77,              if ((rang = calcul_cond(s_etat_processus, matrice_f77,
                     nombre_lignes_a, nombre_colonnes_a, pivot,                      nombre_lignes_a, nombre_colonnes_a, pivot,
                     dimension_vecteur_pivot, 'C', &cond)) < 0)                      'C', &cond)) < 0)
             {              {
                 free(pivot);                  free(pivot);
                 free(matrice_f77);                  free(matrice_f77);
Line 323  void valeurs_singulieres(struct_processu Line 326  void valeurs_singulieres(struct_processu
     integer4                nombre_valeurs_singulieres;      integer4                nombre_valeurs_singulieres;
     integer4                taille_matrice_f77;      integer4                taille_matrice_f77;
   
       integer8                i;
       integer8                j;
       integer8                k;
   
     real8                   *rwork;      real8                   *rwork;
   
     unsigned char           jobu;      unsigned char           jobu;
     unsigned char           jobvh;      unsigned char           jobvh;
   
     unsigned long           i;  
     unsigned long           j;  
     unsigned long           k;  
   
     void                    *matrice_f77;      void                    *matrice_f77;
     void                    *matrice_f77_u;      void                    *matrice_f77_u;
     void                    *matrice_f77_vh;      void                    *matrice_f77_vh;
Line 368  void valeurs_singulieres(struct_processu Line 371  void valeurs_singulieres(struct_processu
     {      {
         case 'I' :          case 'I' :
         {          {
             if ((matrice_f77 = (void *) malloc(taille_matrice_f77 *              if ((matrice_f77 = malloc(((size_t) taille_matrice_f77) *
                     sizeof(real8))) == NULL)                      sizeof(real8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 379  void valeurs_singulieres(struct_processu Line 382  void valeurs_singulieres(struct_processu
             {              {
                 for(j = 0; j < (*s_matrice).nombre_lignes; j++)                  for(j = 0; j < (*s_matrice).nombre_lignes; j++)
                 {                  {
                     ((real8 *) matrice_f77)[k++] = ((integer8 **)                      ((real8 *) matrice_f77)[k++] = (real8) ((integer8 **)
                             (*s_matrice).tableau)[j][i];                              (*s_matrice).tableau)[j][i];
                 }                  }
             }              }
Line 394  void valeurs_singulieres(struct_processu Line 397  void valeurs_singulieres(struct_processu
   
             if (matrice_u != NULL)              if (matrice_u != NULL)
             {              {
                 if ((matrice_f77_u = malloc(nombre_lignes_a * nombre_lignes_a *                  if ((matrice_f77_u = malloc(((size_t) (nombre_lignes_a *
                         sizeof(real8))) == NULL)                          nombre_lignes_a)) * sizeof(real8))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 407  void valeurs_singulieres(struct_processu Line 410  void valeurs_singulieres(struct_processu
                 matrice_f77_u = NULL;                  matrice_f77_u = NULL;
             }              }
   
             if ((vecteur_f77_s = malloc(nombre_valeurs_singulieres *              if ((vecteur_f77_s = malloc(((size_t) nombre_valeurs_singulieres) *
                     sizeof(real8))) == NULL)                      sizeof(real8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme =                  (*s_etat_processus).erreur_systeme =
Line 417  void valeurs_singulieres(struct_processu Line 420  void valeurs_singulieres(struct_processu
   
             if (matrice_vh != NULL)              if (matrice_vh != NULL)
             {              {
                 if ((matrice_f77_vh = malloc(nombre_colonnes_a                  if ((matrice_f77_vh = malloc(((size_t) (nombre_colonnes_a
                         * nombre_colonnes_a * sizeof(real8))) == NULL)                          * nombre_colonnes_a)) * sizeof(real8))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 436  void valeurs_singulieres(struct_processu Line 439  void valeurs_singulieres(struct_processu
                     matrice_f77_vh, &nombre_colonnes_a,                      matrice_f77_vh, &nombre_colonnes_a,
                     work, &lwork, &erreur, longueur, longueur);                      work, &lwork, &erreur, longueur, longueur);
   
             lwork = ((real8 *) work)[0];              lwork = (integer4) ((real8 *) work)[0];
             free(work);              free(work);
   
             if ((work = malloc(lwork * sizeof(real8))) == NULL)              if ((work = malloc(((size_t) lwork) * sizeof(real8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 477  void valeurs_singulieres(struct_processu Line 480  void valeurs_singulieres(struct_processu
                 (*matrice_u).nombre_lignes = nombre_lignes_a;                  (*matrice_u).nombre_lignes = nombre_lignes_a;
                 (*matrice_u).nombre_colonnes = nombre_lignes_a;                  (*matrice_u).nombre_colonnes = nombre_lignes_a;
   
                 if (((*matrice_u).tableau = malloc((*matrice_u).nombre_lignes *                  if (((*matrice_u).tableau = malloc(((size_t)
                         sizeof(real8 *))) == NULL)                          (*matrice_u).nombre_lignes) * sizeof(real8 *))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 488  void valeurs_singulieres(struct_processu Line 491  void valeurs_singulieres(struct_processu
                 for(i = 0; i < (*matrice_u).nombre_lignes; i++)                  for(i = 0; i < (*matrice_u).nombre_lignes; i++)
                 {                  {
                     if ((((real8 **) (*matrice_u).tableau)[i] =                      if ((((real8 **) (*matrice_u).tableau)[i] =
                             malloc((*matrice_u).nombre_colonnes *                              malloc(((size_t) (*matrice_u).nombre_colonnes) *
                             sizeof(real8))) == NULL)                              sizeof(real8))) == NULL)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
Line 514  void valeurs_singulieres(struct_processu Line 517  void valeurs_singulieres(struct_processu
                 (*matrice_vh).nombre_lignes = nombre_colonnes_a;                  (*matrice_vh).nombre_lignes = nombre_colonnes_a;
                 (*matrice_vh).nombre_colonnes = nombre_colonnes_a;                  (*matrice_vh).nombre_colonnes = nombre_colonnes_a;
   
                 if (((*matrice_vh).tableau = malloc((*matrice_vh)                  if (((*matrice_vh).tableau = malloc(((size_t) (*matrice_vh)
                         .nombre_lignes * sizeof(real8 *))) == NULL)                          .nombre_lignes) * sizeof(real8 *))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 525  void valeurs_singulieres(struct_processu Line 528  void valeurs_singulieres(struct_processu
                 for(i = 0; i < (*matrice_vh).nombre_lignes; i++)                  for(i = 0; i < (*matrice_vh).nombre_lignes; i++)
                 {                  {
                     if ((((real8 **) (*matrice_vh).tableau)[i] =                      if ((((real8 **) (*matrice_vh).tableau)[i] =
                             malloc((*matrice_vh).nombre_colonnes *                              malloc(((size_t) (*matrice_vh).nombre_colonnes) *
                             sizeof(real8))) == NULL)                              sizeof(real8))) == NULL)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
Line 555  void valeurs_singulieres(struct_processu Line 558  void valeurs_singulieres(struct_processu
   
         case 'R' :          case 'R' :
         {          {
             if ((matrice_f77 = (void *) malloc(taille_matrice_f77 *              if ((matrice_f77 = malloc(((size_t) taille_matrice_f77) *
                     sizeof(real8))) == NULL)                      sizeof(real8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 581  void valeurs_singulieres(struct_processu Line 584  void valeurs_singulieres(struct_processu
   
             if (matrice_u != NULL)              if (matrice_u != NULL)
             {              {
                 if ((matrice_f77_u = malloc(nombre_lignes_a * nombre_lignes_a *                  if ((matrice_f77_u = malloc(((size_t) (nombre_lignes_a *
                         sizeof(real8))) == NULL)                          nombre_lignes_a)) * sizeof(real8))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 594  void valeurs_singulieres(struct_processu Line 597  void valeurs_singulieres(struct_processu
                 matrice_f77_u = NULL;                  matrice_f77_u = NULL;
             }              }
   
             if ((vecteur_f77_s = malloc(nombre_valeurs_singulieres *              if ((vecteur_f77_s = malloc(((size_t) nombre_valeurs_singulieres) *
                     sizeof(real8))) == NULL)                      sizeof(real8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme =                  (*s_etat_processus).erreur_systeme =
Line 604  void valeurs_singulieres(struct_processu Line 607  void valeurs_singulieres(struct_processu
   
             if (matrice_vh != NULL)              if (matrice_vh != NULL)
             {              {
                 if ((matrice_f77_vh = malloc(nombre_colonnes_a                  if ((matrice_f77_vh = malloc(((size_t) (nombre_colonnes_a
                         * nombre_colonnes_a * sizeof(real8))) == NULL)                          * nombre_colonnes_a)) * sizeof(real8))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 623  void valeurs_singulieres(struct_processu Line 626  void valeurs_singulieres(struct_processu
                     matrice_f77_vh, &nombre_colonnes_a,                      matrice_f77_vh, &nombre_colonnes_a,
                     work, &lwork, &erreur, longueur, longueur);                      work, &lwork, &erreur, longueur, longueur);
   
             lwork = ((real8 *) work)[0];              lwork = (integer4) ((real8 *) work)[0];
             free(work);              free(work);
   
             if ((work = malloc(lwork * sizeof(real8))) == NULL)              if ((work = malloc(((size_t) lwork) * sizeof(real8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 664  void valeurs_singulieres(struct_processu Line 667  void valeurs_singulieres(struct_processu
                 (*matrice_u).nombre_lignes = nombre_lignes_a;                  (*matrice_u).nombre_lignes = nombre_lignes_a;
                 (*matrice_u).nombre_colonnes = nombre_lignes_a;                  (*matrice_u).nombre_colonnes = nombre_lignes_a;
   
                 if (((*matrice_u).tableau = malloc((*matrice_u).nombre_lignes *                  if (((*matrice_u).tableau = malloc(((size_t)
                         sizeof(real8 *))) == NULL)                          (*matrice_u).nombre_lignes) * sizeof(real8 *))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 675  void valeurs_singulieres(struct_processu Line 678  void valeurs_singulieres(struct_processu
                 for(i = 0; i < (*matrice_u).nombre_lignes; i++)                  for(i = 0; i < (*matrice_u).nombre_lignes; i++)
                 {                  {
                     if ((((real8 **) (*matrice_u).tableau)[i] =                      if ((((real8 **) (*matrice_u).tableau)[i] =
                             malloc((*matrice_u).nombre_colonnes *                              malloc(((size_t) (*matrice_u).nombre_colonnes) *
                             sizeof(real8))) == NULL)                              sizeof(real8))) == NULL)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
Line 701  void valeurs_singulieres(struct_processu Line 704  void valeurs_singulieres(struct_processu
                 (*matrice_vh).nombre_lignes = nombre_colonnes_a;                  (*matrice_vh).nombre_lignes = nombre_colonnes_a;
                 (*matrice_vh).nombre_colonnes = nombre_colonnes_a;                  (*matrice_vh).nombre_colonnes = nombre_colonnes_a;
   
                 if (((*matrice_vh).tableau = malloc((*matrice_vh)                  if (((*matrice_vh).tableau = malloc(((size_t) (*matrice_vh)
                         .nombre_lignes * sizeof(real8 *))) == NULL)                          .nombre_lignes) * sizeof(real8 *))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 712  void valeurs_singulieres(struct_processu Line 715  void valeurs_singulieres(struct_processu
                 for(i = 0; i < (*matrice_vh).nombre_lignes; i++)                  for(i = 0; i < (*matrice_vh).nombre_lignes; i++)
                 {                  {
                     if ((((real8 **) (*matrice_vh).tableau)[i] =                      if ((((real8 **) (*matrice_vh).tableau)[i] =
                             malloc((*matrice_vh).nombre_colonnes *                              malloc(((size_t) (*matrice_vh).nombre_colonnes) *
                             sizeof(real8))) == NULL)                              sizeof(real8))) == NULL)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
Line 742  void valeurs_singulieres(struct_processu Line 745  void valeurs_singulieres(struct_processu
   
         case 'C' :          case 'C' :
         {          {
             if ((matrice_f77 = (void *) malloc(taille_matrice_f77 *              if ((matrice_f77 = malloc(((size_t) taille_matrice_f77) *
                     sizeof(complex16))) == NULL)                      sizeof(complex16))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 768  void valeurs_singulieres(struct_processu Line 771  void valeurs_singulieres(struct_processu
   
             if (matrice_u != NULL)              if (matrice_u != NULL)
             {              {
                 if ((matrice_f77_u = malloc(nombre_lignes_a * nombre_lignes_a *                  if ((matrice_f77_u = malloc(((size_t) (nombre_lignes_a *
                         sizeof(complex16))) == NULL)                          nombre_lignes_a)) * sizeof(complex16))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 781  void valeurs_singulieres(struct_processu Line 784  void valeurs_singulieres(struct_processu
                 matrice_f77_u = NULL;                  matrice_f77_u = NULL;
             }              }
   
             if ((vecteur_f77_s = malloc(nombre_valeurs_singulieres *              if ((vecteur_f77_s = malloc(((size_t) nombre_valeurs_singulieres) *
                     sizeof(real8))) == NULL)                      sizeof(real8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme =                  (*s_etat_processus).erreur_systeme =
Line 791  void valeurs_singulieres(struct_processu Line 794  void valeurs_singulieres(struct_processu
   
             if (matrice_vh != NULL)              if (matrice_vh != NULL)
             {              {
                 if ((matrice_f77_vh = malloc(nombre_colonnes_a                  if ((matrice_f77_vh = malloc(((size_t) (nombre_colonnes_a
                         * nombre_colonnes_a * sizeof(complex16))) == NULL)                          * nombre_colonnes_a)) * sizeof(complex16))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 804  void valeurs_singulieres(struct_processu Line 807  void valeurs_singulieres(struct_processu
                 matrice_f77_vh = NULL;                  matrice_f77_vh = NULL;
             }              }
   
             if ((rwork = malloc(5 * nombre_valeurs_singulieres * sizeof(real8)))              if ((rwork = malloc(5 * ((size_t) nombre_valeurs_singulieres)
                     == NULL)                      * sizeof(real8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme =                  (*s_etat_processus).erreur_systeme =
                         d_es_allocation_memoire;                          d_es_allocation_memoire;
Line 818  void valeurs_singulieres(struct_processu Line 821  void valeurs_singulieres(struct_processu
                     matrice_f77_vh, &nombre_colonnes_a,                      matrice_f77_vh, &nombre_colonnes_a,
                     work, &lwork, rwork, &erreur, longueur, longueur);                      work, &lwork, rwork, &erreur, longueur, longueur);
   
             lwork = ((real8 *) work)[0];              lwork = (integer4) ((real8 *) work)[0];
             free(work);              free(work);
   
             if ((work = malloc(lwork * sizeof(real8))) == NULL)              if ((work = malloc(((size_t) lwork) * sizeof(real8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 860  void valeurs_singulieres(struct_processu Line 863  void valeurs_singulieres(struct_processu
                 (*matrice_u).nombre_lignes = nombre_lignes_a;                  (*matrice_u).nombre_lignes = nombre_lignes_a;
                 (*matrice_u).nombre_colonnes = nombre_lignes_a;                  (*matrice_u).nombre_colonnes = nombre_lignes_a;
   
                 if (((*matrice_u).tableau = malloc((*matrice_u).nombre_lignes *                  if (((*matrice_u).tableau = malloc(((size_t)
                         sizeof(complex16 *))) == NULL)                          (*matrice_u).nombre_lignes) * sizeof(complex16 *)))
                           == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 871  void valeurs_singulieres(struct_processu Line 875  void valeurs_singulieres(struct_processu
                 for(i = 0; i < (*matrice_u).nombre_lignes; i++)                  for(i = 0; i < (*matrice_u).nombre_lignes; i++)
                 {                  {
                     if ((((complex16 **) (*matrice_u).tableau)[i] =                      if ((((complex16 **) (*matrice_u).tableau)[i] =
                             malloc((*matrice_u).nombre_colonnes *                              malloc(((size_t) (*matrice_u).nombre_colonnes) *
                             sizeof(complex16))) == NULL)                              sizeof(complex16))) == NULL)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
Line 897  void valeurs_singulieres(struct_processu Line 901  void valeurs_singulieres(struct_processu
                 (*matrice_vh).nombre_lignes = nombre_colonnes_a;                  (*matrice_vh).nombre_lignes = nombre_colonnes_a;
                 (*matrice_vh).nombre_colonnes = nombre_colonnes_a;                  (*matrice_vh).nombre_colonnes = nombre_colonnes_a;
   
                 if (((*matrice_vh).tableau = malloc((*matrice_vh)                  if (((*matrice_vh).tableau = malloc(((size_t) (*matrice_vh)
                         .nombre_lignes * sizeof(complex16 *))) == NULL)                          .nombre_lignes) * sizeof(complex16 *))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 908  void valeurs_singulieres(struct_processu Line 912  void valeurs_singulieres(struct_processu
                 for(i = 0; i < (*matrice_vh).nombre_lignes; i++)                  for(i = 0; i < (*matrice_vh).nombre_lignes; i++)
                 {                  {
                     if ((((complex16 **) (*matrice_vh).tableau)[i] =                      if ((((complex16 **) (*matrice_vh).tableau)[i] =
                             malloc((*matrice_vh).nombre_colonnes *                              malloc(((size_t) (*matrice_vh).nombre_colonnes) *
                             sizeof(complex16))) == NULL)                              sizeof(complex16))) == NULL)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
Removed from v.1.1.1.1  
changed lines
  Added in v.1.72

CVSweb interface <joel.bertrand@systella.fr>