In che modo C calcola sin () e altre funzioni matematiche?

Ho analizzato i disassemblaggi .NET e il codice sorgente GCC, ma non riesco a trovare da nessuna parte l'implementazione effettiva di sin()e altre funzioni matematiche ... sembrano sempre fare riferimento a qualcos'altro.

Qualcuno può aiutarmi a trovarli? Sento che è improbabile che TUTTO l'hardware su cui C funzionerà supporti le funzioni di trigger nell'hardware, quindi ci deve essere un algoritmo software da qualche parte , giusto?

Sono a conoscenza di diversi modi in cui le funzioni possono essere calcolate e ho scritto le mie routine per calcolare le funzioni usando le serie di Taylor per divertimento. Sono curioso di sapere quanto siano reali i linguaggi di produzione, dal momento che tutte le mie implementazioni sono sempre più lente di diversi ordini di grandezza, anche se penso che i miei algoritmi siano piuttosto intelligenti (ovviamente non lo sono).

In GNU libm, l'implementazione di sindipende dal sistema. Pertanto è possibile trovare l'implementazione, per ciascuna piattaforma, da qualche parte nella sottodirectory appropriata di sysdeps .

Una directory include un'implementazione in C, fornita da IBM. Da ottobre 2011, questo è il codice che viene effettivamente eseguito quando si chiama sin()un tipico sistema Linux x86-64. Apparentemente è più veloce delle fsinistruzioni di montaggio. Codice sorgente: sysdeps / ieee754 / dbl-64 / s_sin.c , cercare __sin (double x).

Questo codice è molto complesso. Nessun algoritmo software è il più veloce possibile e preciso su tutta la gamma di valori x , quindi la libreria implementa diversi algoritmi diversi e il suo primo compito è guardare x e decidere quale algoritmo usare.

• Quando x è molto molto vicino a 0, sin(x) == xè la risposta giusta.

• Un po 'più in là, sin(x)usa la familiare serie Taylor. Tuttavia, questo è accurato solo vicino a 0, quindi ...

• Quando l'angolo è superiore a circa 7 °, viene utilizzato un algoritmo diverso, che calcola le approssimazioni della serie Taylor sia per sin (x) che per cos (x), quindi utilizza i valori di una tabella pre-calcolata per perfezionare l'approssimazione.

• Quando | x | > 2, nessuno degli algoritmi sopra funzionerebbe, quindi il codice inizia calcolando un valore più vicino a 0 che può essere alimentato sino cosinvece.

• C'è ancora un altro ramo da affrontare con x essere una NaN o infinito.

Questo codice utilizza alcuni hack numerici che non ho mai visto prima, anche se per quello che ne so potrebbero essere ben noti tra gli esperti in virgola mobile. A volte alcune righe di codice richiederebbero diversi paragrafi per spiegare. Ad esempio, queste due linee

double t = (x * hpinv + toint);
double xn = t - toint;

sono usati (a volte) nel ridurre x ad un valore vicino a 0 che differisce da x da un multiplo di π / 2, in particolare xn× π / 2. Il modo in cui questo viene fatto senza divisione o ramificazione è piuttosto intelligente. Ma non ci sono commenti!

Le versioni precedenti a 32 bit di GCC / glibc utilizzavano l' fsinistruzione, che è sorprendentemente inaccurata per alcuni ingressi. C'è un affascinante post sul blog che illustra questo con solo 2 righe di codice .

L'implementazione di fdlibm sinin C puro è molto più semplice di quella di glibc ed è ben commentata. Codice sorgente: fdlibm / s_sin.c e fdlibm / k_sin.c

Funzioni come seno e coseno sono implementate nel microcodice all'interno dei microprocessori. I chip Intel, ad esempio, hanno istruzioni di assemblaggio per questi. Il compilatore CA genererà il codice che chiama queste istruzioni di assemblaggio. (Al contrario, un compilatore Java non lo farà. Java valuta le funzioni di trigger nel software piuttosto che nell'hardware, e quindi funziona molto più lentamente.)

