1

Bonjour,

Cherchant toujours à m'éloigner de l'ignorance, je reviens vers vous !

1. Les registres de données du 68k font 32bits. Ils stockent des entiers de 32 bits. Comment fait-on pour travailler sur des flottants (partie entière + mantisse) ?

2. Si je veux calculer le sinus d'un nombre, il n'y a pas de commande pour ça ? On en reste aux quatre opérations ? Donc pour du calcul mathématique je dois bosser en C ou programmer le calcul du sinus à partir des opérations élémentaires ?

par exemple (c'est du C, mais p'tet qu'en ASM, ça irait plus vite ?):
#  // On travaille modulo 2*pi
# x = fmod(x, 2*PI);
#
# // On utilise le DSE du sin : x - x^3/3! + x^5/5! - x^7/7!... en le factorisant par x
# double res = 1;
# double x_carre = x*x;
# double coeff = 1;
# int i = 2;
#
# do
# {
# coeff = (-coeff * x_carre) / (i*(i+1));
# res += coeff;
#
# i+=2;
# } while (fabs(coeff)>PRECISION);
#
# return x * res; 




Merci de vos réponses à ces (nombreuses) questions !

2

cidrolin (./1) :
1. Les registres de données du 68k font 32bits. Ils stockent des entiers de 32 bits. Comment fait-on pour travailler sur des flottants (partie entière + mantisse) ?
Ça dépend du codage utilisé pour représenter les flottants, qui dépend lui-même de la plate-forme. Tu es sur TI ?
2. Si je veux calculer le sinus d'un nombre, il n'y a pas de commande pour ça ? On en reste aux quatre opérations ? Donc pour du calcul mathématique je dois bosser en C ou programmer le calcul du sinus à partir des opérations élémentaires ?
Effectivement, le 68k ne gère pas nativement les nombres flottants mais peut-être que ton environnement d’exécution (système d’exploitation + bibliothèques) te fournit déjà les opérations dont tu as besoin.
avatar
« Quand le dernier arbre sera abattu, la dernière rivière empoisonnée, le dernier poisson capturé, alors vous découvrirez que l'argent ne se mange pas. »

3

Oui, je suis bien sur TI...


Le système d'exploitation de la calculatrice ? Alors j'ai PreOs (ou PedroM) !

4

En général par souci de simplicité on utilise des table de (co)sinus précalculées, mais évidemment ça dépend de ce que tu veux faire. (i.e. le résultat final)
Car les calculs trigonométriques sont inévitablement lourds, mais la précision des valeurs précalculées, elle, est limitée.
Sinon, les nombres flottant sur TI 68k sont stockés en BCD 80 bits et les fonctions pour calculer avec te seront accessibles avec TIGCC. (mais forcément c'est très lent ^^)
avatar
Le scénario de notre univers a été rédigée par un bataillon de singes savants. Tout s'explique enfin.
T'as un problème ? Tu veux un bonbon ?
[CrystalMPQ] C# MPQ Library/Tools - [CrystalBoy] C# GB Emulator - [Monoxide] C# OSX library - M68k Opcodes

5

(10 octets pour le stockage en BCD)

./3 Sur TI, l’OS te fournit déjà plein d’opérations mathématiques (cf http://tigcc.ticalc.org/doc/timath.html ). Et ça doit être pareil avec PedroM.
avatar
« Quand le dernier arbre sera abattu, la dernière rivière empoisonnée, le dernier poisson capturé, alors vous découvrirez que l'argent ne se mange pas. »

6

GoldenCrystal (./4) :
En général par souci de simplicité on utilise des table de (co)sinus précalculées, mais évidemment ça dépend de ce que tu veux faire. (i.e. le résultat final)

Ou alors un mélange entre les deux : d'abord une réduction d'argument (voire double réduction d'argument), puis un calcul en s'aidant de tables précalculées.
avatar
<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant

7

Ce que je veux faire ?

Trouver une combine pour accélérer le tracé des graphs.


Donc le précalcul... Ca se chiffre en ko pour une fonction. Pas raisonnable.


Donc les flottants, je ne peux les utiliser qu'en C ?

8

Pour le sinus, faut juste avoir des tables entre 0 et pi/2, donc pas besoin de trop de chiffres
avatar
<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant

9

./7 Non, en ASM aussi.

Pour ce qui est du précalcul, tout dépend de tes contraintes…
avatar
« Quand le dernier arbre sera abattu, la dernière rivière empoisonnée, le dernier poisson capturé, alors vous découvrirez que l'argent ne se mange pas. »

10

Sasume (./5) :
./3 Sur TI, l’OS te fournit déjà plein d’opérations mathématiques (cf http://tigcc.ticalc.org/doc/timath.html ). Et ça doit être pareil avec PedroM.



MAis c'est looooooooong pour tracer un graphique.

un pauvre sinus prend 2 secondes.

Alors qu'avec une fonction de ce genre, c'est (quasi)-instantané.

 void i_sin(float w)
 {
 	ypix_tab[0] = sin(-2*w);

 	ypix_tab[1] = sin(-w);

 	const float p = 2.0 * cos(w);
 	
 	int i;
 	for (i=2; i<160; i++ )

 	{

 		ypix_tab[i] = p*ypix_tab[i-1] - ypix_tab[i-2];


 	}
 }


c'est un cas particulier, mais j'y travaille

11

Nan mais en assembleur tu peux appeler des fonctions hein, tout ce qui est techniquement faisable en C l'est en assembleur aussi. C'est juste que comme tu n'as pas de type natif tu vas devoir appeler toi même les fonctions qui vont bien pour réaliser les opérations que tu souhaites (en l'occurence celles de l'OS proposées en ./5).
En fait là tu touches à un cas où l'assembleur ne t'apporterait rien, étant donné que le 99.9999% du temps est passé dans les fonctions mathématiques implémentées par l'OS ou par TIGCC, et que tu les appelles via l'assembleur ou le C c'est pareil.
avatar
Highway Runners, mon jeu de racing à la Outrun qu'il est sorti le 14 décembre 2016 ! N'hésitez pas à me soutenir :)

https://itunes.apple.com/us/app/highway-runners/id964932741

12

Brunni (./11) :
En fait là tu touches à un cas où l'assembleur ne t'apporterait rien, étant donné que le 99.9999% du temps est passé dans les fonctions mathématiques implémentées par l'OS ou par TIGCC, et que tu les appelles via l'assembleur ou le C c'est pareil.



OK. Donc si je veux bricoler les algos de calcul, ça sert à rien de jouer avec les registres, je fais ça en C !

Merci.

13

cidrolin: oui mais l'os de la calculette (et les progs basic), quand tu lui donnes à manger sin(machin), il est obligé de faire plein de tests dessus pour essayer d'en tirer une expression mathématique exacte qui est ensuite évaluée et arrondie.

alors que quand tu fais la même opération en C/asm, tu appelles directement le calcul en tant que nombre à virgule. c'est direct cash sans passer par la prison et sans toucher 20000€ grin

tu peux accélérer les calculs avec une table précalculée entre 0 et PI/2 puis faire les opérations dessus, tu vas gagner mais je dirais que c'est une optimisation de dernier ressort.

14

Tu peux aussi faire des calculs avec des approximations polynomiales (par exemple les développements limités).
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

15

faut d'abord faire une réduction d'argument entre 0 et pi/2, sinon c'est pourri embarrassed
avatar
<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant

16

Kevin Kofler (./14) :
Tu peux aussi faire des calculs avec des approximations polynomiales (par exemple les développements limités).


C'est la première méthode à laquelle j'avais pensée, mais je crois bien que c'est celle implémentée en C.
Flanker (./15) :
faut d'abord faire une réduction d'argument entre 0 et pi/2, sinon c'est pourri


float fsin(float x)
{

 {
 // On travaille modulo 2*pi
 x = fmod(x, 2*PI);

 // On utilise le DSE du sin : x - x^3/3! + x^5/5! - x^7/7!... en le factorisant par x
 float res = 1;
 float x_carre = x*x;
 double coeff = 1;
 int i = 2;

 do
 {
 coeff = (-coeff * x_carre) / (i*(i+1));
 res += coeff;

 i+=2;
 } while (fabs(coeff)>0.01);

 return x * res;
 } 
}


Mais c'est encore plus long que TI, même avec cette précision toute pourrie.

Cela dit, la réduction d'argument elle ne sert à rien là (enfin je crois). Il faudrait garder en mémoire les valeurs déjà calculées et les reprendre ? Ouh là là. Ca va être dur.


J'ai essayé aussi avec l'algorithme de Cordic, mais là, c'est affreusement lent.

17

lent avec CORDIC ? normalement c'est plus rapide, justement hum
avatar
<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant

18

Je pense que AMS utilise Cordic.
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

19

Flanker (./17) :
lent avec CORDIC ? normalement c'est plus rapide, justement


float f3tan(float angle)
{// cordic, 3 fois plus lent que celui de la TI
	angle = fmod(angle, PI);
	//return tan(angle);
	float theta[7];
	theta[0]=0.78539816339744830962;
	theta[1]=0.099668652491162027378;
	theta[2]=0.0099996666866652382063;
	theta[3]=0.00099999966666686666652;
	theta[4]=0.000099999999666666668667;
	theta[5]=0.0000099999999996666666667;
	theta[6]=0.00000099999999999966666667;
	int k = 0;
	float X = 1;
	float Y = 0;
	const float epsilon = 0.01;
	while (angle > epsilon)
	{
		while (angle < theta[k])
		{
			k++;
		}
	angle=angle-theta[k];
	float temp = X;
	X = X - pow(10,-k)*Y;
	Y = Y + pow(10,-k)*temp;
	}
	return Y/X;
}



Ou j'm'a gouré ?



Kevin Kofler (./18) :
Je pense que AMS utilise Cordic.



Oui, c'est ce qui semble le plus courant pour ce genre de calcul. Mais je comprends pas pourquoi mon implémentation est si lente (je vais finir par croire en les vertus magiques de l'ASM... ou en mon incompétence !)

20

cidrolin (./19) :
je vais finir par croire en les vertus magiques de l'ASM

pencil hehe

21

cidrolin (./19) :
pow(10,-k)


Evites de le calculer 2x par boucle.
Utilise une variable initialisé à 1, et divises la par 10 à chaque k++.

Je me demande bien aussi ce que fait ton algo avec un angle à 0.0...

22

PpHd (./21) :
Utilise une variable initialisé à 1, et divises la par 10 à chaque k++.


Bien vu ! maintenant, c'est à peine deux fois plus lent que la TI ! Français, encore un effort...

Quand aux angles 0.000..., c'est pour le calcul de petits angles

si j'ai compris : http://www.trigofacile.com/maths/trigo/calcul/cordic/cordic.htm

23

Ne divise pas par 10, utilise bcd_var(mavar).exponent--; à la place!
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

24

et heu... pas moyen d'utiliser des puissances de 2 trifus

25

C'est plus lent en BCD!
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

26

ok, vu pour l'archi ti68k.
mais pour de la virgule fixe ou de l'IEEE754 ce serait mieux, non?

27

Évidemment, oui.
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité