Как быстрее всего вычислить sin и cos вместе?

Я хотел бы вычислить как синус, так и косинус значения вместе (например, для создания матрицы вращения). Конечно, я мог бы вычислить их отдельно, одно за другим a = cos(x); b = sin(x);, но мне интересно, есть ли более быстрый способ, когда нужны оба значения.

Изменить: чтобы обобщить ответы на данный момент:

• Влад сказал, что есть команда asm, вычисляющая ихFSINCOSобоих (почти одновременно с вызовом вFSINодиночку)

• Как заметил Чи , эта оптимизация иногда уже выполняется компилятором (при использовании флагов оптимизации).

• caf указал, что функцииsincosиsincosf, вероятно, доступны и могут быть вызваны напрямую, просто включивmath.h

• Подход tanascius к использованию справочной таблицы является спорным. (Однако на моем компьютере и в тестовом сценарии он работает в 3 раза быстрее, чемsincosс почти такой же точностью для 32-битных чисел с плавающей запятой.)

• Джоэл Гудвин связался с интересным подходом к чрезвычайно быстрой технике аппроксимации с довольно хорошей точностью (для меня это даже быстрее, чем поиск в таблице)

Современные процессоры Intel / AMD имеют инструкции FSINCOSпо одновременному вычислению синусоидальных и косинусных функций. Если вам нужна сильная оптимизация, возможно, вам стоит ее использовать.

Вот небольшой пример: http://home.broadpark.no/~alein/fsincos.html

Вот еще один пример (для MSVC): http://www.codeguru.com/forum/showthread.php?t=328669

Вот еще один пример (с gcc): http://www.allegro.cc/forums/thread/588470

Надеюсь, что один из них поможет. (Сам не использовал эту инструкцию, извините.)

Поскольку они поддерживаются на уровне процессора, я ожидаю, что они будут намного быстрее, чем поиск в таблицах.

Изменить:
Википедия предполагает, что это FSINCOSбыло добавлено на 387 процессорах, поэтому вы вряд ли найдете процессор, который его не поддерживает.

Изменить:
в документации Intel указано, что FSINCOSэто примерно в 5 раз медленнее, чем FDIV(т.е. деление с плавающей запятой).

Изменить:
обратите внимание, что не все современные компиляторы оптимизируют вычисление синуса и косинуса в вызове FSINCOS. В частности, мой VS 2008 этого не делал.

Изменить:
ссылка на первый пример мертва, но на Wayback Machine все еще есть версия .

В современных процессорах x86 есть инструкция fsincos, которая будет делать именно то, что вы просите - вычислять sin и cos одновременно. Хороший оптимизирующий компилятор должен обнаруживать код, который вычисляет sin и cos для одного и того же значения, и использовать команду fsincos для его выполнения.

Чтобы это сработало, потребовалось немного перевернуть флаги компилятора, но:

$ gcc --version
i686-apple-darwin9-gcc-4.0.1 (GCC) 4.0.1 (Apple Inc. build 5488)
Copyright (C) 2005 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

$ cat main.c
#include <math.h> 

struct Sin_cos {double sin; double cos;};

struct Sin_cos fsincos(double val) {
  struct Sin_cos r;
  r.sin = sin(val);
  r.cos = cos(val);
  return r;
}

$ gcc -c -S -O3 -ffast-math -mfpmath=387 main.c -o main.s

$ cat main.s
    .text
    .align 4,0x90
.globl _fsincos
_fsincos:
    pushl   %ebp
    movl    %esp, %ebp
    fldl    12(%ebp)
    fsincos
    movl    8(%ebp), %eax
    fstpl   8(%eax)
    fstpl   (%eax)
    leave
    ret $4
    .subsections_via_symbols

Тада, пользуется инструкцией fsincos!

Когда вам нужна производительность, вы можете использовать предварительно вычисленную таблицу sin / cos (подойдет одна таблица, сохраненная в виде словаря). Ну, это зависит от необходимой точности (возможно, таблица будет слишком большой), но это должно быть очень быстро.

Технически этого можно добиться, используя комплексные числа и формулу Эйлера . Таким образом, что-то вроде (C ++)

complex<double> res = exp(complex<double>(0, x));
// or equivalent
complex<double> res = polar<double>(1, x);
double sin_x = res.imag();
double cos_x = res.real();