Patatine fritte non usano la serie Taylor per calcolare le funzioni di trigger, almeno non del tutto. Prima di tutto usano CORDIC , ma possono anche usare una breve serie di Taylor per perfezionare il risultato di CORDIC o per casi speciali come il seno sinusoidale con elevata precisione relativa per angoli molto piccoli. Per ulteriori spiegazioni, vedere questa risposta StackOverflow .

OK bambini, tempo per i professionisti ... Questa è una delle mie più grandi lamentele con ingegneri del software inesperti. Arrivano nel calcolo da zero delle funzioni trascendentali (usando la serie di Taylor) come se nessuno avesse mai fatto questi calcoli prima nella loro vita. Non vero. Questo è un problema ben definito ed è stato affrontato migliaia di volte da ingegneri software e hardware molto intelligenti e ha una soluzione ben definita. Fondamentalmente, la maggior parte delle funzioni trascendentali usa i polinomi di Chebyshev per calcolarli. Quanto a che polinomi sono usati dipende dalle circostanze. In primo luogo, la Bibbia su questo argomento è un libro intitolato "Computer Approximations" di Hart e Cheney. In quel libro, puoi decidere se hai un sommatore hardware, un moltiplicatore, un divisore, ecc. E decidere quali operazioni sono più veloci. ad es. se avessi un divisore molto veloce, il modo più veloce per calcolare il seno potrebbe essere P1 (x) / P2 (x) dove P1, P2 sono polinomi di Chebyshev. Senza il divisore veloce, potrebbe essere solo P (x), dove P ha molti più termini di P1 o P2 .... quindi sarebbe più lento. Quindi, il primo passo è determinare il tuo hardware e cosa può fare. Quindi si sceglie la combinazione appropriata di polinomi di Chebyshev (di solito è della forma cos (ax) = aP (x) per il coseno, ad esempio, sempre dove P è un polinomio di Chebyshev). Quindi decidi quale precisione decimale desideri. ad es. se si desidera una precisione di 7 cifre, la si cerca nella tabella appropriata nel libro che ho citato e vi darà (per precisione = 7,33) un numero N = 4 e un numero polinomiale 3502. N è l'ordine del polinomiale (quindi è p4.x ^ 4 + p3.x ^ 3 + p2.x ^ 2 + p1.x + p0), perché N = 4. Quindi si cerca il valore effettivo di p4, p3, p2, p1, valori di p0 nella parte posteriore del libro sotto 3502 (saranno in virgola mobile). Quindi implementate il vostro algoritmo nel software nel formato: (((p4.x + p3) .x + p2) .x + p1) .x + p0 .... ed è così che calcolereste il coseno al 7 decimale posti su quell'hardware.

