rpl/src/algebre_lineaire1.c - diff

Return to algebre_lineaire1.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/algebre_lineaire1.c between versions 1.1.1.1 and 1.50

version 1.1.1.1, 2010/01/26 15:22:44	version 1.50, 2015/01/05 13:12:28
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.9	RPL/2 (R) version 4.1.19
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2015 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 49 inversion_matrice(struct_processus *s_et	Line 49 inversion_matrice(struct_processus *s_et
integer4 erreur;	integer4 erreur;
integer4 *pivot;	integer4 *pivot;

	integer8 i;
	integer8 j;
	integer8 k;
integer8 rang_estime;	integer8 rang_estime;
	integer8 taille_matrice_f77;

struct_complexe16 *c_work;	struct_complexe16 *c_work;

unsigned long i;
unsigned long j;
unsigned long k;
unsigned long taille_matrice_f77;

void *matrice_f77;	void *matrice_f77;

rang(s_etat_processus, s_matrice, &rang_estime);	rang(s_etat_processus, s_matrice, &rang_estime);
Line 87 inversion_matrice(struct_processus *s_et	Line 86 inversion_matrice(struct_processus *s_et
{	{
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 98 inversion_matrice(struct_processus *s_et	Line 97 inversion_matrice(struct_processus *s_et
{	{
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 110 inversion_matrice(struct_processus *s_et	Line 109 inversion_matrice(struct_processus *s_et

free((integer8 *) (s_matrice).tableau);	free((integer8 *) (s_matrice).tableau);

if (((s_matrice).tableau = (void ) malloc((s_matrice)	if (((s_matrice).tableau = malloc(((size_t) (s_matrice)
.nombre_lignes * sizeof(real8 *))) == NULL)	.nombre_lignes) * sizeof(real8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 120 inversion_matrice(struct_processus *s_et	Line 119 inversion_matrice(struct_processus *s_et
for(i = 0; i < (*s_matrice).nombre_lignes; i++)	for(i = 0; i < (*s_matrice).nombre_lignes; i++)
{	{
if ((((*s_matrice).tableau)[i] =	if ((((*s_matrice).tableau)[i] =
(real8 ) malloc((s_matrice)	(real8 ) malloc(((size_t) (s_matrice)
.nombre_colonnes * sizeof(real8))) == NULL)	.nombre_colonnes) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 131 inversion_matrice(struct_processus *s_et	Line 130 inversion_matrice(struct_processus *s_et

(*s_matrice).type = 'R';	(*s_matrice).type = 'R';

if ((pivot = (integer4 ) malloc((s_matrice).nombre_lignes *	if ((pivot = (integer4 ) malloc(((size_t) (s_matrice)
sizeof(integer4))) == NULL)	.nombre_lignes) * sizeof(integer4))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 171 inversion_matrice(struct_processus *s_et	Line 170 inversion_matrice(struct_processus *s_et

free(work);	free(work);

if ((work = (real8 ) malloc(dim_work sizeof(real8))) == NULL)	if ((work = (real8 ) malloc(((size_t) dim_work) sizeof(real8)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 238 inversion_matrice(struct_processus *s_et	Line 238 inversion_matrice(struct_processus *s_et

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 254 inversion_matrice(struct_processus *s_et	Line 254 inversion_matrice(struct_processus *s_et
}	}
}	}

if ((pivot = (integer4 ) malloc((s_matrice).nombre_lignes *	if ((pivot = (integer4 ) malloc(((size_t) (s_matrice)
sizeof(integer4))) == NULL)	.nombre_lignes) * sizeof(integer4))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 294 inversion_matrice(struct_processus *s_et	Line 294 inversion_matrice(struct_processus *s_et

free(work);	free(work);

if ((work = (real8 ) malloc(dim_work sizeof(real8))) == NULL)	if ((work = (real8 ) malloc(((size_t) dim_work) sizeof(real8)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 361 inversion_matrice(struct_processus *s_et	Line 362 inversion_matrice(struct_processus *s_et

case 'C' :	case 'C' :
{	{
if ((matrice_f77 = (void ) malloc(taille_matrice_f77	if ((matrice_f77 = malloc(((size_t) taille_matrice_f77) *
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 382 inversion_matrice(struct_processus *s_et	Line 383 inversion_matrice(struct_processus *s_et
}	}
}	}

if ((pivot = (integer4 ) malloc((s_matrice).nombre_lignes *	if ((pivot = (integer4 ) malloc(((size_t) (s_matrice)
sizeof(integer4))) == NULL)	.nombre_lignes) * sizeof(integer4))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 423 inversion_matrice(struct_processus *s_et	Line 424 inversion_matrice(struct_processus *s_et

free(c_work);	free(c_work);

if ((c_work = (struct_complexe16 ) malloc(dim_work	if ((c_work = (struct_complexe16 ) malloc(((size_t) dim_work)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 535 valeurs_propres(struct_processus *s_etat	Line 536 valeurs_propres(struct_processus *s_etat
integer4 lwork;	integer4 lwork;
integer4 erreur;	integer4 erreur;

	integer8 i;
	integer8 j;
	integer8 k;
	integer8 taille_matrice_f77;

struct_complexe16 *matrice_f77;	struct_complexe16 *matrice_f77;
struct_complexe16 *vpd_f77;	struct_complexe16 *vpd_f77;
struct_complexe16 *vpg_f77;	struct_complexe16 *vpg_f77;
Line 544 valeurs_propres(struct_processus *s_etat	Line 550 valeurs_propres(struct_processus *s_etat
unsigned char calcul_vp_gauches;	unsigned char calcul_vp_gauches;
unsigned char negatif;	unsigned char negatif;

unsigned long i;
unsigned long j;
unsigned long k;
unsigned long taille_matrice_f77;

taille_matrice_f77 = (s_matrice).nombre_lignes	taille_matrice_f77 = (s_matrice).nombre_lignes
(*s_matrice).nombre_colonnes;	(*s_matrice).nombre_colonnes;
dim_matrice = (integer4) (*s_matrice).nombre_lignes;	dim_matrice = (integer4) (*s_matrice).nombre_lignes;
Line 557 valeurs_propres(struct_processus *s_etat	Line 558 valeurs_propres(struct_processus *s_etat
* Allocation de la matrice complexe	* Allocation de la matrice complexe
*/	*/

if ((matrice_f77 = (struct_complexe16 ) malloc(taille_matrice_f77	if ((matrice_f77 = (struct_complexe16 *) malloc(((size_t)
sizeof(struct_complexe16))) == NULL)	taille_matrice_f77) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 639 valeurs_propres(struct_processus *s_etat	Line 640 valeurs_propres(struct_processus *s_etat
(s_valeurs_propres).taille = (s_matrice).nombre_lignes;	(s_valeurs_propres).taille = (s_matrice).nombre_lignes;

if (((s_valeurs_propres).tableau = (struct_complexe16 )	if (((s_valeurs_propres).tableau = (struct_complexe16 )
malloc((s_valeurs_propres).taille sizeof(struct_complexe16)))	malloc(((size_t) (s_valeurs_propres).taille)
== NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 651 valeurs_propres(struct_processus *s_etat	Line 652 valeurs_propres(struct_processus *s_etat
(*s_vecteurs_propres_gauches).type = 'C';	(*s_vecteurs_propres_gauches).type = 'C';
calcul_vp_gauches = 'V';	calcul_vp_gauches = 'V';

if ((vpg_f77 = (struct_complexe16 ) malloc(taille_matrice_f77	if ((vpg_f77 = (struct_complexe16 *) malloc(((size_t)
sizeof(struct_complexe16))) == NULL)	taille_matrice_f77) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 669 valeurs_propres(struct_processus *s_etat	Line 670 valeurs_propres(struct_processus *s_etat
(*s_vecteurs_propres_droits).type = 'C';	(*s_vecteurs_propres_droits).type = 'C';
calcul_vp_droits = 'V';	calcul_vp_droits = 'V';

if ((vpd_f77 = (struct_complexe16 ) malloc(taille_matrice_f77	if ((vpd_f77 = (struct_complexe16 *) malloc(((size_t)
sizeof(struct_complexe16))) == NULL)	taille_matrice_f77) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 685 valeurs_propres(struct_processus *s_etat	Line 686 valeurs_propres(struct_processus *s_etat
negatif = 'N';	negatif = 'N';
lwork = -1;	lwork = -1;

if ((rwork = (real8 ) malloc(2 (s_matrice).nombre_lignes	if ((rwork = (real8 ) malloc(2 ((size_t) (s_matrice).nombre_lignes)
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 736 valeurs_propres(struct_processus *s_etat	Line 737 valeurs_propres(struct_processus *s_etat
lwork = (integer4) work[0].partie_reelle;	lwork = (integer4) work[0].partie_reelle;
free(work);	free(work);

if ((work = (struct_complexe16 ) malloc(lwork sizeof(struct_complexe16)))	if ((work = (struct_complexe16 ) malloc(((size_t) lwork)
== NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 790 valeurs_propres(struct_processus *s_etat	Line 791 valeurs_propres(struct_processus *s_etat
(*s_matrice).nombre_colonnes;	(*s_matrice).nombre_colonnes;

if (((*s_vecteurs_propres_gauches).tableau = malloc(	if (((*s_vecteurs_propres_gauches).tableau = malloc(
(s_vecteurs_propres_gauches).nombre_lignes	((size_t) (s_vecteurs_propres_gauches).nombre_lignes)
sizeof(struct_complexe16 *))) == NULL)	sizeof(struct_complexe16 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 800 valeurs_propres(struct_processus *s_etat	Line 801 valeurs_propres(struct_processus *s_etat
for(i = 0; i < (*s_vecteurs_propres_gauches).nombre_lignes; i++)	for(i = 0; i < (*s_vecteurs_propres_gauches).nombre_lignes; i++)
{	{
if ((((struct_complexe16 *) (s_vecteurs_propres_gauches)	if ((((struct_complexe16 *) (s_vecteurs_propres_gauches)
.tableau)[i] = (struct_complexe16 *) malloc(	.tableau)[i] = (struct_complexe16 *) malloc(((size_t)
(s_vecteurs_propres_gauches).nombre_colonnes	(s_vecteurs_propres_gauches).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 835 valeurs_propres(struct_processus *s_etat	Line 836 valeurs_propres(struct_processus *s_etat
(*s_matrice).nombre_colonnes;	(*s_matrice).nombre_colonnes;

if (((*s_vecteurs_propres_droits).tableau = malloc(	if (((*s_vecteurs_propres_droits).tableau = malloc(
(s_vecteurs_propres_droits).nombre_lignes	((size_t) (s_vecteurs_propres_droits).nombre_lignes)
sizeof(struct_complexe16 *))) == NULL)	sizeof(struct_complexe16 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 845 valeurs_propres(struct_processus *s_etat	Line 846 valeurs_propres(struct_processus *s_etat
for(i = 0; i < (*s_vecteurs_propres_droits).nombre_lignes; i++)	for(i = 0; i < (*s_vecteurs_propres_droits).nombre_lignes; i++)
{	{
if ((((struct_complexe16 *) (s_vecteurs_propres_droits)	if ((((struct_complexe16 *) (s_vecteurs_propres_droits)
.tableau)[i] = (struct_complexe16 *) malloc(	.tableau)[i] = (struct_complexe16 *) malloc(((size_t)
(s_vecteurs_propres_droits).nombre_colonnes	(s_vecteurs_propres_droits).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 915 valeurs_propres_generalisees(struct_proc	Line 916 valeurs_propres_generalisees(struct_proc
integer4 lwork;	integer4 lwork;
integer4 erreur;	integer4 erreur;

	integer8 i;
	integer8 j;
	integer8 k;
	integer8 taille_matrice_f77;

struct_complexe16 *alpha;	struct_complexe16 *alpha;
struct_complexe16 *beta;	struct_complexe16 *beta;
struct_complexe16 *matrice_f77;	struct_complexe16 *matrice_f77;
Line 927 valeurs_propres_generalisees(struct_proc	Line 933 valeurs_propres_generalisees(struct_proc
unsigned char calcul_vp_gauches;	unsigned char calcul_vp_gauches;
unsigned char negatif;	unsigned char negatif;

unsigned long i;
unsigned long j;
unsigned long k;
unsigned long taille_matrice_f77;

taille_matrice_f77 = (s_matrice).nombre_lignes	taille_matrice_f77 = (s_matrice).nombre_lignes
(*s_matrice).nombre_colonnes;	(*s_matrice).nombre_colonnes;
dim_matrice = (integer4) (*s_matrice).nombre_lignes;	dim_matrice = (integer4) (*s_matrice).nombre_lignes;
Line 940 valeurs_propres_generalisees(struct_proc	Line 941 valeurs_propres_generalisees(struct_proc
* Allocation de la matrice complexe	* Allocation de la matrice complexe
*/	*/

if ((matrice_f77 = (struct_complexe16 ) malloc(taille_matrice_f77	if ((matrice_f77 = (struct_complexe16 *) malloc(((size_t)
sizeof(struct_complexe16))) == NULL)	taille_matrice_f77) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1022 valeurs_propres_generalisees(struct_proc	Line 1023 valeurs_propres_generalisees(struct_proc
* Allocation de la metrique complexe	* Allocation de la metrique complexe
*/	*/

if ((metrique_f77 = (struct_complexe16 ) malloc(taille_matrice_f77	if ((metrique_f77 = (struct_complexe16 *) malloc(((size_t)
sizeof(struct_complexe16))) == NULL)	taille_matrice_f77) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1104 valeurs_propres_generalisees(struct_proc	Line 1105 valeurs_propres_generalisees(struct_proc
(s_valeurs_propres).taille = (s_matrice).nombre_lignes;	(s_valeurs_propres).taille = (s_matrice).nombre_lignes;

if (((s_valeurs_propres).tableau = (struct_complexe16 )	if (((s_valeurs_propres).tableau = (struct_complexe16 )
malloc((s_valeurs_propres).taille sizeof(struct_complexe16)))	malloc(((size_t) (*s_valeurs_propres).taille)
== NULL)	* sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1116 valeurs_propres_generalisees(struct_proc	Line 1117 valeurs_propres_generalisees(struct_proc
(*s_vecteurs_propres_gauches).type = 'C';	(*s_vecteurs_propres_gauches).type = 'C';
calcul_vp_gauches = 'V';	calcul_vp_gauches = 'V';

if ((vpg_f77 = (struct_complexe16 ) malloc(taille_matrice_f77	if ((vpg_f77 = (struct_complexe16 *) malloc(((size_t)
sizeof(struct_complexe16))) == NULL)	taille_matrice_f77) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1134 valeurs_propres_generalisees(struct_proc	Line 1135 valeurs_propres_generalisees(struct_proc
(*s_vecteurs_propres_droits).type = 'C';	(*s_vecteurs_propres_droits).type = 'C';
calcul_vp_droits = 'V';	calcul_vp_droits = 'V';

if ((vpd_f77 = (struct_complexe16 ) malloc(taille_matrice_f77	if ((vpd_f77 = (struct_complexe16 *) malloc(((size_t)
sizeof(struct_complexe16))) == NULL)	taille_matrice_f77) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1150 valeurs_propres_generalisees(struct_proc	Line 1151 valeurs_propres_generalisees(struct_proc
negatif = 'N';	negatif = 'N';
lwork = -1;	lwork = -1;

if ((rwork = (real8 ) malloc(8 (s_matrice).nombre_lignes	if ((rwork = (real8 ) malloc(8 ((size_t) (s_matrice).nombre_lignes)
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 1164 valeurs_propres_generalisees(struct_proc	Line 1165 valeurs_propres_generalisees(struct_proc
return;	return;
}	}

if ((alpha = (struct_complexe16 ) malloc((s_valeurs_propres).taille *	if ((alpha = (struct_complexe16 ) malloc(((size_t) (s_valeurs_propres)
sizeof(struct_complexe16))) == NULL)	.taille) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

if ((beta = (struct_complexe16 ) malloc((s_valeurs_propres).taille *	if ((beta = (struct_complexe16 ) malloc(((size_t) (s_valeurs_propres)
sizeof(struct_complexe16))) == NULL)	.taille) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1208 valeurs_propres_generalisees(struct_proc	Line 1209 valeurs_propres_generalisees(struct_proc
(*s_vecteurs_propres_gauches).nombre_lignes = 1;	(*s_vecteurs_propres_gauches).nombre_lignes = 1;
(*s_vecteurs_propres_gauches).nombre_colonnes = 1;	(*s_vecteurs_propres_gauches).nombre_colonnes = 1;

if (((*s_vecteurs_propres_gauches).tableau = malloc(	if (((*s_vecteurs_propres_gauches).tableau = malloc(((size_t)
(s_vecteurs_propres_gauches).nombre_lignes	(s_vecteurs_propres_gauches).nombre_lignes)
sizeof(struct_complexe16 *))) == NULL)	sizeof(struct_complexe16 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1217 valeurs_propres_generalisees(struct_proc	Line 1218 valeurs_propres_generalisees(struct_proc
}	}

if ((((struct_complexe16 *) (s_vecteurs_propres_gauches)	if ((((struct_complexe16 *) (s_vecteurs_propres_gauches)
.tableau)[0] = (struct_complexe16 *) malloc(	.tableau)[0] = (struct_complexe16 *) malloc(((size_t)
(s_vecteurs_propres_gauches).nombre_colonnes	(s_vecteurs_propres_gauches).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1234 valeurs_propres_generalisees(struct_proc	Line 1235 valeurs_propres_generalisees(struct_proc
(*s_vecteurs_propres_droits).nombre_lignes = 1;	(*s_vecteurs_propres_droits).nombre_lignes = 1;
(*s_vecteurs_propres_droits).nombre_colonnes = 1;	(*s_vecteurs_propres_droits).nombre_colonnes = 1;

if (((*s_vecteurs_propres_droits).tableau = malloc(	if (((*s_vecteurs_propres_droits).tableau = malloc(((size_t)
(s_vecteurs_propres_droits).nombre_lignes	(s_vecteurs_propres_droits).nombre_lignes)
sizeof(struct_complexe16 *))) == NULL)	sizeof(struct_complexe16 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1243 valeurs_propres_generalisees(struct_proc	Line 1244 valeurs_propres_generalisees(struct_proc
}	}

if ((((struct_complexe16 *) (s_vecteurs_propres_droits)	if ((((struct_complexe16 *) (s_vecteurs_propres_droits)
.tableau)[0] = (struct_complexe16 *) malloc(	.tableau)[0] = (struct_complexe16 *) malloc(((size_t)
(s_vecteurs_propres_droits).nombre_colonnes	(s_vecteurs_propres_droits).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1258 valeurs_propres_generalisees(struct_proc	Line 1259 valeurs_propres_generalisees(struct_proc
lwork = (integer4) work[0].partie_reelle;	lwork = (integer4) work[0].partie_reelle;
free(work);	free(work);

if ((work = (struct_complexe16 ) malloc(lwork sizeof(struct_complexe16)))	if ((work = (struct_complexe16 ) malloc(((size_t) lwork)
== NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1296 valeurs_propres_generalisees(struct_proc	Line 1297 valeurs_propres_generalisees(struct_proc
(*s_vecteurs_propres_gauches).nombre_lignes = 1;	(*s_vecteurs_propres_gauches).nombre_lignes = 1;
(*s_vecteurs_propres_gauches).nombre_colonnes = 1;	(*s_vecteurs_propres_gauches).nombre_colonnes = 1;

if (((*s_vecteurs_propres_gauches).tableau = malloc(	if (((*s_vecteurs_propres_gauches).tableau = malloc(((size_t)
(s_vecteurs_propres_gauches).nombre_lignes	(s_vecteurs_propres_gauches).nombre_lignes)
sizeof(struct_complexe16 *))) == NULL)	sizeof(struct_complexe16 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1305 valeurs_propres_generalisees(struct_proc	Line 1306 valeurs_propres_generalisees(struct_proc
}	}

if ((((struct_complexe16 *) (s_vecteurs_propres_gauches)	if ((((struct_complexe16 *) (s_vecteurs_propres_gauches)
.tableau)[0] = (struct_complexe16 *) malloc(	.tableau)[0] = (struct_complexe16 *) malloc(((size_t)
(s_vecteurs_propres_gauches).nombre_colonnes	(s_vecteurs_propres_gauches).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1322 valeurs_propres_generalisees(struct_proc	Line 1323 valeurs_propres_generalisees(struct_proc
(*s_vecteurs_propres_droits).nombre_lignes = 1;	(*s_vecteurs_propres_droits).nombre_lignes = 1;
(*s_vecteurs_propres_droits).nombre_colonnes = 1;	(*s_vecteurs_propres_droits).nombre_colonnes = 1;

if (((*s_vecteurs_propres_droits).tableau = malloc(	if (((*s_vecteurs_propres_droits).tableau = malloc(((size_t)
(s_vecteurs_propres_droits).nombre_lignes	(s_vecteurs_propres_droits).nombre_lignes)
sizeof(struct_complexe16 *))) == NULL)	sizeof(struct_complexe16 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1331 valeurs_propres_generalisees(struct_proc	Line 1332 valeurs_propres_generalisees(struct_proc
}	}

if ((((struct_complexe16 *) (s_vecteurs_propres_droits)	if ((((struct_complexe16 *) (s_vecteurs_propres_droits)
.tableau)[0] = (struct_complexe16 *) malloc(	.tableau)[0] = (struct_complexe16 *) malloc(((size_t)
(s_vecteurs_propres_droits).nombre_colonnes	(s_vecteurs_propres_droits).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1375 valeurs_propres_generalisees(struct_proc	Line 1376 valeurs_propres_generalisees(struct_proc
(*s_vecteurs_propres_gauches).nombre_colonnes =	(*s_vecteurs_propres_gauches).nombre_colonnes =
(*s_matrice).nombre_colonnes;	(*s_matrice).nombre_colonnes;

if (((*s_vecteurs_propres_gauches).tableau = malloc(	if (((*s_vecteurs_propres_gauches).tableau = malloc(((size_t)
(s_vecteurs_propres_gauches).nombre_lignes	(s_vecteurs_propres_gauches).nombre_lignes)
sizeof(struct_complexe16 *))) == NULL)	sizeof(struct_complexe16 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1386 valeurs_propres_generalisees(struct_proc	Line 1387 valeurs_propres_generalisees(struct_proc
for(i = 0; i < (*s_vecteurs_propres_gauches).nombre_lignes; i++)	for(i = 0; i < (*s_vecteurs_propres_gauches).nombre_lignes; i++)
{	{
if ((((struct_complexe16 *) (s_vecteurs_propres_gauches)	if ((((struct_complexe16 *) (s_vecteurs_propres_gauches)
.tableau)[i] = (struct_complexe16 *) malloc(	.tableau)[i] = (struct_complexe16 *) malloc(((size_t)
(s_vecteurs_propres_gauches).nombre_colonnes	(s_vecteurs_propres_gauches).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1420 valeurs_propres_generalisees(struct_proc	Line 1421 valeurs_propres_generalisees(struct_proc
(*s_vecteurs_propres_droits).nombre_colonnes =	(*s_vecteurs_propres_droits).nombre_colonnes =
(*s_matrice).nombre_colonnes;	(*s_matrice).nombre_colonnes;

if (((*s_vecteurs_propres_droits).tableau = malloc(	if (((*s_vecteurs_propres_droits).tableau = malloc(((size_t)
(s_vecteurs_propres_droits).nombre_lignes	(s_vecteurs_propres_droits).nombre_lignes)
sizeof(struct_complexe16 *))) == NULL)	sizeof(struct_complexe16 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1431 valeurs_propres_generalisees(struct_proc	Line 1432 valeurs_propres_generalisees(struct_proc
for(i = 0; i < (*s_vecteurs_propres_droits).nombre_lignes; i++)	for(i = 0; i < (*s_vecteurs_propres_droits).nombre_lignes; i++)
{	{
if ((((struct_complexe16 *) (s_vecteurs_propres_droits)	if ((((struct_complexe16 *) (s_vecteurs_propres_droits)
.tableau)[i] = (struct_complexe16 *) malloc(	.tableau)[i] = (struct_complexe16 *) malloc(((size_t)
(s_vecteurs_propres_droits).nombre_colonnes	(s_vecteurs_propres_droits).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1501 moindres_carres(struct_processus *s_etat	Line 1502 moindres_carres(struct_processus *s_etat

complex16 *cwork;	complex16 *cwork;

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;
unsigned long k;	integer8 k;
unsigned long taille_matrice_a_f77;	integer8 taille_matrice_a_f77;
unsigned long taille_matrice_b_f77;	integer8 taille_matrice_b_f77;
unsigned long taille_matrice_x_f77;	integer8 taille_matrice_x_f77;

void *matrice_a_f77;	void *matrice_a_f77;
void *matrice_b_f77;	void *matrice_b_f77;
Line 1529 moindres_carres(struct_processus *s_etat	Line 1530 moindres_carres(struct_processus *s_etat
* Garniture de la matrice A	* Garniture de la matrice A
*/	*/

if ((matrice_a_f77 = (void ) malloc(taille_matrice_a_f77	if ((matrice_a_f77 = malloc(((size_t) taille_matrice_a_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 1542 moindres_carres(struct_processus *s_etat	Line 1543 moindres_carres(struct_processus *s_etat
{	{
for(j = 0; j < (*s_matrice_a).nombre_lignes; j++)	for(j = 0; j < (*s_matrice_a).nombre_lignes; j++)
{	{
((real8 ) matrice_a_f77)[k++] = ((integer8 *)	((real8 ) matrice_a_f77)[k++] = (real8) ((integer8 *)
(*s_matrice_a).tableau)[j][i];	(*s_matrice_a).tableau)[j][i];
}	}
}	}
Line 1563 moindres_carres(struct_processus *s_etat	Line 1564 moindres_carres(struct_processus *s_etat
* Garniture de la matrice B	* Garniture de la matrice B
*/	*/

if ((matrice_b_f77 = (void *) malloc(((taille_matrice_b_f77	if ((matrice_b_f77 = malloc(((size_t) ((taille_matrice_b_f77
< taille_matrice_x_f77) ? taille_matrice_x_f77	< taille_matrice_x_f77) ? taille_matrice_x_f77
: taille_matrice_b_f77) * sizeof(real8))) == NULL)	: taille_matrice_b_f77)) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1577 moindres_carres(struct_processus *s_etat	Line 1578 moindres_carres(struct_processus *s_etat
{	{
for(j = 0; j < (*s_matrice_b).nombre_lignes; j++)	for(j = 0; j < (*s_matrice_b).nombre_lignes; j++)
{	{
((real8 ) matrice_b_f77)[k++] = ((integer8 *)	((real8 ) matrice_b_f77)[k++] = (real8) ((integer8 *)
(*s_matrice_b).tableau)[j][i];	(*s_matrice_b).tableau)[j][i];
}	}

Line 1606 moindres_carres(struct_processus *s_etat	Line 1607 moindres_carres(struct_processus *s_etat
smlsiz = ilaenv_(&registre_1, "DGELSD", " ", &registre_2,	smlsiz = ilaenv_(&registre_1, "DGELSD", " ", &registre_2,
&registre_2, &registre_2, &registre_2, 6, 1);	&registre_2, &registre_2, &registre_2, 6, 1);

nlvl = 1 + ((integer4) log(((real8) (((*s_matrice_a).nombre_lignes <	nlvl = 1 + ((integer4) (log(((real8) (((*s_matrice_a).nombre_lignes <
(s_matrice_a).nombre_colonnes) ? (s_matrice_a).nombre_lignes	(s_matrice_a).nombre_colonnes) ? (s_matrice_a).nombre_lignes
: (*s_matrice_a).nombre_colonnes)) / (smlsiz + 1)) /	: (*s_matrice_a).nombre_colonnes)) / (smlsiz + 1)) /
log((real8) 2));	log((real8) 2)));

if ((iwork = (integer4 ) malloc(((((s_matrice_a).nombre_lignes <	if ((iwork = (integer4 ) malloc(((size_t) ((((s_matrice_a)
(s_matrice_a).nombre_colonnes) ? (s_matrice_a).nombre_lignes	.nombre_lignes < (*s_matrice_a).nombre_colonnes)
: (s_matrice_a).nombre_colonnes) (11 + (3 * nlvl))) *	? (*s_matrice_a).nombre_lignes
	: (s_matrice_a).nombre_colonnes) (11 + (3 * nlvl)))) *
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 1632 moindres_carres(struct_processus *s_etat	Line 1634 moindres_carres(struct_processus *s_etat
return;	return;
}	}

if ((vecteur_s = (real8 ) malloc(registre_5 sizeof(real8)))	if ((vecteur_s = (real8 ) malloc(((size_t) registre_5)
== NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1667 moindres_carres(struct_processus *s_etat	Line 1669 moindres_carres(struct_processus *s_etat
lwork = (integer4) work[0];	lwork = (integer4) 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 1704 moindres_carres(struct_processus *s_etat	Line 1706 moindres_carres(struct_processus *s_etat
(s_matrice_x).nombre_lignes = (s_matrice_a).nombre_colonnes;	(s_matrice_x).nombre_lignes = (s_matrice_a).nombre_colonnes;
(s_matrice_x).nombre_colonnes = (s_matrice_b).nombre_colonnes;	(s_matrice_x).nombre_colonnes = (s_matrice_b).nombre_colonnes;

if (((s_matrice_x).tableau = malloc((s_matrice_x).nombre_lignes *	if (((s_matrice_x).tableau = malloc(((size_t) (s_matrice_x)
sizeof(real8 *))) == NULL)	.nombre_lignes) * sizeof(real8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1714 moindres_carres(struct_processus *s_etat	Line 1716 moindres_carres(struct_processus *s_etat
for(j = 0; j < (*s_matrice_x).nombre_lignes; j++)	for(j = 0; j < (*s_matrice_x).nombre_lignes; j++)
{	{
if ((((real8 *) (s_matrice_x).tableau)[j] = (real8 *)	if ((((real8 *) (s_matrice_x).tableau)[j] = (real8 *)
malloc((s_matrice_x).nombre_colonnes	malloc(((size_t) (s_matrice_x).nombre_colonnes)
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 1745 moindres_carres(struct_processus *s_etat	Line 1747 moindres_carres(struct_processus *s_etat
* Garniture de la matrice A	* Garniture de la matrice A
*/	*/

if ((matrice_a_f77 = (void ) malloc(taille_matrice_a_f77	if ((matrice_a_f77 = malloc(((size_t) taille_matrice_a_f77) *
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1799 moindres_carres(struct_processus *s_etat	Line 1801 moindres_carres(struct_processus *s_etat
* Garniture de la matrice B	* Garniture de la matrice B
*/	*/

if ((matrice_b_f77 = (void *) malloc(((taille_matrice_b_f77	if ((matrice_b_f77 = malloc(((size_t) ((taille_matrice_b_f77
< taille_matrice_x_f77) ? taille_matrice_x_f77	< taille_matrice_x_f77) ? taille_matrice_x_f77
: taille_matrice_b_f77) * sizeof(struct_complexe16))) == NULL)	: taille_matrice_b_f77)) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1864 moindres_carres(struct_processus *s_etat	Line 1866 moindres_carres(struct_processus *s_etat
smlsiz = ilaenv_(&registre_1, "ZGELSD", " ", &registre_2,	smlsiz = ilaenv_(&registre_1, "ZGELSD", " ", &registre_2,
&registre_2, &registre_2, &registre_2, 6, 1);	&registre_2, &registre_2, &registre_2, 6, 1);

nlvl = 1 + ((integer4) log(((real8) (((*s_matrice_a).nombre_lignes <	nlvl = 1 + ((integer4) (log(((real8) (((*s_matrice_a).nombre_lignes <
(s_matrice_a).nombre_colonnes) ? (s_matrice_a).nombre_lignes	(s_matrice_a).nombre_colonnes) ? (s_matrice_a).nombre_lignes
: (*s_matrice_a).nombre_colonnes)) / (smlsiz + 1))	: (*s_matrice_a).nombre_colonnes)) / (smlsiz + 1))
/ log((real8) 2));	/ log((real8) 2)));

if ((s_matrice_a).nombre_lignes >= (s_matrice_a).nombre_colonnes)	if ((s_matrice_a).nombre_lignes >= (s_matrice_a).nombre_colonnes)
{	{
Line 1880 moindres_carres(struct_processus *s_etat	Line 1882 moindres_carres(struct_processus *s_etat
smlsiz) + (8 * nlvl) + (*s_matrice_b).nombre_colonnes));	smlsiz) + (8 * nlvl) + (*s_matrice_b).nombre_colonnes));
}	}

if ((rwork = (real8 ) malloc(lrwork sizeof(real8))) == NULL)	if ((rwork = (real8 ) malloc(((size_t) lrwork) sizeof(real8)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

if ((iwork = (integer4 ) malloc(((((s_matrice_a).nombre_lignes <	if ((iwork = (integer4 ) malloc(((size_t) ((((s_matrice_a)
(s_matrice_a).nombre_colonnes) ? (s_matrice_a).nombre_lignes	.nombre_lignes < (*s_matrice_a).nombre_colonnes)
: (s_matrice_a).nombre_colonnes) (11 + (3 * nlvl))) *	? (*s_matrice_a).nombre_lignes
	: (s_matrice_a).nombre_colonnes) (11 + (3 * nlvl)))) *
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 1907 moindres_carres(struct_processus *s_etat	Line 1911 moindres_carres(struct_processus *s_etat
return;	return;
}	}

if ((vecteur_s = (real8 ) malloc(registre_5 sizeof(real8)))	if ((vecteur_s = (real8 ) malloc(((size_t) registre_5)
== NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1943 moindres_carres(struct_processus *s_etat	Line 1947 moindres_carres(struct_processus *s_etat
lwork = (integer4) cwork[0].partie_reelle;	lwork = (integer4) cwork[0].partie_reelle;
free(cwork);	free(cwork);

if ((cwork = malloc(lwork * sizeof(struct_complexe16))) == NULL)	if ((cwork = malloc(((size_t) lwork) * sizeof(struct_complexe16)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1982 moindres_carres(struct_processus *s_etat	Line 1987 moindres_carres(struct_processus *s_etat
(s_matrice_x).nombre_lignes = (s_matrice_a).nombre_colonnes;	(s_matrice_x).nombre_lignes = (s_matrice_a).nombre_colonnes;
(s_matrice_x).nombre_colonnes = (s_matrice_b).nombre_colonnes;	(s_matrice_x).nombre_colonnes = (s_matrice_b).nombre_colonnes;

if (((s_matrice_x).tableau = malloc((s_matrice_x).nombre_lignes *	if (((s_matrice_x).tableau = malloc(((size_t) (s_matrice_x)
sizeof(struct_complexe16 *))) == NULL)	.nombre_lignes) * sizeof(struct_complexe16 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1992 moindres_carres(struct_processus *s_etat	Line 1997 moindres_carres(struct_processus *s_etat
for(j = 0; j < (*s_matrice_x).nombre_lignes; j++)	for(j = 0; j < (*s_matrice_x).nombre_lignes; j++)
{	{
if ((((struct_complexe16 *) (s_matrice_x).tableau)[j] =	if ((((struct_complexe16 *) (s_matrice_x).tableau)[j] =
(struct_complexe16 ) malloc((s_matrice_x).nombre_colonnes	(struct_complexe16 *) malloc(((size_t)
	(*s_matrice_x).nombre_colonnes)
* sizeof(struct_complexe16)))== NULL)	* sizeof(struct_complexe16)))== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.1.1.1
changed lines
	Added in v.1.50