Reklama
Nepřihlášený uživatel | Zaregistrovat se
 

Téma:

Věda a technika, mládeži

Spravují:

arnost,
snop

Může vás zajímat



Reklama



pojmy a tak naleznete docela dobre vysvetlene a definovane zde (Wikipedia)
Nebo z jineho zdroje zde (Math Thesaurus)

pripadne se zkuste pohrabat v nejvetsi encyklopedii matematiky: http://mathworld.wolfram.com/


dupinozka co kdyby vyšetřující personál byl nahý 
Já sním čehokoliv podobného přesně tolik, kolik si toho koupím, a to i v případě, že už v průběhu akce mi z toho není volno.
r0b0t ~ matika šmatika ~  braidd drwg
Ano. :-(
radamec Staňte se členy  FRA
Ty sníš jedenáct sušenek?
(M&S věci jsou obvykle celkem dobré)
Reakce na | Vlákno  
ocs sine ira et studio  OCSite
(Nonevím, raději bych to nadrobil sýkorkám. Mám děti hodně rád, ale obětovat se pro ně tak, abych jedl něco jako tohle?!? :-O)
r0b0t ~ matika šmatika ~  braidd drwg
Ano, každé číslo je dělitelné jedničkou. :)

(Jedná se tu samozřejmě o čistě akademický problém. Ve skutečném světě rodič sám zbaští příslušný počet sušenek, aby bylo spravedlnosti učiněno zadost.)
dupinozka co kdyby vyšetřující personál byl nahý 
Jedno?
ocs sine ira et studio  OCSite
Minimální počet je jedno.
r0b0t ~ matika šmatika ~  braidd drwg
Nicméně sem jdu po dnešním náročném dni hlavně s tímhle.

Spočítejte si sušenky, zamyslete se nad tím, kolik musíte mít dětí, abyste je mezi ně rozdělili rovným dílem.


M&S -- trolling hard
 
r0b0t ~ matika šmatika ~  braidd drwg
To xyzw bude spíš ijk1, ne? Jinak chápu. (Akorát ta Rodriguesova formule mi nějak nevyšla. Mimochodem -- je to ne na dvacet násobení, ale na 15.)
Budu hádat… to q.xyz je vektorová část kvaternionu q a q.w je jeho skalární část. Je to tak?
My nemáme oddělenej typ pro vektor a kvaternion, máme prostě nějáký vec4, a vzhleden k tomu, že z 99% tam ukládáme vektory v homogenních souřadnicích, tak se jeho komponenty jmenují x, y, z, w, a když máme nějákou funkci, která s vektory pracuje jako s kvaterniony, tak xyzw se interpretuje jako 1ijk.
r0b0t ~ matika šmatika ~  braidd drwg
Jo aha, my se nemusíme omezovat na jednotkové kvaterniony, takže máme k dispozici mnohem větší a nekompaktní grupu!
r0b0t ~ matika šmatika ~  braidd drwg
Na kolik násobení se dají udělat ty matice?

Budu hádat... to q.xyz je vektorová část kvaternionu q a q.w je jeho skalární část. Je to tak?

Zkusím se zamyslet, jestli se pomocí kvaternionů nedají dělat i neortogonální transformace. (Pomocí těch standardních určitě ne, protože násobení kvaternionem je element grupy SO(4) a do ní nejde vnořit nic nekompaktního.)

(Ty jiné verze kvaternionů se občas používají v modelování kinematiky tuhých těles nebo v něčem podobném.)
Kdepak, myslím normální sešikmující transformaci.
Rotace kvaternionem, pokud jí uděláš takovým tím kanonickým způsobem, je dražší než násobení transformační maticí. Ale dá se přepsat tak, že to vychází asi na 20 násobení:

v' = q * v * conjugate(q)

se dá přepsat jako

t = 2 * cross(q.xyz, v)
v' = v + q.w * t + cross(q.xyz, t)

Ale jak říkám, nám to nestačí, protože potřebujeme transformace s neuniformním scalem a sešikmením.
r0b0t ~ matika šmatika ~  braidd drwg
Dík!

Co myslíš tím skew? Skew-kvaterniony? (Další doplňující dotazy si nechám na zítřek.)
Jo, to jsem napsal blbě :) Myslím na vektorovou aritmetiku a lineární algebru, a napíšu vektorová algebra.

Většina normálních enginů si vystačí se single precision (32bit) floaty. Single precision má na mantissu alokováno 23 bitů, z toho vychází, že bude přesnej tak na 6 signifikantních číslic -> pokud máš origin ve středu země, tak na povrchu vzdálenám 6378 km máš přesnost asi na jeden metr, takže počítat s double precision je nutnost.

Intelácký procesory mají už od dob Pentia 3 sadu instrukcí SSE: osm registrů (xmm0 - xmm7), každý o velikosti 128 bitů a sadu instrukcí, které s nimi zacházejí jako s vektorem 4x32bit floatů nebo 2x64bit doublů. Od procesorů Sandy Bridge a novějších (tj. 2011) mají intelácký procesory instrukční sadu AVX - 16 registrů o délce 256 bitů (ymm0 - ymm15) a instrukce, které s nimi zacházejí jako s 4x64bit doublama (nebo 8x32bit floatama). Problém je, že kompilery se snaží tyhle instrukční sady využívat, ale moc jim to nejde.
Když si třeba v C++ uděláš vector4 klasicky jako strukturu se čtyřma doublama a přetížíš na ní nějáký ten operátor násobení nebo sčítání, tak se ti to přeloží jako 4 x mulsd / addsd (tedy SSE instrukce, které pracují jenom s prvním prvkem toho vektoru - MULtiply Scalar Double), zatímco my bysme chtěli jednu instrukci MULtiply Packed Double. To musíš říct kompileru dost explicitně - proměnné si deklarovat jako nějáký speciální typ __mm256, používat intrinsic funkce (typu _mm256_mul_pd() - emitují AVX instrukce, psaní je jenom o málo pohodlnější než psaní assembleru), a hlavně se starat o to, aby bylo všechno alignovaný na 32 bajtů, protože unaligned verze instrukcí, které loadujou/storujou tyhle xmm / ymm registry jsou třeba 2x pomalejší.