Si noti che la maggior parte delle implementazioni hardware delle operazioni trascendentali in una FPU di solito comporta alcuni microcodici e operazioni come questa (dipende dall'hardware). I polinomi di Chebyshev sono usati per la maggior parte dei trascendentali ma non per tutti. ad esempio, Square root è più veloce nell'usare una doppia iterazione del metodo Newton raphson usando prima una tabella di ricerca. Ancora una volta, quel libro "Computer Approximations" te lo dirà.

Se hai intenzione di implorare queste funzioni, consiglierei a chiunque di ottenere una copia di quel libro. È davvero la bibbia per questo tipo di algoritmi. Nota che ci sono un sacco di mezzi alternativi per calcolare questi valori come cordics, ecc., Ma questi tendono ad essere i migliori per algoritmi specifici in cui hai solo bisogno di bassa precisione. Per garantire sempre la precisione, i polinomi chebyshev sono la strada da percorrere. Come ho detto, problema ben definito. È stato risolto per 50 anni ormai ..... ed è così che è stato fatto.

Ora, detto questo, ci sono tecniche in base alle quali i polinomi di Chebyshev possono essere usati per ottenere un singolo risultato di precisione con un polinomio di basso grado (come nell'esempio sopra per il coseno). Quindi, ci sono altre tecniche per interpolare tra i valori per aumentare la precisione senza dover passare a un polinomio molto più ampio, come "Gal's Accurate Tables Method". Quest'ultima tecnica è a cui si riferisce il post riferito alla letteratura ACM. Ma alla fine, i polinomi di Chebyshev sono quelli che vengono utilizzati per ottenere il 90% del percorso.

Godere.

In sinparticolare, l'utilizzo dell'espansione Taylor ti darebbe:

sin (x): = x - x ^ 3/3! + x ^ 5/5! - x ^ 7/7! + ... (1)

continueresti ad aggiungere termini finché la differenza tra loro non è inferiore a un livello di tolleranza accettato o solo per un numero finito di passaggi (più veloce, ma meno preciso). Un esempio potrebbe essere qualcosa del tipo:

float sin(float x)
{
  float res=0, pow=x, fact=1;
  for(int i=0; i<5; ++i)
  {
    res+=pow/fact;
    pow*=-1*x*x;
    fact*=(2*(i+1))*(2*(i+1)+1);
  }

  return res;
}

Nota: (1) funziona a causa dell'aproximation sin (x) = x per angoli piccoli. Per angoli più grandi è necessario calcolare sempre più termini per ottenere risultati accettabili. Puoi usare un argomento while e continuare con una certa precisione:

double sin (double x){
    int i = 1;
    double cur = x;
    double acc = 1;
    double fact= 1;
    double pow = x;
    while (fabs(acc) > .00000001 &&   i < 100){
        fact *= ((2*i)*(2*i+1));
        pow *= -1 * x*x; 
        acc =  pow / fact;
        cur += acc;
        i++;
    }
    return cur;

}

Sì, ci sono anche algoritmi software per il calcolo sin. Fondamentalmente, il calcolo di questo tipo di cose con un computer digitale viene solitamente fatto usando metodi numerici come l'approssimazione della serie di Taylor che rappresenta la funzione.

I metodi numerici possono approssimare le funzioni a una quantità arbitraria di precisione e poiché la quantità di precisione che hai in un numero fluttuante è limitata, si adattano abbastanza bene a questi compiti.

Usa la serie Taylor e cerca di trovare una relazione tra i termini della serie in modo da non calcolare più e più volte le cose

Ecco un esempio di coseno:

double cosinus(double x, double prec)
{
    double t, s ;
    int p;
    p = 0;
    s = 1.0;
    t = 1.0;
    while(fabs(t/s) > prec)
    {
        p++;
        t = (-t * x * x) / ((2 * p - 1) * (2 * p));
        s += t;
    }
    return s;
}

usando questo possiamo ottenere il nuovo termine della somma usando quello già usato (evitiamo il fattoriale e x ^2p )

È una domanda complessa. La CPU simile a Intel della famiglia x86 ha un'implementazione hardware della sin()funzione, ma fa parte della FPU x87 e non viene più utilizzata in modalità 64-bit (dove invece vengono utilizzati i registri SSE2). In quella modalità, viene utilizzata un'implementazione software.

Esistono diverse implementazioni di questo tipo. Uno è in fdlibm ed è usato in Java. Per quanto ne so, l'implementazione di glibc contiene parti di fdlibm e altre parti fornite da IBM.

Le implementazioni software di funzioni trascendentali come sin()tipicamente usano approssimazioni da polinomi, spesso ottenute dalla serie di Taylor.

I polinomi di Chebyshev, come menzionato in un'altra risposta, sono i polinomi in cui la più grande differenza tra la funzione e il polinomio è il più piccola possibile. È un inizio eccellente.

In alcuni casi, l'errore massimo non è quello che ti interessa, ma l'errore relativo massimo. Ad esempio per la funzione seno, l'errore vicino a x = 0 dovrebbe essere molto più piccolo che per valori più grandi; vuoi un piccolo errore relativo . Quindi calcoleresti il ​​polinomio di Chebyshev per sin x / x e moltiplicheresti quel polinomio per x.

Successivamente devi capire come valutare il polinomio. Si desidera valutarlo in modo tale che i valori intermedi siano piccoli e quindi gli errori di arrotondamento siano piccoli. Altrimenti gli errori di arrotondamento potrebbero diventare molto più grandi degli errori nel polinomio. E con funzioni come la funzione seno, se sei incurante, potrebbe essere possibile che il risultato che calcoli per sin x sia maggiore del risultato per sin y anche quando x <y. Sono quindi necessarie un'attenta scelta dell'ordine di calcolo e il calcolo dei limiti superiori per l'errore di arrotondamento.

Ad esempio, sin x = x - x ^ 3/6 + x ^ 5/120 - x ^ 7/5040 ... Se si calcola in modo ingenuo sin x = x * (1 - x ^ 2/6 + x ^ 4 / 120 - x ^ 6/5040 ...), allora tale funzione in parentesi sta diminuendo, e si accadere che se y è il numero più grande successiva alla x, poi a volte sin y saranno più piccole di quelle sin x. Invece, calcola sin x = x - x ^ 3 * (1/6 - x ^ 2/120 + x ^ 4/5040 ...) dove ciò non può accadere.

Quando si calcolano i polinomi di Chebyshev, di solito è necessario arrotondare i coefficienti per raddoppiare la precisione, ad esempio. Ma mentre un polinomio di Chebyshev è ottimale, il polinomio di Chebyshev con coefficienti arrotondati alla doppia precisione non è il polinomio ottimale con coefficienti di doppia precisione!

Ad esempio per sin (x), dove hai bisogno di coefficienti per x, x ^ 3, x ^ 5, x ^ 7 ecc., Fai quanto segue: Calcola la migliore approssimazione di sin x con un polinomio (ax + bx ^ 3 + cx ^ 5 + dx ^ 7) con precisione superiore alla doppia, quindi arrotondare a per raddoppiare la precisione, dando A. La differenza tra a e A sarebbe piuttosto grande. Ora calcola la migliore approssimazione di (sin x - Ax) con un polinomio (bx ^ 3 + cx ^ 5 + dx ^ 7). Ottieni coefficienti diversi, perché si adattano alla differenza tra a e A. Round b per doppia precisione B. Quindi approssimativo (sin x - Ax - Bx ^ 3) con un polinomio cx ^ 5 + dx ^ 7 e così via. Otterrai un polinomio che è quasi buono come il polinomio originale di Chebyshev, ma molto meglio di Chebyshev arrotondato alla doppia precisione.

Successivamente dovresti tenere conto degli errori di arrotondamento nella scelta del polinomio. Hai trovato un polinomio con un errore minimo nel polinomio che ignora l'errore di arrotondamento, ma desideri ottimizzare il polinomio più l'errore di arrotondamento. Una volta che hai il polinomio di Chebyshev, puoi calcolare i limiti per l'errore di arrotondamento. Dì che f (x) è la tua funzione, P (x) è il polinomio ed E (x) è l'errore di arrotondamento. Non vuoi ottimizzare | f (x) - P (x) |, si desidera ottimizzare | f (x) - P (x) +/- E (x) |. Otterrai un polinomio leggermente diverso che cerca di mantenere gli errori polinomiali in basso quando l'errore di arrotondamento è grande e rilassa gli errori polinomiali un po 'dove l'errore di arrotondamento è piccolo.

Tutto ciò ti consentirà di arrotondare facilmente gli errori al massimo 0,55 volte l'ultimo bit, dove +, -, *, / avranno errori di arrotondamento al massimo 0,50 volte l'ultimo bit.

Per quanto riguarda la funzione trigonometrica come sin(), dopo 5 anni cos(), tan()non è stato fatto menzione di un aspetto importante delle funzioni trig di alta qualità: riduzione della portata .

Un primo passo in una di queste funzioni è ridurre l'angolo, in radianti, ad un intervallo di un intervallo di 2 * π. Ma π è irrazionale, quindi riduzioni semplici come x = remainder(x, 2*M_PI)introdurre l'errore come M_PI, o machine pi, è un'approssimazione di π. Quindi, come si fa x = remainder(x, 2*π)?

Le prime biblioteche utilizzavano una precisione estesa o una programmazione artigianale per fornire risultati di qualità, ma comunque entro un intervallo limitato di double. Quando è stato richiesto un valore elevato sin(pow(2,30)), i risultati erano insignificanti o0.0 forse, con un flag di errore impostato su qualcosa come TLOSSperdita totale di precisione o PLOSSperdita parziale di precisione.

Una buona riduzione della gamma di valori di grandi dimensioni a un intervallo da -π a π è un problema impegnativo che rivaleggia con le sfide della funzione di trig base di base, come la sin()stessa.

Un buon rapporto è la riduzione degli Argomenti per grandi argomenti: buono fino all'ultimo bit (1992). Copre bene il problema: discute la necessità e come erano le cose su varie piattaforme (SPARC, PC, HP, 30+ altri) e fornisce un algoritmo di soluzione che fornisce risultati di qualità per tutti double da-DBL_MAX a DBL_MAX.

Se gli argomenti originali sono in gradi, ma possono avere un valore elevato, utilizzare fmod()prima per una maggiore precisione. Un buono fmod()non introdurrà alcun errore e quindi fornirà un'eccellente riduzione della portata.

// sin(degrees2radians(x))
sin(degrees2radians(fmod(x, 360.0))); // -360.0 < fmod(x,360) < +360.0

Varie identità di trigoni remquo()offrono un miglioramento ancora maggiore. Esempio: sind ()

L'implementazione effettiva delle funzioni della libreria dipende dal compilatore specifico e / o dal fornitore della libreria. Che si tratti di hardware o software, che si tratti di un'espansione di Taylor o no, ecc., Varierà.

Mi rendo conto che non è assolutamente d'aiuto.

In genere sono implementati nel software e nella maggior parte dei casi non utilizzano le chiamate hardware corrispondenti (vale a dire l'assemblaggio). Tuttavia, come ha sottolineato Jason, questi sono specifici dell'implementazione.

Si noti che queste routine software non fanno parte delle fonti del compilatore, ma si troveranno piuttosto nella libreria di ricodifica come il clib o glibc per il compilatore GNU. Vedi http://www.gnu.org/software/libc/manual/html_mono/libc.html#Trig-Functions

Se desideri un maggiore controllo, dovresti valutare attentamente ciò di cui hai bisogno. Alcuni dei metodi tipici sono l'interpolazione delle tabelle di ricerca, la chiamata di assembly (che spesso è lenta) o altri schemi di approssimazione come Newton-Raphson per le radici quadrate.

Se desideri un'implementazione nel software, non nell'hardware, il posto dove cercare una risposta definitiva a questa domanda è il Capitolo 5 delle Ricette numeriche . La mia copia è in una scatola, quindi non posso fornire dettagli, ma la versione breve (se ricordo bene) è che prendi tan(theta/2)come operazione primitiva e calcoli gli altri da lì. Il calcolo viene eseguito con un'approssimazione di serie, ma è qualcosa che converge molto più rapidamente di una serie di Taylor.

Mi dispiace non poter ricordare di più senza mettere la mano sul libro.

Non c'è niente come colpire la fonte e vedere come qualcuno l'ha effettivamente fatto in una libreria di uso comune; diamo un'occhiata all'implementazione di una libreria C in particolare. Ho scelto uLibC.

Ecco la funzione sin:

http://git.uclibc.org/uClibc/tree/libm/s_sin.c

che sembra gestire alcuni casi speciali e quindi esegue una riduzione dell'argomento per mappare l'input nell'intervallo [-pi / 4, pi / 4], (suddividendo l'argomento in due parti, una grande e una coda) prima di chiamare

http://git.uclibc.org/uClibc/tree/libm/k_sin.c

che quindi opera su quelle due parti. Se non c'è coda, viene generata una risposta approssimativa usando un polinomio di grado 13. Se c'è una coda, si ottiene una piccola aggiunta correttiva basata sul principio chesin(x+y) = sin(x) + sin'(x')y

Ogni volta che viene valutata una tale funzione, a un certo livello è molto probabile che:

• Una tabella di valori che viene interpolata (per applicazioni veloci e imprecise, ad es. Computer grafica)
• La valutazione di una serie che converge al valore desiderato --- probabilmente non una serie di Taylor, molto probabilmente qualcosa basata su una quadratura di fantasia come Clenshaw-Curtis.

Se non è disponibile alcun supporto hardware, il compilatore probabilmente utilizza quest'ultimo metodo, emettendo solo codice assembler (senza simboli di debug), anziché utilizzare la libreria ac --- rendendoti difficile rintracciare il codice effettivo nel tuo debugger.

Come molte persone hanno sottolineato, dipende dall'implementazione. Ma per quanto ho capito la tua domanda, eri interessato a una vera implementazione software delle funzioni matematiche, ma non sei riuscito a trovarne una. In questo caso, eccoti qui:

• Scarica il codice sorgente di glibc da http://ftp.gnu.org/gnu/glibc/
• Guarda il file che si dosincos.ctrova nella cartella glibc root \ sysdeps \ ieee754 \ dbl-64 decompressa
• Allo stesso modo è possibile trovare implementazioni del resto della libreria matematica, basta cercare il file con il nome appropriato

Puoi anche dare un'occhiata ai file con l' .tblestensione, il loro contenuto non è altro che enormi tabelle di valori pre - calcolati di diverse funzioni in forma binaria. Ecco perché l'implementazione è così veloce: invece di calcolare tutti i coefficienti di qualunque serie utilizzino, eseguono solo una rapida ricerca, che è molto più veloce. A proposito, usano le serie Tailor per calcolare seno e coseno.

Spero che aiuti.

Proverò a rispondere per il caso di sin()un programma C, compilato con il compilatore C di GCC su un attuale processore x86 (diciamo un Intel Core 2 Duo).

Nel linguaggio C la libreria C standard include funzioni matematiche comuni, non inclusi nel linguaggio stesso (ad esempio pow, sine cosper il potere, seno, coseno e rispettivamente). Le intestazioni sono incluse in math.h .

Ora su un sistema GNU / Linux, queste funzioni delle librerie sono fornite da glibc (GNU libc o GNU C Library). Ma il compilatore GCC vuole che tu ti colleghi alla libreria matematica ( libm.so) usando il -lmflag del compilatore per abilitare l'uso di queste funzioni matematiche. Non sono sicuro del perché non faccia parte della libreria C standard. Si tratterebbe di una versione software delle funzioni in virgola mobile o "soft-float".

A parte: la ragione per cui le funzioni matematiche sono separate è storica, e aveva semplicemente lo scopo di ridurre le dimensioni dei programmi eseguibili in sistemi Unix molto vecchi, possibilmente prima che fossero disponibili librerie condivise, per quanto ne so.

Ora il compilatore può ottimizzare la funzione di libreria C standard sin()(fornita da libm.so) per essere sostituita con una chiamata a un'istruzione nativa alla funzione sin () integrata della CPU / FPU, che esiste come istruzione FPU ( FSINper x86 / x87) su processori più recenti come la serie Core 2 (questo è corretto fino all'i486DX). Ciò dipende dai flag di ottimizzazione passati al compilatore gcc. Se si dicesse al compilatore di scrivere codice che verrebbe eseguito su qualsiasi i386 o processore più recente, non si farebbe una tale ottimizzazione. La -mcpu=486bandiera informerebbe il compilatore che era sicuro effettuare tale ottimizzazione.

