Další semestr za mnou (diskuse)

[Mrkva]

Jé, kolega!.

V současnosti mám za sebou 3. semestr, který někdo (někde ) označoval jako nejvíce praktický.

Destil (reálné jméno si nepamatuju, prostě zakladetl Duny online), na svém blogu.

Chtěl bych se zeptat: je Matematická logika/Logika(LOG/MLO) fakt masakr? Lineární algebra/úvod do algebry(LAG/ALG) byla nakonec docela v pohodě a logikou mě všichni straší.

Přednášky jsem navštěvoval, nejen kvůli špatným přednášejícím, ale také díky tomu, že byly od 7:30.

No, nevím, který vůl dělá rozvrhy, ale přednáška od 7:30 je zabiják. Už se těším na pondělní pravděpodobnost a statistiku... Budu muset jezdit do Prahy v neděli. Sakra.

Ústní zkouška vůbec není (zdá se mi to trochu divné, protože jsem se s tím ještě nesetkal a navíc si nejsem jistý, jestli to nějak neodporuje školnímu řádu).

ÚOS a známka ze semestru? Agoritimizace, Matalýza, Algebra a podobné předměty ze kterých je ústí jen volitelná?

P.S.: já měl hotovo za 14 dní :)

[Saljack]

Nevím co všichni s tou logikou mají, mě to přišlo úplně v pohodě. Na přednášky jsem vůbec nechodil protože přednášející si mluvil sám pro sebe a navíc do tabule. Cvičení stály taky za nic. Zápočet dostal každý kdo tam chodil jiné podmínky tam nebyly. Rozhodně je logika mnohem logičtější než algebra. Je taky pravda, že mě všechny předměty co měli v názvu matematiku na FELu jdou a baví dokonce mě baví . Vy máte pravděpodobnost a statistiku povinnou? Já jsem si jí chtěl taky zapsat, ale chtělo to po mě snad Matematiku 2.

[Saljack]

Ústní je volitelná všude, ale tady ústní vůbec není.

[kotyz]

ja uz zazil takovejch predmetu kde nebyl ani zapocet, ale jenom zkouska a to formou testu o deseti otazkach na abcd

[vulgární Nick]

Rozhodně je logika mnohem logičtější než algebra

Algebra je zase algebraičtější; všechno má něco.

Jinak navrhuji promptní zápis předmětu Čeština pro začátečníky.

[David Watzke]

Jinak navrhuji promptní zápis předmětu Čeština pro začátečníky.

Já jsem se jednou pro zajímavost díval na ty testy z češtiny (2-2) pro cizince a musím říct, že bych se u toho občas zapotil i já... Čeština musí bejt fakt pakárna pro cizince.

[Saljack]

To znamená, že na sebe logika nějak navazuje a dává to smysl na rozdíl od algebry, která pro prváka rozhodně nedává smysl. Spoustu vět, které se v algebře (Úvod do lineární algebry) učí, je naprosto k ničemu, když se s tím rovnou neučí jejich využití. Pak se stane, jako v mém případě, že vám ty věty dojdou až o rok později při jejich využití a to je podle mě špatně.

[CET]

Ale gramatiku na stredi jsi prolez jen tak tak co? Nastesti ta se na VS nehodnoti, jinak bys vylitnul asi na ni

[Jakub Lucký]

Jak kde... U nás na mediálních studiích je součástí známky z testu ( aspoň v některých předmětech, ale zpravidla těch, které mají test rozepisovací ) i pravopis a gramatika...

[David Watzke]

Dík za zápisek, rád jsem si ho přečet.

[CIJOML]

Jak to tak ctu, tak jsem rad, ze jsem studoval jeste ve starem programu a hlavne vsemi kantory, kteri potom utekli na FIT...

[Luboš Doležel (Doli)]

Velká část jich učí na FELu dál. Akorát by bylo praktické, aby průkazky FELáků fungovaly i do FITu, protože teď je to otrava, když tam člověk za těmi učiteli musí chodit a má v cestě venkovní dveře a turniket...

[Saljack]

A proč?

[CIJOML]

ja osobne sest matematik, teorii pole, teorie obvodu, obe fyziky povazuju za dulezite pro IT oblast. Mno a rozdeleni fakult schvaluji, ale STM se od praktickeho a uzce zamereneho oboru na IT velmi odchylilo...

[Saljack]

Za sebou již mám 4 matematiky. Na co fyziku? Předměty jako je elektrotechniky pro informatiky a struktura a architektura počítačů jsou jako základ podle mě dostačující. Jestli to studenta zajímá podrobněji může si libovolný z jmenovaných předmětů zapsat nebo doučit.

[CIJOML]

algebru a matematickou logiku taky? Na co fyziku? Tezko muzes programovat treba 3D simulace bez znalosti fyziky.

[Luboš Doležel (Doli)]

To aby se pak programátor učil úplně všechno, kdyby to pak náhodou potřeboval simulovat.

[Fluttershy, yay!]

Třeba sociologii.

[CIJOML]

skola ma poskytnout prehled znalosti nezalezi zdali se s danou problematikou clovek bude v zivote dale zaobirat. Ale to je na dalsi flame a na tu nemam cas. Staci se podivat na diskuzi na fel foru kdyz STM vznikal. Jsou tam nazory pro i proti. Podle me STMaci jsou proste jen tretinovy absolventi FEL. Z elektroinzenyra nemaji temer nic.

[Saljack]

Ano algebru a logiku jsem počítal do matematik. Čekal jsem, že napíšeš, že fyzika je důležitá kvůli elektřině atp. To co jsi uvedl je naprostý nesmysl, protože by informatik musel umět všechno. To by potom měla být důležitá i chemie, takže pokud jí nemáte nejste informatik. Příjde mi, že na STM každý hází jenom hnůj a jak je ten program podružný a na nic. Přitom si jsou s otevřenou informatikou dosti podobné a na tu jsem nikoho nadávat neviděl.

[Josef Kufner]

Tak zrovna STM je mnohem povedenější než byla výpočetka na EaI. Ne že by to byl nějaký zázrak, ale bylo to celkem výrazné zlepšení. Vystudované mám obojí, takže jsou to zkušenosti z první ruky.

[Vskutečnosti Saýc]

Jo, to vyrazne zlepseni bylo predpokladam vynechani teorie grafu, opracnich systemu a automatu a gramatik. Tuhle diskusi uz jsme tu meli.

[Josef Kufner]

Zrovna tomuhle jsem pozornost moc nevěnoval, protože už jsem to měl jednou hotové a znovu jsem to nedělal. Spíš jsem teď měl na mysli vynechání věcí jako třeba fyzika, el. obvody a el. materiály. A hlavně přidání věcí o návrhu programů. Nicméně oba obory stály za prd.

[karel]

Na druhou stranu je v STM dost volitelných předmětů takže není problém si chybějící předměty dozapsat. Teorie grafů byla na FELu dost nepovedená. Kromě názvosloví a základních algoritmů se neprobralo nic (pamatuju si, že v 9. týdnu semestru!!! jsme na cvičení psali kontrolní písemku z názvosloví). Dalo se to bez problémů zvládnout v poloviční době. Z lidí co pokračují dál na magistra si tyhle předměty zapsali skoro všichni (dokonce to bylo i v bílé knize). Samozřejmě, že když si to někdo chtěl ulehčit, tak si zapsal programování v PHP nebo etiku apod.

[Luboš Doležel (Doli)]

Odchod Vágnera z C++ je docela průšvih, současná podoba předmětu je docela absurdní. Shodnul jsem se s cvičícími/přenášejícími a i s proděkanem, že praktické zaměření STM jde do kytek a jediné těžké předměty jsou teď matematiky.

