Пряме перетворення

1. // пряме перетворення в базовому найпростішому випадку: 
2. // припускаємо, що S[i]*S[i­1] та D[i]«0
3. D[i] = S[i] – S[i­1];
4. // якщо потрібно писати в той же масив: current = S[i]; // візьмемо черговий елемент
5. S[i] = current ­ last; // обчислимо його різницю з попереднім last = current; // тепер черговий елемент став попереднім
6. У той ж массив:
7. // h=4, Ki=1/4; S[i] = (S[i­1] + S[i­2] + S[i­3] + S[i­4] )/4. Тоді:
8. D[i] = S[i] – (S[i­1] + S[i­2] + S[i­3] + S[i­4] )/4; int Last[4] ={ 0,0,0,0 }; int last_pos = 0;
9. // і далі в циклі перетворення для кожного елементу S[i] виконуємо: current=S[i]; // візьмемо черговий елемент і обчислимо  S[i] = current ­ (Last[0]+Last[1]+Last[2]+Last[3])/4; Last[last_pos]=current; // занесемо current в масив Last last_pos=(last_pos+1)&3; // нове значення позиції в Last
10. // його різницю зі значенням прогнозу:

Зворотне перетворення

1. S[i] = D[i] + S[i­1]; // якщо S[i]=S[i­1]
2. // якщо для D и S використовуємо один і той же масив (S):
3. S [i] = S[i] + S[i­1]; // сума дельти з попереднім елементом
4. // якщо пишемо в той же масив:
5. S[i] = S[i] + (S[i­1] + S[i­2] + S[i­3] + S[i­4])/4;

Зчитування аудіофайлу формату AU та його відтворення:

1. #include <fstream>
2. #include "au.h" 
3. #include "aplayer.h"
4. // пробуємо вибрати відповідну програму­програвач для
5. // систем Win32, Macintosh або UNIX / NAS.#if defined(_WIN32) 
6. #include "winplayr.h"  typedef WinPlayer Player;  #elif defined(macintosh)  #include "macplayr.h"  typedef MacPlayer Player; 
7. #else 
8. #include "nasplayr.h" typedef NasPlayer Player; 
9. #endif 
10. int main() { 
11. AuRead auRead(cin);      // створюємо об’єкт AuRead  Player player(&auRead);  // з’єднуємо вихід об’єкта АuRead  player.Play();  // запускаємо програму­програвач return 0; }

Процес узгодження діапазону значень кодування звуку

1. void AudioAbstract::MinMaxSamplingRate(long *min, long *max, long *preferred){  if (Previous()) 
2. Previous()­>MinMaxSamplingRate(min,max,preferred);  if (_samplingRate)  *preferred = _samplingRate;  if (*preferred < *min)  *preferred = *min;  if (*preferred > *max) 
3. *preferred = *max; 
4. } 
5. void AudioAbstract::SetSamplingRateRecursive(long s) {  if (Previous())  // спочатку встановлюємо для того, що справа 
6. Previous()­>SetSamplingRateRecursive(s);
7. SamplingRate(s); //  встановлюємо 
8. _samplingRateFrozen = true;  // частота узгоджена
9. }

По довжинах генерація коду Хаффмана

1. typedef unsigned int uint; typedef unsigned long ulong; template <class T> struct Node{  T key; uint code_len; ulong code; 
2. Node() : key(T()), code_len(0), code(0) {}; 
3. Node(T k, int cl=0, int cd=0) : key(k), code_len(cl), code(cd) {}; 
4. Node& operator=(const Node& _n) {  key=_n.key;  code_len=_n.code_len; 
5. code=_n.code; }
6. };
7. typedef Node<char> CharNode;
8. typedef Node<wchar_t> WCharNode;

Рекурсивна функція кодування дерева

1. void makeCodes(sym *root) // рекурсивна функція кодування дерева
2. { 
3.   if ( root­>left ) {
4.    strcpy(root­>left­>code,root­>code);
5.     strcat(root­>left­>code,"0");
6.     makeCodes(root­>left);
7.   }
8.  if ( root­>right ) {
9.     strcpy(root­>right­>code,root­>code);
10.     strcat(root­>right­>code,"1");
11.     makeCodes(root­>right);
12.   }
13. }

Функція підрахунку кількості кожного символу і його ймовірності void Statistics(char *String){

1.   int i, j;
2.   // побайтово зчитуємо рядок і складаємо таблицю зустріч 
3.   for ( i = 0; i < strlen(String); i++) {
4.     chh = String[i];
5.     for ( j = 0; j < 256; j++) {
6.       if (chh==simbols[j].ch) {
7.         kolvo[j]++;
8.         kk++; 
9.         break;
10.       }
11.       if (simbols[j].ch==0)     {
12.         simbols[j].ch=(unsigned char)chh;
13.         kolvo[j]=1;
14.         k++; 
15.         break;
16.       } 
17.     } 
18.   }
19.   for ( i = 0; i < k; i++) {  // розрахунок частоти зустрічі
20.     simbols[i].freq = (float)kolvo[i] / kk;
21. }
22.   for ( i = 0; i < k; i++)  { // в масив покажчиків заносимо адреси записів     psym[i] = &simbols[i];
23. }
24.   // сортування за збиттям
25.   sym tempp;
26.   for ( i = 1; i < k; i++){
27.   for ( j = 0; j < k ­ 1; j++){
28.     if ( simbols[j].freq < simbols[j+1].freq ) {
29.       tempp = simbols[j];
30.       simbols[j] = simbols[j+1];
31.       simbols[j+1] = tempp;
32.     } 
33.   for( i=0;i<k;i++)  {
34.     summir+=simbols[i].freq;
35.     printf("Ch= %d\tFreq= %f\tPPP= %c\t\n",simbols[i].ch,
36.             simbols[i].freq,psym[i]­>ch,i);
37.   }
38.   printf("\n Slova = %d\tSummir=%f\n",kk,summir);
39. }

Компресія біло­чорних рядків

1. for(по всіх рядках зображення){ 
2. //перетворимо рядок в набір довжин серій; 
3. for(по всіх серіях) {  if(серія біла) {         L= довжина серії;
4.         while(L > 2623) {
5.          L=L­2560;
6.         ЗаписатиБілийКодДля (2560); 
7. } 
8.  if(L > 63) {
9.         L2=МаксимальнийСостКодМеньшеL(L);
10.         L=L­L2;
11.         ЗаписатиБілийКодДля(L2); 
12. }
13.       ЗаписатиБілийКодДля(L); // Це завжди код завершення 
14. } else {
15.       //Код аналогічний білої серії, з тією різницею, що записуються парні коди 
16. }
17. } 
18.   // Закінчення рядка зображення
19. }

Mалювання ліній

1. case WM_PAINT:
2. hdc = BeginPaint(hWnd, &ps) ; // TODO: Add any drawing code here... // Відновлюємо поверхні, якщо це необхідно  if (primsurf­>IsLost()) RestoreSurfaces();
3. // очищення поверхні 
4. ClearSurfасе(backsurf, 0);
5. DrawLine(backsurf,  10, 10, 220, 20, 255, 0, 0);
6. DrawLine(backsurf, 10, 10, 50,  100, 0, 0, 255); 
7. DrawLine(backsurf, 20, 200, 300, 100, 0, 255,255); 
8. DrawLine(backsurf, 500, 500, 100, 300, 255, 0, 255);
9. // перемикання поверхні
10. primsurf­>Flip(NULL,  DDFLIP_WAIT);
11. EndPaint(hWnd,  &ps);  break;

Фейєрверк

1. void DrawScene() { 
2. // Підготовка до блокування поверхні ClearSurface(backsurf, 0); 
3. DDSURFACEDESC2 desc; 
4. ZeroMemory(&desc, sizeof(desc)) ; 
5. desc.dwSize = sizeof(desc);  // блокування поверхні if (backsurf­>Lock(0,  &desc,  DDLOCK_WAIT,  0)==DD_OK) {  BYTE* dst = (BYTE *)desc.IpSurface; for (int i=0; i<iParticleNumber; i++) // Цикл малювання іскор 
6. { 
7. // Розраховуємо нове положення іскри 
8. ParticleList[i].angle+=ParticleList[i].adjust; 
9. ParticleList[i].x += (WORD)(cos(ParticleList[i].angle/360) *ParticleList[i].speed); 
10. ParticleList[i].у += (WORD)(sin(ParticleList[i].angle/360) *ParticleList[i].speed);  // Зменшуємо час життя іскри 
11. ParticleList[i].life­­; 
12. //Якщо іскра "померла" або вийшла за межі екрану, то ініціюємо її заново
13.  if((ParticleList[i].life<0)||(ParticleList[i].x<0)|| (ParticleList[i].x>=iWidth) ||(ParticleList[i].y<0)  || (ParticleList[i].y>=iHeight)) {
14. ParticleList[i].life=rand()%200; 
15. ParticleList[i].x=iWidth/2; 
16. ParticleList[i].y=iHeight/2;
17.     }
18. // Коректуємо колір іскри
19. ParticleList[i].g+=ParticleList[i].adjust;
20. ParticleList[i].b­=ParticleList[i].adjust; //  Формуємо колір і відображаємо
21. WORD с = (WORD)(ParticleList[i].b/8 | (ParticleList[i].g/4 « 5)|(ParticleList[i].r/8 « 11)); 
22. *(WORD *)(dst+ParticleList[i].y*desc.lPitch+ParticleList[i].x*2)=c; backsurf­>Unlock(0);  primsurf­>Flip(NULL,  DDFLIPJWAIT);

Вогняна лава

1. float4 Pixel_Sh(float2 tex_coord: TEXCOORDO) : COLOR {  float3 coord;  coord.xy = tex_coord;  coord.z = 1;
2. // Визначаємо координати текстури шуму  float noiseX = tex3D(Noise, coord);  float noiseY = tex3D(Noise, coord);  // Координати текстури вогню  coord.z = ViewAngle / 2; 
3. coord.x = tex_coord.x + noiseX * 0.1+coord.z;  coord.у = tex_coord.y + noiseY * 0.1+coord.z; 
4. // Визначаємо колір шуму float n = tex3D(Noise, coord);
5. // Об'єднуємо колір шуму та колір точки на текстурі вогню 
6. float4 flame = texlD(Flame, n­0.15);  // Повертаємо колір точки 
7. return flame;
8. }