Więc do kodu start..

Kolejnym ważnym rozkładem, po wcześniej poznanym rozkładzie równomiernym, jest rozkład wykładniczy. Jest on bardzo ważny ponieważ obrazuje wiele zjawisk zarówno w telekomunikacji jak i informatyce. Przykładem są odstępy czasu pomiędzy kolejnymi zgłoszeniami w systemie telekomunikacyjnym, czy też między nowymi zadaniami w systemie operacyjnym. Jest to tzw. poissonowski strumień zgłoszeń, dotyczy on generalnie systemów kolejkowych. Poniżej kod generatora rozkładu wykładniczego o zadanej intensywności( intensywność w rozkładzie wykładniczym jest odwrotnością wartości oczekiwanej ).

class ExpotentialGenerator : public Generator
{
public:
ExpotentialGenerator( int _seed = 1, double _intensity = 0.5 );
double NextValue();
private:
UniformGenerator* uniform;
double intensity;
};

ExpotentialGenerator::ExpotentialGenerator( int _seed, double _intensity ): intensity( _intensity )
{
uniform = new UniformGenerator( _seed );
}

double ExpotentialGenerator::NextValue()
{
return -log( uniform->NextValue() )/intensity;
}

Generator opiera się na rozkładzie równomiernym [0,1], jak zdecydowana większość generatorów. Tutaj jest własnie losowana wartość z rozkładu równomiernego, z jej odwrotności liczony jest logarytm a następnie dzielimy przez intensywność ( lub mnożymy przez wartość oczekiwaną ). Zależnie co jest wygodniej dla pisanego programu można łatwo przerobić, aby argumentem wejściowym dla konstruktora była własnie wartość oczekiwana.

Przejdziemy teraz do drugiego omawianego dziś generatora - o rozkładzie Bernoulliego. Jest to rozkład, który może obrazować rzut monetą, teoretycznie prawdopodobieństwo wylosowania orła i reszki jest takie samo. Zwykle mamy dwa możliwe zdarzenia, których suma prawdopodobieństw wynosi 1. Stosujemy właśnie ten rozkład. Oto kod:

class BernoulliGenerator : public Generator
{
public:
BernoulliGenerator( int _seed, double _probability );
double NextValue();
private:
UniformGenerator* uniform;
double probability;
};

BernoulliGenerator::BernoulliGenerator( int _seed = 1, double _probability = 0.5 ): probability( _probability )
{
uniform = new UniformGenerator( _seed );
}

double BernoulliGenerator::NextValue()
{
double val = uniform->NextValue();
//// if random value belongs to "false" range return zero

if( val <= probability )
return 0.0;
else
return 1.0;
}

Sztuczka polega na tym, że losujemy liczbę w przedziale [0,1] i przedział ten dzielimy na dwie części - zgodnie z wymaganymi prawdopodobieństwami. Wartości zwracane są oczywiście umowne i zwracamy wartość odpowiadającą danemu przedziałowi. Przyjąłem tu wartości 0.0 i 1.0 czyli graniczne całego dzielonego przedziału.

W następnej części poruszymy temat generatorów rozkładu normalnego.

Zaczynamy od samych podstaw. Jak już pisałem w jednym z pierwszych wpisów na moim blogu, można rozpocząć od dwóch następujących pozycji:

1. Symfonia C ++ Standard - mam wersję 3 tomową, wydanie 5 poprawione. Obecnie dostępna jest odświeżona wersja, opisująca i zgodna z obecnymi standardami języka cpp uzupełniona np. o opis i wykorzystywanie klasy std::string. Dokładne informacje można uzyskać ze spisu treści.
   Uważam, że książka jest rzeczywiście "łatwym podręcznikiem", jak pisze sam autor - zawiera bardzo przyjazne zapoznanie czytelnika z prezentowanym zagadnieniem, odpowiada na szereg pytań które się nasuwają (bądź nie) przy czytaniu kolejnych rozdziałów. Uważam że książka przeznaczona jest dla każdego, kto chce się nauczyć programować. Bardzo dużo przykładów, tłumaczonych czytelnikowi linia po linii.
   Książka ta wprowadzi nas w solidne podstawy języka cpp. Jej uzupełnieniem była kiedyś seria Pasja C++, lecz nie wiem jak to obecnie wygląda.
