Classe C++ pour coordonnées spatiales - Page 3

momotte (./40) :
surtout, ca doit etre emule en software, donc atrocement lent... (enfin bon, si ca en vaut la peine point de vue precision et que les perfs importent peu, pourquoi pas...)

(d'ailleurs, t'utilises quel compilo spomky pour qu'il supporte ce type la? GCC ? Oo)

g++ -v :
Utilisation des specs internes.
libraries: x86_64-linux-gnu
Configuré avec: ../src/configure -v --enable-languages=c,c++,fortran,objc,obj-c++,treelang --prefix=/usr --enable-shared --with-system-zlib --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --enable-nls --program-suffix=-4.1 --enable-__cxa_atexit --enable-clocale=gnu --enable-libstdcxx-debug --enable-mpfr --enable-checking=release x86_64-linux-gnu
Modèle de thread: posix
version gcc 4.1.2 (Ubuntu 4.1.2-0ubuntu4)

spectras (./38) :
L'important c'est de ne pas prendre les critiques personellement : elles ne visent pas le développeur, elles visent le code.

Quoi d'autre encore qui ne va pas dans mon code?
Au fait comment créer un namedspace? histoire d'éviter aux utilisateurs de rappeler CLocate:: à chaque fois.

truc imparable: __flaot128 ça m'étonnerait que ce soit portable sur 32 bits

squalyl (./50) :
Kevin > Ils ont vraiment fait les boulets TI avec le BCD. Ca a un avantage, en plus de tous les inconvénients?

euh une calculette qui utiliserait des floats binaires au lieu des BCD ce serait un peu n'importe quoi ^^ (va dire aux élèves que 1/10 = 0.09999999986 en fait )

squalyl (./55) :
j'aurais jamais codé un truc pareil, c'était juste pour savoir.

C'est clairement un code de merde.

tu n'utilises absolument jamais de variables locales qui pourraient correspondre à une variable globale d'un autre module ?

Pollux (./63) :
euh une calculette qui utiliserait des floats binaires au lieu des BCD ce serait un peu n'importe quoi ^^ (va dire aux élèves que 1/10 = 0.09999999986 en fait

J'ai une calculatrice qui utilise des floats binaires sous la main, mais elle me sort:
A 10 digitis, 1.000000000E-1
A 100 Digits, 1.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E-1

Pollux (./63) :
tu n'utilises absolument jamais de variables locales qui pourraient correspondre à une variable globale d'un autre module ?

nan
car j'utilise des conventions de nommage. Mes globales commencent toujours par g.
en plus je me démerde pour éviter autant que possible les variables globales autres que "static" (avec la sémantique du C, ie pas visible dans un autre fichier)
C'est plus propre de coder des choses réentrantes.

ptet pas, mais pas grave, ça me plait

Mais tu pourrais aussi utiliser un module écrit par qq1 d'autre qui n'aurait pas pris ces précautions ?

non.

en général si c'est des modules pas à moi, ça passe en .so, .dll mais pas statique.

AU PIRE si je dois inclure du code ee qn d'autre, je relirai le code avant de l'intégrer. c'est normal non? t'intègres pas du code sans le lire et le comprendre, quand même.

squalyl (./67) :
non.
en général si c'est des modules pas à moi, ça passe en .so, .dll mais pas statique.

Et ?

AU PIRE si je dois inclure du code ee qn d'autre, je relirai le code avant de l'intégrer. c'est normal non? t'intègres pas du code sans le lire et le comprendre, quand même.

Si. Je n'ai pas toujours le temps de lire plusieurs milliers de lignes... Surtout si c'est écrit dans un langage que je ne connais pas.

ahwé... mais bon perso ça m'arrive pas tlj de merger des codes tierce partie de > 10000 lignes dans mes projets

Surtout dans des langages que je ne connais pas.

squalyl (./69) :
ahwé... mais bon perso ça m'arrive pas tlj de merger des codes tierce partie de > 10000 lignes dans mes projets

Bah, si cette expérience te manque, tu peux m'aider avec TIGCC.

PpHd (./64) :

Pollux (./63) :
euh une calculette qui utiliserait des floats binaires au lieu des BCD ce serait un peu n'importe quoi ^^ (va dire aux élèves que 1/10 = 0.09999999986 en fait

J'ai une calculatrice qui utilise des floats binaires sous la main, mais elle me sort:
A 10 digitis, 1.000000000E-1
A 100 Digits, 1.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E-1

oui mais c'est parce qu'il y a une étape d'arrondi vers le BCD le plus proche quelque part ; on peut soit faire cette étape après chaque opération, mais c'est une étape coûteuse donc c'est pas une très bonne idée [*], soit la faire seulement à la fin du calcul au moment de l'affichage mais alors on a bien le type de problèmes que je décris... (pas pour un calcul aussi simple que 1/10, évidemment, mais le fait qu'en interne 1/10 ne soit pas exactement 0.1 finit bien par se manifester, et c'est sûrement bien plus confusing pour un élève que le fait qu'1/3 ne soit pas exactement 0.3333... avec une infinité de 3 )

[*]: quoique ça peut être une bonne idée si par exemple l'opération est très complexe (nettement plus que l'arrondi) et qu'elle peut être faite de façon plus efficace en binaire qu'en décimal ; mais alors ça ne serait pas vraiment moins performant de faire BCD->binaire puis calcul en binaire puis binaire->BCD

Pollux (./72) :
on peut soit faire cette étape après chaque opération, mais c'est une étape coûteuse donc c'est pas une très bonne idée [*], soit la faire seulement à la fin du calcul au moment de l'affichage mais alors on a bien le type de problèmes que je décris...

Ca le fait à la fin, et il n'y a aucun problèmes d'arrondis

Pollux (./72) :
[*]: quoique ça peut être une bonne idée si par exemple l'opération est très complexe (nettement plus que l'arrondi) et qu'elle peut être faite de façon plus efficace en binaire qu'en décimal ; mais alors ça ne serait pas vraiment moins performant de faire BCD->binaire puis calcul en binaire puis binaire->BCD

