algorithm fonction atan

Version imprimable

25/05/2009, 16h56
chris069

algorithm fonction atan

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.
25/05/2009, 17h12
ram-0000

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.
25/05/2009, 17h50
chris069

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 ?
26/05/2009, 11h05
Ulmo

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

L'algorithme CORDIC est rapide et précis.
26/05/2009, 11h14
PRomu@ld

Citation:

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
26/05/2009, 16h41
FR119492
Salut!
Personnellement, je commencerais par subdiviser l'intervalle de définition en 4 parties:
1. de 0 à +1;
2. de +1 à +infini;
3. de -1 à 0;
4. 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

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:

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

26/05/2009, 17h42
FR119492

Salut!

Citation:

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
27/05/2009, 08h44
chris069

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?
27/05/2009, 09h38
FR119492

Salut!

Citation:

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
27/05/2009, 09h46
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 :lol:

Citation:

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 :lol:

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:

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);
}

27/05/2009, 16h43
chris069

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

Merci de ton aide! :ccool: