GTC prob type float - Page 2

et donc tu avais un message d'erreur avant, ou pas ?

non...

autre chose : on peut faire des niveaux de gris avec GTC ?

oui, comme avec TIGCC ^^

mais le code de TIGCC il marche pas (Gray Test)

euh, ça marche nickel sur VTI, tu as un message d'erreur ?

A tous les C users essayez GTC c'est trop bien,Pollux a fait un travail fantastique.J'ai ma v200 , dehors sur la terrasse et programme en niveaux de gris,sprite8 ,16,32, c'est genial !!! je programme aussi en ASM sur la HP-49 et la quelle galere compare au C on calc de la TI.

Au fait Pollux, t'y travaille toujours sur GTC ou c'est "en pause" ?

à part pour corriger des bugs c'est en pause oui ^^

Pollux>non pas de message d'erreur mais une fois le programme compilé y a pas de niveaux de gris, juste 2 rectangles noirs

ah ok, ben alors c'est "normal" parce que GTC utilise une vieille version des routines de TIGCC qui était pas compatible titanium :/ j'essayerai de corriger ça qd j'aurai le temps ^^

ok ^^

GTC ne gère pas les nombres à virgule ? comme 100.5 ?

Pollux :
non, GTC ne gère pas les floats : les floats FFP ont été implémentés à 80% mais personne ne s'en servira donc c'est désactivé, et les floats BCD n'ont jamais vraiment été implémentés...

et 100.5 est un "float"

ah oui désolé ^^

Twindruff (./2) :
GTC ne gère pas les float si je me souviens bien.
Mais dans presque tous les cas tu peux te débrouiller en virgule fixe.

hello c'est remoi ^^
je voulais juste savoir ce que signifiait ce message parce que j'y comprends rien au lien donné

comment on utilise la virgule fixe ?

tama (./48) :
hello c'est remoi ^^
je voulais juste savoir ce que signifiait ce message parce que j'y comprends rien au lien donné

comment on utilise la virgule fixe ?

Ce document devrait te paraître plus clair, à la base ça concerne la programmation sur GBA mais la partie Fixed Point est valable pour tout.

euh désolé je crois que j'y comprends encore moins de choses ^^
mais c'est parce que je débute complètement en C ^^
t'aurais pas un rapide exemple ? par exemple pour utiliser 100.5 je fais comment ?

Je te donne un exemple en base 10:
ton type de données te permet de stocker des entiers de 7 chiffres,
tu vas choisir de dédier 5 chiffres à la partie entière et 2 à la partie fractionnaire on appellera ça du "fixed point 5.2"
tu vas donc représenter 3,5 par 350.

ok et ensuite je peux utiliser 3 d'un côté et 50 de l'autre côté
et je fait ça comment pour les utiliser séparément

(merci de ta patience ^^)

en base b, en fixed point e.f
tu récupère la partie entière du nombre n par
et en C pour diviser un nombre par c'est n>>k (décalage binaire).

Edit: oublié un mot

je comprends pas
pourquoi faut diviser le nombre par 2^k ?

tu pourrais pas mettre un petit bout de code très rapide pour que j'y comprenne quelque chose ? ^^

C'est juste une convention, tu vas utiliser des entiers pour représenter des valeurs décimales, donc à toi de choisir combien de bits tu vas utiliser pour ta partie entière et ta partie décimale et d'effectuer les divisions au bon moment.

Pour être plus parlant, mettons que tu veux avoir deux coordonnées X et Y pour un objet, et tu veux que ces coordonnées soient des nombres décimaux. Tu peux par exemple dédier 3 bits pour la partie flottante (ce qui te fait une précision à 1/3^2 = 1/8 = 0.125 près, c'est pas top mais ça dépend pour quoi). Tu fais grosso modo tous tes calculs sans te soucier de ça, mais au moment d'afficher ton objet à l'écran par exemple, tu divises tes valeurs par 8 (= tu décales de 3 bits, c'est plus rapide) pour récupérer ce qui correspond à la partie entière dans ta représentation. De la même façon tu peux isoler les 3 derniers bits pour obtenir l'équivalent de la partie "après la virgule" de ta représentation.

