¿Cuál es la forma más rápida de calcular sin y cos juntos?

Me gustaría calcular el seno y el coseno de un valor juntos (por ejemplo, para crear una matriz de rotación). Por supuesto, podría calcularlos por separado uno tras otro a = cos(x); b = sin(x);, pero me pregunto si hay una forma más rápida cuando se necesitan ambos valores.

Editar: para resumir las respuestas hasta ahora:

• Vlad dijo que existe el comando asm que losFSINCOScalcula a ambos (casi al mismo tiempo que una llamada aFSINsolo)

• Como advirtió Chi , esta optimización a veces ya la realiza el compilador (cuando se utilizan indicadores de optimización).

• caf señaló, que las funcionessincosysincosfprobablemente están disponibles y se pueden llamar directamente con solo incluirmath.h

• El enfoque de tanascius del uso de una tabla de consulta es controvertido. (Sin embargo, en mi computadora y en un escenario de referencia, se ejecuta 3 veces más rápido quesincoscon casi la misma precisión para puntos flotantes de 32 bits).

• Joel Goodwin se vinculó a un enfoque interesante de una técnica de aproximación extremadamente rápida con una precisión bastante buena (para mí, esto es incluso más rápido que la búsqueda de tablas)

Los procesadores Intel / AMD modernos tienen instrucciones FSINCOSpara calcular funciones de seno y coseno simultáneamente. Si necesita una optimización sólida, tal vez debería usarla.

Aquí hay un pequeño ejemplo: http://home.broadpark.no/~alein/fsincos.html

Aquí hay otro ejemplo (para MSVC): http://www.codeguru.com/forum/showthread.php?t=328669

Aquí hay otro ejemplo (con gcc): http://www.allegro.cc/forums/thread/588470

Espero que alguno de ellos ayude. (No utilicé esta instrucción, lo siento).

Como son compatibles a nivel de procesador, espero que sean mucho más rápidos que las búsquedas de tablas.

Editar:
Wikipedia sugiere que FSINCOSse agregó en 387 procesadores, por lo que difícilmente puede encontrar un procesador que no lo admita.

Editar:
la documentación de Intel indica que FSINCOSes aproximadamente 5 veces más lento que FDIV(es decir, división de punto flotante).

Editar:
tenga en cuenta que no todos los compiladores modernos optimizan el cálculo de seno y coseno en una llamada a FSINCOS. En particular, mi VS 2008 no lo hizo de esa manera.

Editar:
El primer enlace de ejemplo está muerto, pero todavía hay una versión en Wayback Machine .

Los procesadores x86 modernos tienen una instrucción fsincos que hará exactamente lo que está pidiendo: calcular sin y cos al mismo tiempo. Un buen compilador de optimización debería detectar el código que calcula sin y cos para el mismo valor y usar el comando fsincos para ejecutarlo.

Se necesitaron algunos juegos de banderas del compilador para que esto funcionara, pero:

$ 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, usa la instrucción fsincos!

Cuando necesite rendimiento, puede usar una tabla sin / cos precalculada (una tabla servirá, almacenada como un diccionario). Bueno, depende de la precisión que necesites (quizás la mesa sea demasiado grande), pero debería ser muy rápido.

Técnicamente, lograrías esto usando números complejos y la fórmula de Euler . Por lo tanto, 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();

debería darte seno y coseno en un solo paso. Cómo se hace esto internamente depende del compilador y la biblioteca que se utilicen. Podría (y podría) llevar más tiempo hacerlo de esta manera (solo porque la Fórmula de Euler se usa principalmente para calcular el complejo expusando siny cos, y no al revés) pero podría haber alguna optimización teórica posible.

Editar

Los encabezados <complex>de GNU C ++ 4.2 utilizan cálculos explícitos de siny cosadentro polar, por lo que no se ve demasiado bien para las optimizaciones allí a menos que el compilador haga algo de magia (vea los interruptores -ffast-mathy -mfpmathcomo está escrito en la respuesta de Chi ).

Puede calcular cualquiera y luego usar la identidad:

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

pero como dice @tanascius, una tabla precalculada es el camino a seguir.

Si usa la biblioteca GNU C, entonces puede hacer:

#define _GNU_SOURCE
#include <math.h>

y obtendrá declaraciones de las funciones sincos(), sincosf()y sincosl()que calculan ambos valores juntos, presumiblemente de la manera más rápida para su arquitectura de destino.

Hay cosas muy interesantes en esta página del foro, que se centra en encontrar buenas aproximaciones que sean rápidas: http://www.devmaster.net/forums/showthread.php?t=5784

Descargo de responsabilidad: no utilicé nada de esto yo mismo.

Actualización 22 de febrero de 2018: Wayback Machine es la única forma de visitar la página original ahora: https://web.archive.org/web/20130927121234/http://devmaster.net/posts/9648/fast-and-accurate- seno-coseno

Muchas bibliotecas matemáticas de C, como indica caf, ya tienen sincos (). La excepción notable es MSVC.

• Sun ha tenido sincos () desde al menos 1987 (veintitrés años; tengo una página de manual impresa)
• HPUX 11 lo tenía en 1997 (pero no está en HPUX 10.20)
• Agregado a glibc en la versión 2.1 (febrero de 1999)
• Se convirtió en una función integrada en gcc 3.4 (2004), __builtin_sincos ().

Y con respecto a la búsqueda, Eric S. Raymond en Art of Unix Programming (2004) (Capítulo 12) dice explícitamente que esta es una mala idea (en el momento actual):

