L'approximation de fonctions trigonométriques

- Je mettre en place asin, acos et atan dans l'environnement où j'ai seulement à la suite d'math tools:

sine
cosinus
élémentaires point fixe de l'arithmétique (nombres à virgule flottante ne sont pas disponibles)

J'ai aussi déjà avoir raisonnablement bonne fonction racine carrée.

Puis-je utiliser celles à mettre en œuvre raisonnablement efficace des fonctions trigonométriques inverses?

Je n'ai pas besoin de trop grand de précision (les nombres en virgule flottante ont très peu de précision, de toute façon), de base rapprochement va faire.

Je suis déjà à moitié décidé d'aller avec la lecture de la table, mais je voudrais savoir s'il est plus propre de l'option (qui n'a pas besoin de plusieurs centaines de lignes de code pour mettre en œuvre les mathématiques de base).

EDIT:

Pour éclaircir les choses: j'ai besoin d'exécuter la fonction centaines de fois par trame à 35 images par seconde.

double possible de Comment puis-fonctions Trigonométriques travail?
Le projet en double est plus sur la façon dont les fonctions trigonométriques de travail (comme c'est le titre). C'est sur les fonctions trigonométriques.

OriginalL'auteur Matěj Zábský | 2011-09-11

2

Avez-vous besoin d'une grande précision pour arcsin(x) fonction? Si non, vous pouvez calculer arcsin à N nœuds, et de garder les valeurs en mémoire. Je suggère d'utiliser la ligne de aproximation. si x = A*x_(N) + (1-A)*x_(N+1) puis x = A*arcsin(x_(N)) + (1-A)*arcsin(x_(N+1)) où arcsin(x_(N)) est connu.

Ouais, c'est la lecture de la table dont je parlais dans l'OP. ne vois pas de raison pourquoi j'ai calculé qu'au moment de l'exécution, je simoly cuire les valeurs dans le programme, de sorte que le réel asin calcul serait juste être une interpolation entre deux valeurs.

OriginalL'auteur Eugeny89
8

En un point fixe de l'environnement (S15.16) j'ai utilisé avec succès l'algorithme CORDIC (voir Wikipedia pour une description générale) pour calculer atan2(y,x), dérivée asin() et acos() de l'utilisation bien connue fonctionnelle des identités qui impliquent la racine carrée:
```
asin(x) = atan2 (x, sqrt ((1.0 + x) * (1.0 - x)))
acos(x) = atan2 (sqrt ((1.0 + x) * (1.0 - x)), x)
```
Il s'avère que le fait de trouver une description utile du CORDIC itération pour atan2() sur le double est plus difficile que je pensais. Le site web suivant semble contenir une description suffisamment détaillée, et traite également de deux autres approches, approximation polynomiale et de tables de recherche:

http://ch.mathworks.com/examples/matlab-fixed-point-designer/615-calculate-fixed-point-arctangent

À partir de wikipedia, CORDIC n'a même pas utiliser les fonctions trigonométriques (chouette!); J'imagine que vous n'avez fait une recherche; sin(), cos (), il semble Newton-Raphson ou quelque chose comme ça serait mieux? (Besoin de moins d'itérations, bien que le coût de la itérations serait différent.)
La raison pour laquelle je suggère à la recherche dans CORDIC est parce qu'il n'exige point fixe de l'arithmétique. L'utilisation la plus courante de CORDIC est probablement pour la mise en œuvre de sin / cos, qui est de savoir comment j'ai appris à ce sujet (en 1987). Mais un certain nombre d'autres fonctions peuvent être calculées avec CORDIC, comme atan2. Depuis je n'ai pas de code qui traînent pour le calcul de la atan2 avec CORDIC j'ai essayé de trouver un site avec suffisamment de détails pour que quelqu'un pourrait la base d'une mise en œuvre sur elle. Le lien que j'ai posté ci-dessus a été le meilleur de la page que j'ai pu trouver via un moteur de recherche dans l'espace de quelques minutes.

OriginalL'auteur njuffa
2

vous pouvez utiliser l'approximation: utiliser un série infinie jusqu'à ce que la solution est assez proche pour vous.

par exemple:

arcsin(z) = Sigma((2n!)/((2^2n)*(n!)^2)*((z^(2n+1))/(2n+1))) où n dans [0,infinity)

OriginalL'auteur amit
1

Peut-être une sorte de intelligent de la force brute comme newton rapson.

Donc, pour résoudre asin() vous y allez avec la plus raide descente sur le péché()

et vous pouvez choisir le point de départ d'une petite liste de choix-table pour accélérer le calcul.

OriginalL'auteur aero
1

http://en.wikipedia.org/wiki/Inverse_trigonometric_functions#Expression_as_definite_integrals

Vous pourriez faire de l'intégration numérique avec votre fonction racine carrée, le rapprochement avec une série infinie:

