Как линукс/glibc считают синусы?

man 3 sin

а открыть исходники и посмотреть кто запрещает?

Смотрю glibc/math/*

Там всё подозрительно кратко, и ссылки на __ieee754_*

неправда, я там видел 1) вычисление по рядам Тейлора 2) fsin, fcos, fsincos и прочую нечисть Это то, что сходу вспомнилось.

Нашёл sysdeps/i386/fpu/s_sinf.S

но там вызов fsin (сопроцессора)

Были ряды, век воли не видать!

>но там вызов fsin (сопроцессора)

Вы ответили на свой вопрос.

Я знаю, мне нужен пруфлинк :-)

Как сопроцессор считает синус?

А на этот вопрос скорее всего ответил devinull. :)

>Как сопроцессор считает синус?

очень быстро. // К.О.

Возмите в библиотеке таблице Брадиса. Лучше любого пруфлинка.

а зачем это вам?

Нашёл эмуляцию FPU в ядре :-)

linux/arch/x86/math-emu

И похоже, они фигачат через комплексные числа.

Фраза "компьютер считает с помощью ряда Тейлора" нуждается в пруфлинках ;-)

В каких ещё пруфлинках? Методов-то всего ничего: либо ряды, либо Тейлор.

понимаете, я всё же хочу ЭТО ВИДЕТЬ :-)

> Методов-то всего ничего: либо ряды, либо Тейлор.
lim (sin x)/x as x->0 = 1
Тоже вариант :)

Синусы обычно считает все-таки процессор. В отдельных случаях (softfloat для армов и compile-time-константность) они считаются и софтверно, но это то, с чем большинство людей не сталкивается.

>Методов-то всего ничего: либо ряды, либо Тейлор.

еще можно Брадиса интерполировать

Прозреваю, что интерполяция, например по Лагранжу, даст тот же ряд Тейлора :-)

> Нашёл эмуляцию FPU в ядре :-)

в этом ноль информации о том, как считает сопроцессор

>>lim (sin x)/x as x->0 = 1

Ну и как ты это собираешься использовать? Или просто взблеснуть решил?

> Ну и как ты это собираешься использовать?
Если x имеет небольшое значение, sin x можно приравнять к x.
> Или просто взблеснуть решил?
Да. Получилось?

sysdeps/ieee754/flt-32v/k_sinf.c Константы half - S6 как бы намекают нам...

Если x имеет небольшое значение, sin x можно приравнять к x.

А если большое? Тады ой? [quuote]Получилось? Нет!

> А если большое?
Считать FSIN
> Нет!
:(

в этом ноль информации о том, как считает сопроцессор

\begin{4.2} ЦАП -> аналоговые умножители, сумматоры и делитель ->аналоговое ЗУ -> АЦП \end{4.2} Выпендрился? ;)

1. Сначала аргумент приводится к полуинтервалу [0, 2Pi) вычислением по модулю 2Pi

2. Затем при помощи формул половинного угла (рекурсивно) уменьшается до достаточно малого числа, например 0.5

3. Затем используется отрезок разложения по полиномам Чебышева, предствленный в виде ряда по степеням x. Он НЕ совпадает с рядом Тейлора!

ЗЫ. Второй пункт может не использоваться. С другой стороны, используя рекурсию, можно на пункте 3. ограничиться вообще x'ом.

Ряд по полиномам Чебышева нужен для фактического построения полинома, близкого к полиному наилучшего равномерного приближения

k_sin.c этому противоречит ;)

> Методов-то всего ничего: либо ряды, либо Тейлор.

если обрезать тейлора, то полученный многочлен будет ОЧЕНЬ хорош вблизи нуля, а дальше хуже и хуже.

На каком-нибудь отрезке, скажем [-pi/2, pi] можно подобрать многочлен той же степени что и тот отрезок тейлора, но он будет лучше приближать по всему отрезку (хотя конечно около нуля -- хуже). Поэтому там не тейлор, а вручную подобранный многочлен. (плюс учет периодичности).

В точку!

http://pastebin.com/d5892b2a7

> Синусы обычно считает все-таки процессор

подозреваю что во всяких intel math kernel library есть функции которые считают синусы/косинусы с ухудшенной точностью, но быстрее процессорного FSIN

>Если x имеет небольшое значение, sin x можно приравнять к x.

Это как, умник?
-> sin (0.1) = 0.00174533
-> sin (1e-3) = 1.74533e-05
-> sin (1e-13) = 1.74533e-15

Различается на несколько порядков даже для x=10**-13

> Это как, умник? -> sin (0.1) = 0.00174533

use google, luke:

sin(0.1) = 0.0998334166

>>На каком-нибудь отрезке, скажем [-pi/2, pi]

Из всех синусов-косинусов существенным является синус от 0 до пи/2, остальное — отражение и сдвиг.

Зачем многочлены на таких широких избыточных отрезках?

Помнится, в нашем 10м классе физмат лицея один гений отжёг на физике: раз синус малого угла примерно равен значению самого угла, то положим sin(4)=4. Реально было ;) Урок был сорван.

Вот мой учебный код. Использует рекурсию, не использует многочлен равномерного приближения. sin.c

/*****************************************************************
               sin(x) evaluation routine
 If x >  EPS value, the following recursion is used
    sin(x) = 3*sin(x/3)-4*sin(x/3)^3.
 When x < EPS, a part of Taylor series for sinus is employed
    sin(x) = x + O(x^3), O<=1/6
 EPS is chosen so, that EPS^3/6 <= macheps = 5.551115e-17 (for double)

 Если x >  EPS, выполняется рекурсивный спуск по формуле
    sin(x) = 3*sin(x/3)-4*sin(x/3)^3.
 Когда x < EPS, используется отрезок ряда Тейлора
    sin(x) = x + O(x^3), O<=1/6
 EPS выбирается так, что его остаток не превосходит маш. точности,
 macheps = 5.551115e-17 (для чисел двойной точности)

*****************************************************************/
#include<stdio.h>
#include <stdlib.h>


