Arcsin (sin-1) Programmation C

[sylvainmahe]

Bonjour

J'ai une question, la fonction sinus est:

(((-1)^n)/(n*2+1)!)*x^(n*2+1)

x = l'angle en radians
n = une valeur partant de 0 qui s'incrémente dans une boucle (c'est la précision du calcul que l'on veut)

Voila ma fonction sinus en langage C:

float Core::sin (const float ANGLE)
{
	float angle = 0;
	float alpha = 0;
	unsigned long n = 0;
	float value = 0;
	bool quickSearch = false;
	unsigned long foundMultiply = 0;
	unsigned char precision = 0;
	unsigned char nPrecision = 0;
	signed char inverter = 1;
	unsigned long long powerFactor = 0;
	float powerAngle = 0;
	
	if (ANGLE >= -180 && ANGLE <= 180)
	{
		angle = ANGLE;
		alpha = ANGLE / (180.0 / _PI);
	}
	else if (ANGLE < -180)
	{
		while (quickSearch == false)
		{
			for (n = 1; ANGLE + (360 * (foundMultiply + n)) < -180; n *= 10)
			{
			}
			
			if (n == 1)
			{
				quickSearch = true;
			}
			else
			{
				foundMultiply += float (n) / 10.0;
			}
		}
		
		foundMultiply += 1;
		
		angle = ANGLE + (360 * foundMultiply);
		alpha = (ANGLE + (360 * foundMultiply)) / (180.0 / _PI);
	}
	else
	{
		while (quickSearch == false)
		{
			for (n = 1; ANGLE - (360 * (foundMultiply + n)) > 180; n *= 10)
			{
			}
			
			if (n == 1)
			{
				quickSearch = true;
			}
			else
			{
				foundMultiply += float (n) / 10.0;
			}
		}
		
		foundMultiply += 1;
		
		angle = ANGLE - (360 * foundMultiply);
		alpha = (ANGLE - (360 * foundMultiply)) / (180.0 / _PI);
	}
	
	if (angle == -90 || angle == 270)
	{
		value = -1;
	}
	else if (angle == -270 || angle == 90)
	{
		value = 1;
	}
	else if (angle != -360 && angle != -180 && angle != 0 && angle != 180 && angle != 360)
	{
		for (precision = 0; precision < 16; precision++)
		{
			nPrecision = (precision * 2) + 1;
			powerFactor = nPrecision;
			
			for (n = 2; n < nPrecision; n++)
			{
				powerFactor *= nPrecision - (n - 1);
			}
			
			powerAngle = alpha;
			
			for (n = 1; n < nPrecision; n++)
			{
				powerAngle *= alpha;
			}
			
			value += (float (inverter) / float (powerFactor)) * powerAngle;
			
			inverter *= -1;
		}
	}
	
	return value;
}

Elle fonctionne parfaitement bien (quel que soit l'angle qu'on y met, < 360 ou >), j'ai également créé la fonction cosinus et tangente...

Je souhaite maintenant créer la fonction arcsinus mais cela ne donne pas le bon résultat.
La voici:

float Core::arcsin (const float SIN)
{
	float alpha = 0;
	unsigned char n = 0;
	unsigned char precision = 0;
	unsigned char nPrecision = 0;
	signed char inverter = 1;
	unsigned long long powerFactor = 0;
	float powerAlpha = 0;
	
	for (precision = 0; precision < 16; precision++)
	{
		nPrecision = (precision * 2) + 1;
		powerFactor = nPrecision;
		
		for (n = 2; n < nPrecision; n++)
		{
			powerFactor *= nPrecision - (n - 1);
		}
		
		powerAlpha = SIN;
		
		for (n = 1; n < nPrecision; n++)
		{
			powerAlpha *= SIN;
		}
		
		powerAlpha = powerAlpha * (180.0 / _PI);
		
		alpha += powerAlpha * (float (inverter) / float (powerFactor));
		
		inverter *= -1;
	}
	
	//return alpha * (180.0 / _PI);
	return alpha;
}

Ce qu'il me faudrait en fait c'est quelqu'un qui sache m'expliquer l'inverse de:

(((-1)^n)/(n*2+1)!)*x^(n*2+1)

Pour que je puisse modifier ma fonction sinus comme il faut.

Pouvez-vous m'aider s'il vous plaît?

Merci d'avance.
-----

[invite57a1e779]

Bonjour,

Voici le développement en série de l'arcsinus :



mais il y a des algorithmes plus performants que les calculs brutaux en série entière.

[gg0]

Chercher sur Internet "algorithme CORDIC".

Cordialement.

[sylvainmahe]

Ok merci pour votre aide c'est sympa

La fonction arcsin proposé par *God's Breath marche bien
J'ai regardé également l’algorithme de cordic, c'est intéressant effectivement, je mettrais peut être ça en place plus tard (ou pas), car malgré le microcontrôleur seulement 16Mhz que j'utilise (atmega328p) le calcul est très rapide car ce dernier n'a pas besoin de beaucoup d'itérations pour être assez précis.

Si jamais vous avez aussi la fonction arccos cela m'intéresse (car chez wikipedia ou autre je ne trouve pas de la façon dont vous l'avez écrit, et qui fonctionne directement...).

Merci pour votre aide

[A voir en vidéo sur Futura]

[invite57a1e779]

[sylvainmahe]

Ah oui exact, ça parait logique maintenant

En fait, pour sinus comme je le disais je fait ceci:

sin = (((-1)^n)/(n*2+1)!)*x^(n*2+1);

Et pour cosinus j'avais trouvé que faire ceci fonctionnait:

cos = 1 - ((((-1)^n)/((n+1)*2)!)*x^((n+1)*2));

C'est à dire remplacer n*2+1 par (n+1)*2 et faire 1 - (calcul)

Du coup je me disais qu'il y avait une façon de faire sans utiliser PI / 2 -
?

Merci.

[sylvainmahe]

je pense que ça devrait fonctionner avec ceci:

1-(((n*2)!/((4^n)*(n!)^2))*((x^((n+1)*2))/((n+1)*2)));

[invite57a1e779]

Le terme « 1 » qui initie le développement du cosinus n'est rien autre que pour .

Comme on te l'a dit, il y a d'autres algorithmes pour calculer rapidement ces fonctions ; mais si tu veux utiliser les développements en série entière, tu ne peux pas éviter le premier terme en pour l'arccosinus.

[sylvainmahe]

Ok d'accord.

Pour les calculs plus rapides il parlent entre autre de valeurs pré-calculées, mais...
...je me dit que tant qu'à pré-calculer des valeurs, autant pré-calculer genre 1024 valeur pour 0° à 90°, ça fait une résolution suffisante pour la majorité des applications non?

Après tout dépend des applications bien-sûr...


Pour la fonction arcsinus finalement je crois qu'elle a un soucis, avec disons 16 itérations j'obtiens pour:
arcsin 0 = 0°
arcsin 0.173648178 = 9.99999° (pour normalement 10)° -> ok
arcsin 0.342020143 = 20° (pour normalement 20°) -> ok
arcsin 0.707106781 = 44.99974° (pour normalement 45°) -> ok
arcsin 0.984807753 = 77.15650° (pour normalement 80°) -> problème
arcsin 0.999847695 = 80.19308° (pour normalement 89°) -> gros problème
arcsin 1 = 80.22537° (pour normalement 90°) -> gros gros problème

Il faut mettre environ 1.04 pour obtenir 90°, c'est étrange

J'ai essayé à la calculatrice directement, en additionnant une 10ène de valeurs (n0, n1, n2, n..., n9), on obtient le même résultat.

Il doit manquer quelque chose dans cette fonction non?

[Tryss2]

Non.

C'est le développement limité en zéro, il est donc parfaitement normal qu'en s'éloignant de zéro, l'approximation soit de moins en moins bonne.

Ça va faire redite mais les développements limités ne donnent pas des algorithmes très efficaces

[sylvainmahe]

Ok je comprends

[invite57a1e779]

Il ne manque rien!
La convergence est très lente et il faudrait un grand nombre d'itérations pour obtenir un résultat convenable.

C'est pour cela que l'on utilise dans la pratique d'autres algorithmes plus rapides.

[sylvainmahe]

Ok c'est bien ce que je pensais, par contre avec sinus la convergence est très rapide, en 4 ou 5 itération on a déjà un résultat très satisfaisant, j'aurais pensé qu'avec arcsinus ça aurait été pareil.

La solution serait peut être que j'utilise sinus pour "chercher" l'angle d'un sinus. Un peu comme racine carré ou on doit tester des valeurs au carré...

[pm42]

Je viens de regarder dans le code source d'un firmware pour calculatrice scientifique (WP34s sur Sourceforge) et c'est classiquement basé sur arctan.
Lequel arctan est basé sur de la réduction d'argument puis du Taylor.

Tu as des infos ici par ex :

http://mathonweb.com/help_ebook/html...hms.htm#arctan
http://mathonweb.com/help_ebook/html...hms.htm#arcsin

Tu dois trouver pas mal d'autres choses en cherchant un peu.

[jiherve]

Bonsoir,

Chercher sur Internet "algorithme CORDIC".

Cordialement.

+10 c'est le plus precis et le plus rapide fonctionnait déjà très bien sur les calculateurs série des années 70 et tourne très bien sur ATMEGA 328.L'avantage c'est que l’algorithme est générique et permet de calculer de nombreuses fonctions il est très largement utilisé sur les calculatrices, le nombre de boucles ne dépend que du nombre de bits attendus.
JR

[stefjm]

Pour les calculs plus rapides il parlent entre autre de valeurs pré-calculées, mais...
...je me dit que tant qu'à pré-calculer des valeurs, autant pré-calculer genre 1024 valeur pour 0° à 90°, ça fait une résolution suffisante pour la majorité des applications non?

Si vous avez la place mémoire, c'est évidement le plus rapide.
C'est vieux comme le monde, dans le temps, on mettait dans une eprom la fonction Arcos pour les calculs des redresseurs commandés (en cos) pour avoir une commande linéaire.

[sylvainmahe]

Ok merci pour les infos

Pour cordic *jiherve moi je veux bien mais faudrait déjà que je le comprenne ! Et c'est pas gagné vu mon niveau en math, mise à part que ça ressemble à ce que je voulais faire en premier lieu: pré-calculer une partie des valeurs et chercher le reste (à moins que je me trompe c'est peut être pas ça qui est expliqué...).
Je vois que dans l'algorithme de cordic il utilise sin et cos, je me trompe?

Pour l'instant si je ne voit pas plus de truc génial dans l’algorithme de cordic que ce que je pensais faire dès le départ, ou si personne ne peut expliquer ce qui se passe vraiment dans cet algorithme, et bien je ferais avec ma méthode.

[gg0]

Bonjour.

Et pourquoi ne pas utiliser la fonction arcsin de C ? Si elle n'existe pas en natif, elle figure dans une bibliothèque de base.

Cordialement.

[sylvainmahe]

Bonjour, oui c'est sûr, c'est ce que la majorité des programmeurs font.

Ça mérite une explication: depuis maintenant 1 an et demi je programme une bibliothèque (une alternative à arduino) pour un microcontrôleur. Bref, je programmais cela sur la base de la bibliothèque avr-c, puisque dans la logique l'architecture du microcontrôleur que j'utilise est RISC c'est à dire un cœur que atmel nomme AVR.

J'ai décidé il y a quelques mois de me passer d'avr-c, mais aussi de toute autre bibliothèque, genre:
stdlib.h
math.h
stdio.h
string.h
etc...

L’intérêt de cette démarche est que je souhaitais comprendre comment les choses que j'utilisais naïvement fonctionnaient, ce qu'il y avait derrière. Et l'autre intérêt était de rendre ma programmation totalement indépendante (0 include).

Le boulo est presque fini, et il ne reste que quelques fonctions de math: arcsin arccos et arctan

Dans quelques heures ce sera réglé pour ces fonctions...

[sylvainmahe]

Si jamais vous voulez les fonctions sinus, cosinus, tangent, arc sinus, arc cosinus, et arc tangent en langage C, n'hésitez pas à me faire signe

Merci aux intervenants de m'avoir aidé (sujet résolu).

[sylvainmahe]

J'ai fait un petit test de rapidité avec mcu 16mhz et précision au 0.0001:

sin = 446 µs
cos = 498 µs
tan = 892 µs
arcsin = 14774 µs
arccos = 16614 µs
arctan = 26158 µs

C'est ni exceptionnel, ni catastrophique (2.6ms pour arctan), je pense que ça peut être amélioré avec les doués des mathématiques, moi je ne suis pas doué des mathématiques, mais disons que c'est correct.

[sylvainmahe]

Je voulais dire 26ms pour arctan, ce qui effectivement est médiocre pour cette fonction.

Je viens d'essayer de mettre les calculs sur une seule ligne sans boucle dans le genre:

alpha = angle / (180.0 / _PI);
sinus = alpha - ((1.0 / 6.0) * (alpha * alpha * alpha)) + ((1.0 / 120.0) * (alpha * alpha * alpha * alpha * alpha)) - ((1.0 / 5040.0) * (alpha * alpha * alpha * alpha * alpha * alpha * alpha));
cosinus = 1.0 - (((1.0 / 2.0) * (alpha * alpha)) - ((1.0 / 24.0) * (alpha * alpha * alpha * alpha)) + ((1.0 / 720.0) * (alpha * alpha * alpha * alpha * alpha * alpha)) - ((1.0 / 40320.0) * (alpha * alpha * alpha * alpha * alpha * alpha * alpha * alpha)));

J'obtiens maintenant toujours avec une précision de 0.0001:

sin = 176 µs
cos = 200 µs
tan = 326 µs

arcsin = 5268 µs
arccos = 5930 µs
arctan = 6128 µs

Voila le détail des fonctions:

float Core::sin (const float ANGLE)
{
	float angle = 0;
	float alpha = 0;
	unsigned long n = 0;
	float sinus = 0;
	bool quickSearch = false;
	unsigned long foundMultiply = 0;
	
	if (ANGLE >= -180 && ANGLE <= 180)
	{
		angle = ANGLE;
		alpha = ANGLE / (180.0 / _PI);
	}
	else if (ANGLE < -180)
	{
		while (quickSearch == false)
		{
			for (n = 1; ANGLE + (360 * (foundMultiply + n)) < -180; n *= 10)
			{
			}
			
			if (n == 1)
			{
				quickSearch = true;
			}
			else
			{
				foundMultiply += float (n) / 10.0;
			}
		}
		
		foundMultiply += 1;
		
		angle = ANGLE + (360 * foundMultiply);
		alpha = (ANGLE + (360 * foundMultiply)) / (180.0 / _PI);
	}
	else
	{
		while (quickSearch == false)
		{
			for (n = 1; ANGLE - (360 * (foundMultiply + n)) > 180; n *= 10)
			{
			}
			
			if (n == 1)
			{
				quickSearch = true;
			}
			else
			{
				foundMultiply += float (n) / 10.0;
			}
		}
		
		foundMultiply += 1;
		
		angle = ANGLE - (360 * foundMultiply);
		alpha = (ANGLE - (360 * foundMultiply)) / (180.0 / _PI);
	}
	
	if (angle == -90 || angle == 270)
	{
		sinus = -1;
	}
	else if (angle == -270 || angle == 90)
	{
		sinus = 1;
	}
	else if (angle != -360 && angle != -180 && angle != 0 && angle != 180 && angle != 360)
	{
		sinus = alpha - ((1.0 / 6.0) * (alpha * alpha * alpha)) + ((1.0 / 120.0) * (alpha * alpha * alpha * alpha * alpha)) - ((1.0 / 5040.0) * (alpha * alpha * alpha * alpha * alpha * alpha * alpha));
	}
	
	return sinus;
}

float Core::cos (const float ANGLE)
{
	float angle = 0;
	float alpha = 0;
	unsigned long n = 0;
	float cosinus = 0;
	bool quickSearch = false;
	unsigned long foundMultiply = 0;
	
	if (ANGLE >= -180 && ANGLE <= 180)
	{
		angle = ANGLE;
		alpha = ANGLE / (180.0 / _PI);
	}
	else if (ANGLE < -180)
	{
		while (quickSearch == false)
		{
			for (n = 1; ANGLE + (360 * (foundMultiply + n)) < -180; n *= 10)
			{
			}
			
			if (n == 1)
			{
				quickSearch = true;
			}
			else
			{
				foundMultiply += float (n) / 10.0;
			}
		}
		
		foundMultiply += 1;
		
		angle = ANGLE + (360 * foundMultiply);
		alpha = (ANGLE + (360 * foundMultiply)) / (180.0 / _PI);
	}
	else
	{
		while (quickSearch == false)
		{
			for (n = 1; ANGLE - (360 * (foundMultiply + n)) > 180; n *= 10)
			{
			}
			
			if (n == 1)
			{
				quickSearch = true;
			}
			else
			{
				foundMultiply += float (n) / 10.0;
			}
		}
		
		foundMultiply += 1;
		
		angle = ANGLE - (360 * foundMultiply);
		alpha = (ANGLE - (360 * foundMultiply)) / (180.0 / _PI);
	}
	
	if (angle == -180 || angle == 180)
	{
		cosinus = -1;
	}
	else if (angle == -360 || angle == 0 || angle == 360)
	{
		cosinus = 1;
	}
	else if (angle != -270 && angle != -90 && angle != 90 && angle != 270)
	{
		cosinus = 1.0 - (((1.0 / 2.0) * (alpha * alpha)) - ((1.0 / 24.0) * (alpha * alpha * alpha * alpha)) + ((1.0 / 720.0) * (alpha * alpha * alpha * alpha * alpha * alpha)) - ((1.0 / 40320.0) * (alpha * alpha * alpha * alpha * alpha * alpha * alpha * alpha)));
	}
	
	return cosinus;
}

float Core::tan (const float ANGLE)
{
	float angle = 0;
	float alpha = 0;
	unsigned long n = 0;
	float sinus = 0;
	float cosinus = 0;
	bool quickSearch = false;
	unsigned long foundMultiply = 0;
	
	if (ANGLE >= -180 && ANGLE <= 180)
	{
		angle = ANGLE;
		alpha = ANGLE / (180.0 / _PI);
	}
	else if (ANGLE < -180)
	{
		while (quickSearch == false)
		{
			for (n = 1; ANGLE + (360 * (foundMultiply + n)) < -180; n *= 10)
			{
			}
			
			if (n == 1)
			{
				quickSearch = true;
			}
			else
			{
				foundMultiply += float (n) / 10.0;
			}
		}
		
		foundMultiply += 1;
		
		angle = ANGLE + (360 * foundMultiply);
		alpha = (ANGLE + (360 * foundMultiply)) / (180.0 / _PI);
	}
	else
	{
		while (quickSearch == false)
		{
			for (n = 1; ANGLE - (360 * (foundMultiply + n)) > 180; n *= 10)
			{
			}
			
			if (n == 1)
			{
				quickSearch = true;
			}
			else
			{
				foundMultiply += float (n) / 10.0;
			}
		}
		
		foundMultiply += 1;
		
		angle = ANGLE - (360 * foundMultiply);
		alpha = (ANGLE - (360 * foundMultiply)) / (180.0 / _PI);
	}
	
	if (angle == -90 || angle == 270)
	{
		sinus = -1;
	}
	else if (angle == -270 || angle == 90)
	{
		sinus = 1;
	}
	else if (angle != -360 && angle != -180 && angle != 0 && angle != 180 && angle != 360)
	{
		sinus = alpha - ((1.0 / 6.0) * (alpha * alpha * alpha)) + ((1.0 / 120.0) * (alpha * alpha * alpha * alpha * alpha)) - ((1.0 / 5040.0) * (alpha * alpha * alpha * alpha * alpha * alpha * alpha));
	}
	
	if (angle == -180 || angle == 180)
	{
		cosinus = -1;
	}
	else if (angle == -360 || angle == 0 || angle == 360)
	{
		cosinus = 1;
	}
	else if (angle != -270 && angle != -90 && angle != 90 && angle != 270)
	{
		cosinus = 1.0 - (((1.0 / 2.0) * (alpha * alpha)) - ((1.0 / 24.0) * (alpha * alpha * alpha * alpha)) + ((1.0 / 720.0) * (alpha * alpha * alpha * alpha * alpha * alpha)) - ((1.0 / 40320.0) * (alpha * alpha * alpha * alpha * alpha * alpha * alpha * alpha)));
	}
	
	return sinus / cosinus;
}

float Core::arcsin (const float SINUS)
{
	float angle = 10;
	float anglePrevious = 0;
	float increment = 10;
	float alpha = 0;
	float sinus = 0;
	float sinusPositive = 0;
	bool quickSearch = false;
	unsigned char decimal = 0;
	unsigned char error = 0;
	
	if (SINUS < 0)
	{
		sinusPositive = SINUS * -1;
	}
	else
	{
		sinusPositive = SINUS;
	}
	
	if (SINUS <= -1)
	{
		angle = -90;
	}
	else if (SINUS == 0)
	{
		angle = 0;
	}
	else if (SINUS >= 1)
	{
		angle = 90;
	}
	else
	{
		while (quickSearch == false)
		{
			alpha = angle / (180.0 / _PI);
			sinus = alpha - ((1.0 / 6.0) * (alpha * alpha * alpha)) + ((1.0 / 120.0) * (alpha * alpha * alpha * alpha * alpha)) - ((1.0 / 5040.0) * (alpha * alpha * alpha * alpha * alpha * alpha * alpha));
			
			if (sinus < sinusPositive && increment >= 1)
			{
				anglePrevious = angle;
				angle += increment;
			}
			else if (sinus < sinusPositive && increment < 1 && error < 9)
			{
				anglePrevious = angle;
				angle += increment;
				
				error++;
			}
			else if (sinus == sinusPositive || decimal == 4 + 1)
			{
				quickSearch = true;
			}
			else
			{
				increment /= 10.0;
				angle = anglePrevious + increment;
				
				decimal++;
				error = 0;
			}
			
			if (angle > 90.0001)
			{
				angle = 89.9999;
				quickSearch = true;
			}
		}
		
		if (SINUS < 0)
		{
			angle *= -1;
		}
	}
	
	return angle;
}

