algorithm fonction atan

**chris069** · 25/05/2009, 16h56

Bonjour,

j'aurais besoin de coder sur un microcontroleur la fonction atan, je ne sais pas si il est plus performant de faire une table, ou si coder soit meme l'algo de l'atan est faisable.(je possede le compilateur C ou sinon je peut aussi programmer directement en assembleur)

Merci de votre aide.

**ram-0000** · 25/05/2009, 17h12

Cela dépend aussi de la précision de l'angle que tu fournis.

Si tu acceptes une précision au degre près seulement, je partirai sur une table. Par contre, si tu veux le millième de degré, il faudra implémenter l'algorithme.

**chris069** · 25/05/2009, 17h50

malheuresement il me faut une précision de au minimum de l'ordre de 0.1 degré, j'ai essayé avec la formule de taylor mais je trouve que c'est pas fameux. Est ce que tu connaitrais un algo performant ?

**Ulmo** · 26/05/2009, 11h05

Les formules de Taylor, c'est principalement pour la théorie.

L'algorithme CORDIC est rapide et précis.

**PRomu@ld** · 26/05/2009, 11h14

L'algorithme CORDIC est rapide et précis.

+1.

Si je peux me permettre de faire un peu de pub pour un de mes anciens prof :

http://orochoir.club.fr/Maths/cordic.htm

**FR119492** · 26/05/2009, 16h41

Salut!
Personnellement, je commencerais par subdiviser l'intervalle de définition en 4 parties:

de 0 à +1;
de +1 à +infini;
de -1 à 0;
de -infini à -1.

Pour le premier intervalle, on approxime la fonction atan par une combinaison linéaires de polynômes de Tchebychev. Les valeurs sur les 3 autres intervalles s'en déduisent facilement.
Jean-Marc Blanc

**chris069** · 26/05/2009, 17h00

j'ai trouvé un algo qui fonctionne vraiment bien au niveau de la précision, il me reste a voir au niveau implémentation si ce n'est pas trop lourd, et le temps que ca prend pour un calcul d'arctan :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
sq2p1 = 2.414213562373095048802;
sq2m1  = 0.414213562373095048802;
p4  = 16.1536412982230228262;
p3  = 268.42548195503973794141;
p2  = 1153.0293515404850115428136;
p1  = 1780.40631643319697105464587;
p0  = 896.78597403663861959987488;
q4  = 58.95697050844462222791;
q3  = 536.265374031215315104235;
q2  = 1666.7838148816337184521798;
q1  = 2079.33497444540981287275926;
q0  = 896.78597403663861962481162;
PI_2 = 1.5707963267948966135;
PI_4 = 0.7853981634;
 
 
if(x > 0)
    flag = 0;   %(bool)
    arg = x;
else
    flag = 1;
    arg = -x;
end
 
        if(arg < sq2m1)
                temp = arg;
                argsq = temp*temp;
                value = ( ( ( (p4*argsq + p3)*argsq + p2) *argsq + p1) *argsq + p0);
                value = value /( ( ( ( (argsq + q4)*argsq + q3) *argsq + q2)*argsq + q1) *argsq + q0);
                if(flag == 0)
                    result = value*temp;
                else
                    result = -1*(value*temp);
                end
 
        elseif(arg > sq2p1)
                temp = 1/arg;
                argsq = temp*temp;
                value = ( ( ( (p4*argsq + p3)*argsq + p2) *argsq + p1) *argsq + p0);
                value = value /( ( ( ( (argsq + q4)*argsq + q3) *argsq + q2) *argsq + q1) *argsq + q0);
                if(flag == 0)
                    result = PI_2 - (value*temp);
                else
                    result = -1*(PI_2 - (value*temp));
                end
        else
                temp = (arg-1)/(arg+1);
                argsq = temp*temp;
                value = ( ( ( (p4*argsq + p3)*argsq + p2) *argsq + p1) *argsq + p0);
                value = value /( ( ( ( (argsq + q4)*argsq + q3) *argsq + q2) *argsq + q1) *argsq + q0);
                if(flag == 0)
                    result = (PI_4) +  (value*temp);
                else
                    result = -1*((PI_4) +  (value*temp));
                end
        end