[Luboš Doležel (Doli)]

Jinak koukám, že bych letos mohl mít i prospěchové stipendium (A,B,A,B,A,E).

[Saljack]

Já jsem ti říkal ať jdeš na DSA, to by jsi to měl ještě lepší . Tušíš kolik to stipendium je? S tím C/C++ souhlasím podle mě tomu klesla úroveň, ale zase nemohu porovnat. Ale průser taky byl, že přednášející půl semestru nemohl chodit přednášet, tak přednášel někdo jiný. Co jsem však slyšel od lidí, co to absolvovali přede mnou, tak je to přibližně stejné, akorát se zbavili studenty proklínaného progtestu. Kdybych s C++ nikdy nepřišel do styku, byl by pro mě předmět taky obtížný.

[Martin Matějek]

Ad C++: Buďte rádi, že si Vágner vzal Progtest s sebou na FIT (a my teď trpíme místo vás ). Lidská kontrola písemek/úkolů je pro 90 % studentů lepší, protože když máš dobře algoritmus, ale někde ti to selhává (špatné ošetření vstupu, segfault v nějaké hodně zastrčené větvi kódu, time limit exceeded, ...) většinou dostaneš body za to, že víš o čem je řeč. Od Progtestu dostaneš 0 bodů, protože jsi nedostal víc než XY % v jednom z testů (test podle ukázky, test náhodnými daty, test práce s pamětí, ...). Ale jinak pokud C/C++ rozumíš, algoritmy taháš z rukávu, Progtest tě naučí odladit program i na situace, které v realitě prakticky nenastanou (ale teoreticky by mohly).

A prosemináře s Vágnerem jsou super. Sice většina studentů nechápe, co tam píše za kód a proč (píše kód, říká co to má dělat a ještě komentuje jak by to šlo vylepšit; tohle všechno najednou), ale když se aspoň trochu tušíš o čem je řeč, uvidíš tu pravou Cčkovou magii a pár výborných triků s textovým editorem (což mě nakoplo se ještě víc naučit s Vimem).

Ad Databáze: Kdo vás učil databáze? Na FITu nás to koukám učili líp. Navíc jsme měli k dispozici příklady i s řešeními (RA, SQL) na webu. Stačilo říct přednášejícímu. Nevím co se ti na relační algebře nelíbí, nejdřív jsem ji taky moc nechápal, ale pak jsem měl spíš problém napsat něco v SQL než RA. Jasně v RA chybí agregace a nějaké vychytávky (GROUP BY, HAVING, ...), ale obecně v RA nemusíš psát zbytečná slova (select * from ... WHERE ...) a píšeš jenom tu „podstatu“ problému. Kromě toho, v SQL bez selekce neuděláš levé/pravé přirozené spojení (o nic moc nejde, ale strávil jsem dost času hledáním a syntaxe pro to neexistuje).

Jo a semestrálku jsem psal doma na PostgreSQL a žádný problém.

Ad Softwarové inženýrství: Na to jsem docela zvědavej, nás to čeká v létě spolu se Softwarovým projektem a to nebude žádná legrace - zadání zjevně přímo od firem, pevně dané technologie/platformy (o některých slyším prvně) - nevím jestli to trochu nepřehnali. Naštěstí si můžeme vybrat projekt (kdo dřív příjde), případně navrhnout vlastní (když je přesvědčíme), a týmy jsme si vytvářeli už během zkouškového, abychom stihli zabrat včas projekt. Inu, jiný kraj, jiný mrav.

[Saljack]

Databáze vyučuje duo Nečaský Mlýnková. Mě nedělá problém relační algebra jenom jsem nepochopil k čemu to je.

[Fluttershy, yay!]

Z matfyzu?

[Saljack]

JJ těch je u nás dost.

[Martin Matějek]

Mea culpa, po odeslání komentáře jsem si blogpost znova pořádně přečetl, takže ten odstavec byl vcelku zbytečný.

Zajímavý, já měl za to, že Valenta učí jak na FITu tak na FELu. Ale zas je fakt, že by se na to asi musel naklonovat, aby to všechno stíhal.

[Luboš Doležel (Doli)]

Buďte rádi, že si Vágner vzal Progtest s sebou na FIT (a my teď trpíme místo vás ). Lidská kontrola písemek/úkolů je pro 90 % studentů lepší, protože když máš dobře algoritmus, ale někde ti to selhává (špatné ošetření vstupu, segfault v nějaké hodně zastrčené větvi kódu, time limit exceeded, ...) většinou dostaneš body za to, že víš o čem je řeč.

Jenomže v reálném světě není programování o tom, že člověk ví, o čem je řeč, ale že je opravdu schopen napsat dobrý kód. Ty vyjmenované chyby jsou všechny dost závažné.

Ad Softwarové inženýrství: Na to jsem docela zvědavej, nás to čeká v létě spolu se Softwarovým projektem a to nebude žádná legrace

Mě jen zaujalo podepisování copyright assignment na cvičícího (resp. neomezené licence bla bla). Čekal bych, že by se to psalo na školu.

[dad]

...ale že je opravdu schopen napsat dobrý kód. ...

myslim, ze problem bude s tou definici 'dobreho kodu'

[Luboš Doležel (Doli)]

Zoufale pomalý kód, padající nebo dokonce děravý kód a leakující software? Děkuji, nechci.

[karel]

+1 Progtest nehodnotí kvalitu kódu z hlediska čitelnosti. Hodnotí pouze, jestli daný kód běží bez chyb, rychle a s minimem paměti.Není důvod vymýšlet sofistikované API, když můžu celou funkčnost naprasit do pár funkcí pomocí rozsáhlé soustavy cyklů a podmínek. Běží to rychle, (podle testů progtestu) dobře a s minimem paměti. Co na tom, že to už nikdo nikdy nerozluští. A zrovna čitelnost kódu je nejdůležitější věc co by si lidi měli z podobných předmětů odnést. To že zapomenu ošetřit nějakou super okrajovou podmínku mi až tak zásadní nepřipadá, zásadnější je, že se ta chyba dá najít a opravit s minimálním úsilím.

[Saljack]

S tímhle nejde nesouhlasit.

[JS]

Na druhou stranu, pokud je nekdo schopen napsat necitelny kod, ktery bezi dobre a osetruje vsechny okrajove podminky, patrne by ho levou zadni zvladl napsat i citelne, s trochou domluvy. Pokud by neslo o nejakeho autistickeho genia, ale to je uvaha tak mozna do filmu.

P.S. Uvedomujete si, ze opravdu rychle algoritmy byvaji casto necitelne?

[Josef Kufner]

Můžeš tohle tvrzení něčím podložit?

Kvalitní návrh programů vydá víceméně na samostatné odvětví v programování a (uvnitř) hezké programy jsou celkem vzácností.

[JS]

Nemuzu ho nicim podlozit, jen si proste myslim, ze pokud uz nekdo je schopen napsat kod bezchybne, pak to pravdepodobne napsal citelne. Z toho samozrejme neplyne opak, ale zda se mi, ze napsat necitelny bezchybny kod je daleko tezsi, nez napsat citelny bezchybny kod. Z cehoz mi vyplyva, ze patrne je ten clovek, ktery napsal takovy kod, velmi chytry, ale lajdak, a s tim se da (s trochou vule) neco delat. (Takze nevidim v tom netestovani citelnosti velky problem.)

Nevim, jestli jsem vubec nekdy videl bezchybny ale presto necitelny kod (pokud byl necitelny, bylo i tezke dokazat, ze je bezchybny). Naopak necitelny chybny kod vidim co chvili. Z toho vyplyva, ze je tam vzajemna korelace.

[Josef Kufner]

