是的，也有计算罪恶的软件算法。基本上，用数字计算机计算这些东西通常是用数值方法来完成的，比如近似表示函数的泰勒级数。

数值方法可以将函数近似到任意精度，因为浮点数的精度是有限的，所以它们非常适合这些任务。

它们通常在软件中实现，在大多数情况下不会使用相应的硬件(即汇编)调用。然而，正如Jason所指出的，这些是特定于实现的。

请注意，这些软件例程不是编译器源代码的一部分，而是可以在相应的库中找到，例如clib或GNU编译器的glibc。看到http://www.gnu.org/software/libc/manual/html_mono/libc.html三角函数

如果你想要更大的控制权，你应该仔细评估你到底需要什么。一些典型的方法是查找表的插值、程序集调用(通常很慢)或其他近似方案，如Newton-Raphson的平方根。

对于罪恶，用泰勒展开可以得到

Sin (x) = x - x^3/3!+ x ^ 5/5 !- x ^ 7/7 !+……(1）

您将继续添加项，直到它们之间的差异低于可接受的容忍水平，或者只是有限的步数(更快，但不太精确)。举个例子:

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

注:(1)适用于小角度的近似值sin(x)=x。对于更大的角度，你需要计算越来越多的项才能得到可接受的结果。 你可以使用while参数并继续，以达到一定的准确性:

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;

}

像正弦和余弦这样的函数是在微处理器内部的微码中实现的。例如，英特尔芯片就有相应的组装指令。C编译器将生成调用这些汇编指令的代码。(相反，Java编译器不会。Java在软件而不是硬件中计算三角函数，因此运行速度要慢得多。)

芯片不使用泰勒级数来计算三角函数，至少不完全是这样。首先，他们使用CORDIC，但他们也可能使用一个短的泰勒级数来优化CORDIC的结果，或者用于特殊情况，例如在非常小的角度下以相对较高的精度计算正弦。有关更多解释，请参阅StackOverflow的回答。

这是一个复杂的问题。x86家族的类似intel的CPU有一个sin()函数的硬件实现，但它是x87 FPU的一部分，不再用于64位模式(使用SSE2寄存器代替)。在这种模式下，使用软件实现。

有几个这样的实现。一个在fdlibm中，在Java中使用。据我所知，glibc实现包含fdlibm的部分，以及IBM贡献的其他部分。

先验函数的软件实现，如sin()，通常使用多项式逼近，通常从泰勒级数获得。

使用泰勒级数，试着找出级数项之间的关系这样你就不用一遍又一遍地计算了

下面是一个关于余窦的例子:

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

使用这个，我们可以得到新的和项使用已经使用的和项(我们避免阶乘和x2p)

无论何时这样一个函数被求值，那么在某种程度上很可能有:

内插的值表(用于快速，不准确的应用程序-例如计算机图形) 收敛于期望值的级数的计算——可能不是泰勒级数，更可能是基于像克伦肖-柯蒂斯这样的奇异正交。

如果没有硬件支持，那么编译器可能会使用后一种方法，只发出汇编代码(没有调试符号)，而不是使用c库——这让您在调试器中跟踪实际代码变得很棘手。

在GNU libm中，sin的实现依赖于系统。因此，您可以在sysdeps的适当子目录中找到每个平台的实现。

一个目录包含一个由IBM贡献的C语言实现。自2011年10月以来，这是在典型的x86-64 Linux系统上调用sin()时实际运行的代码。它显然比汇编指令中的f_f快。源代码:sysdeps/ieee754/dbl-64/s_sin.c，查找__sin (double x)。

这段代码非常复杂。没有一种软件算法在整个x值范围内尽可能快且准确，因此库实现了几种不同的算法，它的第一项工作是查看x并决定使用哪种算法。

When x is very very close to 0, sin(x) == x is the right answer. A bit further out, sin(x) uses the familiar Taylor series. However, this is only accurate near 0, so... When the angle is more than about 7°, a different algorithm is used, computing Taylor-series approximations for both sin(x) and cos(x), then using values from a precomputed table to refine the approximation. When |x| > 2, none of the above algorithms would work, so the code starts by computing some value closer to 0 that can be fed to sin or cos instead. There's yet another branch to deal with x being a NaN or infinity.

这段代码使用了一些我以前从未见过的数值技巧，尽管据我所知，它们可能在浮点专家中很有名。有时几行代码需要几段文字来解释。例如，这两条线

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