**FR119492** · 26/05/2009, 17h42

Salut!

j'ai trouvé un algo qui fonctionne vraiment bien au niveau de la précision

Ce n'est pas exactement ce que je t'ai proposé, mais ça y ressemble beaucoup. Juste une petite remarque: tes coefficients sont donnés avec plus de chiffres que ce que ton processeur est capable de traiter, selon la norme IEEE 754.
Jean-Marc Blanc

**chris069** · 27/05/2009, 08h44

C'est vrai que la j'ai testé sous Matlab pour voir si cela fonctionnait bien, à moi de voir si avec des coefs moins précis, le résultat final est satisfaisant.

@FR119492 : Tu m'a l'air de connaitre un peu cette algo, serait tu me dire de quel méthode il vient et comment ont été trouvé ces coéfficients?

**FR119492** · 27/05/2009, 09h38

Salut!

Tu m'a l'air de connaitre un peu cette algo

Comme je travaille depuis longtemps avec des ordinateurs sur lesquels la fonction atan est déjà implémentée, je ne me suis pas fatigué à la reprogrammer. Malgré cela, je peux t'indiquer quelques pistes.

Tu sais que l'on a
arctan(0)=0
arctan(2-sqrt(3))=pi/12
arctan(1/sqrt(3))=pi/6
arctan(1)=pi/4
D'autre part, tu as
tan(x/2)=(1-cos(x))/sin(x)=sin(x)/(1+cos(x))
ce qui te permet de calculer d'autres valeurs.

Ensuite, pour ce qui concerne l'approximation de Tchebychev, va voir dans Numerical Recipes ou dans Wikipedia.

Jean-Marc Blanc

**chris069** · 27/05/2009, 09h46

oki merci pour ton aide, je vais quand même essayer de comprendre un minimum ce que fait cette algorithme, l'histoire de ne pas l'utiliser betemment

**pseudocode** · 27/05/2009, 11h24

Envoyé par chris069

oki merci pour ton aide, je vais quand même essayer de comprendre un minimum ce que fait cette algorithme, l'histoire de ne pas l'utiliser betemment

Ca m'a tout l'air d'être le calcul de l'approximant de Padé de Atan(x), découpé sur les 3 intervalles: [0,Sqrt(2)-1] [Sqrt(2)-1,Sqrt(2)+1] [Sqrt(2)+1,+oo]

C'est peut être plus clair comme cela:

Code java :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
double PI_4 = 0.78539816339744830675;
double PI_2 = 1.5707963267948966135;
 
double sq2p1 = 2.414213562373095048802;
double sq2m1  = 0.414213562373095048802;
 
double p4  = 16.1536412982230228262;
double p3  = 268.42548195503973794141;
double p2  = 1153.0293515404850115428136;
double p1  = 1780.40631643319697105464587;
double p0  = 896.78597403663861959987488;
 
double q4  = 58.95697050844462222791;
double q3  = 536.265374031215315104235;
double q2  = 1666.7838148816337184521798;
double q1  = 2079.33497444540981287275926;
double q0  = 896.78597403663861962481162;
 
// atan near 0
double atan_near0(double x) {
	double x2,result;
	x2 = x*x;
	double P = ( ( ( (p4*x2 + p3)*x2 + p2) *x2 + p1) *x2 + p0);
	double Q = ( ( ( ( (x2 + q4)*x2 + q3) *x2 + q2)*x2 + q1) *x2 + q0);
	result = x*(P/Q);
	return result;
}
 
// atan in range [0,+inf]
double atan_positive(double x) {
	if(x < sq2m1)
		return atan_near0(x);
	else if(x > sq2p1)
		return PI_2 - atan_near0(1/x);
	else
		return PI_4 + atan_near0((x-1)/(x+1));
}
 
//  atan in range [-inf,+inf]
double atan(double x) {
	if (x<0)
		return -atan_positive(-x);
	else
		return atan_positive(x);
}

**chris069** · 27/05/2009, 16h43

exacte, j'arrive a voir le lien avec l'approximant de Padé.

Merci de ton aide!

algorithm fonction atan

Algorithmes et structures de données

Discussions similaires

Partager

Partager