Pour un pseudo-exemple de code, faute d'imagination voilà ce que ça pourrait donner :

/* Je choisis de réserver 3 bits pour ma partie décimale */

x = 5 << 3; /* Je veux fixer x à 5.0, dans ma représentation il faut multiplier
par 3^2 : une valeur de 5 serait en fait équivalente dans ma représentation à
5 / 3^2 soit 0.625. */
y = 12 << 3; /* Idem */

while (53)
{
x += 1; /* Si l'on prend en compte le sens de ma représentation, ici je
n'ajoute pas 1 à x mais 1/3^2 donc "l'équivalent" de 0.125. Si j'avais
voulu ajouter 1, il aurait fallu ajouter 1 * 3^2 donc 8. */

putPixel (x >> 3, y >> 3); /* Je veux les parties entières de mes nombres
qui sont dans une représentation particulière, on dégage donc les 3 derniers
bits qui correspondent à la partie décimale. */}

[edit] Le résultat de ce bout de code serait que le pixel n'est visiblement déplacé qu'une fois tous les 8 tours de boucle. Tel quel ça n'a pas beaucoup d'interêt, mais par exemple dans un jeu ça peut permettre des écarts de vitesse bien plus fins (8 fois) qu'entre "mon objet se déplace de 1 en 1 pixels" et "mon objet se déplace de 2 en 2 pixels"; ici tu peux avoir un mobile qui se déplace en moyenne de 1.625 pixels par boucle, par exemple.

./54 > 2^k c'est parce que ton nombre est représenté en binaire ; en base 10 ce serait 10^k.
Pour reprendre l'exemple de Twindruff, 3.50 est représenté par 350 donc pour récupérer la partie entière tu divises par 100, c'est-à-dire 10^2 (ici k = 2, c'est le nombre de chiffres après la virgule). En pratique tu suis ce principe mais pour la base 2 (seule base que sait utiliser l'ordinateur, ou la calculatrice en l'occurrence)

tama (./54) :
je comprends pas
pourquoi faut diviser le nombre par 2^k ?

tu pourrais pas mettre un petit bout de code très rapide pour que j'y comprenne quelque chose ? ^^

En base 100, si tu as 350:
* 350 / 100 = 3 (division entière)
* 350 % 100 = 50 (% = modulo = reste de la division de 350 par 100)
Donc ça marche bien, par contre la division est très lente, et le modulo aussi. C'est pour ça qu'ils te proposent d'utiliser des décalages de bits.
Par exemple si tu prends le nombre 8 ça donne en binaire 1000. Si tu le décales d'un bit vers la droite ça donne 100, ce qui est 4. Ca réalise donc bien une division par 2 (pour chaque décalage), et c'est bcp plus rapide (plus facile de décaler les bits que faire une division, à la main aussi d'ailleurs). Mais comme on ne peut pas réaliser une division de 100 avec des puissances de 2 (2, 4, 8, ..., 64, 128, 256, ...), on choisit une autre valeur, par exemple 256 (ou plus ou moins selon la précision dont tu as besoin).
Pour le modulo on a le "AND" bit à bit, avec un masque qui ne garde que les derniers bits. Exemple:
* 3.5: 3 * 256 + 0.5 * 256 = 896 (0x380 en hexa)
* 896 >> 8 = 896 / 256 = 3 (division entière)
* 896 & 255 = 896 % 256 = 128
128 est la moitié de la base (256) donc ça donne bien 3.5

[Edit] Réellement désolé Zephyr, j'ai complètement zappé ton message (et une demie heure de perdue, une)

merci beaucoup de vos 2 explications ça m'aide ^^

avec 3.75 ça donne ça alors :
3.75: 3*256+0.75*256=960 (0x3C0 en hexa)
960 >>8 = 960/256=3 (division entière)
960&255=960%256=192
et 192 c'est bien 3/4 de 256 donc c'est bien 3.75

en gros 192 ça représente 3.75

Pas tout à fait, 192 ça représente 0.75. Une unité (1.0) c'est 256. 960 ça représente 3.50.

ok.