Prtogramowanie c/ C++ http://www.programowanie.pun.pl Prtogramowanie c/ C++ pl http://backend.userland.com/rss http://www.programowanie.pun.pl/viewtopic.php?pid=16#p16 16@http://www.programowanie.pun.pl www.fipomat.ugu.pl/kody/threads2/Zal.zip
Powodzenia żołnierzu:D





www.fipomat.ugu.pl/kody/threads2/Zal2.zip]]> Pištek 27 Styczeń Pištek 27 Styczeń source http://www.programowanie.pun.pl/viewtopic.php?pid=15#p15 15@http://www.programowanie.pun.pl #include <stdio.h>
#include <stdlib.h>
#include <pthread.h> // zainkludowanie biblioteki
#include <queue>

using namespace std;

// dwa watki - jeden odczytuje z pliku tekstowego znak po znaku
// drugi wyswietla odczytane dane na ekranie
// oba watki dzialaja do momentu odczytania i wyswietlenia calego pliku
// watek wyswietlajacy dane powiniene wyswietlac je co 100 ms

#define SIGNS_TO_READ = 5;

pthread_t reader;
pthread_t writer;

int finishRead = 1;
int finishWrite = 1;

pthread_mutex_t finishCreatedMutex;
pthread_cond_t finishTreshold;

pthread_mutex_t fifoMutex;

queue<char> fifo;

FILE *fp;

void openFile() {
    /* używamy metody wysokopoziomowej - musimy mieć zatem identyfikator pliku, uwaga na gwiazdkę! */
    if ((fp = fopen("czytaj.txt", "r")) == NULL) {
        printf("Nie mogę otworzyć pliku czytaj.txt do odczytu!\n");
        exit(1);
    } else {
        printf("Otworzono plik");
    }
}

void waitingMutex() {
    pthread_cond_wait(&finishTreshold, &finishCreatedMutex);
}

void sendSignal() {
    pthread_cond_signal(&finishTreshold);
}

void *read(void* data) {
    char ch;
    while (1) {
        int count = 0;
        while (count < 2) {
            count++;
            ch = fgetc(fp);
            pthread_mutex_lock(&fifoMutex);
            if (ch != EOF)
                fifo.push(ch);
            pthread_mutex_unlock(&fifoMutex);
        }

        waitingMutex();

        if (ch == EOF) {
            printf("Zamkniecie pliku\n");
            fclose(fp);
            break;
        }
    }
    printf("Zakonczenie 1 watku\n");
    finishRead = 0;
    pthread_exit(NULL);
}
void *write(void* data) {
    printf("Watek 2 rozpoczyna dzialanie\n");
    char z;
    while (finishRead) {
        usleep(100000);
        pthread_mutex_lock(&fifoMutex);
        while (fifo.size() != 0) {
            z = fifo.front();
            fifo.pop();
            cout << z << endl;
        }
        pthread_mutex_unlock(&fifoMutex);
        sendSignal();
    }
    printf("Zakonczenie 2 watku");
    pthread_exit(NULL);
}

void createThreads() {

    pthread_mutex_init(&finishCreatedMutex, NULL);

    printf("\nCreate thread\n");
    int rc;
    rc = pthread_create(&reader, NULL, read, NULL);
    if (rc) {
        printf("ERROR; return code from pthread_create() is %d\n", rc);
        exit(-1);
    }
    usleep(100000);
    printf("\nDrugi\n");
    rc = pthread_create(&writer, NULL, write, NULL);
    if (rc) {
        printf("ERROR; return code from pthread_create() is %d\n", rc);
        exit(-1);
    }
}

void joinThread() {
    pthread_join(reader, NULL);
    pthread_join(writer, NULL);
}

int main(void) {
    printf("Program start\n");
    openFile();
    createThreads();
    joinThread();
    return 0;
}]]> Pištek 27 Styczeń Pištek 27 Styczeń kompilacja linux http://www.programowanie.pun.pl/viewtopic.php?pid=14#p14 14@http://www.programowanie.pun.pl
1. Odplamy konsole przechodzimy do katalogu w ktorym mamy pliki zrodlowe projektu
2. Tworzymy sobie prosty sktypcik:
   - poleceniem touch nazwapliku.rozszerzenie   mozna bez rozrzerzenia albo .sh bedzie to konsolowe
3 Otwieramy skrypcik i wklejamy do niego to co ma robic np:

rm wynik
g++ Main.cpp Consumer.cpp ConsumerKeyboard.cpp Product.cpp ProductType.cpp Manufacturer.cpp Order.cpp OrderList.cpp Mutex.cpp Utils.cpp  -o wynik -lpthread
./wynik

gdzie kolejno pierwsza linia usuwa nam skompilowany plik wynik
druga kompiluje nam wszystkie klasy ze zlinkowniem -lpthread i skompilowany program zapisuje w pliku wynik
trzecia natomiast odpala nam skompilowany program

4. Wazne jest to zeby nadac uprawnienia do wykonania skryptu. W linuksie mozna to zrobic przez wpisanie w konsole polecenia:

chmod a+x  ./nazwapliku.rozrzerzenie    oczywiscie mowa o pliku ktory ma nam kompilowac


5. Ostatnim krokiem jest odpalanie naszego skryptu przez : ./nazwapliku.rozszerzenie    Skrypt automatycznie nam zrobic clear projektu skompiluje zliknkuje i odpali program wynikowy. Jesli odpowiedz byla przydatna daj plusa:)]]> Wtorek 3 StyczeĹ„ Wtorek 3 StyczeĹ„ kompilacja linux http://www.programowanie.pun.pl/viewtopic.php?pid=13#p13 13@http://www.programowanie.pun.pl   gcc dla czystego C
  g++ dla c++

Kod:

 gcc main.cpp(pliki wejsciowe) -o prog(definiujemy plik wyjsciowy) -lpthread(dolacz biblioteki -l o nazwie thread)
mozna sobie wygenerować makefile neo.dmcs.pl/tk/makehtml]]> Wtorek 3 StyczeĹ„ Wtorek 3 StyczeĹ„ pliki http://www.programowanie.pun.pl/viewtopic.php?pid=12#p12 12@http://www.programowanie.pun.pl
http://infobot.pl/r/234F               Img8Operations.cpp


thread


http://infobot.pl/r/234G              Kolejka.cpp
http://infobot.pl/r/234H              Kolejka.h
http://infobot.pl/r/234I               ProducentKlient.cpp

OpenMP


http://infobot.pl/r/234J                 vector.cpp
http://infobot.pl/r/234K                vector.h
http://infobot.pl/r/234L                 main.cpp


Inne

http://strony.toya.net.pl/~a_bo/]]> Wtorek 3 Styczeń Wtorek 3 Styczeń Linki http://www.programowanie.pun.pl/viewtopic.php?pid=11#p11 11@http://www.programowanie.pun.pl http://neo.dmcs.pl/num/wyklad.pdf

informacje o w±tkach : https://computing.llnl.gov/tutorials/pthreads/#Mu]]> Wtorek 3 StyczeĹ„ Wtorek 3 StyczeĹ„ tworzenie watkow podstawowe http://www.programowanie.pun.pl/viewtopic.php?pid=10#p10 10@http://www.programowanie.pun.pl https://computing.llnl.gov/tutorials/pthreads/#Mu

Kod:

#include <pthread.h>
#include <stdio.h>
#define NUM_THREADS     5

void *PrintHello(void *threadid)
{
   long tid;
   tid = (long)threadid;
   printf("Hello World! It's me, thread #%ld!\n", tid);
   pthread_exit(NULL);
}

int main (int argc, char *argv[])
{
   pthread_t threads[NUM_THREADS];
   int rc;
   long t;
   for(t=0; t<NUM_THREADS; t++){
      printf("In main: creating thread %ld\n", t);
      rc = pthread_create(&threads[t], NULL, PrintHello, (void *)t);
      if (rc){
         printf("ERROR; return code from pthread_create() is %d\n", rc);
         exit(-1);
      }
   }

   /* Last thing that main() should do */
   pthread_exit(NULL);
}
bardziej rozbudowany przykład :D

Kod:

#include <iostream>
#include "Kolejka.h"
#include <pthread.h>
#include <stdio.h>
#include <ctime>
#include <iostream>
#include <cstdlib>
#include <stdlib.h>
using namespace std;

#define KLIENT_NUMBER         7
#define MAX_COUNT             15


int ZamowienieID=1;
int count=0;
int flaga=0;

pthread_mutex_t Signal_Mutex;
pthread_attr_t attr;
pthread_cond_t count_treshold_cv;