Ora, se il programma eseguisse la versione software della funzione sin (), lo farebbe sulla base di un algoritmo CORDIC (COordinate Rotation DIgital Computer) o BKM , o più probabilmente di una tabella o di un calcolo della serie di potenza che viene comunemente utilizzato ora per calcolare tali funzioni trascendentali. [Src: http://en.wikipedia.org/wiki/Cordic#Application]

Qualsiasi versione recente (dal 2.9x circa) di gcc offre anche una versione integrata di sin, __builtin_sin()che verrà utilizzata per sostituire la chiamata standard alla versione della libreria C, come ottimizzazione.

Sono sicuro che sia chiaro come il fango, ma spero che ti dia più informazioni di quanto ti aspettassi e molti punti da saltare per imparare di più da solo.

Se vuoi guardare l'implementazione GNU effettiva di quelle funzioni in C, controlla l'ultimo trunk di glibc. Vedere la GNU C Library .

Non usare la serie Taylor. I polinomi di Chebyshev sono sia più veloci che più precisi, come sottolineato da un paio di persone sopra. Ecco un'implementazione (originariamente dalla ROM ZX Spectrum): https://albertveli.wordpress.com/2015/01/10/zx-sine/

Il calcolo di seno / coseno / tangente è in realtà molto semplice da eseguire tramite il codice utilizzando la serie Taylor. Scriverne uno da soli richiede 5 secondi.

L'intero processo può essere riassunto con questa equazione qui:

Ecco alcune routine che ho scritto per C:

double _pow(double a, double b) {
    double c = 1;
    for (int i=0; i<b; i++)
        c *= a;
    return c;
}

double _fact(double x) {
    double ret = 1;
    for (int i=1; i<=x; i++) 
        ret *= i;
    return ret;
}

double _sin(double x) {
    double y = x;
    double s = -1;
    for (int i=3; i<=100; i+=2) {
        y+=s*(_pow(x,i)/_fact(i));
        s *= -1;
    }  
    return y;
}
double _cos(double x) {
    double y = 1;
    double s = -1;
    for (int i=2; i<=100; i+=2) {
        y+=s*(_pow(x,i)/_fact(i));
        s *= -1;
    }  
    return y;
}
double _tan(double x) {
     return (_sin(x)/_cos(x));  
}

Versione migliorata del codice dalla risposta di Blindy

#define EPSILON .0000000000001
// this is smallest effective threshold, at least on my OS (WSL ubuntu 18)
// possibly because factorial part turns 0 at some point
// and it happens faster then series element turns 0;
// validation was made against sin() from <math.h>
double ft_sin(double x)
{
    int k = 2;
    double r = x;
    double acc = 1;
    double den = 1;
    double num = x;

//  precision drops rapidly when x is not close to 0
//  so move x to 0 as close as possible
    while (x > PI)
        x -= PI;
    while (x < -PI)
        x += PI;
    if (x > PI / 2)
        return (ft_sin(PI - x));
    if (x < -PI / 2)
        return (ft_sin(-PI - x));
//  not using fabs for performance reasons
    while (acc > EPSILON || acc < -EPSILON)
    {
        num *= -x * x;
        den *= k * (k + 1);
        acc = num / den;
        r += acc;
        k += 2;
    }
    return (r);
}

L'essenza di come ciò si trova in questo estratto da Applied Numerical Analysis di Gerald Wheatley:

Quando il tuo programma software chiede al computer di ottenere un valore o , ti sei mai chiesto come può ottenere i valori se le funzioni più potenti che può calcolare sono i polinomi? Non li cerca nelle tabelle e non interpola! Piuttosto, il computer approssima ogni funzione diversa dai polinomi da un polinomio su misura per fornire i valori in modo molto accurato.

Alcuni punti da menzionare su quanto sopra è che alcuni algoritmi infatti interpolano da una tabella, anche se solo per le prime iterazioni. Nota anche come menziona il fatto che i computer utilizzano i polinomi approssimativi senza specificare quale tipo di polinomio approssimativo. Come hanno sottolineato altri nel thread, i polinomi di Chebyshev sono più efficienti dei polinomi di Taylor in questo caso.

se vuoi sinallora

 __asm__ __volatile__("fsin" : "=t"(vsin) : "0"(xrads));

se vuoi cosallora

 __asm__ __volatile__("fcos" : "=t"(vcos) : "0"(xrads));

se vuoi sqrtallora

 __asm__ __volatile__("fsqrt" : "=t"(vsqrt) : "0"(value));

quindi perché usare un codice impreciso quando le istruzioni della macchina lo faranno?