должен дать вам синус и косинус за один шаг. Как это делается внутри, зависит от используемого компилятора и библиотеки. Это может (и может) занять больше времени, чтобы сделать это таким образом (просто потому, что формула Эйлера в основном используется для вычисления сложных expс использованием sinи cos- а не наоборот), но возможна некоторая теоретическая оптимизация.

редактировать

Заголовки в <complex>ГНУ C ++ 4.2 используют явные вычисления sinи cosвнутри polar, поэтому он не выглядит слишком хорошо для оптимизаций там , если компилятор не делает некоторые магии (см -ffast-mathи -mfpmathпереключатели , как написано в ответ Чи ).

Вы можете вычислить любое из них, а затем использовать идентификатор:

соз (х) 2 = 1 - грех (х) 2

но, как говорит @tanascius, заранее вычисленная таблица - это путь.

Если вы используете библиотеку GNU C, вы можете:

#define _GNU_SOURCE
#include <math.h>

и вы получите объявления функций sincos(), sincosf()и, sincosl()которые вычисляют оба значения вместе - вероятно, самым быстрым способом для вашей целевой архитектуры.

На этой странице форума есть очень интересные материалы, которые ориентированы на быстрый поиск хороших приближений: http://www.devmaster.net/forums/showthread.php?t=5784

Отказ от ответственности: Я не использовал ничего из этого.

Обновление от 22 февраля 2018 г .: Wayback Machine - единственный способ посетить исходную страницу сейчас: https://web.archive.org/web/20130927121234/http://devmaster.net/posts/9648/fast-and-accurate- синус-косинус

Многие математические библиотеки C, как указывает caf, уже имеют sincos (). Заметным исключением является MSVC.

• У Sun есть sincos () по крайней мере с 1987 года (двадцать три года; у меня есть бумажная страница руководства)
• У HPUX 11 он был в 1997 году (но его нет в HPUX 10.20)
• Добавлен в glibc в версии 2.1 (февраль 1999 г.)
• Стал встроенным в gcc 3.4 (2004), __builtin_sincos ().

Что касается поиска, Эрик С. Реймонд в книге « Искусство программирования Unix» (2004) (глава 12) прямо говорит, что это плохая идея (в настоящий момент):

Другой пример - предварительное вычисление небольших таблиц - например, таблица sin (x) по градусам для оптимизации вращений в движке трехмерной графики займет 365 × 4 байта на современной машине. До того, как процессоры стали достаточно быстрее памяти, чтобы требовать кэширования , это была очевидная оптимизация скорости.В настоящее время может быть быстрее каждый раз пересчитывать, чем платить за процент дополнительных промахов в кэше, вызванных таблицей.

«Но в будущем это может измениться снова, когда кеши станут больше. В целом, многие оптимизации являются временными и могут легко превратиться в пессимизацию при изменении соотношений затрат. Единственный способ узнать - это измерить и увидеть». (из Искусства программирования Unix )

Но, судя по изложенному выше, не все согласны.

Я не верю, что справочные таблицы обязательно являются хорошей идеей для решения этой проблемы. Если ваши требования к точности не очень низкие, таблица должна быть очень большой. А современные процессоры могут выполнять много вычислений, пока значение извлекается из основной памяти. Это не один из тех вопросов, на которые можно правильно ответить с помощью аргументов (даже не моих), тестирования, измерения и рассмотрения данных.

Но я бы посмотрел на быстрые реализации SinCos, которые вы найдете в таких библиотеках, как AMD ACML и Intel MKL.

Если вы хотите использовать коммерческий продукт и одновременно рассчитываете несколько вычислений sin / cos (чтобы вы могли использовать векторные функции), вам следует обратиться к библиотеке Intel Math Kernel Library.

Имеет функцию синкос

Согласно этой документации, он в среднем составляет 13,08 тактов на элемент на дуэте Core 2 в режиме высокой точности, что, я думаю, будет даже быстрее, чем fsincos.

В этой статье показано, как построить параболический алгоритм, который генерирует как синус, так и косинус:

Уловка DSP: одновременное параболическое приближение Sin и Cos

http://www.dspguru.com/dsp/tricks/parabolic-approximation-of-sin-and-cos

Когда производительность критична для такого рода вещей, нередко вводится таблица поиска.

Что касается творческого подхода, как насчет расширения серии Тейлора? Поскольку у них похожие термины, вы можете сделать что-то вроде следующего псевдонима:

numerator = x
denominator = 1
sine = x
cosine = 1
op = -1
fact = 1