void *KlientKeyboardTask(void *threadid)
 {
       long NumerWatku;
       NumerWatku = (long)threadid;
       int TypeOfProduct=-1;
   for(;;)
       {

       std::cout<<"\n\n\nWybierz produkt dla zamowienia klienta "<<NumerWatku<<"\n";

       while(TypeOfProduct == -1)
           {
           std::cin>>TypeOfProduct;
           usleep(10);
           }

           std::cout<<"\n\n\Klient o ID: "<<NumerWatku<<"probuje zlozyc zamowienie\n\n\n";

           Kolejka::GetKolejka()->wstaw_na_kon(NumerWatku,TypeOfProduct,&ZamowienieID);

                   pthread_mutex_lock(&Signal_Mutex);
                   pthread_cond_wait(&count_treshold_cv,&Signal_Mutex);
                   Kolejka::GetKolejka()->usun_pierwszy();
                   cout<<"\n\n\t\t\t\t\t\t\t\t\t"<<NumerWatku<<" odebral swoje zamowienie\n\n";
                   TypeOfProduct=-1;
                   pthread_mutex_unlock(&Signal_Mutex);
       }
pthread_exit(NULL);
 }

void *ProducentTask(void *threadid)
{
   sleep(2);
   for(;;)
           {
           //std::cout<<"working";
           while(Kolejka::GetKolejka()->pierwszy->produkt[4]==0 && Kolejka::GetKolejka()->pierwszy->produkt[5]==0)
             {
                  pthread_mutex_lock(&Signal_Mutex);

                          int NumerZamowienia = Kolejka::GetKolejka()->pobierz_pierwszy(1);
                          int NumerKlienta = Kolejka::GetKolejka()->pobierz_pierwszy(2);
                          int RodzajTowaru = Kolejka::GetKolejka()->pobierz_pierwszy(3);
                          pthread_mutex_unlock(&Signal_Mutex);
                          std::cout<<"\t\t\t\t\t\t\t\t\tProducent rozpoczyna realizacje za2mowienia ID: "<<NumerZamowienia<<"\n\t\t\t\t\t\t\t\t\tZamowienie klienta: "<<NumerKlienta<<" na towar: "<<RodzajTowaru<<"\n";
                          int CountLimit;
                          switch(RodzajTowaru)
                                  {
                                         case 0: std::cout<<"\t\t\t\t\t\t\t\t\tWykonanie produktu zajmie okolo 300min\n";CountLimit=2;break;

                                  }
                          Kolejka::GetKolejka()->pierwszy->produkt[4]=1;

                          pthread_cond_signal(&count_treshold_cv);
                          sleep(CountLimit);
             }

           }
   pthread_exit(NULL);

}
int main (int argc, char *argv[])
{
   pthread_t Klient[KLIENT_NUMBER];
   pthread_t Producent;
   pthread_t KlientKeyboard;
   pthread_mutex_init(&Signal_Mutex, NULL);
   pthread_cond_init(&count_treshold_cv,NULL);
   pthread_attr_init(&attr);


   int rc;
   int rd;
   int re;


   for(long t=1; t<=KLIENT_NUMBER-1; t++)
       {
       //sleep(2);
       rc = pthread_create(&Klient[t],&attr, KlientTask, (void *)t);
       std::cout<<"Klient "<<t<<" gotowy do dzialania\n";
       if (rc!=NULL)
                {
                std::cout<<"Bład podczas tworzenia klienta"<<t<<"funkcja zwraca wartosc"<<rc;
                }
       }
   rd=pthread_create(&Producent, &attr, ProducentTask, (void *)int(KLIENT_NUMBER+1));
   if (rd!=NULL)
               {
               std::cout<<"Bład podczas tworzenia producenta funkcja zwraca wartosc"<<rd;
               }
   re=pthread_create(&KlientKeyboard, &attr, KlientKeyboardTask, (void *)KLIENT_NUMBER);
   if (re!=NULL)
                {
                std::cout<<"Bład podczas tworzenia klienta z obsluga klawiatury funkcja zwraca wartosc"<<re;
                }

   pthread_join(Producent,NULL);

   pthread_exit(NULL);
}
]]> Wtorek 3 Styczeń Wtorek 3 Styczeń FiFo alokowane dynamicznie http://www.programowanie.pun.pl/viewtopic.php?pid=9#p9 9@http://www.programowanie.pun.pl
#include <iostream>
#include  <stdio.h>
#include <cstdlib>
#include <ctime>

Kolejka Kolejka::kolejka;


Kolejka::Kolejka()
            {
            pierwszy =ostatni = NULL;
            ile = 0;
            }

Kolejka::~Kolejka()
            {
            dane *temp;
            while(pierwszy) {
            temp = pierwszy;
            pierwszy = pierwszy->nastepny;
            delete temp;
            }
}

void Kolejka::wstaw_na_kon(int klient, int WybranyProdukt, int *ZamowienieID)
            {
            dane *nowy = new dane;
            if(ile<=4)
                {
                    if(ile)
                    {
                    ostatni->nastepny = nowy;
                    nowy->produkt[1] = *ZamowienieID;
                    std::cout<<"Wygenerowano zamowienie numer:"<<nowy->produkt[1];
                    nowy->produkt[2]= klient;
                    std::cout<<" przez klienta: "<<nowy->produkt[2];
                    nowy->produkt[3]= WybranyProdukt;
                    std::cout<<" na produkt: "<<nowy->produkt[3]<<"\n";
                    nowy->nastepny = NULL;
                    nowy->produkt[4]=0;
                    nowy->produkt[5]=0;
                    ostatni = nowy;
                    ile++;
                    (*ZamowienieID)++;
                    //Kolejka::sprawdzanie=1;
                    }
                else
                    {
                    pierwszy = ostatni = nowy;
                    nowy->produkt[1] = *ZamowienieID;
                    std::cout<<"Wygenerowano zamowienie numer:"<<nowy->produkt[1];
                    nowy->produkt[2]=klient;
                    std::cout<<" przez klienta: "<<nowy->produkt[2];
                    nowy->produkt[3]=WybranyProdukt;
                    std::cout<<" na produkt: "<<nowy->produkt[3]<<"\n";
                    nowy->nastepny = NULL;
                    nowy->produkt[4]=0;
                    nowy->produkt[5]=0;
                    ile++;
                    (*ZamowienieID)++;
                    //Kolejka::sprawdzanie=1;
                    }
                }

            }
void Kolejka::usun_pierwszy()
            {
            dane *pom;
            pom = pierwszy;
            pierwszy = pierwszy->nastepny;
            delete pom;
            ile-=1;
            }

int Kolejka::pobierz_pierwszy(int liczba)
            {
            dane *pom;
            pom = pierwszy;
            return pom->produkt[liczba];
            }
void Kolejka::wypisz()
            {
            dane *pom;
            pom = pierwszy;
            while (pom)
                {
                std::cout <<"ID zamowienia: "<< pom->produkt[1]<<", zlozone przez klienta: "<<pom->produkt[2]<<" na produkt: "<<pom->produkt[3]<< "\n";
                pom = pom->nastepny;
                }
            }]]> Wtorek 3 StyczeĹ„ Wtorek 3 StyczeĹ„ SSE2 http://www.programowanie.pun.pl/viewtopic.php?pid=8#p8 8@http://www.programowanie.pun.pl

Kod:

__int64 c = b;
__m128i nChange128 = Get_m128(c,c);
                        {
                            vektor4 = _mm_loadu_si128((__m128i*)&pSource[counter]);
                            _mm_store_si128((__m128i*)&pDest[counter], _mm_adds_epu8(vektor4,nChange128));
                                
                        }
odejmowanie

Kod:

__int64 c = b;
__m128i nChange128 = Get_m128(c,c);
                        {
                            vektor4 = _mm_loadu_si128((__m128i*)&pSource[counter]);
                            _mm_store_si128((__m128i*)&pDest[counter], _mm_subs_epu8(vektor4,nChange128));
                                
                        }
porównywanie wartosci

Kod:

        {
            vektor1 = _mm_loadu_si128((__m128i*)&pSource[i]);
            _mm_store_si128((__m128i*)&pDest[i],_mm_cmpeq_epi8(_mm_subs_epu8(threshold128,vektor1), zero128));
        }
wartosc bezwzgledna

Kod:

    __m128i *vektor1;
    __m128i *vektor2;
    __m128i *vektor3;
    __m128i *vektor4;
    __m128i *vektor5;

    __m128i abs1;
    __m128i abs2;

            vektor1 = (__m128i*)&pSource[counter];
            vektor2 = (__m128i*)&pSource[counter+1+nWidth];
            vektor3 = (__m128i*)&pSource[counter+1];
            vektor4 = (__m128i*)&pSource[counter+nWidth];
            vektor5 = (__m128i*)&pDest[counter];

            abs1 = _mm_or_si128(_mm_subs_epu8(_mm_loadu_si128(vektor1),_mm_loadu_si128(vektor2)), _mm_subs_epu8(_mm_loadu_si128(vektor2),_mm_loadu_si128(vektor1)));
            abs2 = _mm_or_si128(_mm_subs_epu8(_mm_loadu_si128(vektor3),_mm_loadu_si128(vektor4)), _mm_subs_epu8(_mm_loadu_si128(vektor4),_mm_loadu_si128(vektor3)));
            
            _mm_store_si128(vektor5,_mm_adds_epu8(abs1, abs2));
        }
]]> Wtorek 3 Styczeń Wtorek 3 Styczeń MMX http://www.programowanie.pun.pl/viewtopic.php?pid=7#p7 7@http://www.programowanie.pun.pl

Kod:

_mm_set1_pi8
dodawanie:

Kod:

__m64* vektor1;
__m64* vektor2;
                  for(int counter=0; counter<nNumberOfPixels; counter+=8)
                        {
                            vektor1 = (__m64*)&pSource[counter];
                            vektor2 = (__m64*)&pDest[counter];
                            *vektor2 =_mm_adds_pu8(*vektor1,nChange64);    
                        }
                  _mm_empty();
odejmowanie

Kod:

__m64* vektor1;
__m64* vektor2;
                        {
                            vektor1 = (__m64*)&pSource[counter];
                            vektor2 = (__m64*)&pDest[counter];
                            *vektor2 =_mm_subs_pu8(*vektor1,nChange64);    
                        }
porownywanie wartosci

Kod:

__m64* vektor1;
__m64* vektor2;

        {
            vektor1 = (__m64*)&pSource[counter];
            vektor2 = (__m64*)&pDest[counter];
            *vektor2 = _mm_cmpeq_pi8(_mm_subs_pu8(threshold64,*vektor1), zero64);
        }
        _mm_empty();
liczenie wartosci bezwzglednej

Kod:

            vektor1 = (__m64*)&pSource[counter];
            vektor2 = (__m64*)&pSource[counter+1+nWidth];
            vektor3 = (__m64*)&pSource[counter+1];
            vektor4 = (__m64*)&pSource[counter+nWidth];
            vektor5 = (__m64*)&pDest[counter];

            abs1 = _mm_or_si64(_mm_subs_pu8(*vektor1,*vektor2), _mm_subs_pu8(*vektor2,*vektor1));
            abs2 = _mm_or_si64(_mm_subs_pu8(*vektor3,*vektor4), _mm_subs_pu8(*vektor4,*vektor3));

            *vektor5 = _mm_adds_pu8(abs1, abs2);
        }
        _mm_empty();
]]> Wtorek 3 Styczeń Wtorek 3 Styczeń main http://www.programowanie.pun.pl/viewtopic.php?pid=6#p6 6@http://www.programowanie.pun.pl

Kod:

Vector MyVector1(Capacity);    

start = clock();
MyVector1.AddVector(MyVector2);
finish = clock();
duration = (double)(finish - start) / CLOCKS_PER_SEC;

cout<<"\n\nCzas dodawania wektorow bez uzycia instrukcji wynosi            : "<<duration<<"s\n";
]]> Wtorek 3 Styczeń Wtorek 3 Styczeń sprawdzanie czy procesor wspiera instrukcje http://www.programowanie.pun.pl/viewtopic.php?pid=5#p5 5@http://www.programowanie.pun.pl Wtorek 3 Styczeń Wtorek 3 Styczeń sprawdzanie czy procesor wspiera instrukcje http://www.programowanie.pun.pl/viewtopic.php?pid=4#p4 4@http://www.programowanie.pun.pl
CheckSupportedInstructions();

Kod:

void CheckSupportedInstructions()
             {
                int CPUInfo[4] = {-1};    
                __cpuid(CPUInfo, 1);

                if(CPUInfo[3] & ((int)1<<23))
                    {
                     cout<<"Procesor obsluguje instrukcje :        MMX\n";
                    }
                
                if(CPUInfo[3] & ((int)1<<25))
                    {
                     cout<<"Procesor obsluguje instrukcje :        SSE\n";
                    }
                if(CPUInfo[3] & ((int)1<<26))
                    {
                     cout<<"Procesor obsluguje instrukcje :        SSE2\n";
                    }
                if(CPUInfo[2] & ((int)1<<9))
                    {
                     cout<<"Procesor obsluguje instrukcje :        SSE3\n";
                    }
                if(CPUInfo[2] & ((int)1<<19))
                    {
                    cout<<"Procesor obsluguje instrukcje :        SSE4\n";
                    }
             }
]]> Wtorek 3 Styczeń Wtorek 3 Styczeń struktura vector.cpp http://www.programowanie.pun.pl/viewtopic.php?pid=3#p3 3@http://www.programowanie.pun.pl

Kod:

Vector::Vector(int ArraySize)
                 {
                   this->Size = 0;
                   this->Capacity = ArraySize;
                   this->VectorArray = new unsigned char[this->Capacity];
                 }

void Vector::PutSignIntoArray(unsigned char Sign)
                {
                    if(this->Size < this->Capacity)
                        {
                        this->VectorArray[this->Size]= Sign;
                        this->Size++;
                        //cout << "Dodano Element :" << Sign<< "\n";
                        }
                    else
                        {
                            int NewCapacity=this->Size+5;
                            Vector MyVector3(NewCapacity);

                            for(int counter = 0; counter <= this->Size; counter++)
                                {
                                    if(counter == this->Size)
                                        {
                                            MyVector3.VectorArray[counter] = Sign;
                                            MyVector3.Size++;
                                        }                                    
                                    else
                                        {
                                            MyVector3.VectorArray[counter] = this->ReadArrayAt(counter);
                                            MyVector3.Size++;
                                        }
                                }
                            
                            cout << "\nDodano Element (zostala rozszerzona tablica)\n\n";
                            delete[] this->VectorArray;
                            this->VectorArray = new unsigned char[NewCapacity];
                            this->Capacity = NewCapacity;
                            this->Size = 0;

                            for(int counter2 = 0; counter2 < MyVector3.Size; counter2++)
                                {
                                    this->VectorArray[counter2]=MyVector3.ReadArrayAt(counter2);
                                    this->Size++;
                                }
                            
                        
                        }
                }


void Vector::AddVectorMMX(Vector VectorToAdd)
                        {
                        
                                        __m64* vektor1;
                                        __m64* vektor2;

                                if(this->Size >= VectorToAdd.Size)
                                    {
                                        for(int counter = 0; counter< this->Size; counter+=8)
                                            {
                                                vektor1 = (__m64*)&this->VectorArray[counter];
                                                vektor2 = (__m64*)&VectorToAdd.VectorArray[counter];
                                                *vektor1 = _mm_adds_pu8(*vektor1,*vektor2);    
                                            }
                                      _mm_empty();
                                    }
             }

void    Vector::AddVectorSSE(Vector VectorToAdd)
                        {
                            __m128i vektor4;
                            __m128i vektor5;
                            
                            if(this->Size >= VectorToAdd.Size)
                                    {
                                     for(int counter=0; counter < this->Size; counter+=16)
                                            {
                                                vektor4 = _mm_loadu_si128((__m128i*)&this->VectorArray[counter]);
                                                vektor5 = _mm_loadu_si128((__m128i*)&VectorToAdd.VectorArray[counter]);
                                                _mm_storeu_si128((__m128i*)&this->VectorArray[counter], _mm_add_epi8(vektor5, vektor4));
                                            }
                                    }
              }
]]> Wtorek 3 Styczeń Wtorek 3 Styczeń struktura 1 pliku vector.h http://www.programowanie.pun.pl/viewtopic.php?pid=2#p2 2@http://www.programowanie.pun.pl

Kod:

class Vector 
{
    public:
    //constructors
            Vector();
            Vector(int size);
            Vector(const Vector& VectorCopy);
            Vector& operator=(Vector& VectorCopy2);
            ~Vector();
    //methods
            int                GetArraySize();
            int                GetArrayCapacity();
            int                Capacity;
            int                Size;
            void            PutSignIntoArray(unsigned char Sign);
            void            AddVector(Vector VectorToAdd);
            void            AddVectorMMX(Vector VectorToAdd);
            void            AddVectorSSE(Vector VectorToAdd);
            void            FillArray(unsigned char Sign);
            unsigned char   ReadArrayAt(int Position);
            
    private:
            unsigned char *VectorArray; 


};
]]> Wtorek 3 Styczeń Wtorek 3 Styczeń