Takhle třeba vypadá násobení kvaternionů (tohle je verze z knihovny DirectXMath, která je mimochodem dost dobrá, ale jenom single precision):

inline XMVECTOR XM_CALLCONV XMQuaternionMultiply ( FXMVECTOR Q1, FXMVECTOR Q2 ) { // Returns the product Q2*Q1 (which is the concatenation of a rotation Q1 followed by the rotation Q2) // [ (Q2.w * Q1.x) + (Q2.x * Q1.w) + (Q2.y * Q1.z) - (Q2.z * Q1.y), // (Q2.w * Q1.y) - (Q2.x * Q1.z) + (Q2.y * Q1.w) + (Q2.z * Q1.x), // (Q2.w * Q1.z) + (Q2.x * Q1.y) - (Q2.y * Q1.x) + (Q2.z * Q1.w), // (Q2.w * Q1.w) - (Q2.x * Q1.x) - (Q2.y * Q1.y) - (Q2.z * Q1.z) ] static const XMVECTORF32 ControlWZYX = { 1.0f,-1.0f, 1.0f,-1.0f}; static const XMVECTORF32 ControlZWXY = { 1.0f, 1.0f,-1.0f,-1.0f}; static const XMVECTORF32 ControlYXWZ = {-1.0f, 1.0f, 1.0f,-1.0f}; // Copy to SSE registers and use as few as possible for x86 XMVECTOR Q2X = Q2; XMVECTOR Q2Y = Q2; XMVECTOR Q2Z = Q2; XMVECTOR vResult = Q2; // Splat with one instruction vResult = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(3,3,3,3)); Q2X = XM_PERMUTE_PS(Q2X,_MM_SHUFFLE(0,0,0,0)); Q2Y = XM_PERMUTE_PS(Q2Y,_MM_SHUFFLE(1,1,1,1)); Q2Z = XM_PERMUTE_PS(Q2Z,_MM_SHUFFLE(2,2,2,2)); // Retire Q1 and perform Q1*Q2W vResult = _mm_mul_ps(vResult,Q1); XMVECTOR Q1Shuffle = Q1; // Shuffle the copies of Q1 Q1Shuffle = XM_PERMUTE_PS(Q1Shuffle,_MM_SHUFFLE(0,1,2,3)); // Mul by Q1WZYX Q2X = _mm_mul_ps(Q2X,Q1Shuffle); Q1Shuffle = XM_PERMUTE_PS(Q1Shuffle,_MM_SHUFFLE(2,3,0,1)); // Flip the signs on y and z Q2X = _mm_mul_ps(Q2X,ControlWZYX); // Mul by Q1ZWXY Q2Y = _mm_mul_ps(Q2Y,Q1Shuffle); Q1Shuffle = XM_PERMUTE_PS(Q1Shuffle,_MM_SHUFFLE(0,1,2,3)); // Flip the signs on z and w Q2Y = _mm_mul_ps(Q2Y,ControlZWXY); // Mul by Q1YXWZ Q2Z = _mm_mul_ps(Q2Z,Q1Shuffle); vResult = _mm_add_ps(vResult,Q2X); // Flip the signs on x and w Q2Z = _mm_mul_ps(Q2Z,ControlYXWZ); Q2Y = _mm_add_ps(Q2Y,Q2Z); vResult = _mm_add_ps(vResult,Q2Y); return vResult; }
Zrovna co se týče těch kvaternionů, ty používáme na skeletální animace, ale pro transformace ve vertex shaderech a podobně používáme normální matice. Občas potřebujeme i skew, kvaterniony by nám nestačily.
r0b0t ~ matika šmatika ~  braidd drwg
Tak můžeš začít třeba tím, cos konkrétně myslel tou vektorou algebrou, do čeho přesně si to přepisoval a jaké zrychlení to přineslo. :)

Doplňující dotazy: Proč tyhle věci nedělat na GPU? Používáte kvaterniony případně nějaké jiné "exotické" algebraické struktury?

(Navazujeme na toto.)
Čau, r0b0t psal, že se tady mám zastavit. Tak já nevim, jestli se chcete na něco zeptat :)
 
arnost snad nechci tak   moks
The Number of the Beast (Heinlein), Flatland
DadB jsem zralý na  šrotovné
Dotaz: Přišla včera řeč na vícerozměrné světy a jiné borcení dimenzí... Na odreagování jsem doporučil tyto povídky: Domeček jako klícka (Robert A. Heinlein, čtyřrozměrná krychle), Podzemní dráha Möbius (Armin J. Deutsch, téma jasné) a Stěna z temnoty (A. C. Clarke, také v podstatě Möbiova páska)
Napadají vás nějaké další? Dík.