"Otro ejemplo es el cálculo previo de tablas pequeñas; por ejemplo, una tabla de sin (x) por grado para optimizar las rotaciones en un motor de gráficos 3D ocuparía 365 × 4 bytes en una máquina moderna. Antes de que los procesadores fueran lo suficientemente más rápidos que la memoria para exigir el almacenamiento en caché , esta fue una optimización de velocidad obvia. Hoy en día, puede ser más rápido volver a calcular cada vez que pagar el porcentaje de pérdidas de caché adicionales causadas por la tabla.

"Pero en el futuro, esto podría cambiar de nuevo a medida que los cachés crezcan. De manera más general, muchas optimizaciones son temporales y pueden convertirse fácilmente en pesimizaciones a medida que cambian los índices de costos. La única forma de saberlo es medir y ver". (del arte de la programación Unix )

Pero, a juzgar por la discusión anterior, no todos están de acuerdo.

No creo que las tablas de búsqueda sean necesariamente una buena idea para este problema. A menos que sus requisitos de precisión sean muy bajos, la mesa debe ser muy grande. Y las CPU modernas pueden realizar muchos cálculos mientras se obtiene un valor de la memoria principal. Esta no es una de esas preguntas que pueden responderse adecuadamente con un argumento (ni siquiera el mío), probar y medir y considerar los datos.

Pero buscaría las implementaciones rápidas de SinCos que se encuentran en bibliotecas como ACML de AMD y MKL de Intel.

Si está dispuesto a utilizar un producto comercial y está calculando una serie de cálculos sin / cos al mismo tiempo (para poder utilizar funciones vectoriales), debería consultar la biblioteca de kernel matemática de Intel.

Tiene una función sincos

De acuerdo con esa documentación, promedia 13.08 relojes / elemento en core 2 duo en modo de alta precisión, que creo que será incluso más rápido que fsincos.

Este artículo muestra cómo construir un algoritmo parabólico que genera tanto el seno como el coseno:

Truco DSP: Aproximación parabólica simultánea de Sin y Cos

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

Cuando el rendimiento es fundamental para este tipo de cosas, no es inusual introducir una tabla de búsqueda.

Para un enfoque creativo, ¿qué tal expandir la serie Taylor? Dado que tienen términos similares, podría hacer algo como el siguiente 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
}

Esto significa que haces algo como esto: comenzando en xy 1 para el pecado y el coseno, sigue el patrón: reste x ^ 2/2. del coseno, reste x ^ 3/3! desde el seno, agregue x ^ 4/4! al coseno, suma x ^ 5/5! a seno ...

No tengo idea de si esto funcionaría bien. Si necesita menos precisión que la incorporada sin () y cos (), puede ser una opción.

Hay una buena solución en la biblioteca CEPHES que puede ser bastante rápida y puede agregar / eliminar precisión de manera bastante flexible por un poco más / menos de tiempo de CPU.

Recuerde que cos (x) y sin (x) son las partes real e imaginaria de exp (ix). Entonces queremos calcular exp (ix) para obtener ambos. Calculamos previamente exp (iy) para algunos valores discretos de y entre 0 y 2pi. Cambiamos x al intervalo [0, 2pi). Luego seleccionamos la y que está más cerca de x y escribimos
exp (ix) = exp (iy + (ix-iy)) = exp (iy) exp (i (xy)).

Obtenemos exp (iy) de la tabla de búsqueda. Y desde | xy | es pequeña (como mucho la mitad de la distancia entre los valores de y), la serie de Taylor convergerá muy bien en unos pocos términos, por lo que la usamos para exp (i (xy)). Y luego solo necesitamos una multiplicación compleja para obtener exp (ix).

Otra buena propiedad de esto es que puedes vectorizarlo usando SSE.

Es posible que desee echar un vistazo a http://gruntthepeon.free.fr/ssemath/ , que ofrece una implementación vectorizada SSE inspirada en la biblioteca CEPHES. Tiene buena precisión (desviación máxima de sin / cos en el orden de 5e-8) y velocidad (supera ligeramente a fsincos en una sola llamada y un claro ganador sobre múltiples valores).

He publicado una solución que implica un ensamblaje ARM en línea capaz de calcular tanto el seno como el coseno de dos ángulos a la vez aquí: seno / coseno rápido para ARMv7 + NEON

Se puede encontrar una aproximación precisa pero rápida de la función sin y cos simultáneamente, en javascript, aquí: http://danisraelmalta.github.io/Fmath/ (se importa fácilmente a c / c ++)

¿Ha pensado en declarar tablas de búsqueda para las dos funciones? Aún tendría que "calcular" sin (x) y cos (x), pero sería decididamente más rápido, si no necesita un alto grado de precisión.

El compilador de MSVC puede utilizar las funciones SSE2 (internas)

 ___libm_sse2_sincos_ (for x86)
 __libm_sse2_sincos_  (for x64)

en compilaciones optimizadas si se especifican los indicadores del compilador apropiados (al mínimo / O2 / arch: SSE2 / fp: fast). Los nombres de estas funciones parecen implicar que no calculan sen y cos por separado, sino que ambos "en un solo paso".

Por ejemplo:

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

Ensamblado (para x86) con / 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

Ensamblaje (para x86) sin / fp: rápido pero con / fp: preciso en su lugar (que es el predeterminado) llama sin y cos por separado:

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

Entonces / fp: fast es obligatorio para la optimización de sincos.

Pero tenga en cuenta que

___libm_sse2_sincos_

tal vez no sea tan preciso como

__libm_sse2_sin_precise
__libm_sse2_cos_precise

debido a la falta "precisa" al final de su nombre.

En mi sistema "ligeramente" más antiguo (Intel Core 2 Duo E6750) con el último compilador MSVC 2019 y las optimizaciones apropiadas, mi punto de referencia muestra que la llamada sincos es aproximadamente 2,4 veces más rápida que las llamadas sin y cos por separado.