Podívej se třeba na Psi. To je odladěné, funkční, ale přitom nechutný šmodrchanec tříd do kterého něco přidat je horor.

[Grunt]

Můžeš tohle tvrzení něčím podložit?

To já zas můžu. Takto vypadá (pomalá ) DCT z libjpegu:

#if CONST_BITS == 13
#define FIX_0_298631336  ((INT32)  2446)	/* FIX(0.298631336) */
#define FIX_0_390180644  ((INT32)  3196)	/* FIX(0.390180644) */
#define FIX_0_541196100  ((INT32)  4433)	/* FIX(0.541196100) */
#define FIX_0_765366865  ((INT32)  6270)	/* FIX(0.765366865) */
#define FIX_0_899976223  ((INT32)  7373)	/* FIX(0.899976223) */
#define FIX_1_175875602  ((INT32)  9633)	/* FIX(1.175875602) */
#define FIX_1_501321110  ((INT32)  12299)	/* FIX(1.501321110) */
#define FIX_1_847759065  ((INT32)  15137)	/* FIX(1.847759065) */
#define FIX_1_961570560  ((INT32)  16069)	/* FIX(1.961570560) */
#define FIX_2_053119869  ((INT32)  16819)	/* FIX(2.053119869) */
#define FIX_2_562915447  ((INT32)  20995)	/* FIX(2.562915447) */
#define FIX_3_072711026  ((INT32)  25172)	/* FIX(3.072711026) */
#else
#define FIX_0_298631336  FIX(0.298631336)
#define FIX_0_390180644  FIX(0.390180644)
#define FIX_0_541196100  FIX(0.541196100)
#define FIX_0_765366865  FIX(0.765366865)
#define FIX_0_899976223  FIX(0.899976223)
#define FIX_1_175875602  FIX(1.175875602)
#define FIX_1_501321110  FIX(1.501321110)
#define FIX_1_847759065  FIX(1.847759065)
#define FIX_1_961570560  FIX(1.961570560)
#define FIX_2_053119869  FIX(2.053119869)
#define FIX_2_562915447  FIX(2.562915447)
#define FIX_3_072711026  FIX(3.072711026)
#endif


/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
 * For 8-bit samples with the recommended scaling, all the variable
 * and constant values involved are no more than 16 bits wide, so a
 * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
 * For 12-bit samples, a full 32-bit multiplication will be needed.
 */

#if BITS_IN_JSAMPLE == 8
#define MULTIPLY(var,const)  MULTIPLY16C16(var,const)
#else
#define MULTIPLY(var,const)  ((var) * (const))
#endif


/*
 * Perform the forward DCT on one block of samples.
 */

GLOBAL(void)
jpeg_fdct_islow (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
{
  INT32 tmp0, tmp1, tmp2, tmp3;
  INT32 tmp10, tmp11, tmp12, tmp13;
  INT32 z1;
  DCTELEM *dataptr;
  JSAMPROW elemptr;
  int ctr;
  SHIFT_TEMPS

  /* Pass 1: process rows. */
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
  /* furthermore, we scale the results by 2**PASS1_BITS. */

  dataptr = data;
  for (ctr = 0; ctr < DCTSIZE; ctr++) {
    elemptr = sample_data[ctr] + start_col;

    /* Even part per LL&M figure 1 --- note that published figure is faulty;
     * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
     */

    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[7]);
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[6]);
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[5]);
    tmp3 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[4]);

    tmp10 = tmp0 + tmp3;
    tmp12 = tmp0 - tmp3;
    tmp11 = tmp1 + tmp2;
    tmp13 = tmp1 - tmp2;

    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[7]);
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[6]);
    tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[5]);
    tmp3 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[4]);

    /* Apply unsigned->signed conversion */
    dataptr[0] = (DCTELEM) ((tmp10 + tmp11 - 8 * CENTERJSAMPLE) << PASS1_BITS);
    dataptr[4] = (DCTELEM) ((tmp10 - tmp11) << PASS1_BITS);

    z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
    /* Add fudge factor here for final descale. */
    z1 += ONE << (CONST_BITS-PASS1_BITS-1);
    dataptr[2] = (DCTELEM) RIGHT_SHIFT(z1 + MULTIPLY(tmp12, FIX_0_765366865),
				       CONST_BITS-PASS1_BITS);
    dataptr[6] = (DCTELEM) RIGHT_SHIFT(z1 - MULTIPLY(tmp13, FIX_1_847759065),
				       CONST_BITS-PASS1_BITS);

    /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
     * cK represents sqrt(2) * cos(K*pi/16).
     * i0..i3 in the paper are tmp0..tmp3 here.
     */

    tmp10 = tmp0 + tmp3;
    tmp11 = tmp1 + tmp2;
    tmp12 = tmp0 + tmp2;
    tmp13 = tmp1 + tmp3;
    z1 = MULTIPLY(tmp12 + tmp13, FIX_1_175875602); /*  c3 */
    /* Add fudge factor here for final descale. */
    z1 += ONE << (CONST_BITS-PASS1_BITS-1);

    tmp0  = MULTIPLY(tmp0,    FIX_1_501321110);    /*  c1+c3-c5-c7 */
    tmp1  = MULTIPLY(tmp1,    FIX_3_072711026);    /*  c1+c3+c5-c7 */
    tmp2  = MULTIPLY(tmp2,    FIX_2_053119869);    /*  c1+c3-c5+c7 */
    tmp3  = MULTIPLY(tmp3,    FIX_0_298631336);    /* -c1+c3+c5-c7 */
    tmp10 = MULTIPLY(tmp10, - FIX_0_899976223);    /*  c7-c3 */
    tmp11 = MULTIPLY(tmp11, - FIX_2_562915447);    /* -c1-c3 */
    tmp12 = MULTIPLY(tmp12, - FIX_0_390180644);    /*  c5-c3 */
    tmp13 = MULTIPLY(tmp13, - FIX_1_961570560);    /* -c3-c5 */

    tmp12 += z1;
    tmp13 += z1;

    dataptr[1] = (DCTELEM)
      RIGHT_SHIFT(tmp0 + tmp10 + tmp12, CONST_BITS-PASS1_BITS);
    dataptr[3] = (DCTELEM)
      RIGHT_SHIFT(tmp1 + tmp11 + tmp13, CONST_BITS-PASS1_BITS);
    dataptr[5] = (DCTELEM)
      RIGHT_SHIFT(tmp2 + tmp11 + tmp12, CONST_BITS-PASS1_BITS);
    dataptr[7] = (DCTELEM)
      RIGHT_SHIFT(tmp3 + tmp10 + tmp13, CONST_BITS-PASS1_BITS);

    dataptr += DCTSIZE;		/* advance pointer to next row */
  }

  /* Pass 2: process columns.
   * We remove the PASS1_BITS scaling, but leave the results scaled up
   * by an overall factor of 8.
   */

  dataptr = data;
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
    /* Even part per LL&M figure 1 --- note that published figure is faulty;
     * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
     */

    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
    tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
    tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];

    /* Add fudge factor here for final descale. */
    tmp10 = tmp0 + tmp3 + (ONE << (PASS1_BITS-1));
    tmp12 = tmp0 - tmp3;
    tmp11 = tmp1 + tmp2;
    tmp13 = tmp1 - tmp2;

    tmp0 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
    tmp1 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
    tmp2 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
    tmp3 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];

    dataptr[DCTSIZE*0] = (DCTELEM) RIGHT_SHIFT(tmp10 + tmp11, PASS1_BITS);
    dataptr[DCTSIZE*4] = (DCTELEM) RIGHT_SHIFT(tmp10 - tmp11, PASS1_BITS);

    z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
    /* Add fudge factor here for final descale. */
    z1 += ONE << (CONST_BITS+PASS1_BITS-1);
    dataptr[DCTSIZE*2] = (DCTELEM)
      RIGHT_SHIFT(z1 + MULTIPLY(tmp12, FIX_0_765366865), CONST_BITS+PASS1_BITS);
    dataptr[DCTSIZE*6] = (DCTELEM)
      RIGHT_SHIFT(z1 - MULTIPLY(tmp13, FIX_1_847759065), CONST_BITS+PASS1_BITS);

    /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
     * cK represents sqrt(2) * cos(K*pi/16).
     * i0..i3 in the paper are tmp0..tmp3 here.
     */

    tmp10 = tmp0 + tmp3;
    tmp11 = tmp1 + tmp2;
    tmp12 = tmp0 + tmp2;
    tmp13 = tmp1 + tmp3;
    z1 = MULTIPLY(tmp12 + tmp13, FIX_1_175875602); /*  c3 */
    /* Add fudge factor here for final descale. */
    z1 += ONE << (CONST_BITS+PASS1_BITS-1);

    tmp0  = MULTIPLY(tmp0,    FIX_1_501321110);    /*  c1+c3-c5-c7 */
    tmp1  = MULTIPLY(tmp1,    FIX_3_072711026);    /*  c1+c3+c5-c7 */
    tmp2  = MULTIPLY(tmp2,    FIX_2_053119869);    /*  c1+c3-c5+c7 */
    tmp3  = MULTIPLY(tmp3,    FIX_0_298631336);    /* -c1+c3+c5-c7 */
    tmp10 = MULTIPLY(tmp10, - FIX_0_899976223);    /*  c7-c3 */
    tmp11 = MULTIPLY(tmp11, - FIX_2_562915447);    /* -c1-c3 */
    tmp12 = MULTIPLY(tmp12, - FIX_0_390180644);    /*  c5-c3 */
    tmp13 = MULTIPLY(tmp13, - FIX_1_961570560);    /* -c3-c5 */

    tmp12 += z1;
    tmp13 += z1;

    dataptr[DCTSIZE*1] = (DCTELEM)
      RIGHT_SHIFT(tmp0 + tmp10 + tmp12, CONST_BITS+PASS1_BITS);
    dataptr[DCTSIZE*3] = (DCTELEM)
      RIGHT_SHIFT(tmp1 + tmp11 + tmp13, CONST_BITS+PASS1_BITS);
    dataptr[DCTSIZE*5] = (DCTELEM)
      RIGHT_SHIFT(tmp2 + tmp11 + tmp12, CONST_BITS+PASS1_BITS);
    dataptr[DCTSIZE*7] = (DCTELEM)
      RIGHT_SHIFT(tmp3 + tmp10 + tmp13, CONST_BITS+PASS1_BITS);

    dataptr++;			/* advance pointer to next column */
  }
}

A takhle úplně ta stejná transformace akorát zapsaná trošku čitelněji:

void fct(const double *input, double *output, int length)
{
int h,j;
	for(h=0; h<length; h++)
	{
		double sum = 0;
		for(j=0; j<length; j++)
		{
			double xk = input[j];
			double c = (M_PI/length)*h*(j+0.5);
			sum += xk*cos(c);
		}
		output[h] = sum;
	}
}

(Chybí k němu ještě ke kompletnosti převrácení, ale to též žádná hrůza:)

for(a=0;a<LAJNA;a++)
  for(b=0;b<LAJNA;b++)
    in_pole[a][b] = out_pole[b][a];

Obojí dělá přibližně to samé, akorát to druhé asi tak 1000× pomaleji a ještě k tomu nepotřebuje float.

Stejně jako kupř. syntézní filtr (QMF) z reperenční implementace MPEG-1 Layer I/II:

/*************************************************************
/*
/*   Pass the subband sample through the synthesis window
/*
/**************************************************************/

/* create in synthesis filter */

void create_syn_filter(filter)
double FAR filter[64][SBLIMIT];
{
    register int i,k;

    for (i=0; i<64; i++)
        for (k=0; k<32; k++) {
            if ((filter[i][k] = 1e9*cos((double)((PI64*i+PI4)*(2*k+1)))) >= 0)
                modf(filter[i][k]+0.5, &filter[i][k]);
            else
                modf(filter[i][k]-0.5, &filter[i][k]);
            filter[i][k] *= 1e-9;
        }
}

/***************************************************************
/*
/*   Window the restored sample
/*
/***************************************************************/

/* read in synthesis window */

void read_syn_window(window)
double FAR window[HAN_SIZE];
{
    int i,j[4];
    FILE *fp;
    double f[4];
    char t[150];

    if (!(fp = OpenTableFile("dewindow") )) {
        printf("Please check synthesis window table 'dewindow'\n");
        exit(1);
    }
    for (i=0;i<512;i+=4) {
        fgets(t, 150, fp);
        sscanf(t,"D[%d] = %lf D[%d] = %lf D[%d] = %lf D[%d] = %lf\n",
               j, f,j+1,f+1,j+2,f+2,j+3,f+3);
        if (i==j[0]) {
            window[i] = f[0];
            window[i+1] = f[1];
            window[i+2] = f[2];
            window[i+3] = f[3];
        }
        else {
            printf("Check index in synthesis window table\n");
            exit(1);
        }
        fgets(t,150,fp);
    }
    fclose(fp);
}

int SubBandSynthesis (bandPtr, channel, samples)
double *bandPtr;
int channel;
short *samples;
{
    register int i,j,k;
    register double *bufOffsetPtr, sum;
    static int init = 1;
    typedef double NN[64][32];
    static NN FAR *filter;
    typedef double BB[2][2*HAN_SIZE];
    static BB FAR *buf;
    static int bufOffset[2] = {64,64};
    static double FAR *window;
    int clip = 0;               /* count & return how many samples clipped */

    if (init) {
        buf = (BB FAR *) mem_alloc(sizeof(BB),"BB");
        filter = (NN FAR *) mem_alloc(sizeof(NN), "NN");
        create_syn_filter(*filter);
        window = (double FAR *) mem_alloc(sizeof(double) * HAN_SIZE, "WIN");
        read_syn_window(window);
        init = 0;
    }
/*    if (channel == 0) */
    bufOffset[channel] = (bufOffset[channel] - 64) & 0x3ff;
    bufOffsetPtr = &((*buf)[channel][bufOffset[channel]]);

    for (i=0; i<64; i++) {
        sum = 0;
        for (k=0; k<32; k++)
            sum += bandPtr[k] * (*filter)[i][k];
        bufOffsetPtr[i] = sum;
    }
    /*  S(i,j) = D(j+32i) * U(j+32i+((i+1)>>1)*64)  */
    /*  samples(i,j) = MWindow(j+32i) * bufPtr(j+32i+((i+1)>>1)*64)  */
    for (j=0; j<32; j++) {
        sum = 0;
        for (i=0; i<16; i++) {
            k = j + (i<<5);
            sum += window[k] * (*buf) [channel] [( (k + ( ((i+1)>>1) <<6) ) +
                                                  bufOffset[channel]) & 0x3ff];
        }

/*   {long foo = (sum > 0) ? sum * SCALE + 0.5 : sum * SCALE - 0.5; */
     {long foo = sum * SCALE;
     if (foo >= (long) SCALE)      {samples[j] = SCALE-1; ++clip;}
     else if (foo < (long) -SCALE) {samples[j] = -SCALE;  ++clip;}
     else                           samples[j] = foo;
 }
    }
    return(clip);
}

vs cca. ten samý filtr z Musepacku, akorát asi jenou či dvakrát tak rychlejší:

static void
mpc_compute_new_V(const MPC_SAMPLE_FORMAT* p_sample, MPC_SAMPLE_FORMAT* pV)
{
    // Calculating new V-buffer values for left channel
    // calculate new V-values (ISO-11172-3, p. 39)
    // based upon fast-MDCT algorithm by Byeong Gi Lee
    MPC_SAMPLE_FORMAT A00, A01, A02, A03, A04, A05, A06, A07, A08, A09, A10, A11, A12, A13, A14, A15;
    MPC_SAMPLE_FORMAT B00, B01, B02, B03, B04, B05, B06, B07, B08, B09, B10, B11, B12, B13, B14, B15;
    MPC_SAMPLE_FORMAT tmp;

    A00 = p_sample[ 0] + p_sample[31];
    A01 = p_sample[ 1] + p_sample[30];
    A02 = p_sample[ 2] + p_sample[29];
    A03 = p_sample[ 3] + p_sample[28];
    A04 = p_sample[ 4] + p_sample[27];
    A05 = p_sample[ 5] + p_sample[26];
    A06 = p_sample[ 6] + p_sample[25];
    A07 = p_sample[ 7] + p_sample[24];
    A08 = p_sample[ 8] + p_sample[23];
    A09 = p_sample[ 9] + p_sample[22];
    A10 = p_sample[10] + p_sample[21];
    A11 = p_sample[11] + p_sample[20];
    A12 = p_sample[12] + p_sample[19];
    A13 = p_sample[13] + p_sample[18];
    A14 = p_sample[14] + p_sample[17];
    A15 = p_sample[15] + p_sample[16];

    B00 = A00 + A15;
    B01 = A01 + A14;
    B02 = A02 + A13;
    B03 = A03 + A12;
    B04 = A04 + A11;
    B05 = A05 + A10;
    B06 = A06 + A09;
    B07 = A07 + A08;;
    B08 = MPC_SCALE_CONST((A00 - A15) , 0.5024192929f , 31);
    B09 = MPC_SCALE_CONST((A01 - A14) , 0.5224986076f , 31);
    B10 = MPC_SCALE_CONST((A02 - A13) , 0.5669440627f , 31);
    B11 = MPC_SCALE_CONST((A03 - A12) , 0.6468217969f , 31);
    B12 = MPC_SCALE_CONST((A04 - A11) , 0.7881546021f , 31);
    B13 = MPC_SCALE_CONST((A05 - A10) , 1.0606776476f , 30);
    B14 = MPC_SCALE_CONST((A06 - A09) , 1.7224471569f , 30);
    B15 = MPC_SCALE_CONST((A07 - A08) , 5.1011486053f , 28);

    A00 =  B00 + B07;
    A01 =  B01 + B06;
    A02 =  B02 + B05;
    A03 =  B03 + B04;
    A04 = MPC_SCALE_CONST((B00 - B07) , 0.5097956061f , 31);
    A05 = MPC_SCALE_CONST((B01 - B06) , 0.6013448834f , 31);
    A06 = MPC_SCALE_CONST((B02 - B05) , 0.8999761939f , 31);
    A07 = MPC_SCALE_CONST((B03 - B04) , 2.5629155636f , 29);
    A08 =  B08 + B15;
    A09 =  B09 + B14;
    A10 =  B10 + B13;
    A11 =  B11 + B12;
    A12 = MPC_SCALE_CONST((B08 - B15) , 0.5097956061f , 31);
    A13 = MPC_SCALE_CONST((B09 - B14) , 0.6013448834f , 31);
    A14 = MPC_SCALE_CONST((B10 - B13) , 0.8999761939f , 31);
    A15 = MPC_SCALE_CONST((B11 - B12) , 2.5629155636f , 29);

    B00 =  A00 + A03;
    B01 =  A01 + A02;
    B02 = MPC_MULTIPLY_FRACT_CONST_FIX((A00 - A03) , 0.5411961079f , 1);
    B03 = MPC_MULTIPLY_FRACT_CONST_FIX((A01 - A02) , 1.3065630198f , 2);
    B04 =  A04 + A07;
    B05 =  A05 + A06;
    B06 = MPC_MULTIPLY_FRACT_CONST_FIX((A04 - A07) , 0.5411961079f , 1);
    B07 = MPC_MULTIPLY_FRACT_CONST_FIX((A05 - A06) , 1.3065630198f , 2);
    B08 =  A08 + A11;
    B09 =  A09 + A10;
    B10 = MPC_MULTIPLY_FRACT_CONST_FIX((A08 - A11) , 0.5411961079f , 1);
    B11 = MPC_MULTIPLY_FRACT_CONST_FIX((A09 - A10) , 1.3065630198f , 2);
    B12 =  A12 + A15;
    B13 =  A13 + A14;
    B14 = MPC_MULTIPLY_FRACT_CONST_FIX((A12 - A15) , 0.5411961079f , 1);
    B15 = MPC_MULTIPLY_FRACT_CONST_FIX((A13 - A14) , 1.3065630198f , 2);

    A00 =  B00 + B01;
    A01 = MPC_MULTIPLY_FRACT_CONST_FIX((B00 - B01) , 0.7071067691f , 1);
    A02 =  B02 + B03;
    A03 = MPC_MULTIPLY_FRACT_CONST_FIX((B02 - B03) , 0.7071067691f , 1);
    A04 =  B04 + B05;
    A05 = MPC_MULTIPLY_FRACT_CONST_FIX((B04 - B05) , 0.7071067691f , 1);
    A06 =  B06 + B07;
    A07 = MPC_MULTIPLY_FRACT_CONST_FIX((B06 - B07) , 0.7071067691f , 1);
    A08 =  B08 + B09;
    A09 = MPC_MULTIPLY_FRACT_CONST_FIX((B08 - B09) , 0.7071067691f , 1);
    A10 =  B10 + B11;
    A11 = MPC_MULTIPLY_FRACT_CONST_FIX((B10 - B11) , 0.7071067691f , 1);
    A12 =  B12 + B13;
    A13 = MPC_MULTIPLY_FRACT_CONST_FIX((B12 - B13) , 0.7071067691f , 1);
    A14 =  B14 + B15;
    A15 = MPC_MULTIPLY_FRACT_CONST_FIX((B14 - B15) , 0.7071067691f , 1);

    pV[48] = -A00;
    pV[ 0] =  A01;
    pV[40] = -A02 - (pV[ 8] = A03);
    pV[36] = -((pV[ 4] = A05 + (pV[12] = A07)) + A06);
    pV[44] = - A04 - A06 - A07;
    pV[ 6] = (pV[10] = A11 + (pV[14] = A15)) + A13;
    pV[38] = (pV[34] = -(pV[ 2] = A09 + A13 + A15) - A14) + A09 - A10 - A11;
    pV[46] = (tmp = -(A12 + A14 + A15)) - A08;
    pV[42] = tmp - A10 - A11;

    A00 = MPC_MULTIPLY_FRACT_CONST_SHR((p_sample[ 0] - p_sample[31]) , 0.5006030202f ,     MPC_FIXED_POINT_SYNTH_FIX);
    A01 = MPC_MULTIPLY_FRACT_CONST_SHR((p_sample[ 1] - p_sample[30]) , 0.5054709315f ,     MPC_FIXED_POINT_SYNTH_FIX);
    A02 = MPC_MULTIPLY_FRACT_CONST_SHR((p_sample[ 2] - p_sample[29]) , 0.5154473186f ,     MPC_FIXED_POINT_SYNTH_FIX);
    A03 = MPC_MULTIPLY_FRACT_CONST_SHR((p_sample[ 3] - p_sample[28]) , 0.5310425758f ,     MPC_FIXED_POINT_SYNTH_FIX);
    A04 = MPC_MULTIPLY_FRACT_CONST_SHR((p_sample[ 4] - p_sample[27]) , 0.5531039238f ,     MPC_FIXED_POINT_SYNTH_FIX);
    A05 = MPC_MULTIPLY_FRACT_CONST_SHR((p_sample[ 5] - p_sample[26]) , 0.5829349756f ,     MPC_FIXED_POINT_SYNTH_FIX);
    A06 = MPC_MULTIPLY_FRACT_CONST_SHR((p_sample[ 6] - p_sample[25]) , 0.6225041151f ,     MPC_FIXED_POINT_SYNTH_FIX);
    A07 = MPC_MULTIPLY_FRACT_CONST_SHR((p_sample[ 7] - p_sample[24]) , 0.6748083234f ,     MPC_FIXED_POINT_SYNTH_FIX);
    A08 = MPC_MULTIPLY_FRACT_CONST_SHR((p_sample[ 8] - p_sample[23]) , 0.7445362806f ,     MPC_FIXED_POINT_SYNTH_FIX);
    A09 = MPC_MULTIPLY_FRACT_CONST_SHR((p_sample[ 9] - p_sample[22]) , 0.8393496275f ,     MPC_FIXED_POINT_SYNTH_FIX);
    A10 = MPC_MULTIPLY_FRACT_CONST_SHR((p_sample[10] - p_sample[21]) , 0.9725682139f ,     MPC_FIXED_POINT_SYNTH_FIX);
#if MPC_FIXED_POINT_SYNTH_FIX>=2
    A11 = MPC_MULTIPLY_FRACT_CONST_SHR((p_sample[11] - p_sample[20]) , 1.1694399118f ,     MPC_FIXED_POINT_SYNTH_FIX);
    A12 = MPC_MULTIPLY_FRACT_CONST_SHR((p_sample[12] - p_sample[19]) , 1.4841645956f ,     MPC_FIXED_POINT_SYNTH_FIX);
#else
    A11 = MPC_SCALE_CONST_SHR         ((p_sample[11] - p_sample[20]) , 1.1694399118f , 30, MPC_FIXED_POINT_SYNTH_FIX);
    A12 = MPC_SCALE_CONST_SHR         ((p_sample[12] - p_sample[19]) , 1.4841645956f , 30, MPC_FIXED_POINT_SYNTH_FIX);
#endif
    A13 = MPC_SCALE_CONST_SHR         ((p_sample[13] - p_sample[18]) , 2.0577809811f , 29, MPC_FIXED_POINT_SYNTH_FIX);
    A14 = MPC_SCALE_CONST_SHR         ((p_sample[14] - p_sample[17]) , 3.4076085091f , 29, MPC_FIXED_POINT_SYNTH_FIX);
    A15 = MPC_SCALE_CONST_SHR         ((p_sample[15] - p_sample[16]) , 10.1900081635f, 27 ,MPC_FIXED_POINT_SYNTH_FIX);

    B00 =  A00 + A15;
    B01 =  A01 + A14;
    B02 =  A02 + A13;
    B03 =  A03 + A12;
    B04 =  A04 + A11;
    B05 =  A05 + A10;
    B06 =  A06 + A09;
    B07 =  A07 + A08;
    B08 = MPC_SCALE_CONST((A00 - A15) , 0.5024192929f , 31);
    B09 = MPC_SCALE_CONST((A01 - A14) , 0.5224986076f , 31);
    B10 = MPC_SCALE_CONST((A02 - A13) , 0.5669440627f , 31);
    B11 = MPC_SCALE_CONST((A03 - A12) , 0.6468217969f , 31);
    B12 = MPC_SCALE_CONST((A04 - A11) , 0.7881546021f , 31);
    B13 = MPC_SCALE_CONST((A05 - A10) , 1.0606776476f , 30);
    B14 = MPC_SCALE_CONST((A06 - A09) , 1.7224471569f , 30);
    B15 = MPC_SCALE_CONST((A07 - A08) , 5.1011486053f , 28);

    A00 =  B00 + B07;
    A01 =  B01 + B06;
    A02 =  B02 + B05;
    A03 =  B03 + B04;
    A04 = MPC_SCALE_CONST((B00 - B07) , 0.5097956061f , 31);
    A05 = MPC_SCALE_CONST((B01 - B06) , 0.6013448834f , 31);
    A06 = MPC_SCALE_CONST((B02 - B05) , 0.8999761939f , 31);
    A07 = MPC_SCALE_CONST((B03 - B04) , 2.5629155636f , 29);
    A08 =  B08 + B15;
    A09 =  B09 + B14;
    A10 =  B10 + B13;
    A11 =  B11 + B12;
    A12 = MPC_SCALE_CONST((B08 - B15) , 0.5097956061f , 31);
    A13 = MPC_SCALE_CONST((B09 - B14) , 0.6013448834f , 31);
    A14 = MPC_SCALE_CONST((B10 - B13) , 0.8999761939f , 31);
    A15 = MPC_SCALE_CONST((B11 - B12) , 2.5629155636f , 29);

    B00 =  A00 + A03;
    B01 =  A01 + A02;
    B02 = MPC_SCALE_CONST((A00 - A03) , 0.5411961079f , 31);
    B03 = MPC_SCALE_CONST((A01 - A02) , 1.3065630198f , 30);
    B04 =  A04 + A07;
    B05 =  A05 + A06;
    B06 = MPC_SCALE_CONST((A04 - A07) , 0.5411961079f , 31);
    B07 = MPC_SCALE_CONST((A05 - A06) , 1.3065630198f , 30);
    B08 =  A08 + A11;
    B09 =  A09 + A10;
    B10 = MPC_SCALE_CONST((A08 - A11) , 0.5411961079f , 31);
    B11 = MPC_SCALE_CONST((A09 - A10) , 1.3065630198f , 30);
    B12 =  A12 + A15;
    B13 =  A13 + A14;
    B14 = MPC_SCALE_CONST((A12 - A15) , 0.5411961079f , 31);
    B15 = MPC_SCALE_CONST((A13 - A14) , 1.3065630198f , 30);

    A00 = MPC_SHL(B00 + B01, MPC_FIXED_POINT_SYNTH_FIX);
    A01 = MPC_SCALE_CONST_SHL((B00 - B01) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);
    A02 = MPC_SHL(B02 + B03, MPC_FIXED_POINT_SYNTH_FIX);
    A03 = MPC_SCALE_CONST_SHL((B02 - B03) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);
    A04 = MPC_SHL(B04 + B05, MPC_FIXED_POINT_SYNTH_FIX);
    A05 = MPC_SCALE_CONST_SHL((B04 - B05) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);
    A06 = MPC_SHL(B06 + B07, MPC_FIXED_POINT_SYNTH_FIX);
    A07 = MPC_SCALE_CONST_SHL((B06 - B07) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);
    A08 = MPC_SHL(B08 + B09, MPC_FIXED_POINT_SYNTH_FIX);
    A09 = MPC_SCALE_CONST_SHL((B08 - B09) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);
    A10 = MPC_SHL(B10 + B11, MPC_FIXED_POINT_SYNTH_FIX);
    A11 = MPC_SCALE_CONST_SHL((B10 - B11) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);
    A12 = MPC_SHL(B12 + B13, MPC_FIXED_POINT_SYNTH_FIX);
    A13 = MPC_SCALE_CONST_SHL((B12 - B13) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);
    A14 = MPC_SHL(B14 + B15, MPC_FIXED_POINT_SYNTH_FIX);
    A15 = MPC_SCALE_CONST_SHL((B14 - B15) , 0.7071067691f , 31, MPC_FIXED_POINT_SYNTH_FIX);

    // mehrfach verwendete Ausdrcke: A04+A06+A07, A09+A13+A15
    pV[ 5] = (pV[11] = (pV[13] = A07 + (pV[15] = A15)) + A11) + A05 + A13;
    pV[ 7] = (pV[ 9] = A03 + A11 + A15) + A13;
    pV[33] = -(pV[ 1] = A01 + A09 + A13 + A15) - A14;
    pV[35] = -(pV[ 3] = A05 + A07 + A09 + A13 + A15) - A06 - A14;
    pV[37] = (tmp = -(A10 + A11 + A13 + A14 + A15)) - A05 - A06 - A07;
    pV[39] = tmp - A02 - A03;                      // abh�gig vom Befehl drber
    pV[41] = (tmp += A13 - A12) - A02 - A03;       // abh�gig vom Befehl 2 drber
    pV[43] = tmp - A04 - A06 - A07;                // abh�gig von Befehlen 1 und 3 drber
    pV[47] = (tmp = -(A08 + A12 + A14 + A15)) - A00;
    pV[45] = tmp - A04 - A06 - A07;                // abh�gig vom Befehl drber

    pV[32] = -pV[ 0];
    pV[31] = -pV[ 1];
    pV[30] = -pV[ 2];
    pV[29] = -pV[ 3];
    pV[28] = -pV[ 4];
    pV[27] = -pV[ 5];
    pV[26] = -pV[ 6];
    pV[25] = -pV[ 7];
    pV[24] = -pV[ 8];
    pV[23] = -pV[ 9];
    pV[22] = -pV[10];
    pV[21] = -pV[11];
    pV[20] = -pV[12];
    pV[19] = -pV[13];
    pV[18] = -pV[14];
    pV[17] = -pV[15];

    pV[63] =  pV[33];
    pV[62] =  pV[34];
    pV[61] =  pV[35];
    pV[60] =  pV[36];
    pV[59] =  pV[37];
    pV[58] =  pV[38];
    pV[57] =  pV[39];
    pV[56] =  pV[40];
    pV[55] =  pV[41];
    pV[54] =  pV[42];
    pV[53] =  pV[43];
    pV[52] =  pV[44];
    pV[51] =  pV[45];
    pV[50] =  pV[46];
    pV[49] =  pV[47];
}

static void
mpc_synthese_filter_float_internal(MPC_SAMPLE_FORMAT* p_out, MPC_SAMPLE_FORMAT* pV, const MPC_SAMPLE_FORMAT* pY, mpc_int_t channels)
{
    mpc_uint32_t n;
    for ( n = 0; n < 36; n++, pY += 32 )
    {
        MPC_SAMPLE_FORMAT*       pData = p_out;
        const MPC_SAMPLE_FORMAT* pD    = (const MPC_SAMPLE_FORMAT*) &Di_opt;
        mpc_int32_t k;
        pV -= 64;
        mpc_compute_new_V( pY, pV );
        for ( k = 0; k < 32; k++, pD += 16, pV++ )
        {
            *pData = MPC_SHL(
                     MPC_MULTIPLY_FRACT(pV[  0], pD[ 0]) + MPC_MULTIPLY_FRACT(pV[ 96], pD[ 1]) + MPC_MULTIPLY_FRACT(pV[128], pD[ 2]) + MPC_MULTIPLY_FRACT(pV[224], pD[ 3])
                   + MPC_MULTIPLY_FRACT(pV[256], pD[ 4]) + MPC_MULTIPLY_FRACT(pV[352], pD[ 5]) + MPC_MULTIPLY_FRACT(pV[384], pD[ 6]) + MPC_MULTIPLY_FRACT(pV[480], pD[ 7])
                   + MPC_MULTIPLY_FRACT(pV[512], pD[ 8]) + MPC_MULTIPLY_FRACT(pV[608], pD[ 9]) + MPC_MULTIPLY_FRACT(pV[640], pD[10]) + MPC_MULTIPLY_FRACT(pV[736], pD[11])
                   + MPC_MULTIPLY_FRACT(pV[768], pD[12]) + MPC_MULTIPLY_FRACT(pV[864], pD[13]) + MPC_MULTIPLY_FRACT(pV[896], pD[14]) + MPC_MULTIPLY_FRACT(pV[992], pD[15])
                   , 2);
            pData += channels;
        }
        pV    -= 32; //bleh
        p_out += 32 * channels;
    }
}

Dost často je to dáno tím, že ty rychlejší varianty jsou ty registrové hrůzy (uvedený příklad ještě nic moc, ale v knížce mám hnusnou potvoru na celou stránku kde se v těch čárách člověk i ztratí … akorát nemám po ruce skener) implementované v Céčku a nebo nedejbože v Assembleru (to už jsou možnosti prasení a znečitelnění téměř nekonečné).

[Grunt]

A tady možná ještě o kapičku čitelnější syntézní smyčka než ta z referenční implementace MPEGu, ale zas o řád nebo dva pomalejší:

 // coefficient input and reconstruction
    for (part = 0;  part < 3;  ++part)
        for (gr = 0;  gr < 4;  ++gr) {

            // read the samples
            for (sb = 0;  sb < bound;  ++sb)
                for (ch = 0;  ch < 2;  ++ch)
                    read_samples(allocation[ch][sb], scalefactor[ch][sb][part], &sample[ch][sb][0]);
            for (sb = bound;  sb < sblimit;  ++sb) {
                read_samples(allocation[0][sb], scalefactor[0][sb][part], &sample[0][sb][0]);
                for (idx = 0;  idx < 3;  ++idx)
                    sample[1][sb][idx] = sample[0][sb][idx];
            }
            for (ch = 0;  ch < 2;  ++ch)
               for (sb = sblimit;  sb < 32;  ++sb)
                    for (idx = 0;  idx < 3;  ++idx)
                        sample[ch][sb][idx] = 0;

            // synthesis loop
            for (idx = 0;  idx < 3;  ++idx) {
                // shifting step
                mp2->Voffs = table_idx = (mp2->Voffs - 64) & 1023;

                for (ch = 0;  ch < 2;  ++ch) {
                    // matrixing
                    for (i = 0;  i < 64;  ++i) {
                        sum = 0;
                        for (j = 0;  j < 32;  ++j)
                            sum += N[i][j] * sample[ch][j][idx];  // 8b*15b=23b
                        // intermediate value is 28 bit (23 + 5), clamp to 14b
                        mp2->V[ch][table_idx + i] = (sum + 8192) >> 14;
                    }

                    // construction of U
                    for (i = 0;  i < 8;  ++i)
                        for (j = 0;  j < 32;  ++j) {
                            U[(i << 6) + j]      = mp2->V[ch][(table_idx + (i << 7) + j     ) & 1023];
                            U[(i << 6) + j + 32] = mp2->V[ch][(table_idx + (i << 7) + j + 96) & 1023];
                        }

                    // apply window
                    for (i = 0;  i < 512;  ++i)
                        U[i] = (U[i] * D[i] + 32) >> 6;

                    // output samples
                    for (j = 0;  j < 32;  ++j) {
                        sum = 0;
                        for (i = 0;  i < 16;  ++i)
                            sum -= U[(i << 5) + j];
                        sum = (sum + 8) >> 4;
                        if (sum < -32768) sum = -32768;
                        if (sum > 32767) sum = 32767;
                        pcm[(idx << 6) | (j << 1) | ch] = (signed short) sum;
                    }
                } // end of synthesis channel loop
            } // end of synthesis sub-block loop

            // adjust PCM output pointer: decoded 3 * 32 = 96 stereo samples
            pcm += 192;

        } // decoding of the granule finished

    return frame_size;
}