2. Thinking in C++ oraz Thinking in C++ Tom 2 - możliwa do pobrania w formie ebook'ów ze strony domowej autora. Autor jest równie niesamowity w cierpliwym i przyjaznym tłumaczeniu zagadnień jak autor wspomniany wyżej. Bardzo dużo przykładów, bardzo dobre wprowadzenie w świat obiektów. Drugi tom wprowadza w bardziej zaawansowane wykorzystywanie cpp. Olbrzymim plusem jest oczywiście inicjatywa udostępnienia wersji elektronicznych swoich (wybranych) książek - jedyną przeszkodę może stanowić znajomość języka angielskiego...

"Nie od razu Rzym zbudowano" i do tematyki programowania należy podejść z olbrzymią dozą samozaparcia i co najważniejsze: przepisywać kod do używanego IDE i kompilować. Zmieniać. Kompilować. Dzięki temu nasza wiedza będzie nie tylko teoretyczna (która nie będzie ugruntowana) ale również praktyczna (wyłapiemy wtedy bardzo szybko błędy składniowe, utrwalimy sobie słowa kluczowe języka, wzorce tworzenia metod, klas - jednym słowem praktyka).

Gdy już mamy ten etap za sobą, warto jeszcze przeczytać kurs Xion'a - Megatutorial "Od zera do gier kodera". Stanowi on bardzo dobrą powtórkę materiały oraz zwraca uwagę na pewne niuanse, które mają szczególne znaczenie dla programistów gier. Oczywiście sam kurs jest podzielony na 3 części:

1. Podstawy programowania,
2. Zaawansowane C++,
3. Windows API.

Dla mnie szczególnie pomocny okazał się rozdział o szablonach (bardzo zaawansowane) oraz cześć 3 kursu (Windows API), ponieważ w jednym miejscu mamy solidną porcję wiadomości na temat programowania okienek.

W tym momencie posiadasz (konkretną) wiedzę na temat szablonów, proponuję zatem ustabilizować swoją wiedzę w temacie kontenerów. Bardzo dobrym punktem wyjścia w tym momencie może być portal cplusplus.com - zresztą wspomniany portal powinien być zawsze "pod ręką" czyli w zakładkach przeglądarki internetowej.
Gdy wiedza o kontenerach jest na odpowiednim poziomie, przeskakujemy na algorytmy - tak naprawdę będziesz używał nielicznych z nich, ale wiedza o istnieniu właśnie "tych" użytecznych musisz przecież mieć.

Jeśli zainteresowany jesteś w ogólności programowaniem gier w cpp (chociaż niekoniecznie) to polecam książkę C++ dla programistów gier lub całą serię Perełek programowania gier, ale to już temat na inny wpis.

Uff. Było tego trochę. Można przez to przejść spokojnie w 3-5 miesięcy. Warto sprawdzić czego się nauczyliśmy oraz poznać niuanse języka cpp przez odwiedzenie strony Guru of the Week. Na stronie tej znajduje się około 90 (w tym momencie 88) zadań programistycznych z różnych zagadnień wykorzystywania języka cpp, które zawierają też poprawne odpowiedzi, z których można się naprawdę dużo jeszcze dowiedzieć. Jeśli chodzi o książkę to polecam Exceptional C++ Style 40 New Engineering Puzzles [Addison Wesley, 2004], oraz trochę starszą Herb Sutter - More Exceptional CPP [Addison Wesley, 2001], które są pisane w ten sam sposób (gdyby ktoś miał problem ze zdobyciem to mogę pomóc).

Bardzo pomocne może się również okazać przeczytania FAQ twórcy języka cpp - Bjarne Stroustrup's C++ Style and Technique FAQ.

Oczywiście sam język programowania to nie wszystko - warto poświęcić trochę czasu na poznanie struktór i różnych algorytmów. Można wtedy sięgnąć po biblię Wprowadzenie do algorytmów Cormen'a lub trochę "nowszą" książę Algorytmy. Od podstaw.