float Core::arccos (const float COSINUS)
{
	float angle = 0;
	float anglePrevious = 10;
	float increment = 10;
	float alpha = 0;
	float cosinus = 0;
	float cosinusPositive = 0;
	bool quickSearch = false;
	unsigned char decimal = 0;
	unsigned char error = 0;
	
	if (COSINUS < 0)
	{
		cosinusPositive = COSINUS * -1;
	}
	else
	{
		cosinusPositive = COSINUS;
	}
	
	if (COSINUS <= -1)
	{
		angle = 180;
	}
	else if (COSINUS == 0)
	{
		angle = 90;
	}
	else if (COSINUS >= 1)
	{
		angle = 0;
	}
	else
	{
		while (quickSearch == false)
		{
			alpha = angle / (180.0 / _PI);
			cosinus = 1.0 - (((1.0 / 2.0) * (alpha * alpha)) - ((1.0 / 24.0) * (alpha * alpha * alpha * alpha)) + ((1.0 / 720.0) * (alpha * alpha * alpha * alpha * alpha * alpha)) - ((1.0 / 40320.0) * (alpha * alpha * alpha * alpha * alpha * alpha * alpha * alpha)));
			
			if (cosinus > cosinusPositive && increment >= 1)
			{
				anglePrevious = angle;
				angle += increment;
			}
			else if (cosinus > cosinusPositive && increment < 1 && error < 9)
			{
				anglePrevious = angle;
				angle += increment;
				
				error++;
			}
			else if (cosinus == cosinusPositive || decimal == 4 + 1)
			{
				quickSearch = true;
			}
			else
			{
				increment /= 10.0;
				angle = anglePrevious + increment;
				
				decimal++;
				error = 0;
			}
			
			if (angle > 90.0001)
			{
				angle = 89.9999;
				quickSearch = true;
			}
		}
		
		if (COSINUS < 0)
		{
			angle = 180 - angle;
		}
	}
	
	return angle;
}

float Core::arctan (const float TANGENT)
{
	float angle = 10;
	float anglePrevious = 0;
	float increment = 10;
	float alpha = 0;
	float sinus = 0;
	float cosinus = 0;
	float tangent = 0;
	float tangentPositive = 0;
	bool quickSearch = false;
	unsigned char decimal = 0;
	unsigned char error = 0;
	
	if (TANGENT < 0)
	{
		tangentPositive = TANGENT * -1;
	}
	else
	{
		tangentPositive = TANGENT;
	}
	
	if (TANGENT <= -9999999999999999)
	{
		angle = -90;
	}
	else if (TANGENT == -1)
	{
		angle = -45;
	}
	else if (TANGENT == 0)
	{
		angle = 0;
	}
	else if (TANGENT == 1)
	{
		angle = 45;
	}
	else if (TANGENT >= 9999999999999999)
	{
		angle = 90;
	}
	else
	{
		while (quickSearch == false)
		{
			alpha = angle / (180.0 / _PI);
			sinus = alpha - ((1.0 / 6.0) * (alpha * alpha * alpha)) + ((1.0 / 120.0) * (alpha * alpha * alpha * alpha * alpha)) - ((1.0 / 5040.0) * (alpha * alpha * alpha * alpha * alpha * alpha * alpha));
			cosinus = 1.0 - (((1.0 / 2.0) * (alpha * alpha)) - ((1.0 / 24.0) * (alpha * alpha * alpha * alpha)) + ((1.0 / 720.0) * (alpha * alpha * alpha * alpha * alpha * alpha)) - ((1.0 / 40320.0) * (alpha * alpha * alpha * alpha * alpha * alpha * alpha * alpha)));
			tangent = sinus / cosinus;
			
			if (tangent < tangentPositive && increment >= 1)
			{
				anglePrevious = angle;
				angle += increment;
			}
			else if (tangent < tangentPositive && increment < 1 && error < 9)
			{
				anglePrevious = angle;
				angle += increment;
				
				error++;
			}
			else if (tangent == tangentPositive || decimal == 4 + 1)
			{
				quickSearch = true;
			}
			else
			{
				increment /= 10.0;
				angle = anglePrevious + increment;
				
				decimal++;
				error = 0;
			}
			
			if (angle > 90.0001)
			{
				angle = 89.9999;
				quickSearch = true;
			}
		}
		
		if (TANGENT < 0)
		{
			angle *= -1;
		}
	}
	
	return angle;
}

N'hésitez pas à montrer vos fonctions notamment avec algorithme de cordic.