(有时)用于将x减小到接近0的值，该值与x相差π/2的倍数，特别是xn × π/2。这种没有划分或分支的方式相当聪明。但是没有任何评论!

旧的32位版本的GCC/glibc使用fsin指令，这对于某些输入是非常不准确的。有一篇精彩的博客文章用两行代码说明了这一点。

fdlibm在纯C中实现sin要比glibc简单得多，而且注释很好。源代码:fdlibm/s_sin.c和fdlibm/k_sin.c

我将尝试在一个C程序中回答sin()的情况，该程序用GCC的C编译器在当前的x86处理器(假设是Intel Core 2 Duo)上编译。

在C语言中，标准C库包含了一些常见的数学函数，而这些函数并不包含在语言本身中(例如pow, sin和cos分别表示幂，sin和cos)。它们的头文件包含在math.h中。

现在在GNU/Linux系统上，这些库函数是由glibc (GNU libc或GNU C库)提供的。但是GCC编译器希望您使用-lm编译器标志链接到数学库(libm.so)，以启用这些数学函数的使用。我不确定为什么它不是标准C库的一部分。这些将是浮点函数的软件版本，或“软浮动”。

题外话:将数学函数分开的原因由来已久，据我所知，可能是在共享库可用之前，它仅仅是为了在非常古老的Unix系统中减少可执行程序的大小。

Now the compiler may optimize the standard C library function sin() (provided by libm.so) to be replaced with an call to a native instruction to your CPU/FPU's built-in sin() function, which exists as an FPU instruction (FSIN for x86/x87) on newer processors like the Core 2 series (this is correct pretty much as far back as the i486DX). This would depend on optimization flags passed to the gcc compiler. If the compiler was told to write code that would execute on any i386 or newer processor, it would not make such an optimization. The -mcpu=486 flag would inform the compiler that it was safe to make such an optimization.