Cóż, w tym momencie potrafię już tylko wskazać kierunek, którym sam będę podążał (jeśli chodzi o programowanie w cpp i gdy uporam się do końca z niektórymi z wymienionych wyżej):

• Meyers Scott - Effective C++,
• Meyers Scott - More Effective C++.

Na koniec jeszcze coś, co mogłem podać na początku...ale nikt by wtedy nie czytał mojego wpisu do końca - Z czego się uczyć (gamedev.pl).

Rozkład równomierny dla zmiennej losowej ciągłej na podanym przedziale [a,b] oznacza, że prawdopodobieństwo wystąpienia każdej z wartości w tym przedziale jest dokładnie takie samo i wynosi dokładnie 1/(b-a) - stąd widać, że a i b muszą być wartościami skończonymi, aby wynik był sensowny. Prawdopodobieństwo wystąpienia każdej wartości spoza przedziału wynosi 0. Analogicznie sytuacja ma się dla zmiennej losowej dyskretnej. Przykładem dla dyskretnej zmiennej losowej może być rzut monetą lub kostką sześcienną ( zakładając, że nie są w jakiś sposób zmodyfikowane ). Więcej teorii łatwo znaleźć na wikipedii - ten wpis nie ma na celu wykładu matematycznego.

Zajmijmy się teraz właściwym tematem czyli generatorami. Pomysłów na generatory liczb o takim rozkładzie było w historii kilka. Przedstawię tutaj dwa z nich: generator mieszany oraz multiplikatywny.

Generator mieszany opiera się na prostym wzorze matematycznym:

X_(n+1) = ( a*X_n + c ) mod m

Przy założeniu, że a, c, m > 0. Te współrzynniki powinny być odpowiednio dobrano, przy czym kryteria są następujące:

• okres generatora powinien być możliwie długi
• jak największe złudzenie losowości

Pierwszy aspekt jest w miarę oczywisty natomiast w drugim, chodzi o to, że patrząc na wygenerowane liczby nie można zauważyć wzoru, który je generuje. Powiedzmy, że mamy 3 możliwe wartości do wylosowania: 1, 2 i 3. Wygenerowane wartości mogą wyglądać tak: 1 1 1 2 2 2 3 3 3 1 itd. widać, że rozkład jest równomierny, ale losowość żadna. Wracając do pierwszego kryterium, aby je spełnić trzeba trzymać się następujących zasad:

• współczynniki c i m powinny być liczbami wzajemnie pierwszymi
• a = 1 mod p dla każdego czynnika pierwszego p liczby m

Patrząc na wzór matematyczny, można dostrzec, że może być problem z jego implementacją tak, aby uzyskać najdłuższy możliwy okres na maszynie 32-bitowej czyli 2147483647. Wiąże się to z przepełnieniem w czasie dokonywania obliczeń. Powstał więc algorytm, który zapobiega takiemu obrotowi sprawy i implementuje wcześniejszy wzór dla c = 0. Oto on:

1. h := floor( X/q )
2. X = a*( X - q*h ) - r*h
3. jeśli X < 0 to X = X + 2147483647

Oczywiście X jest wynikiem. Na potrzeby implementacji zostały opracowane trójki liczb, które spełniają wcześniej ustalone kryteria, poniżej trzy takie przykładowe trójki:

• a = 16807 q = 127773 r = 2836
• a = 48271 q = 44488 r = 3399
• a = 69621 q = 30845 r = 23902

Czas na przykładową implementację w C++. Zacznę od klasy abstrakcyjnej, którą napisałem na potrzeby tworzonego projektu:

class Generator
{
public:
virtual double NextValue() = 0;
};

Jako, że w C++ nie ma typowo klas abstrakcyjnych, tworzomy je poprzez zadeklarowanie wszystkich metod jako czysto wirtualne. Teraz część właściwa, czyli generator liczb o rozkładzie równomiernym:

class UniformGenerator : public Generator
{
public:
UniformGenerator( int _seed = 1, double low = 0.0, double high = 1.0 );
double NextValue();

static const int max = 2147483647;
static const int a = 16807;
static const int q = 127773;
static const int r = 2836;
private:
int seed;
double low_level;
double high_level;
};

Widać tu statyczne stałe, które reprezentują wcześniej wspomniane współczynniki oraz wartość maksymalną. Składowe prywatne to seed czyli tzw jądro generatora, dolny i górny zakres ( czyli granice przedziału [a,b] ). Jądro generatora to X_0 czyli wartość startowa. Implementacja:

UniformGenerator::UniformGenerator( int _seed, double low , double high ): seed( _seed ), low_level( low ), high_level( high )
{

}

double UniformGenerator::NextValue()
{
int h = seed/q;
seed = a*( seed - q*h ) - r*h;
if ( seed < 0 )
seed += max;

return ( (double)seed/(double)max*( high_level-low_level ) + low_level );
}

Nie ma tu żadnych niespodzianek poza "regulacją zakresu". Domyślnie generator wg wcześniejszego wzoru i po podzieleniu przez maksymalną wartość generuje liczby na przedziale [0,1].

Przyszedł czas na generator multiplikatywny, tym razem będzie bez implementacji w C++, dlatego, że widać ją powyżej. Generator multiplikatywny to szczególny przypadek generatora mieszanego, właśnie przy założeniu c = 0. W zasadzie nic więcej na ten temat nie trzeba mówić.

W kolejnej notce dalej będę opisywał metody generacji, jednak innych rozkładów dość powszechnie używanych.

W praktyce daje nam to pewną wspaniałą własność, która może być zarówno być zarówno błogosławieństwem jak i przekleństwem. Dla mnie jest błogosławieństwem ponieważ aktualnie zajmuję się symulacją cyfrową, a tu "powtarzalność" eksperymentu jest bezcenna! Co oznacza owa "powtarzalnosć eksperymentu"? Jest to możliwość prześledzenia procesu, który symulujemy, kilka razy w _identycznych_ warunkach - jest to niemożliwe w rzeczywistości.

Postanowiłem napisać ten cykl artykułów o generatorach pseudolosowych ponieważ ich losowość polega na tym, że przechodzą testy, na zgodność z pewnym, założonym rozkładem prawdopodobieństwa. O testach tych być może również napiszę na koniec cyklu wpisów o samych generatorach różnych rozkładów.

Przy czytaniu przyda się znajomość rachunku prawdopodobieństwa. W następnej notce zacznę od rozkładu równomiernego, który stanowi podstawę dla innych rozkładów - jest więc swego rodzaju "królem". Przykładowe implementacje będę podawał w języku C++, ale pojawią się również algorytmy więc przełożenie ich na inne języki nie powinno stanowić problemu (zwłaszcza, gdy ma się kod podglądowy).

W niniejszej książce znajdziesz połączoną wiedzę ponad 40 utalentowanych twórców gier. Współpracując, stworzyli zbiór wskazówek dotyczących programowania gier, dzięki któremu uzupełnisz swoją wiedzę. Jeśli zaimplementujesz zaprezentowane tutaj techniki (wypracowywane przez wiele godzin), wrogowie będą sprytniejsi, bohater płynnie powali przeciwników, a gracze z powodu wysoce realistycznego trójwymiarowego świata będą się bali zgasić światło w nocy.

Niezależnie od tego, czy pytali mnie o nowinki techniczne wprowadzone w nowej konsoli, czy o złożone algorytmy, jedna rzecz stawała się dla mnie jasna: ciągle zadajemy pytania. Jako programiści gier często nie wiemy, jak wykonać postawione przed nami zadanie. Może właśnie dlatego tak bardzo lubimy tę pracę! Co masz jednak zrobić, gdy przytrafi Ci się opisana sytuacja? Przeszukasz domową biblioteczkę lub zasoby sieci WWW? A może zajrzysz do archiwalnych numerów fachowych czasopism? Żaden twórca gier nie korzysta z jednego określonego źródła. Czy nie byłoby wspaniale, gdyby jednak istniało takie miejsce, do którego zawsze zajrzysz w pierwszej kolejności? Właśnie w tym celu napisaliśmy książkę, którą trzymasz w ręce.