A moins d'avoir un CPU qui calcul du BCD en natif ^^

C'est la mode. Le POWER6 notamment peut calculer directement en base 10. C'est pas que pour faire joli, c'est parce que les soucis d'arrondis posent des problèmes légaux dans des applications financières sinon ^^

(c'est pas tant la mode, ça fait longtemps qu'il y a des CPU qui le font le 6502 le faisait deja il y a 20ans

Financièrement parlant, un calcul flottant, même en base 10, je ne lui ferai pas confiance.

Ben tu peux, c'est normalisé, et les résultats et les façons d'arrondir sont parfaitement définis

Godzil> multiplications, additions, divisions, racines carrées et compagnie, tout en base 10 ? Y compris en flottant ?

spectras (./79) :
Ben tu peux, c'est normalisé, et les résultats et les façons d'arrondir sont parfaitement définis

En base 2 aussi. C'est pas pour ca que c'est mieux.

En base deux tu peux pas représenter les mêmes nombres.

spectras (./79) :
Ben tu peux, c'est normalisé, et les résultats et les façons d'arrondir sont parfaitement définis

Godzil> multiplications, additions, divisions, racines carrées et compagnie, tout en base 10 ? Y compris en flottant ?

add, mul, div, sub, mais sachant que le 6502 n'a pas de FPU

spectras (./81) :
En base deux tu peux pas représenter les mêmes nombres.

Pourquoi ne pas avoir choisi une base 362880 alors. On peut représenter de manière exacte plus de nombres.

base 0xFFFFFFFF

Je propose de prendre une base infinie et d'utiliser un entier à taille variable. Plus simple. Et surement plus rapide aussi

PpHd> législations ^^
(accessoirement, représenter des sommes d'argent en base 10 se fait bien, alors qu'en base 2 c'est inexact).

C'est pas des blagues en plus. Un bon petit GMP, tes sommes codées en Mpz et tu n'as plus aucun problème.

(accessoirement, représenter des sommes d'argent en base 10 se fait bien, alors qu'en base 2 c'est inexact).

Faux. Suffit de représenter la somme en centime. La somme est donc un entier. Et même en base 2, la représentation est exacte.
Seuls les sous-centimes ne sont pas exacts.

et la somme de sous-centimes ca fait quoi?

le bon résultat ? #joker#