Qual é a maneira mais rápida de calcular sin e cos juntos?

Gostaria de calcular o seno e o cosseno de um valor juntos (por exemplo, para criar uma matriz de rotação). Claro que eu poderia computá-los separadamente um após o outro a = cos(x); b = sin(x);, mas gostaria de saber se existe uma maneira mais rápida quando precisar dos dois valores.

Edit: Para resumir as respostas até agora:

• Vlad disse que existe o comando asmFSINCOScomputando os dois (quase ao mesmo tempo que uma chamada paraFSINsozinho)

• Como Chi notou, esta otimização às vezes já é feita pelo compilador (ao usar sinalizadores de otimização).

• caf apontou, que funçõessincosesincosfprovavelmente estão disponíveis e podem ser chamadas diretamente apenas incluindomath.h

• A abordagem de tanascius de usar uma tabela de consulta é discutida como controversa. (No entanto, no meu computador e em um cenário de benchmark, ele é executado 3x mais rápido do quesincoscom quase a mesma precisão para pontos flutuantes de 32 bits.)

• Joel Goodwin vinculou a uma abordagem interessante de uma técnica de aproximação extremamente rápida com uma precisão muito boa (para mim, isso é ainda mais rápido do que a consulta à tabela)

Os processadores Intel / AMD modernos possuem instruções FSINCOSpara calcular as funções seno e cosseno simultaneamente. Se você precisa de uma otimização forte, talvez deva usá-la.

Aqui está um pequeno exemplo: http://home.broadpark.no/~alein/fsincos.html

Aqui está outro exemplo (para MSVC): http://www.codeguru.com/forum/showthread.php?t=328669

Aqui está mais um exemplo (com gcc): http://www.allegro.cc/forums/thread/588470

Espero que um deles ajude. (Eu não usei esta instrução, desculpe.)

Como eles são suportados no nível do processador, espero que sejam muito mais rápidos do que as pesquisas de tabela.

Edit:
Wikipedia sugere que FSINCOSfoi adicionado 387 processadores, então você dificilmente pode encontrar um processador que não o suporte.

Edit:
a documentação da Intel afirma que FSINCOSé cerca de 5 vezes mais lento do que FDIV(isto é, divisão de ponto flutuante).

Editar:
Observe que nem todos os compiladores modernos otimizam o cálculo de seno e cosseno em uma chamada para FSINCOS. Em particular, meu VS 2008 não fazia isso.

Edit:
O primeiro link de exemplo está morto, mas ainda há uma versão na Wayback Machine .

Os processadores x86 modernos têm uma instrução fsincos que fará exatamente o que você está pedindo - calcular sen e cos ao mesmo tempo. Um bom compilador de otimização deve detectar o código que calcula sen e cos para o mesmo valor e usar o comando fsincos para executá-lo.

Demorou alguns ajustes de sinalizadores do compilador para que isso funcionasse, mas:

$ 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

Tada, use a instrução fsincos!

Quando precisar de desempenho, você pode usar uma tabela sin / cos pré-calculada (uma tabela servirá, armazenada como um Dicionário). Bem, depende da precisão que você precisa (talvez a mesa seja muito grande), mas deve ser muito rápido.

Tecnicamente, você conseguiria isso usando números complexos e a Fórmula de Euler . Assim, algo como (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();

deve fornecer seno e cosseno em uma única etapa. Como isso é feito internamente é uma questão do compilador e da biblioteca em uso. Pode (e pode) levar mais tempo para fazer isso dessa forma (só porque a Fórmula de Euler é usada principalmente para calcular o complexo expusando sine cos- e não o contrário), mas pode haver alguma otimização teórica possível.

Editar

Os cabeçalhos no <complex>GNU C ++ 4.2 estão usando cálculos explícitos de sine cosdentro polar, então não parece muito bom para otimizações lá, a menos que o compilador faça alguma mágica (veja as opções -ffast-mathe -mfpmathconforme escritas na resposta de Chi ).

Você pode calcular qualquer um e usar a identidade:

cos (x) 2 = 1 - sin (x) 2

mas, como diz @tanascius, uma mesa pré-computada é o caminho a percorrer.

Se você usa a biblioteca GNU C, pode fazer:

#define _GNU_SOURCE
#include <math.h>

e você terá declarações dos sincos(), sincosf()e sincosl()funções que calculam os dois valores juntos - presumivelmente no caminho mais rápido para sua arquitetura alvo.

Há coisas muito interessantes nesta página do fórum, que se concentra em encontrar boas aproximações que sejam rápidas: http://www.devmaster.net/forums/showthread.php?t=5784

Aviso: Não usei nada disso sozinho.

Atualização de 22 de fevereiro de 2018: Wayback Machine é a única maneira de visitar a página original agora: https://web.archive.org/web/20130927121234/http://devmaster.net/posts/9648/fast-and-accurate- seno-cosseno

Muitas bibliotecas de matemática C, como indica caf, já têm sincos (). A exceção notável é o MSVC.

• A Sun tem sincos () desde pelo menos 1987 (vinte e três anos; tenho uma página do manual impressa)
• HPUX 11 tinha em 1997 (mas não está em HPUX 10.20)
• Adicionado ao glibc na versão 2.1 (fevereiro de 1999)
• Tornou-se um built-in no gcc 3.4 (2004), __builtin_sincos ().

E com relação à pesquisa, Eric S. Raymond em Art of Unix Programming (2004) (Capítulo 12) diz explicitamente que isso é uma má ideia (no momento presente):

"Outro exemplo é pré-computar pequenas tabelas - por exemplo, uma tabela de sin (x) por grau para otimizar rotações em um mecanismo gráfico 3D ocupará 365 × 4 bytes em uma máquina moderna. Antes que os processadores ficassem mais rápidos do que a memória para exigir o cache , essa era uma otimização de velocidade óbvia. Hoje em dia, pode ser mais rápido recomputar a cada vez, em vez de pagar pela porcentagem de falhas de cache adicionais causadas pela tabela.

"Mas no futuro, isso pode mudar novamente à medida que os caches ficarem maiores. De maneira mais geral, muitas otimizações são temporárias e podem facilmente se transformar em pessimizações conforme as taxas de custo mudam. A única maneira de saber é medir e ver." (da Arte da Programação Unix )

Mas, a julgar pela discussão acima, nem todos concordam.

Não acredito que as tabelas de pesquisa sejam necessariamente uma boa ideia para esse problema. A menos que seus requisitos de precisão sejam muito baixos, a mesa precisa ser muito grande. E as CPUs modernas podem fazer muitos cálculos enquanto um valor é buscado na memória principal. Esta não é uma daquelas questões que podem ser respondidas adequadamente por argumentos (nem mesmo os meus), teste, meça e considere os dados.

Mas eu observaria as implementações rápidas de SinCos que você encontra em bibliotecas como ACML da AMD e MKL da Intel.

Se você deseja usar um produto comercial e está calculando vários cálculos sin / cos ao mesmo tempo (para que possa usar funções vetorizadas), consulte a Biblioteca de Kernel de Matemática da Intel.

Tem uma função sincos

De acordo com essa documentação, a média é de 13,08 relógios / elemento no core 2 duo no modo de alta precisão, o que eu acho que será ainda mais rápido que o fsincos.

Este artigo mostra como construir um algoritmo parabólico que gera o seno e o cosseno:

Truque DSP: Aproximação Parabólica Simultânea de Sin e Cos

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

Quando o desempenho é crítico para esse tipo de coisa, não é incomum introduzir uma tabela de pesquisa.

Para uma abordagem criativa, que tal expandir a série Taylor? Como eles têm termos semelhantes, você poderia fazer algo como o seguinte pseudo:

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
}

