[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.11 and 1.56

version 1.11, 2010/07/14 14:19:32 version 1.56, 2016/03/01 22:12:25
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.18    RPL/2 (R) version 4.1.25
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2016 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 74  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 123  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 173  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 185  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 196  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 207  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];
                 }                  }
             }              }
Line 228  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 260  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 322  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 367  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 378  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 393  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 406  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 416  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 435  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 476  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 487  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 513  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 524  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 554  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 580  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 593  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 603  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 622  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 663  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 674  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 700  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 711  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 741  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 767  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 780  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 790  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 803  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 817  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 859  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 870  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 896  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 907  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.11  
changed lines
  Added in v.1.56

CVSweb interface <joel.bertrand@systella.fr>