Günah ve cos'u birlikte hesaplamanın en hızlı yolu nedir?

Bir değerin hem sinüsünü hem de eş sinüsünü birlikte hesaplamak istiyorum (örneğin bir rotasyon matrisi oluşturmak için). Tabii ki onları birbiri ardına ayrı ayrı hesaplayabilirim a = cos(x); b = sin(x);, ancak her iki değere de ihtiyaç duymanın daha hızlı bir yolu olup olmadığını merak ediyorum.

Düzenleme: Şimdiye kadarki cevapları özetlemek için:

• Vlad ,FSINCOSikisini de hesaplayanasm komutuolduğunu söyledi (neredeyseFSINtek başınabir çağrı ile aynı zamanda)

• Gibi Chi fark bu optimizasyon bazen zaten (optimizasyon bayrakları kullanılırken) derleyici tarafından yapılır.

• caf , çalıştığınısincosvesincosfmuhtemelen mevcut olduğunu ve sadece dahil edilerek doğrudan çağrılabileceğini belirtti.math.h

• Bir taramalı tablo kullanmanın tanascius yaklaşımı tartışmalı olarak tartışılmaktadır. (Bununla birlikte, bilgisayarımda ve bir kıyaslama senaryosundasincos, 32-bit kayan noktalar için neredeyse aynı doğruluklaolduğundan 3 kat daha hızlı çalışır.)

• Joel Goodwin , oldukça hızlı bir yaklaşım tekniğinin ilginç bir yaklaşımını oldukça iyi bir doğrulukla ilişkilendirdi (benim için bu, tablo aramasından daha hızlı)

Modern Intel / AMD işlemciler, FSINCOSaynı anda sinüs ve kosinüs işlevlerini hesaplamak için talimatlara sahiptir . Güçlü bir optimizasyona ihtiyacınız varsa, belki onu kullanmalısınız.

İşte küçük bir örnek: http://home.broadpark.no/~alein/fsincos.html

İşte başka bir örnek (MSVC için): http://www.codeguru.com/forum/showthread.php?t=328669

İşte başka bir örnek (gcc ile): http://www.allegro.cc/forums/thread/588470

Umarım içlerinden biri yardımcı olur. (Bu talimatı kendim kullanmadım, üzgünüm.)

İşlemci düzeyinde desteklendikleri için, tablo aramalarından çok daha hızlı olmalarını bekliyorum.

Düzenleme:
WikipediaFSINCOS , 387 işlemciye eklendiğini öne sürüyor , bu yüzden onu desteklemeyen bir işlemci bulmanız çok zor.

Düzenleme:
Intel'in belgeleri , FSINCOSbunun yaklaşık 5 kat daha yavaş olduğunu belirtir FDIV(yani, kayan nokta bölme).

Düzenleme:
Lütfen tüm modern derleyicilerin sinüs ve kosinüs hesaplamasını bir çağrıya dönüştürmediğini unutmayın FSINCOS. Özellikle, VS 2008'im bu şekilde yapmadı.

Düzenleme:
İlk örnek bağlantı öldü, ancak Wayback Machine'de hala bir sürüm var .

Modern x86 işlemcilerin, tam olarak istediğiniz şeyi yapacak bir fsincos talimatı vardır - aynı anda hem günah hem de cos hesaplayın. İyi bir optimizasyon derleyicisi, aynı değer için sin ve cos hesaplayan kodu algılamalı ve bunu yürütmek için fsincos komutunu kullanmalıdır.

Bunun çalışması için derleyici bayraklarının biraz karıştırılması gerekiyordu, ancak:

$ 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, fsincos talimatını kullanıyor!

Performansa ihtiyacınız olduğunda, önceden hesaplanmış bir sin / cos tablosu kullanabilirsiniz (Sözlük olarak saklanan bir tablo olacaktır). İhtiyacınız olan doğruluğa bağlıdır (belki masa büyük olabilir), ancak gerçekten hızlı olmalı.