现在，如果程序执行sin()函数的软件版本，它将基于CORDIC(坐标旋转数字计算机)或BKM算法，或者更可能是现在通常用于计算此类超越函数的表格或幂级数计算。(Src: http://en.wikipedia.org/wiki/Cordic应用程序)

任何最新的gcc版本(大约2.9倍以来)也提供了内置的sin版本__builtin_sin()，作为优化，它将用于取代对C库版本的标准调用。

我相信这是非常清楚的，但希望给你更多的信息比你期望的，和许多出发点，以了解更多自己。

库函数的实际实现取决于特定的编译器和/或库提供程序。不管它是用硬件还是软件，不管它是不是泰勒展开，等等，都会有所不同。

我意识到这完全没有帮助。

如果您想查看这些函数在C语言中的实际GNU实现，请查看glibc的最新主干。参见GNU C库。

如果你想要一个软件实现，而不是硬件实现，可以在《数值公式》的第5章中找到这个问题的明确答案。我的副本在一个盒子里，所以我不能给出细节，但简短的版本(如果我没记错的话)是你把tan(theta/2)作为你的基本操作，然后从那里计算其他的。计算是用级数近似完成的，但它比泰勒级数收敛得快得多。

抱歉，我没拿到书就想不起来了。

正如许多人指出的那样，它依赖于实现。但就我对你的问题的理解而言，你对数学函数的真正软件实现感兴趣，但只是没有找到一个。如果是这样的话，那么你是这样的:

从http://ftp.gnu.org/gnu/glibc/下载glibc源代码 查看位于解包的glibc根\sysdeps\ieee754\dbl-64文件夹中的文件dosincosc 类似地，您可以找到其余数学库的实现，只需查找具有适当名称的文件

您也可以看看扩展名为.tbl的文件，它们的内容只不过是以二进制形式的不同函数的预计算值的巨大表格。这就是为什么实现如此之快:而不是计算他们使用的任何级数的所有系数，他们只是做一个快速查找，这要快得多。顺便说一下，他们确实用裁缝级数来计算正弦和余弦。

我希望这能有所帮助。

OK kiddies, time for the pros.... This is one of my biggest complaints with inexperienced software engineers. They come in calculating transcendental functions from scratch (using Taylor's series) as if nobody had ever done these calculations before in their lives. Not true. This is a well defined problem and has been approached thousands of times by very clever software and hardware engineers and has a well defined solution. Basically, most of the transcendental functions use Chebyshev Polynomials to calculate them. As to which polynomials are used depends on the circumstances. First, the bible on this matter is a book called "Computer Approximations" by Hart and Cheney. In that book, you can decide if you have a hardware adder, multiplier, divider, etc, and decide which operations are fastest. e.g. If you had a really fast divider, the fastest way to calculate sine might be P1(x)/P2(x) where P1, P2 are Chebyshev polynomials. Without the fast divider, it might be just P(x), where P has much more terms than P1 or P2....so it'd be slower. So, first step is to determine your hardware and what it can do. Then you choose the appropriate combination of Chebyshev polynomials (is usually of the form cos(ax) = aP(x) for cosine for example, again where P is a Chebyshev polynomial). Then you decide what decimal precision you want. e.g. if you want 7 digits precision, you look that up in the appropriate table in the book I mentioned, and it will give you (for precision = 7.33) a number N = 4 and a polynomial number 3502. N is the order of the polynomial (so it's p4.x^4 + p3.x^3 + p2.x^2 + p1.x + p0), because N=4. Then you look up the actual value of the p4,p3,p2,p1,p0 values in the back of the book under 3502 (they'll be in floating point). Then you implement your algorithm in software in the form: (((p4.x + p3).x + p2).x + p1).x + p0 ....and this is how you'd calculate cosine to 7 decimal places on that hardware.

请注意，在FPU中大多数硬件实现的超越操作通常涉及一些微码和类似的操作(取决于硬件)。 切比雪夫多项式用于大多数先验多项式，但不是全部。例:使用Newton raphson方法的两次迭代，首先使用查询表，使用平方根更快。 同样，《计算机逼近》这本书会告诉你。

If you plan on implmementing these functions, I'd recommend to anyone that they get a copy of that book. It really is the bible for these kinds of algorithms. Note that there are bunches of alternative means for calculating these values like cordics, etc, but these tend to be best for specific algorithms where you only need low precision. To guarantee the precision every time, the chebyshev polynomials are the way to go. Like I said, well defined problem. Has been solved for 50 years now.....and thats how it's done.

Now, that being said, there are techniques whereby the Chebyshev polynomials can be used to get a single precision result with a low degree polynomial (like the example for cosine above). Then, there are other techniques to interpolate between values to increase the accuracy without having to go to a much larger polynomial, such as "Gal's Accurate Tables Method". This latter technique is what the post referring to the ACM literature is referring to. But ultimately, the Chebyshev Polynomials are what are used to get 90% of the way there.

享受。

计算正弦/余弦/正切其实很容易通过代码使用泰勒级数来实现。自己写一个只需5秒钟。

整个过程可以用这个方程来概括:

下面是我为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));  
}

如果你想犯罪

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

如果你想的话，因为

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

如果你想要根号方根

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

那么，既然机器指令可以做到，为什么还要使用不准确的代码呢?

切比雪夫多项式，正如在另一个答案中提到的，是函数和多项式之间的最大差异尽可能小的多项式。这是一个很好的开始。

在某些情况下，最大误差不是你感兴趣的，而是最大相对误差。例如，对于正弦函数，x = 0附近的误差应该比较大的值小得多;你想要一个小的相对误差。所以你可以计算sinx / x的切比雪夫多项式，然后把这个多项式乘以x。

Next you have to figure out how to evaluate the polynomial. You want to evaluate it in such a way that the intermediate values are small and therefore rounding errors are small. Otherwise the rounding errors might become a lot larger than errors in the polynomial. And with functions like the sine function, if you are careless then it may be possible that the result that you calculate for sin x is greater than the result for sin y even when x < y. So careful choice of the calculation order and calculation of upper bounds for the rounding error are needed.

例如，sinx = x - x^3/6 + x^5 / 120 - x^7 / 5040…如果你天真地计算sinx = x * (1 - x^2/6 + x^4/120 - x^6/5040…)，那么括号中的函数是递减的，如果y是x的下一个大的数字，那么有时siny会小于sinx。相反，计算sinx = x - x^3 * (1/6 - x^2/ 120 + x^4/5040…)，这是不可能发生的。

例如，在计算切比雪夫多项式时，通常需要将系数四舍五入到双倍精度。但是，虽然切比雪夫多项式是最优的，但系数舍入为双精度的切比雪夫多项式并不是具有双精度系数的最优多项式!