+1 - Belle utilisation de LaTeX.
Je viens de copier les images de wikipédia.

OriginalL'auteur nulvinge

Il devrait être facile à addapt le code suivant à point fixe. Il emploie un approximation rationnelle pour calculer l'arctangente normalisée à l' [0 1) intervalle (vous pouvez multiplier par Pi/2 pour obtenir le réel de l'arctangente). Ensuite, vous pouvez utiliser bien connu des identités pour obtenir le arcsin/arccos de l'arctangente.

normalized_atan(x) ~ (b x + x^2) /(1 + 2 b x + x^2)

where b = 0.596227

L'erreur maximale est 0.1620 º

#include <stdint.h>
#include <math.h>

//Approximates atan(x) normalized to the [-1,1] range
//with a maximum error of 0.1620 degrees.

float norm_atan( float x )
{
    static const uint32_t sign_mask = 0x80000000;
    static const float b = 0.596227f;

    //Extract the sign bit
    uint32_t ux_s  = sign_mask & (uint32_t &)x;

    //Calculate the arctangent in the first quadrant
    float bx_a = ::fabs( b * x );
    float num = bx_a + x * x;
    float atan_1q = num /( 1.f + bx_a + num );

    //Restore the sign bit
    uint32_t atan_2q = ux_s | (uint32_t &)atan_1q;
    return (float &)atan_2q;
}

//Approximates atan2(y, x) normalized to the [0,4) range
//with a maximum error of 0.1620 degrees

float norm_atan2( float y, float x )
{
    static const uint32_t sign_mask = 0x80000000;
    static const float b = 0.596227f;

    //Extract the sign bits
    uint32_t ux_s  = sign_mask & (uint32_t &)x;
    uint32_t uy_s  = sign_mask & (uint32_t &)y;

    //Determine the quadrant offset
    float q = (float)( ( ~ux_s & uy_s ) >> 29 | ux_s >> 30 ); 

    //Calculate the arctangent in the first quadrant
    float bxy_a = ::fabs( b * x * y );
    float num = bxy_a + y * y;
    float atan_1q =  num /( x * x + bxy_a + num );

    //Translate it to the proper quadrant
    uint32_t uatan_2q = (ux_s ^ uy_s) | (uint32_t &)atan_1q;
    return q + (float &)uatan_2q;
}

Dans le cas où vous avez besoin de plus de précision, il y a un 3ème ordre fonction rationnelle:

normalized_atan(x) ~ ( c x + x^2 + x^3) /( 1 + (c + 1) x + (c + 1) x^2 + x^3)

where c = (1 + sqrt(17)) /8

qui a un maximum de l'erreur d'approximation de 0.00811 º

OriginalL'auteur rcor

1

Soumettre ici ma réponse à partir de ce autre question similaire.

nVidia a quelques grandes ressources que j'ai utilisé pour mon propre usage, quelques exemples: acos asin atan2 etc etc...

Ces algorithmes produisent assez précise des résultats. Voici un tout droit jusqu'exemple Python avec leur code à copier coller:
```
import math
def nVidia_acos(x):
    negate = float(x<0)
    x=abs(x)
    ret = -0.0187293
    ret = ret * x
    ret = ret + 0.0742610
    ret = ret * x
    ret = ret - 0.2121144
    ret = ret * x
    ret = ret + 1.5707288
    ret = ret * math.sqrt(1.0-x)
    ret = ret - 2 * negate * ret
    return negate * 3.14159265358979 + ret
```
Et voici les résultats pour la comparaison:
```
nVidia_acos(0.5)  result: 1.0471513828611643
math.acos(0.5)    result: 1.0471975511965976
```
C'est à peu près! Multiplier par 57.29577951 pour obtenir des résultats en degrés, ce qui est également de leur "degrés" de la formule.

OriginalL'auteur Fnord
0

Utiliser une approximation polynomiale. La méthode des moindres carrés en forme est plus facile (Microsoft Excel) et de l'approximation de Chebyshev est plus précis.

Cette question a été abordée avant: Comment puis-fonctions Trigonométriques travail?

OriginalL'auteur Jason S
-1

Seulement continue, les fonctions sont approximable par des polynômes. Et arcsin(x) est discontinu au point x=1.même arccos(x).Mais une réduction de l'intervalle 1,sqrt(1/2), dans ce cas, d'éviter cette situation. Nous avons arcsin(x)=pi/2 - arccos(x),arccos(x)=pi/2-arcsin(x).vous pouvez utiliser matlab pour minimax approximation.Approximatif seulement dans l'intervalle [0,sqrt(1/2)](si l'angle pour que arcsin est demande est plus grande que sqrt(1/2) trouver cos(x).la fonction arctangente que pour x<1.arctan(x)=pi/2-arctan(1/x).

OriginalL'auteur florin

Vous devez vous connecter pour publier un commentaire.