Isso significa que você faz algo assim: começando em x e 1 para sen e cosseno, siga o padrão - subtraia x ^ 2/2! do cosseno, subtraia x ^ 3/3! do seno, adicione x ^ 4/4! ao cosseno, adicione x ^ 5/5! para seno ...

Não tenho ideia se isso seria um bom desempenho. Se você precisar de menos precisão do que o sin () e o cos () integrados fornecem, pode ser uma opção.

Há uma boa solução na biblioteca CEPHES que pode ser bem rápida e você pode adicionar / remover precisão de forma bastante flexível por um pouco mais / menos tempo de CPU.

Lembre-se de que cos (x) e sin (x) são as partes reais e imaginárias de exp (ix). Portanto, queremos calcular exp (ix) para obter ambos. Pré-calculamos exp (iy) para alguns valores discretos de y entre 0 e 2pi. Mudamos x para o intervalo [0, 2pi). Em seguida, selecionamos y que está mais próximo de x e escrevemos
exp (ix) = exp (iy + (ix-iy)) = exp (iy) exp (i (xy)).

Obtemos exp (iy) da tabela de pesquisa. E desde | xy | for pequeno (no máximo metade da distância entre os valores de y), a série de Taylor convergirá bem em apenas alguns termos, então usamos isso para exp (i (xy)). E então precisamos apenas de uma multiplicação complexa para obter exp (ix).

Outra propriedade interessante disso é que você pode vetorizá-lo usando SSE.

Você pode querer dar uma olhada em http://gruntthepeon.free.fr/ssemath/ , que oferece uma implementação vetorizada SSE inspirada na biblioteca CEPHES. Tem boa precisão (desvio máximo de sin / cos na ordem de 5e-8) e velocidade (supera ligeiramente fsincos em uma base de chamada única e um vencedor claro sobre vários valores).

Eu postei uma solução envolvendo montagem ARM em linha capaz de calcular o seno e o cosseno de dois ângulos de uma vez aqui: Fast seno / cosseno para ARMv7 + NEON

Uma aproximação precisa, porém rápida, da função sin e cos simultaneamente, em javascript, pode ser encontrada aqui: http://danisraelmalta.github.io/Fmath/ (facilmente importado para c / c ++)

Você já pensou em declarar tabelas de pesquisa para as duas funções? Você ainda teria que "calcular" sin (x) e cos (x), mas seria decididamente mais rápido, se você não precisar de um alto grau de precisão.

O compilador MSVC pode usar as funções SSE2 (internas)

 ___libm_sse2_sincos_ (for x86)
 __libm_sse2_sincos_  (for x64)

em compilações otimizadas se os sinalizadores de compilador apropriados forem especificados (no mínimo / O2 / arch: SSE2 / fp: rápido). Os nomes dessas funções parecem implicar que elas não calculam sen e cos separados, mas ambos "em uma única etapa".

Por exemplo:

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

Montagem (para x86) com / fp: rápido:

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

Montagem (para x86) sem / fp: rápido, mas com / fp: preciso em vez (que é o padrão) chama sen e cos separados:

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

Portanto, / fp: fast é obrigatório para a otimização do sincos.

Mas observe que

___libm_sse2_sincos_

talvez não seja tão preciso quanto

__libm_sse2_sin_precise
__libm_sse2_cos_precise

devido à falta de "preciso" no final de seu nome.

No meu sistema "ligeiramente" mais antigo (Intel Core 2 Duo E6750) com o compilador MSVC 2019 mais recente e otimizações apropriadas, meu benchmark mostra que a chamada sincos é cerca de 2,4 vezes mais rápida do que chamadas sin e cos separadas.