For example for sin (x), where you need coefficients for x, x^3, x^5, x^7 etc. you do the following: Calculate the best approximation of sin x with a polynomial (ax + bx^3 + cx^5 + dx^7) with higher than double precision, then round a to double precision, giving A. The difference between a and A would be quite large. Now calculate the best approximation of (sin x - Ax) with a polynomial (b x^3 + cx^5 + dx^7). You get different coefficients, because they adapt to the difference between a and A. Round b to double precision B. Then approximate (sin x - Ax - Bx^3) with a polynomial cx^5 + dx^7 and so on. You will get a polynomial that is almost as good as the original Chebyshev polynomial, but much better than Chebyshev rounded to double precision.

Next you should take into account the rounding errors in the choice of polynomial. You found a polynomial with minimum error in the polynomial ignoring rounding error, but you want to optimise polynomial plus rounding error. Once you have the Chebyshev polynomial, you can calculate bounds for the rounding error. Say f (x) is your function, P (x) is the polynomial, and E (x) is the rounding error. You don't want to optimise | f (x) - P (x) |, you want to optimise | f (x) - P (x) +/- E (x) |. You will get a slightly different polynomial that tries to keep the polynomial errors down where the rounding error is large, and relaxes the polynomial errors a bit where the rounding error is small.

所有这些将使您轻松地获得最多0.55倍于最后一位的舍入误差，其中+，-，*，/的舍入误差最多为0.50倍于最后一位。

不要用泰勒级数。切比雪夫多项式更快更准确，正如上面几个人指出的那样。下面是一个实现(最初来自ZX Spectrum ROM): https://albertveli.wordpress.com/2015/01/10/zx-sine/

没有什么比点击源代码，看看人们是如何在常用的库中实际完成它的了;让我们特别看看一个C库实现。我选择了uLibC。

这是sin函数:

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

看起来它处理了一些特殊情况，然后执行一些参数约简，将输入映射到范围[-pi/4,pi/4]，(将参数分成两部分，一个大的部分和一个尾巴)，然后调用

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

然后作用于这两个部分。 如果没有尾巴，则使用13次多项式生成近似答案。 如果有尾巴，根据sin(x+y) = sin(x) + sin'(x')y的原理，你会得到一个小的修正

关于sin()， cos()，tan()这样的三角函数，在5年之后，没有提到高质量三角函数的一个重要方面:极差约简。

任何这些函数的早期步骤都是将角度(以弧度为单位)减小到2*π区间。但是π是无理数，所以像x =余数(x, 2*M_PI)这样的简单简化会引入误差，因为M_PI或机器pi是π的近似值。那么，如何求x =余数(x, 2*π)呢?

早期的库使用扩展精度或精心设计的编程来提供高质量的结果，但仍然在有限的double范围内。当请求一个较大的值，如sin(pow(2,30))时，结果是无意义的或0.0，并且可能将错误标志设置为TLOSS完全损失精度或PLOSS部分损失精度。

将大的值缩小到像-π到π这样的区间是一个具有挑战性的问题，它可以与基本三角函数(比如sin())本身的挑战相媲美。

一个好的报告是大论点的论据缩减:好到最后一位(1992)。它涵盖了这个问题很好:讨论了需要和事情是如何在各种平台(SPARC, PC, HP, 30+其他)，并提供了一个解决方案算法，为所有双从-DBL_MAX到DBL_MAX的高质量结果。

如果原始参数以度为单位，但可能值很大，则首先使用fmod()以提高精度。一个好的fmod()将不会引入任何错误，从而提供出色的范围缩小。

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

各种三角恒等式和remquo()提供了更多的改进。示例:信德()

盲汉回答的改进版代码

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

它如何做到这一点的本质在于杰拉德·惠特利的《应用数值分析》节选:

当你的软件程序要求计算机获取一个值时 或者，你有没有想过它是如何得到 如果它能计算的最强大的函数是多项式? 它不会在表中查找这些并进行插值!相反, 计算机逼近除多项式以外的所有函数 一个多项式，可以精确地给出值。

上面要提到的几点是，一些算法实际上是从表中插值的，尽管只是在前几次迭代中。还要注意它是如何提到计算机利用近似多项式而没有指定哪种类型的近似多项式。正如本文中其他人指出的那样，在这种情况下，切比雪夫多项式比泰勒多项式更有效。