Discussion :

[le_voisin]

Salut,

je souhaiterais avoir une explication complementaire sur la partie concernant les types de données du cours de Christian Casteyde, surtout à propos des types signed et unsigned, j'ai pas vraiment compris la différence et je rencontre de drôle de chose quand je programme dûs à l'utilisation de type signed ou unsigned.
Je dois dans un algorithme génére une matrice (j'utilise la classe matrix de boost::ublas)
Pour cela j' ecris :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
matrix<signed double> a ( n, n);
	for(unsigned int i=0; i<a.size1(); ++ i)
	{for(unsigned int j=0; j<a.size2(); ++ j)
	a(i,j)=1-2*i-j*(i+j)*i*j;}

ce qui me permet degenerer une matrice avec des coef negatifs. Donc si j'utilise matrix<signed double> ok, ca marche. par contre si j'utilise matrix<double>, ca ne marche pas, je n'ai pas de nombre negatifs et par defaut il me met le plus grand nombre qu il peut calculer.

Mais lorsque je defini une fonction et que je crée une fonction dans une autre fichier.h et que je compile, il me dit que signed ne peut pas être utilisé avec double... et il me pose un probleme avec le calcul d'une racine carré sur un signed double (le nombre sous la racine est assurement positif... )
Par contre je precise que je ne rencontre pas tout ces problemes si j utilise des float dans ma fonction, je suis par contre oblige de generer une matrice avec des signed float pour avoir les coefs negatifs.

Voilà, je vous remercie en attendant vos explications !

[Kurisu]

Pour commencer, tu n'as pas besoin de préciser signed pour un type, ils le sont par défaut. Par contre, unsigned est obligatoire pour des types non signés.

Ce sont des erreurs de compilation ou d'execution que tu obtiens? Dans le premier cas, ca nous avancerait si tu postais le message du compilateur.

[le_voisin]

Salut,

dans le cas suivant où je genere une matrice

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
matrix<signed double> a ( n, n);
	for(unsigned int i=0; i<a.size1(); ++ i)
	{for(unsigned int j=0; j<a.size2(); ++ j)
	a(i,j)=1-2*i-j*(i+j)*i*j;}

c est une erreur d execution, ca compile sans probleme. A lexecution j ai une matrice avec la valeur max calculable positive lorsque je dervais avoir des coef nul.

Sinon dans mes autres fonctions, notamment la suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
/* Permuting two rows of a matrix */
matrix<signed double> permutation_rows(matrix<signed double> m, int i,int j)
{
	boost::numeric::ublas::vector<double> temp_i = row(m, i); 
	boost::numeric::ublas::vector<double> temp_j = row(m,j);
	for (unsigned int k=0; k<m.size2(); k=k+1)
	{
		m(i,k)=temp_j(k);
		m(j,k)=temp_i(k);
	}
	return (m);
}

si je ne met la "signed" j obtiens le message suivant à la compilation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
Linking...
prog.obj : error LNK2019: unresolved external symbol "class boost::numeric::ublas::matrix<int,struct boost::numeric::ublas::basic_row_major<unsigned int,int>,class boost::numeric::ublas::unbounded_array<int,class std::allocator<int> > > __cdecl permutation_rows(class boost::numeric::ublas::matrix<int,struct boost::numeric::ublas::basic_row_major<unsigned int,int>,class boost::numeric::ublas::unbounded_array<int,class std::allocator<int> > >,int,int)" (?permutation_rows@@YA?AV?$matrix@HU?$basic_row_major@IH@ublas@numeric@boost@@V?$unbounded_array@HV?$allocator@H@std@@@234@@ublas@numeric@boost@@V1234@HH@Z) referenced in function _main
C:\Documents and Settings\Rémi\Mes Documents\Visual Studio 2005\Projects\polynome\Debug\polynome.exe : fatal error LNK1120: 1 unresolved externals
Build log was saved at "file://c:\Documents and Settings\Rémi\Mes Documents\Visual Studio 2005\Projects\polynome\polynome\Debug\BuildLog.htm"
polynome - 2 error(s), 32 warning(s)
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

Ce message est issu du compilateur de visual c++ de microsoft.

Voilà, j'avoue que je comprend vraiment pas ce qu'il se passe.

Je rajoute pour finir avec ce message, que si je n'utilise que des float dans toutes mes fonctions, il y en 3 au total dont les 2 premieres sont utilisees dans la 3e, il n'y a aucun probleme.

Merci.

[koala01]

Salut,

Quand tu écris un code du genre de (je vais utiliser les int, mais ca revient au meme)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
int i;

le signed est sous entendu...

Cela signifie que, si ton entier a une taille de 32 bits (et cest *généralement* le cas, du moins dans le domaines de architectures PC's) les 31 bits "de poids le plus faible" (comme cela, on évite d'entrer dans les discutions boutistes ) sont destinés à représenter la valeur, et le dernier restant est destiné à représenter le signe (+ s'il vaut 0, et - s'il vaut 1)

En d'autre termes, sur une taille d'entier de 32 bits, que tu peux avoir des valeurs allant de -2.147.483.647 à +2.147.483.648 ...

(les valeurs de 0x00000000 à 0x7FFFFFFF étant positives et celles comprises entre 0x80000000 et 0xFFFFFFFF étant négative, et utilisant, pour etre complet, le principe du "complément à 2" pour déterminer la valeur absolue )

Quand tu écris, par contre, un code du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

unsigned int i;

c'est comme si tu disais à l'application "le 32ieme bit, celui de poids le plus fort, je veux que tu l'utilises pour la valeur et non comme indication de positif/négatif"...

Au niveau de la représentation en mémoire, cela n'aura pas énormément d'importance, les 32 bits (en restant dans le cadre de mon exemple ayant chacun une signification, mais, au point de vue de la valeur que tu peux faire afficher, cela en a énormément...

En effet, si tu signale un nombre comme "unsigned (quelque chose)" les seules valeurs affichées seront des valeurs... positives (0 inclus)

Ainsi, en (signed) int, et avec une taille pour les entiers de 32bits, la valeur de 0xFFFFFFFF serait de -1, alors qu'en unsigned int, elle serait de... 4.294.967.295...

Autant dire que, si tu n'auras jamais de problèmes tant que le bit de poids le plus fort reste à 0 (c'est à dire pour une valeur de 0x00000000 à 0x7FFFFFFF), tu risque d'en avoir dés que le bit de poids le plus for passe à un (les valeurs suppérieures à 0x80000000) car... -1 n'est pas vraiment égal à 4.294.967.295 (bien que la représentation en mémoire soit identique)

Je ne connais pas particulièrement boost, et encore moins la ulbas...

Mais, selon le message qui semble ressortir, il serait préférable que tu veilles à ce que le premier parametre passé au template de ublas::basic_row_major<unsigned int,int> soit de type unsigned...

Et, dans un sens, c'est normal: la premiere colone de la premiere ligne, dans une matrice, a l'indice 0,0...et il ne peut pas exister de colone (ni de ligne) -1

[le_voisin]

uneautre question que je me posais :
pourquoi je suis oblige de declare un signed double pour ma matrice lorsque je la genere avec une formule du type m(i,j)=j-2*i alors que le double est signed par defaut.

Et pourquoi le fait de passer me code en double pose probleme alors qu il fonctionne parfaitement en float?

[DaZumba]

Mais lorsque je defini une fonction et que je crée une fonction dans une autre fichier.h et que je compile, il me dit que signed ne peut pas être utilisé avec double...

C'est exact. A moins d'une revolution, signed et unsigned ne peuvent qualifier que les types entiers (char, short, int, long).

[le_voisin]

ok maisce que j aimerai savoir c'est d ou peut venir le probleme lorsque je converti mes float en double ?
Sachant que mon programme en float fonctionne parfaitement.

Merci