[Martin Matějek]

Jenomže v reálném světě není programování o tom, že člověk ví, o čem je řeč, ale že je opravdu schopen napsat dobrý kód. Ty vyjmenované chyby jsou všechny dost závažné.

Souhlasím, ale možná že by se to během školy nemuselo brát tak přísně. To je jako kdyby na PJV na FELu chtěli super objektový program, když to objektové programování do té doby pořádně nevysvětlí (nevím, třeba se to už zlepšilo). A tím myslím skutečně objektové paradigma, ne tu C++/C#/Java pseudo-objektovost.

Minulé léto jsem nedostal zápočet z PA2 (programování a algoritmizace), protože v testu po nás chtěli zkušenosti z praxe (čtení a orientace v cizím kódu), ke které jsme se v podstatě nedostali (samé psaní kódu na zelené louce). A to s odůvodněním, že když tohle teď neumíme, nemá pro nás smysl se jakkoliv věnovat software.

Mě jen zaujalo podepisování copyright assignment na cvičícího (resp. neomezené licence bla bla). Čekal bych, že by se to psalo na školu.

Páni, tak to je docela síla. Kdo ví, jak to bude u nás, protože spousta projektů bude pro firmy a o licencování budou (nejspíš) rozhodovat oni.

[Mrkva]

Mě jen zaujalo podepisování copyright assignment na cvičícího (resp. neomezené licence bla bla). Čekal bych, že by se to psalo na školu.

To si děláš prdel? Takže já se budu semestr patlat s nějakým programem aniž bych za to něco získal (v rámci výuky) a ani to nebudu moct prodat/zveřejnit?

[xxx]

Ja ti nevim. Osetrit vstup se clovek nauci jednou (getopts) a pak uz to jen kopiruje. Co se tyce alokaci, tak se staci nuacit kontrolovat co mi bylo naalokovana, a psat si rovnou funkci na dealokaci. Proste takove to klasicke init_struct() a destroy_struct(). No a pak se naucit nepsat jako prase.

[Luboš Doležel (Doli)]

Vstupem se myslel spíš stdin nebo soubory než argumenty.

[dad]

k tem databazim bych se rad zeptal, zda se probiraji vyhradne systemy zalozene na relacnim modelu?

[Saljack]

Právě, že jo. Ten předmět je naprosto na nic.

[Josef Kufner]

A co bys tam chtěl probírat? Když jsem měl X36DBS, tak tam byla i zmínka o objektových databázích (ale opravdu jen zmínka). Navíc relační databáze jsou docela hojně používanou a důležitou částí mnoha systémů.

[Radek Miček]

Třeba by se mohly probírat deduktivní databáze.

[Josef Kufner]

To leda v navazujícím volitelném předmětu.

[Saljack]

Jo zmínka tam je, ale opravdu jenom zmínka. Já nevím právě co bych tam chtěl. Tenhle předmět je pro mě prostě nemasný neslaný.

[Josef Kufner]

Myslím, že bys tam chtěl lepšího přednášejícího, který by ti i vysvětlil, že ty SQL dotazy umí spoustu zajímavých věcí a ušetří hromadu práce při programování aplikací.

[Saljack]

Já netvrdím, že SQL je na nic. Je jí překvapivě věnovaná malá část celého předmětu. Pořád mi nikdo nevysvětlil, k čemu je relační algebra a kalkul v praxi dobrý.

[jas]

Je to proste abstrakcia pre relacne jazyky. Dobre je to na to, ze nebudes zvyknuty len na prikazy sql, ale aj na nieco trocha ine, vdaka comu by si mal mat lahsi prechod na nieco ine ako sql.

Dalej to poskytuje trocha iny pohlad na relacne databazy. Vacsinou plati, ze cim viac pohladov na nejaku vec, tym by sa to malo lepsie pochopit.

A potom je tu praktickost (pre istu skupinu ludi). Pre cloveka zbehleho v matematike je relacna algebra omnoho rychlejsie stravitelna nez sql.

[Josef Kufner]

Vpodstatě by se dalo říct, že v SQL zapisuješ výrazy relační algebry, takže na naučení SQL, když umíš relační algebru, už stačí jedno odpoledne.

Navíc relační algebra je dobrá v tom, že není zatížená implementačními detaily a lze kolem ní vyrábět důkazy, že opravdu funguje.

[dad]

v dnesnim svete embedded systemu jsou relacni databaze pro kocku (uf, uz zase myslim na Paroubka ).

Procetl jem si ten odkaz a i ty vita te pani Dr. prednasejici (ta ma ve 30 letech vic awards a citaci nez Ritchie a Thompson dohromady) a zjistuji, ze v tom predmetu je to skutecne takove, jak rika kolega - nemastne neslane.

S tim SQL a dotazama zde kdysi tvrdil (zhruba) pan Stehule, ze za 14 nauci slusne sql i simpanze. Na to neni potreba chodit na vysokou skolu. Moje predstava by byla, ze absolvent takoveho oboru bude znat detailne interni struktury znamych databazi , ze bude vedet jake jsou koncepcni rozdily napr mezi db2, oracle informix tam uvnitr, kde jsou jake vyhody a nevyhody. Proste jednosuse, ze absolvent bude schopen v ramci semestralky udelat takovou malou vlastni innodb.

Cele mi to pripada, ze je to zamereno na 'pouzivani' databaze misto na to, umet databazi napsat. A to je moje, patrne mylna predstava o vysokoskolskem studiu teto specializace.

[Saljack]

Naštěstí tomu tak je pouze v tomto předmětu. Jsem celkem zvědavý jak bude vypadat předmět nazvaný Technologie XML, který mají na starosti stejní přednášející. Mám pocit, že to bude to samé.

[Fluttershy, yay!]

Mno, v SISu mají výsledky v anketě výborné. ~_^

[JohnnyDoe]

Spousta lidí si stěžovala, že materiály máme pouze v angličtině (to mi trochu také vadilo, ale nic co by se nedalo snést) a že přednášející nemá slidy na přednáškách. Musím říct, že ti co si stěžovali nemají podle mě na FELu co dělat. Hlavně si stěžovali ti, co předmět loni (nebo předtím) nedali a to důvodu, že se jim předmět trochu změnil. Sepsali dokonce i nesmyslnou petici, ...

Promiň, že to tak říkám, ale nevidíš si do pusy. Předesílám, že předmět jsem zdárně ukončil, takže ze mě opravdu nemluví zášť. Píše je zajímavý učitel, už jsem "pod ním" dělal asi 2 předměty (OMO a PJV) a přišly mi fajn, jen v tomto předmětu jednak zcela objektivně přestřelil nároky na studenty, a zároveň silně podcenil přípravu materiálů. Náměty uvedené v petici doporučuji přečíst, protože nejde o "nesmyslné" požadavky studentů plakajících nad těžkým předmětem, ale o rozumné podněty za lepší předmět. Situace, kdy se člověk chce učit, ale nemá z čeho, má psát zápočtovou písemku, ale vůbec netuší jaký druh příkladů v ní bude, nemá žádné příklady na procvičení (třeba krom jednoho řešeného na cviku, příklady z té knihy byly bez řešení a navíc jiného typu než pak v písemce), tak promiň, ale říct že všichni tihle kterým chyběly materiály (mě nevyjímaje) nemají na FELu co dělat, není moc fér. A nakonec jsem předmět udělal díky materiálům z loňských let. Při porovnání s úrovní materiálů pro všechny ostatní předměty z STM (která byla obecně velice vysoká - až do současného předávání předmětů od učitelů kteří odešli na FIT) to bylo dost hrozné.

[zulu]

Těch chyb je pořád trochu moc, ale i tak docela pěkný čtení.