A voir également:
- Temps d'exécution
- Blocage agriculteur carte en temps réel - Guide
- Renommer plusieurs fichiers en même temps - Guide
- Erreur d'execution 1004 ✓ - Forum VB / VBA
- Ss06 snapchat combien de temps - Forum Snapchat
- Sablier snap temps ✓ - Forum Snapchat
5 réponses
dubcek
Messages postés
18752
Date d'inscription
lundi 15 janvier 2007
Statut
Contributeur
Dernière intervention
3 octobre 2024
5 618
13 mars 2010 à 08:01
13 mars 2010 à 08:01
helo
quelle matrice ?
quelle matrice ?
dubcek
Messages postés
18752
Date d'inscription
lundi 15 janvier 2007
Statut
Contributeur
Dernière intervention
3 octobre 2024
5 618
13 mars 2010 à 17:28
13 mars 2010 à 17:28
si ton temps devient négatif, es-tu sûr d'utiliser le bon type de variable, int au lieu de long ?, par ex.
Salut,
j'utilise le type double pour le temps d'execution et meme je l'ai changé au long double, mais meme resultat:temps négatif des que la dimension de la matrice depasse 500.
double nsec;
struct timespec start, end;
//lecture du temp debut
clock_gettime(CLOCK_THREAD_CPUTIME_ID,&start);
instruction;
clock_gettime(CLOCK_THREAD_CPUTIME_ID,&end);// lecture du temps d'arret
nsec =(end.tv_sec * 1000000000 + end.tv_nsec) - (start.tv_sec * 1000000000 + start.tv_nsec) ;// calcul de l'intervalle
j'utilise le type double pour le temps d'execution et meme je l'ai changé au long double, mais meme resultat:temps négatif des que la dimension de la matrice depasse 500.
double nsec;
struct timespec start, end;
//lecture du temp debut
clock_gettime(CLOCK_THREAD_CPUTIME_ID,&start);
instruction;
clock_gettime(CLOCK_THREAD_CPUTIME_ID,&end);// lecture du temps d'arret
nsec =(end.tv_sec * 1000000000 + end.tv_nsec) - (start.tv_sec * 1000000000 + start.tv_nsec) ;// calcul de l'intervalle
fiddy
Messages postés
11069
Date d'inscription
samedi 5 mai 2007
Statut
Contributeur
Dernière intervention
23 avril 2022
1 840
13 mars 2010 à 19:17
13 mars 2010 à 19:17
Il y a dépassement d'entiers.
Je pense qu'en multipliant par 1e9 au lieu de 1000000000, cela réglera le problème provisoirement.
Par la suite, il faudra vérifier si end.tv_sec >stard.tv_sec.
Cdlt,
Je pense qu'en multipliant par 1e9 au lieu de 1000000000, cela réglera le problème provisoirement.
Par la suite, il faudra vérifier si end.tv_sec >stard.tv_sec.
Cdlt,
fiddy
Messages postés
11069
Date d'inscription
samedi 5 mai 2007
Statut
Contributeur
Dernière intervention
23 avril 2022
1 840
13 mars 2010 à 23:43
13 mars 2010 à 23:43
Ta variable end devrait contenir des nombres (seconde et nano-seconde) d'autant plus grands que le programme mettra du temps à s'exécuter. Le problème est que les secondes sont déclarées en time_t et les nano en long. Lorsque tu vas multiplier ton type time_t avec 1000000000, le C va considérer que c'est toujours du type time_t (donc du 'long' bien souvent). Sur une architecture 32 bits, il y aura dépassement lorsque la valeur dépassera 2^32-1 secondes. A ce moment-là, il repassera à -2^32. D'où le nombre négatif lorsque tu feras ta soustraction.
En remplaçant 1000000000 par 1e9, tu diras implicitement au compilateur de travailler en double. Et comme les limites sont beaucoup plus loin, le problème est réglé temporairement.
Cdlt,
En remplaçant 1000000000 par 1e9, tu diras implicitement au compilateur de travailler en double. Et comme les limites sont beaucoup plus loin, le problème est réglé temporairement.
Cdlt,
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
Salut,mon pb cette fois_ci ne concerne pas le temps d'exécution.Au contraire, je veux bien exploiter le calcul de ce temps dans le programme de la factorisationLU. En effet, j'ai ecrit un code en C mais mais malheureusement, il ne fournit pas des résultats justes toujours puisque dès qu'il tombe sur un pivot nul, le vecteur résultat est rempli de NAN. Ce qui est sur et certain que mon code lui manque des tests que je ne sais pas comment les mettre.
Pouvez vous m'aider s'il vous plait, ça concerne mon projet de fin d'étude.Voilà mon code:
/*La taille maximale de la matrice et pas d'incrementation*/
n=atoi(argv[1]);
inc=atoi(argv[2]);
for(dim=0; dim<=n; dim=dim+inc)
{
/*allocation des trois matrices */
a=(float*)malloc(dim*dim*sizeof(float));
y=(float*)malloc(dim*sizeof(float));
b=(float*)malloc(dim*sizeof(float));
/*Allocation du vecteur x */
x=(float*)malloc(dim*sizeof(float));
/*initialisation de la matrice a */
#pragma omp parallel for private(i,j)
for(i=0;i<dim;i++)
for(j=0;j<dim;j++)
a[i*dim+j]=i*j-1;
/* Initialisation du vecteur b */
#pragma omp parallel for private(i)
for(i=0;i<dim;i++)
b[i]=i-15;
//CALLGRIND_ZERO_STATS;
//lecture du temps début
clock_gettime(CLOCK_THREAD_CPUTIME_ID,&start);
/*------------------------------------------------------------------------------
* DESCRIPTION : Décomposition LU (stockée dans mat) de la matrice mat
* ENTREES : mat : matrice carrée de doubles
* size : taille de la matrice
* RETOUR : aucun
------------------------------------------------------------------------------*/
for (j=0;j<dim-1;j++)
{
for (i=j+1;i<dim;i++)
{
a[dim*i+j] = a[dim*i+j] / a[dim*j+j]; // Construction de Ek
for (k=j+1;k<dim;k++) // Construction de Ak
{
a[dim*i+k] += -a[dim*i+j] * a[dim*j+k];
}
}
}
/*------------------------------------------------------------------------------
* DESCRIPTION : Résolution de l'équation L*y=b
* ENTREES : LU : matrice carrée de doubles décomposée LU
* b : Vecteur de doubles, second membre de l'équation
* size : taille de la matrice
* RETOUR : Vecteur de doubles solution de l'équation
------------------------------------------------------------------------------*/
for (i=0;i<dim;i++)
{
y[i] = b[i];
for(j=0;j<i;j++)
{
y[i] -= y[j]*a[dim*i+j];
}
}
/*------------------------------------------------------------------------------
* DESCRIPTION : Résolution de l'équation U * x = y
* ENTREES : LU : matrice carrée de doubles décomposée LU
* y : Vecteur de doubles, second membre de l'équation provenant
* de la résolution de L * y = b
* size : taille de la matrice
* RETOUR : Vecteur de doubles solution de l'équation
------------------------------------------------------------------------------*/
for (i=dim-1;i>=0;i--)
{
x[i] = y[i];
for(j=dim-1;j>i;j--)
{
x[i] -= x[j]*a[dim*i+j];
}
x[i] = x[i]/a[dim*i+i];
}
//CALLGRIND_DUMP_STATS;
// lecture du temps d'arrêt
clock_gettime(CLOCK_THREAD_CPUTIME_ID,&end);
// calcul de l'intervalle
nsec =(end.tv_sec * 1e9 + end.tv_nsec) - (start.tv_sec * 1e9 + start.tv_nsec) ;
Pouvez vous m'aider s'il vous plait, ça concerne mon projet de fin d'étude.Voilà mon code:
/*La taille maximale de la matrice et pas d'incrementation*/
n=atoi(argv[1]);
inc=atoi(argv[2]);
for(dim=0; dim<=n; dim=dim+inc)
{
/*allocation des trois matrices */
a=(float*)malloc(dim*dim*sizeof(float));
y=(float*)malloc(dim*sizeof(float));
b=(float*)malloc(dim*sizeof(float));
/*Allocation du vecteur x */
x=(float*)malloc(dim*sizeof(float));
/*initialisation de la matrice a */
#pragma omp parallel for private(i,j)
for(i=0;i<dim;i++)
for(j=0;j<dim;j++)
a[i*dim+j]=i*j-1;
/* Initialisation du vecteur b */
#pragma omp parallel for private(i)
for(i=0;i<dim;i++)
b[i]=i-15;
//CALLGRIND_ZERO_STATS;
//lecture du temps début
clock_gettime(CLOCK_THREAD_CPUTIME_ID,&start);
/*------------------------------------------------------------------------------
* DESCRIPTION : Décomposition LU (stockée dans mat) de la matrice mat
* ENTREES : mat : matrice carrée de doubles
* size : taille de la matrice
* RETOUR : aucun
------------------------------------------------------------------------------*/
for (j=0;j<dim-1;j++)
{
for (i=j+1;i<dim;i++)
{
a[dim*i+j] = a[dim*i+j] / a[dim*j+j]; // Construction de Ek
for (k=j+1;k<dim;k++) // Construction de Ak
{
a[dim*i+k] += -a[dim*i+j] * a[dim*j+k];
}
}
}
/*------------------------------------------------------------------------------
* DESCRIPTION : Résolution de l'équation L*y=b
* ENTREES : LU : matrice carrée de doubles décomposée LU
* b : Vecteur de doubles, second membre de l'équation
* size : taille de la matrice
* RETOUR : Vecteur de doubles solution de l'équation
------------------------------------------------------------------------------*/
for (i=0;i<dim;i++)
{
y[i] = b[i];
for(j=0;j<i;j++)
{
y[i] -= y[j]*a[dim*i+j];
}
}
/*------------------------------------------------------------------------------
* DESCRIPTION : Résolution de l'équation U * x = y
* ENTREES : LU : matrice carrée de doubles décomposée LU
* y : Vecteur de doubles, second membre de l'équation provenant
* de la résolution de L * y = b
* size : taille de la matrice
* RETOUR : Vecteur de doubles solution de l'équation
------------------------------------------------------------------------------*/
for (i=dim-1;i>=0;i--)
{
x[i] = y[i];
for(j=dim-1;j>i;j--)
{
x[i] -= x[j]*a[dim*i+j];
}
x[i] = x[i]/a[dim*i+i];
}
//CALLGRIND_DUMP_STATS;
// lecture du temps d'arrêt
clock_gettime(CLOCK_THREAD_CPUTIME_ID,&end);
// calcul de l'intervalle
nsec =(end.tv_sec * 1e9 + end.tv_nsec) - (start.tv_sec * 1e9 + start.tv_nsec) ;
13 mars 2010 à 16:11
il s'agit d'une matrice allouée dynamiquement d'entiers ou de float ou de double.