Rozdziały książki obejmują wiele problemów technicznych, na które możesz się natknąć, pisząc grę. Znajdziesz ogromną liczbę szczegółowo omówionych technik, ale i kilka bardziej ogólnych rozdziałów. Zadaniem książki jest zwiększenie Twojego stopnia zaawansowania niezależnie od aktualnej wiedzy, jaką posiadasz. Na przykład w bardziej ogólnych rozdziałach opisujemy techniki, nie zagłębiając się w szczegóły na ich omówienie czas przychodzi później. Dobrymi przykładami mogą być rozdziały o kwaternionach oraz część dotycząca algorytmów sztucznej inteligencji.

Sięgnij po poradnik »

Wczoraj o godz. 23:46 skończyłem oficjalnie pisać QMC. Jeszcze jutro obrona tego i rozdział ten będę mógł zamknąć :)

Popatrzałem, zmodyfikowałem jedną klasę nieco dopisując kilka linijek. Również kilka linijek doszło do jednej z funkcji.

Na tym zakończyłem na dzisiaj, ale najważniejszy jest fakt, że wogóle się za to wziąłęm - powinno pójść z górki już :)

Nie powiem, że piszę program konkursowy z niechęcią, ale fakt, że mógłbym ciekawsze rzeczy robić niż wynajdywać koło od nowa - dokształcać się albo realizować zlecenia. No ale mus to mus.

O co chodzi ? Należy zaimplementować w C++ algorytm minimalizacji funkcji logicznych metodą Quine'a-McCluskeya. Wszystko pięknie ładne poza kilkoma szkopułami. Nikt tego algorytmu nie przestawił w sposób informatyczny - pokazali nam tylko jak się to robi na kartce. No ale z tego da się sporo wywnioskować i napisać samemu ;) Kolejną rzeczą jest to, że ostatni krok w realizacji algorytmu jest problemem NP zupełnym....

Ale zabawy przy tym co nie miara :)

Algorytm jest wręcz banalny, opiera się na przesunięciu o 3 każdej litery alfabetu. Gdy szyfrujemy przesuwamy "w prawo", gdy deszyfrujemy "w lewo". Zapis matematyczny:

1. E(p) = ( p + 3 ) mod k
2. D(p) = ( p- 3 ) mod k

Gdzie k jest ilością liter danego alfabetu a p aktualnie szyfrowaną literą. Zgodnie z oryginalnym szyfrem, nie szyfrujemy cyfr i innych znaków ( co oczywiście ułatwia deszyfrację ) . Oto kod szyfrowania w C++:

string cezarEncode( string text )
{
    const unsigned int CEZAR_SHIFT = 3;
    const unsigned int ALPHABET_SIZE = 26;
    string result = "";
    unsigned int length = text.length();
    for ( int i(0); i < length; ++i )
    {
        // 65 is ASCII code of A, 90 is ASCII code of Z
        if ( text[i] >= 65 && text[i] <= 90 )
            result += ( text[i] - 65 + CEZAR_SHIFT ) % ALPHABET_SIZE + 65;
        // 97 is ASCII code of a, 122 is ASCII code of z
        else if ( text[i] >= 97 && text[i] <= 122 )
            result += ( text[i] - 97 + CEZAR_SHIFT ) % ALPHABET_SIZE + 97;
        else
            result += text[i];
    }
    return result;
}

Deszyfrowanie:

string cezarDecode( string text )
{
       const unsigned int CEZAR_SHIFT = 3;
       const unsigned int ALPHABET_SIZE = 26;
       string result = "";
       unsigned int length = text.length();
       for ( int i(0); i <   length; ++i )
       {
           // 65 is ASCII code of A, 90 is ASCII code of Z
            if ( text[i] >= 65 && text[i] <= 90 )
                result += ( text[i] - 65 - CEZAR_SHIFT ) % ALPHABET_SIZE + 65;
            // 97 is ASCII code of a, 122 is ASCII code of z
            else if ( text[i] >= 97 && text[i] <= 122 )
                   result += ( text[i] - 97 - CEZAR_SHIFT ) % ALPHABET_SIZE + 97;
            else
                result += text[i];
       }

       return result;
}

I na tym koniec