while (not enough precision) {
    fact++
    denominator *= fact
    numerator *= x

    cosine += op * numerator / denominator

    fact++
    denominator *= fact
    numerator *= x

    sine += op * numerator / denominator

    op *= -1
}

Это означает, что вы делаете что-то вроде этого: начиная с x и 1 для sin и косинуса, следуйте шаблону - вычтите x ^ 2/2! из косинуса вычтите x ^ 3/3! из синуса добавить x ^ 4/4! к косинусу прибавить x ^ 5/5! синус ...

Я понятия не имею, будет ли это работать. Если вам нужна меньшая точность, чем дают встроенные функции sin () и cos (), это может быть вариантом.

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

Помните, что cos (x) и sin (x) - это действительная и мнимая части exp (ix). Итак, мы хотим вычислить exp (ix), чтобы получить и то, и другое. Мы предварительно вычисляем exp (iy) для некоторых дискретных значений y между 0 и 2pi. Сдвигаем x на интервал [0, 2pi). Затем мы выбираем y, ближайший к x, и пишем
exp (ix) = exp (iy + (ix-iy)) = exp (iy) exp (i (xy)).

Мы получаем exp (iy) из справочной таблицы. А поскольку | xy | мала (не более половины расстояния между значениями y), ряд Тейлора будет хорошо сходиться всего за несколько членов, поэтому мы используем это для exp (i (xy)). И тогда нам просто нужно комплексное умножение, чтобы получить exp (ix).

Еще одним приятным свойством этого является то, что вы можете векторизовать его с помощью SSE.

Возможно, вы захотите взглянуть на http://gruntthepeon.free.fr/ssemath/ , который предлагает векторизованную реализацию SSE, вдохновленную библиотекой CEPHES. Он имеет хорошую точность (максимальное отклонение от sin / cos порядка 5e-8) и скорость (немного превосходит fsincos на основе одного вызова и явный победитель над несколькими значениями).

Я опубликовал решение, включающее встроенную сборку ARM, способную вычислять как синус, так и косинус двух углов одновременно здесь: Быстрый синус / косинус для ARMv7 + NEON

Точное, но быстрое приближение функций sin и cos одновременно в javascript можно найти здесь: http://danisraelmalta.github.io/Fmath/ (легко импортируется в c / c ++)

Думали ли вы об объявлении таблиц поиска для двух функций? Вам все равно придется «вычислять» sin (x) и cos (x), но это будет значительно быстрее, если вам не нужна высокая степень точности.

Компилятор MSVC может использовать (внутренние) функции SSE2

 ___libm_sse2_sincos_ (for x86)
 __libm_sse2_sincos_  (for x64)

в оптимизированных сборках, если указаны соответствующие флаги компилятора (как минимум / O2 / arch: SSE2 / fp: fast). Имена этих функций, по-видимому, подразумевают, что они вычисляют не отдельные sin и cos, а вычисляют обе «за один шаг».

Например:

void sincos(double const x, double & s, double & c)
{
  s = std::sin(x);
  c = std::cos(x);
}

Сборка (для x86) с / fp: fast:

movsd   xmm0, QWORD PTR _x$[esp-4]
call    ___libm_sse2_sincos_
mov     eax, DWORD PTR _s$[esp-4]
movsd   QWORD PTR [eax], xmm0
mov     eax, DWORD PTR _c$[esp-4]
shufpd  xmm0, xmm0, 1
movsd   QWORD PTR [eax], xmm0
ret     0

Сборка (для x86) без / fp: fast, но с / fp: precision вместо этого (что по умолчанию) вызывает отдельные sin и cos:

movsd   xmm0, QWORD PTR _x$[esp-4]
call    __libm_sse2_sin_precise
mov     eax, DWORD PTR _s$[esp-4]
movsd   QWORD PTR [eax], xmm0
movsd   xmm0, QWORD PTR _x$[esp-4]
call    __libm_sse2_cos_precise
mov     eax, DWORD PTR _c$[esp-4]
movsd   QWORD PTR [eax], xmm0
ret     0

Итак, / fp: fast является обязательным для оптимизации sincos.

Но учтите, что

___libm_sse2_sincos_

может быть не так точно, как

__libm_sse2_sin_precise
__libm_sse2_cos_precise

из-за отсутствия «точного» в конце названия.

На моей «немного» более старой системе (Intel Core 2 Duo E6750) с последним компилятором MSVC 2019 и соответствующими оптимизациями мой тест показывает, что вызов sincos примерно в 2,4 раза быстрее, чем отдельные вызовы sin и cos.