const double EPS = 1.0e-6;

double fabs (double x) {return (x>0? x: -x);}

double
      p_sin3x(double x)
      {
       return x*(3.0 - 4.0*x*x);
      }

double
       rsin(double x)
       {
        if(fabs(x)>EPS)
         return p_sin3x(rsin(x / 3.0));
        else
         return x * (1.0 + (-1.0 + 1.0/20.0 * x * x) * x * x/6.0);

       }


int
    main(int argc, char* argv[])
    {
     if(argc>1)
      printf("%.17f\n", rsin(atof(argv[1])));
     else
      printf("Usage: %s x\n", argv[0]);

     return 0;
    }

Недостатки: не приводит вначале аргумент к отрезку [0;2Pi], однако работает и вне его, но не столь эффективно.

Это, кстати, многочлен равномерного приближения, вычисляемый по схеме Горнера

>sin(0.1) = 0.0998334166

Я идиот :(. Забыл, что wcalc по умолчанию в градусах аргумент берет.

А нафига мне твой код? Прочитай название темы. Или его ежу в glibc приняли?

Использует рекурсию

Выброси! ;)

Патч:

-- return x * (1.0 + (-1.0 + 1.0/20.0 * x * x) * x * x/6.0);
++ return;

Ну раз ты такой кретин, можешь его не читать. Смысл сводится к тому, что есть разные способы счета без использования сопроцессора. В сопроцессорах обычно многочлены равномерных приближений, как я уже сказал.

Раз ты такой, должен бы знать, что чаще всего вообще таблицами обходятся. А то и в целых числах синусы считать умудряются. И да, читать мне его нифик н сдалось. И вообще, offtopic.

>use google, luke:
>sin(0.1)

ДОжили... Гугл синусы считает. Скрипты он ещё не компилирует?

Извините, но это какая-то херня.

Пока еще нет, приходите через месяца два