Generatory liczb pseudolosowych cz.3

Przyszedł czas na kolejne generatory liczb pseudolosowych. Znowu pojawi się nieco kodu oraz ogólnego wyjaśnienia pt. “Why?” ( i odpowiedzią nie będzie “For money” ;) ).

Więc do kodu start..

Najprostsze rozwiązania zawsze działają

Domyślnie Visual Studio 2008 daje taki nagłówek funkcji main:

int _tmain( int argc, _TCHAR* argv[] )

Niestety miałem problem z typem _TCHAR*, aby rzutować/skonwertować go na cokolwiek użytecznego jak std::string. Pogooglałem chwilę i zanim znalazłem naszła mnie prościutka myśl - zmienić nagłówek main’a!

int _tmain(int argc, char** argv)

Życie od razu stało się prostsze, bo konwersja char* na std::string jest prosta, łatwa i przyjemna - wystarczy podać char* jako argument do konstruktora string’a.

Proste rozwiązania sa świetne :)

Generatory liczb pseudolosowych cz.2

Jak już pisałem w pierwszej części serii o generatorach, tym razem opiszę generator liczb pseudolosowych o rozkładzie równomiernym.

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.

Wczytywanie modelu 3D z pliku OBJ

Napisałem dzisiaj proste wczytywanie współrzędnych wierzchołków oraz tzw. normalnych wierzchołków z pliku OBJ. Oczywiście plik OBJ, z takimi danymi wyeksportowanymi z programów typu 3DS MAX, Blender i pokrewnych. Budowa tego pliku jest bardzo prosta:

• nagłówek z info o programie, który utworzył plik i inne tego typu
• współrzędne wierzchołków
• współrzędne wierzchóków tekstur
• współrzędne normalnych wierzchołków
• powierzchnie

Interesowały mnie głównie rzewczy wymienione we wstępnie, ale kod bardzo łatwo rozszerzyć. Poniżej najprostszy kod, jaki można sobie wyobrazić w tej sytuacji. Na poczet większych projektów wygodnie byłoby to opakować w jakieś klasy/funkcje, aby korzystało się wygodniej.

std::ifstream in( “apple1.obj” );
std::string buffer;
std::string tmp;
float v1;
float v2;
float v3;
std::string tbl[3];
while( !in.eof() )
{
std::getline( in, buffer );
std::istringstream line( buffer );
std::string ch = buffer.substr( 0, 2 );

if( ch == “v ” )
{
line >> tmp >> tbl[0] >> tbl[1] >> tbl[2];
v1 = atof( tbl[0].c_str() );
v2 = atof( tbl[1].c_str() );
v3 = atof( tbl[2].c_str() );

std::cout << “wierzcholki v1: ” << v1 << ” v2: ” << v2 << ” v3: ” << v3 << std::endl;
}
else if( ch == “vn” )
{
line >> tmp >> tbl[0] >> tbl[1] >> tbl[2];
v1 = atof( tbl[0].c_str() );
v2 = atof( tbl[1].c_str() );
v3 = atof( tbl[2].c_str() );

std::cout << “normalne v1: ” << v1 << ” v2: ” << v2 << ” v3: ” << v3 << std::endl;
}
}

Wypadałoby dołączyć oczywiście odpowiednie nagłówki :)

Cytat dnia

ANSI C++ oferuje więcej typów strumien, niż kiedykolwiek będziesz potrzebował - np istream, ostream, iostream, ifsteam, ofsteam, fstream, wistream, wifstream, istrstream itd ( w sumie 18 klas ). Ale Java popadła juz w kompletną przesadę, oferując osobne klasy do buforowania, sprawdzania następnego w kolejce bajtu, swobodnego dostępu, formatowania tekstu, czy też binariów

Dodam od siebie, że Java ma ponad 60 takich klas :)

QMC skończony

Po długiej przerwie ( którą wypełniłem pisaniem programu ) pojawia się kolejny wpis.

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

QMC ciąg dalszy..

Zmobilizowałem się wreszcie i odpaliłem Anjutę. Otworzyłem moje pliczki z kodem implementującym algorytm minimalizacji funkcji logicznych ;)

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ż :)

Konkursowa minimalizacja

No cóż.. na uczelni jest konkurs, ale tym się różni od innych, że jest obowiązkowy dla wszystkich studentów drugiego roku z EiT ;] - piękne prawda ?

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 :)

Czasoniewstrzymywacz

Tym razem prosta klasa, służąca do pomiaru czasu wykonywania jakiś instrukcji, algorytmów etc:

class timer
{
      public:
             timer();
             ~timer();
             void start();
             void stop();
             double getDiffTime() const;
      private:
              void setDiff( clock_t);
              clock_t startTime;
              double diffTime;
};

timer::timer()
{

}

timer::~timer()
{

}

void timer::start()
{
     startTime = clock();
}

void timer::stop()
{
     clock_t stopTime = clock();
     setDiff( stopTime );
}

void timer::setDiff( clock_t time )
{
     diffTime = ( (double) ( time - startTime ) ) / CLOCKS_PER_SEC ;
}

double timer::getDiffTime() const
{
         return diffTime;
}

Komentarza raczej nie wymaga zbyt wielkiego. Zastosowałem typ clock_t, który trzeba podzielić przez stałą CLOCKS_PER_SEC aby otrzymać czas w sekundach.

Szyfr Cezara czyli jak nie szyfrować.

Szyfr Cezara, stosowany prze Juliusza Cezara do szyfrowania swoich listów jest bardzo prosty, ale i przy tym w zasadzie nieskuteczny. Choć podobno Rosjanie jeszcze na początku XX wieku korzystali w wojsku z tego szyfru, ze względu na jego prostotę :)

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