Teknik olarak, bunu karmaşık sayılar ve Euler Formülü kullanarak elde edersiniz . Böylece (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();

tek adımda size sinüs ve kosinüs vermelidir. Bunun dahili olarak nasıl yapıldığı, kullanılan derleyici ve kitaplığın sorusudur. Bunu bu şekilde yapmak daha uzun sürebilir (ve olabilir) (çünkü Euler'in Formülü çoğunlukla kompleksi ve expkullanarak hesaplamak için kullanılır - ve tersi değil), ancak bazı teorik optimizasyonlar mümkün olabilir.sincos

Düzenle

<complex>GNU C ++ 4.2'nin başlıkları açık sinve cosiç hesaplamalarını kullanıyor polar, bu nedenle derleyici biraz sihir yapmadıkça orada optimizasyonlar için çok iyi görünmüyor ( Chi'nin cevabında yazılan -ffast-mathve -mfpmathanahtarlarına bakın ).

Bunlardan birini hesaplayabilir ve ardından kimliği kullanabilirsiniz:

cos (x) 2 = 1 - günah (x) 2

ancak @tanascius'un dediği gibi, önceden hesaplanmış bir tablo gitmenin yoludur.

GNU C kitaplığını kullanıyorsanız, şunları yapabilirsiniz:

#define _GNU_SOURCE
#include <math.h>

ve her iki değeri birlikte hesaplayan sincos(), sincosf()ve sincosl()işlevlerinin bildirimlerini alacaksınız - muhtemelen hedef mimariniz için en hızlı şekilde.

Bu forum sayfasında, hızlı ve iyi tahminler bulmaya odaklanan çok ilginç şeyler var: http://www.devmaster.net/forums/showthread.php?t=5784

Sorumluluk Reddi: Bunlardan hiçbirini kendim kullanmadım.

Güncelleme 22 Şubat 2018: Wayback Machine şu anda orijinal sayfayı ziyaret etmenin tek yoludur: https://web.archive.org/web/20130927121234/http://devmaster.net/posts/9648/fast-and-accurate- sinüs-kosinüs

Caf'in belirttiği gibi birçok C matematik kütüphanesinde zaten sincos () bulunur. Dikkate değer istisna MSVC'dir.

• Sun, en az 1987'den beri sinco'lara () sahiptir (yirmi üç yıldır; basılı bir man sayfam var)
• HPUX 11, 1997'de vardı (ancak HPUX 10.20'de değil)
• 2.1 sürümünde glibc'ye eklendi (Şubat 1999)
• Yerleşik bir gcc 3.4 (2004), __builtin_sincos () oldu.

Ve ilişkin taramalı, Eric S. Raymond Unix Programlama Sanatı (2004) (Bölüm 12) bu (zaman mevcut şu anda) kötü bir fikir açıkça diyor ki:

"Başka bir örnek, küçük tabloların ön hesaplanmasıdır - örneğin, bir 3B grafik motorundaki dönüşleri optimize etmek için derece derece bir günah (x) tablosu, modern bir makinede 365 × 4 bayt alacaktır. İşlemciler, önbelleğe alma talebinde bulunmak için bellekten yeterince hızlı olmadan önce Bu bariz bir hız optimizasyonuydu. Günümüzde, tablonun neden olduğu ek önbellek kayıplarının yüzdesini ödemek yerine her seferinde yeniden hesaplamak daha hızlı olabilir.

"Ancak gelecekte, önbellekler büyüdükçe bu durum tekrar dönebilir. Daha genel olarak, çoğu optimizasyon geçicidir ve maliyet oranları değiştikçe kolayca kötümserleştirmelere dönüşebilir. Bilmenin tek yolu ölçmek ve görmektir." ( Unix Programlama Sanatından )

Ancak yukarıdaki tartışmadan yola çıkarsak, herkes aynı fikirde değil.

Arama tablolarının bu sorun için mutlaka iyi bir fikir olduğuna inanmıyorum. Doğruluk gereksinimleriniz çok düşük olmadığı sürece, tablonun çok büyük olması gerekir. Ve modern CPU'lar, ana bellekten bir değer getirilirken çok fazla hesaplama yapabilir. Bu, argümanla (benim bile değil) doğru bir şekilde cevaplanabilecek, verileri test edip ölçebilecek ve dikkate alabilecek sorulardan biri değil.

Ancak AMD'nin ACML'si ve Intel'in MKL'si gibi kütüphanelerde bulabileceğiniz SinCos'un hızlı uygulamalarına bakacağım.

Ticari bir ürün kullanmak istiyorsanız ve aynı anda bir dizi sin / cos hesaplaması yapıyorsanız (böylece vektörel fonksiyonları kullanabilirsiniz), Intel'in Math Kernel Kitaplığına göz atmalısınız .

Bu bir var SinCos işlevi

Bu belgelere göre, yüksek doğruluk modunda core 2 duo'da ortalama 13.08 saat / öğe alıyor, ki bu fsincos'tan bile daha hızlı olacak.

Bu makale, hem sinüs hem de kosinüsü üreten bir parabolik algoritmanın nasıl oluşturulacağını göstermektedir:

DSP Trick: Sin ve Cos'un Eşzamanlı Parabolik Yaklaşımı

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

Performans bu tür bir şey için kritik olduğunda, bir arama tablosu sunmak alışılmadık bir durum değildir.

Yaratıcı bir yaklaşım için Taylor serisini genişletmeye ne dersiniz? Benzer terimleri olduğundan, aşağıdaki sözde bir şey yapabilirsiniz:

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
}

Bu, şöyle bir şey yaptığınız anlamına gelir: günah ve kosinüs için x ve 1'den başlayarak, kalıbı takip edin - x ^ 2 / 2'yi çıkarın! kosinüsten, x ^ 3 / 3'ü çıkarın! sinüsten x ^ 4/4 ekleyin! kosinüs için x ^ 5/5 ekleyin! sinüs ...

Bunun performans olup olmayacağı konusunda hiçbir fikrim yok. Dahili sin () ve cos () 'nin size verdiğinden daha az kesinliğe ihtiyacınız varsa, bu bir seçenek olabilir.

CEPHES kütüphanesinde oldukça hızlı olabilen güzel bir çözüm var ve biraz daha fazla / daha az CPU süresi için doğruluğu oldukça esnek bir şekilde ekleyebilir / kaldırabilirsiniz.

Cos (x) ve sin (x) 'in exp (ix)' in gerçek ve hayali kısımları olduğunu unutmayın. Bu yüzden ikisini birden elde etmek için exp (ix) hesaplamak istiyoruz. 0 ile 2pi arasındaki bazı ayrık y değerleri için exp (iy) 'i önceden hesaplıyoruz. X'i [0, 2pi) aralığına kaydırıyoruz. Daha sonra x'e en yakın
y'yi seçip exp (ix) = exp (iy + (ix-iy)) = exp (iy) exp (i (xy)) yazıyoruz.

Arama tablosundan exp (iy) alıyoruz. Ve | xy | küçüktür (y-değerleri arasındaki mesafenin en fazla yarısı), Taylor serisi sadece birkaç terimle güzelce yakınsar, bu yüzden bunu exp (i (xy)) için kullanıyoruz. Ve sonra exp (ix) elde etmek için karmaşık bir çarpmaya ihtiyacımız var.

Bunun bir başka güzel özelliği de SSE kullanarak vektörleştirebilmenizdir.

CEPHES kütüphanesinden esinlenerek bir SSE vektörleştirilmiş uygulama sunan http://gruntthepeon.free.fr/ssemath/ adresine bir göz atmak isteyebilirsiniz . İyi bir doğruluğa (5e-8 düzeninde sin / cos'dan maksimum sapma) ve hıza (tek bir çağrı bazında fsincos'tan biraz daha iyi performans gösterir ve birden fazla değere göre açık bir kazanan) sahiptir.

Burada bir seferde iki açının hem sinüsünü hem de kosinüsünü hesaplayabilen satır içi ARM montajını içeren bir çözüm yayınladım: ARMv7 + NEON için hızlı sinüs / kosinüs

Aynı anda javascript'te sin ve cos işlevinin doğru ancak hızlı bir yaklaşımı burada bulunabilir: http://danisraelmalta.github.io/Fmath/ (kolayca c / c ++ 'ya aktarılır)

İki işlev için arama tabloları bildirmeyi düşündünüz mü? Yine de sin (x) ve cos (x) 'i "hesaplamanız" gerekir, ancak yüksek derecede doğruluğa ihtiyacınız yoksa kesinlikle daha hızlı olacaktır.

MSVC derleyicisi (dahili) SSE2 işlevlerini kullanabilir

 ___libm_sse2_sincos_ (for x86)
 __libm_sse2_sincos_  (for x64)

optimize edilmiş yapılarda uygun derleyici bayrakları belirtilirse (minimum / O2 / arch: SSE2 / fp: hızlı). Bu işlevlerin isimleri, ayrı günah ve cos hesaplamadıklarını, ancak her ikisinin de "tek adımda" olduğunu ima ediyor gibi görünmektedir.

Örneğin:

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

/ Fp ile derleme (x86 için): hızlı:

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

Derleme (x86 için) olmadan / fp: hızlı ama bunun yerine / fp: kesin (varsayılandır) ayrı sin ve cos çağırır:

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

So / fp: fast, sincos optimizasyonu için zorunludur.

Ama lütfen unutmayın

___libm_sse2_sincos_

belki kadar kesin değil

__libm_sse2_sin_precise
__libm_sse2_cos_precise

adının sonunda eksik olan "kesin" nedeniyle.

En son MSVC 2019 derleyicisine ve uygun optimizasyonlara sahip "biraz" eski sistemimde (Intel Core 2 Duo E6750), kıyaslamam sincos çağrısının ayrı sin ve cos çağrılarından yaklaşık 2,4 kat daha hızlı olduğunu gösteriyor.