Od Informacji do Wiedzy

Artykuły

Marcin — Fri, 17 Feb 2012 12:22:28 +0000

Ostatnio większość czasu spędzam nad szlifowaniem rozprawy i opisem rezultatów badań. Uzbierało się trochę tego. W między czasie widzę, że spływają recenzje wysłanych artykułów do wydawnictw. Ostatnio ukazał się artykuł – Marcin Mirończuk, Tadeusz Maciak Wykorzystanie komponentów platformy ERP do budowy drugiej generacji hybrydowego systemu wspomagania decyzji dla PSP. Metody Informatyki Stosowanej, 3/2011. Zainteresowanych tematyką zapraszam do działu Abstrakty lub Publikacje, gdzie znajdują się streszczenia oraz linki do wersji elektronicznych ww. artykułów.

Laboratoria nr 16 program nr 1

Marcin — Thu, 12 Jan 2012 17:21:55 +0000

Poniżej przedstawiam zrefaktoryzwoany, przedstawiony wcześniej szkielet kodu aplikacji do przetwarzania tekstów (Labolatorium nr 15) . Aktualnie zaprezentowane zostały tematy związane z takimi zagadnieniami jak:

- biblioteka boost i wykorzystanie inteligentnych wskaźników (rozwiązanie problemów z ewentualnymi wyciekami pamięci np. przy wywoływaniu wyjątków),

- biblioteka standardowa STL,

- modyfikator const.

W miarę czasu postaram przedstawić zagadnienia związane z tampletami (ang. tamplates) stosowanymi do programowania ogólnego oraz wykorzystanie wyrażeń regularnych w budowaniu macierzy wyrażeń (ang. term matrix). Dobre wprowadzenie do biblioteki boost i wyrażeń regularnych zawiera Przemoc’s wiki. W dalszej kolejności planowane jest też pokazanie sposobów testowania kodu (ang. test unity) zamiast stosowania testów wewnątrz funkcji main().

Na koniec, a może nawet w następnym poście dotyczącym C/C++, chciałbym przedstawić zagadnienie związane z łączeniem PHP z C++. Maszyna zenda jest dość ciężka do opanowania (wiele pośrednich makr, dokumentacji etc.). Opanowanie jej zajmuje trochę czasu. Powstało jednakże bardziej elastyczne narzędzie w postaci SWIG w którym na pierwszy rzut oka zadanie to wydaje się o wiele elastyczniejsze i łatwiejsze niż poprzez hackowanie bezpośrednio zenda. Z rozwiązaniem tym pierwszy raz spotkałem się w Linux Magazine (artykuł pt. “PHP z C++”) a następnie na blogu IBMa Build PHP extensions with SWIG, gdzie Martin Streicherwyjaśnia w bardzo przystępny sposób jak pisać rozszerzenia używając C/C++ do PHP.

Kod zrefaktoryzwoanej aplikacji wykorzystujący utworzone interfejsy przedstawia listing poniżej:

//============================================================================
// Name        : agencyText.cpp
// Author      : Marcin Mirończuk
// Version     : 1.0
// Copyright   : GPL
// Description : The agency to text retrive
//============================================================================

/**
 * Rejestracja bibliotek
 */
#include 
#include 
#include 
#include "textAgent.h"

#include "boost/scoped_ptr.hpp"

/**
 * Rejestracja przestrzeni nazw
 */
using namespace std;
using namespace ta;
using namespace boost;

/**
 * Definicja typów
 * Wstep do tworzenia szablonow @see http://pl.wikibooks.org/wiki/C++/Szablony_klas
 */
typedef ta::textAgent agentInt;

/**
 * Program glowny
 */
int main(int argc, char** argv) {

	/**
	 * Wystartowanie kilku agentow dynamicznych oraz statycznych, nazwanych jak i nienazwanych (anonimowych)
         * Zastosowanie inteligentnych wskaznikow z biblioteki boost do zarzadzania czasem zycia obiektow
	 */
	agentInt agentStatyczny(1220, 1, "przetwarzacz tekstu 1", "Agent T1");
	agentInt niezweryfikowanyAgentStatyczny;

	boost::scoped_ptr agentDynamiczny(new agentInt(12330, 2, "przetwarzacz tekstu 2", "Agnet T2"));
	boost::scoped_ptr niezweryfikowanyAgentDynamiczny(new agentInt());

	try {

		/**
		 * Pokazanie informacji o rezydujacych agentach
		 */
		cout << "Zarejestrowany agent i jego dane:" << endl;
		agentStatyczny.showData();

		cout << endl;

		cout << "Agent oczekujacy na rejestracje:" << endl;
		niezweryfikowanyAgentStatyczny.showData();

		cout << endl;

		cout << "Agent dynamiczny zarejstrowany:" << endl;
		agentDynamiczny->showData();

		cout << endl;

		cout << "Agent dynamiczny niezweryfikowany:" << endl;
		niezweryfikowanyAgentDynamiczny->showData();

		cout << endl;

		/**
		 * Rejestracja modulu (przybornika) do przetwarzania tekstow
                 * Dodatkowe testy przybornika
		 */
		tt::textTool tt;
                tt::textTool ttTest;

                cout << "Testowanie tollboksa do przetwarzania tekstu: " << endl;

                ttTest.extractSegments("A ja mam kota. I wiecej tekstu.");
                ttTest.showSegments();

                cout << endl;

		/**
		 * Rejestracja przybornika dla agenta dynamicznego
		 */
		agentDynamiczny->rejestrTextTool(tt);
		agentDynamiczny->rejestrTextTool().extractSegments("Ala ma kota.");

		cout << "Ilosc zliczonych segmentow: " <<  agentDynamiczny->rejestrTextTool().getCountSegments() << endl;
		cout << "Pokaz jakie segmenty zliczyles: " << endl;
		agentDynamiczny->rejestrTextTool().showSegments();

		cout << endl;

		/**
		 * Rejestracja przybornika dla agenta statycznego
		 */
                agentStatyczny.rejestrTextTool(tt);
		agentStatyczny.rejestrTextTool().extractSegments("A ja mam kota. I wiecej tekstu.");

                cout << "Ilosc zliczonych segmentow: " << agentStatyczny.rejestrTextTool().getCountSegments() << endl;
		cout << "Pokaz jakie segmenty zliczyles: " << endl;
		agentStatyczny.rejestrTextTool().showSegments();

		cout << endl;

		cout << "Testowanie usowania spacji:" << endl;

		std::string testString1 = " kota ";
		cout << "- Tekst przed filtracja: " << testString1 << endl;
		cout << "- Filtracja: " << "Tekst odfiltrowany: " << agentStatyczny.rejestrTextTool().stripWhiteSpace(testString1) << endl;
		cout << "- Filtracja: " << "Tekst pierwotny " << testString1 << endl;

		std::string *pTestString1 = &testString1;
		cout << "- Tekst przed filtracja wskaznik / zmienna: " << *pTestString1 << " / " << testString1 << endl;
		agentStatyczny.rejestrTextTool().stripWhiteSpace(pTestString1);
		cout << "- Filtracja: " << "Tekst odfiltrowany " << *pTestString1 << endl;
		cout << "- Filtracja: " << "Tekst pierwotny " << testString1 << endl;

		cout << endl;

		cout << "Testowanie tokenizacji:" << endl;
		std::string testString2 = "Ala ma kota. A kot ma na imie Ala.";
		cout << "- Tekst podlegajacy tokenizacji: " << testString2 << endl;
		agentStatyczny.rejestrTextTool().tokenize(testString2);
		cout << "- Ilosc tokenow: " <<  agentStatyczny.rejestrTextTool().getCountTokens() << endl;
		cout << "- Ilosc unikatowych tokenow: " <<  agentStatyczny.rejestrTextTool().getCountUniqueTokens();

                cout << endl;

                niezweryfikowanyAgentDynamiczny->rejestrTextTool();

	} catch (std::string exception) {
                cout << endl;
		cout<<"Wyjatek: "<< exception;
	}

	return 0;
}

Interfejs agenta który rejestruje moduł do przetwarzania tekstu i za pośrednictwem którego odbywają się wszelkie modyfikacja przedstawia listing poniżej:

/*
 * textAgent.h
 *
 *  Created on: 21-12-2011
 *  Author: Marcin Mirończuk
 *  Licenc: GPL
 *
 *  Klas modelujaca podstawowe elementy agenta do przetwarzania tekstu.
 *  Agent ma mozliwosc rejestrowania u siebie modulu do przetwarzania tekstu za omoca ktorego przetwarza tekst.
 *
 * @note::
 * + Metody [nazwaMetody]get() const nie zmieniaja stanu obiektow na zecz ktorych sa wywolywane.
 *   (pola tylko do odczytu)
 * + Czesc metod [nazwaMetody]get() moze byc wywolana inline
 *
 */

#include 
#include "textTool.h"

#ifndef TA_H_
#define TA_H_

/**
 * Definicja przestrzeni nazw
 */
namespace ta {

	/**
	 *  Definicja klasy
	 */
	class textAgent {

		/**
		 * Skladowe i metody prywatne klasy
		 */
		private:

			/**
			 * @type int timeCreate Czas w sekundach  Unix timestamp
			 */
			int timeCreate;

			/**
			 * @type float priority Priorytet agebta
			 */
			int priority;

			/**
			 * @type string task Zadanie/praca do wykonania przez agebta
			 */
			std::string task;

			/**
			 * @type string name Nazwa agenta
			 */
			std::string name;

			/**
			 * @type bool isTextTool Flaga rejestracji modulu tekstu
			 */
			bool isTextTool;

			/**
			 * @type textTool textTool Uchwyt do modulu przetwarzajacego tekst
			 */
			tt::textTool textTool;

		/**
		 * Skladowe i metody publiczne klasy
		 */
		public:

			/**
			 * Konstruktor podstawowy domyslny
			 */
			textAgent();

			/**
			 * Konstruktor rozszerzony
			 */
			textAgent(int ptimeCreate, int ppriority, std::string ptask, std::string pname);

			/**
			 * Pobranie wieku agenta
			 *
			 * @return float
			 */
			int getTimeCreate() const;

			/**
			 * Pobranie wagi agenta
			 *
			 * @return float
			 */
			int getPriority() const;

			/**
			 * Pobranie zadania agenta
			 *
			 * @return string
			 */
			std::string getTask() const;

			/*
			 * Pobranie nazwy agenta
			 *
			 * @return string
			 */
			std::string getName() const;

			/**
			 * Pokazanie danych o agencie
			 *
			 * @return void
			 */
			void showData() const;

			/**
			 * Rejestracja modulu do przetwarzania tekstu
			 *
			 * @return tt::textTool
			 */
			const tt::textTool & rejestrTextTool(tt::textTool tt);

			/**
			 * Rejestracja, pobranie modulu do przetwarzania tekstu.
			 *
			 * @return tt::textTool
			 * @thorw exception
			 */
			tt::textTool & rejestrTextTool() throw(std::string);

                        /**
                         * @see ta::textAgent::rejestrTextTool()
                         *
			 * @return tt::textTool
			 * @thorw exception
                         */
                        tt::textTool & getTextTool();

			/**
			 * Destruktor
			 */
			virtual ~textAgent();
	};

} /* namespace textagent */
#endif /* TA_H_ */

Interfejs programu (modułu) do przetwarzania strumienia danych tekstowych przedstawia listing poniżej:

/*
 * textAgent.cpp
 *
 *  Created on: 21-12-2011
 *  Author: Marcin Mirończuk
 *  Licenc: GPL
 *
 *  Implementacja interfejsu agenta do przetwarzania tekstu @see textAgent.h
 *
 */

#include 
#include "textAgent.h"
#include "textTool.h"

namespace ta {

	textAgent::textAgent() {
		this->timeCreate = 0;
		this->priority = 0;
		this->task = "unknown";
		this->name = "inkognito";

		this->isTextTool = false;
	}

	textAgent::textAgent(int ptimeCreate, int ppriority, std::string ptask, std::string pname) {
		this->timeCreate = ptimeCreate;
		this->priority = ppriority;
		this->task = ptask;
		this->name = pname;

		this->isTextTool = false;
	}

	int textAgent::getTimeCreate() const {
		return this->timeCreate;
	}

	int textAgent::getPriority() const {
		return this->priority;
	}

	std::string textAgent::getTask() const {
		return this->task;
	}

	std::string textAgent::getName() const {
		return this->name;
	}

	void textAgent::showData() const {
		std::cout << "Time create: " << this->timeCreate << std::endl;
		std::cout << "Priority: " << this->priority << std::endl;
		std::cout << "Name: " << this->name << std::endl;
		std::cout << "Task: " << this->task << std::endl;
	}

	const tt::textTool & textAgent::rejestrTextTool(tt::textTool tt) {
		if(this->isTextTool == false) {
			this->textTool = tt;

			this->isTextTool = true;

			return this->textTool;
		} else {
			return this->textTool;
		}
	}

	tt::textTool & textAgent::rejestrTextTool() throw(std::string) {
		if(this->isTextTool == false) {
			std::string exception = "Unregister text tool!";

			throw exception;
		} else {
			return this->textTool;
		}
	}

        tt::textTool & textAgent::getTextTool() {
            return this->rejestrTextTool();
        }

	textAgent::~textAgent() {
	}

} /* namespace ta */

Implementację interfejsu programu do przetwarzania tekstu zawiera listing poniżej:

/*
 * textTool.h
 *
 *  Created on: 21-12-2011
 *  Author: Marcin Mirończuk
 *  Licenc: GPL
 *
 *  Klas modelujaca modul (przybornik) do przetwarzania tekstu.
 *
 * @note::
 * + Metody [nazwaMetody]get() const nie zmieniaja stanu obiektow na rzecz ktorych sa wywolywane.
 *   (pola tylko do odczytu)
 * + Czesc metod [nazwaMetody]get() moze byc wywolana inline
 * + Zabezpieczenie funkcji zwracajacych referencje modyfikatorem const tj.
 *   Uniemozliwienie wywolan typu ttTest.extractSegments("") = temp;
 *   @see http://rab.ict.pwr.wroc.pl/~kreczmer/po/materialy/referencje.pdf
 *
 */

#include 
#include 
#include 

#ifndef TT_H_
#define TT_H_

/**
 * Definicja przestrzeni nazw
 */
namespace tt {

	/**
	 *  Definicja klasy
	 */
	class textTool {

		/**
		 * Skladowe i metody prywatne klasy
		 */
		private:

			/**
			 * @type vector segment Wektor segmentow
			 */
			std::vector segments;

			/**
			 * @type vector tokens Wektor tokenow (wyrazen)
			 */
			std::vector tokens;

			/**
			 * @type vector uniqueTokens Wektor unikalnych tokenow (wyrazen)
			 */
			std::vector uniqueTokens;

			/**
			 * @type vector tokensFrequ Tablica klucz=wartosc czestotliwosci wyrazen
			 */
			std::map tokensFrequ;

			/**
			 * Usowanie duplikatow wyrazen z wektora wyrazen
			 *
			 * @see http://learningcppisfun.blogspot.com/2008/04/remove-duplicates-from-vector.html
			 * @see http://stackoverflow.com/questions/1041620/most-efficient-way-to-erase-duplicates-and-sort-a-c-vector
			 *
			 * @param vector vec
			 *
			 * @return vector
			 */
			const std::vector & removeDuplicates(std::vector vec);

		public:

			/**
			 * Domyslny konstruktor
			 */
			textTool();

			/**
			 * Wydobywanie segmentow z tekstu.
			 *
			 * @param string &text
			 *
			 * @return vector
			 */
			const std::vector & extractSegments(const std::string &text);

			/**
			 * Pobranie ilosci wydobytych segmentow z tekstu.
                         *
			 * @return int
			 */
			int getCountSegments() const;

			/**
			 * Pokazanie wydobytych segmentow z tekstu.
			 *
			 * @return void
			 */
			void showSegments() const;

			/**
			 * Usuniecie spacji z poczatku jak i z konca lancucha znakow.
			 *
			 * @param string text
			 *
			 * @return string
			 */
			std::string stripWhiteSpace(std::string text);

			/**
			 * Przeciazona wersja usuniecia spacji z poczatku jak i z konca lancucha znakow.
			 *
			 * @param string *text
			 *
			 * @return void
			 */
			void stripWhiteSpace(std::string *text);

			/**
			 * Kalkulacja, wyznaczanie macierzy czetotliwosci wystepowania wyrazen w pojedynczym dokumencie tekstowym.
			 *
			 * @param string &text
			 *
			 * @return map
			 */
			const std::map & computeTokensFrequ(const std::string &text);

			/**
			 * Tokenizacja tekstu tj. rozbicie tekstu na wektor wyrazen.
			 * @see http://oopweb.com/CPP/Documents/CPPHOWTO/Volume/C++Programming-HOWTO-7.html
			 *
			 * @param string &text
			 *
			 * @return vector
			 */
			const std::vector & tokenize(const std::string &text);

			/**
			 * Pobranie ilosci wyrazen.
			 *
			 * @return int
			 */
			int getCountTokens() const;

			/**
			 * Pobranie ilosci unikalnych wyrazen.
			 *
			 * @return int
			 */
			int getCountUniqueTokens();

			/**
			 * Domyslny destruktor
			 */
			virtual ~textTool();
		};

	} /* namespace tt */
#endif /* TT_H_ */

Implementację powyżej zaprezentowanego interfejsu programu do przetwarzania tekstu zawiera listing poniżej:

/*
 * textTool.cpp
 *
 *  Created on: 21-12-2011
 *  Author: Marcin Mirończuk
 *  Licenc: GPL
 *
 *  Implementacja interfejsu modulu do przetwarzania tekstu @see textTool.h
 *
 */

#include 
#include 
#include 
#include 
#include 
#include "textTool.h"

namespace tt {

	textTool::textTool() {
	}

	/**
	 * Bardzo naiwna, prezentacyja wersji algorytmu do rozbijania tekstu na segmenty (zdania)
	 */
	const std::vector & textTool::extractSegments(const std::string &text) {

                std::string tempSegment;

		for(int i = 0; i < text.length(); i++) {
			if(text[i] == '.' || text[i] == '?' || text[i] == '!') {
				tempSegment = (std::string) tempSegment;
				this->segments.push_back(this->stripWhiteSpace(tempSegment));
				tempSegment.clear();
			} else {
				tempSegment += text[i];
			}
		}

		return this->segments;
	}

	int textTool::getCountSegments() const {
		return this->segments.size();
	}

	std::string textTool::stripWhiteSpace(std::string text) {

		if(text[0] == ' ') {
			text.replace(0, 1, "");
		}

		if(text[text.length()-1] == ' ') {
			text.replace(text.length()-1, 1, "");
		}

		return text;
	}

	void textTool::stripWhiteSpace(std::string *text) {
		std::string::iterator it;

		it = text->begin();

		if(*it == ' ') {
			text->replace(0, 1, "");
		}

		it = text->end();

		if(*(it-1) == ' ') {
			text->replace(text->length()-1, 1, "");
		}
	}

	void textTool::showSegments() const {
		for(int i = 0; i < this->segments.size(); i++) {
			std::cout << this->segments[i] << std::endl;
		}
	}

	const std::map & textTool::computeTokensFrequ(const std::string &text) {
		this->tokenize(text);
		this->removeDuplicates(this->tokens);

		std::vector::iterator it;

                //@todo :: Zaimplementowac algorytm do tworzenia macierzy wyrazen (term matrix, tm)
		for (it = this->uniqueTokens.begin(); it < this->uniqueTokens.end(); it++) {
		    std::cout << " " << *it;
		}

		return this->tokensFrequ;
	}

	const std::vector & textTool::tokenize(const std::string &text) {

            // Buforowany string
	    std::string buf;

	    // Wstawienie stringu z potoku
	    std::stringstream ss(text);

	    while (ss >> buf) {
	    	this->tokens.push_back(buf);
		}

		return this->tokens;
	}

	int textTool::getCountTokens() const {
		return this->tokens.size();
	}

	int textTool::getCountUniqueTokens() {
		if(this->tokens.size() != 0 && this->uniqueTokens.size() == 0) {
			this->removeDuplicates(this->tokens);

			return this->uniqueTokens.size();
		} else {
			return this->uniqueTokens.size();
		}
	}

	const std::vector & textTool::removeDuplicates(std::vector vec) {

            std::sort(vec.begin(), vec.end());
	    vec.erase(std::unique(vec.begin(), vec.end()), vec.end());

	    this->uniqueTokens = vec;

            return this->uniqueTokens;
	 }

	textTool::~textTool() {

	}

} /* namespace tt */

Laboratoria nr 15 program nr 1

Marcin — Tue, 03 Jan 2012 16:16:35 +0000

Projektowanie klas i programowanie obiektowe na przykładzie aplikacji do przetwarzanie tekstu.

Poniżej został zaprezentowany szkielet aplikacji do przetwarzania tekstu, który będzie rozbudowywany i omawiany wraz z nowymi laboratoriami. Przedstawiane zagadnienia będą obejmowały zawansowane aspekty programowania w c++. Czytelnicy nabiorą biegłości w wykorzystaniu biblioteki standardowej STL oraz Boost. Zapoznają się z szablonami oraz metodami projektowania klas. Wszytko zostanie przedstawione na podstawie projektowania i implementacji programu do przetwarzania tekstu.

Poniżej zaprezentowano interfejsy jak i ich implementacja klas które będą omawiane, refaktoryzowane i stosowane podczas omawiania ww. materiału. Podstawowy szkielet aplikacji składa się z następujących plików:

- agencyText.cpp – zawiera kod wykonawczy programu oraz testy zaprojektowanych i zaimplementowanych interfejsów,

- textAgent.h oraz textAgent.cpp – interfejs oraz jego implementacja do rejestrowania i użytkowania modułu do przetwarzania tekstu,

- textTool.h oraz textTool.cpp – interfejs oraz jego implementacja do przetwarzania strumienia tekstowego.

Kod aplikacji wykorzystujący utworzone interfejsy przedstawia listing poniżej:

agencyText.cpp 

//============================================================================
// Name        : agencyText.cpp
// Author      : Marcin Mirończuk
// Version     : 1.0
// Copyright   : GPL
// Description : The agency to text retrive
//============================================================================

/**
 * Rejestracja bibliotek
 */
#include 
#include 
#include 
#include "textAgent.h"

/**
 * Rejestracja przestrzeni nazw
 */
using namespace std;
using namespace ta;

/**
 * Program glowny
 */
int main() {

	/**
	 * Wystartowanie kilku agentow dynamicznych oraz statycznych, nazwanych jak i nienazwanych (anonimowych)
	 */
	ta::textAgent agentStatyczny(1220, 1, "przetwarzacz tekstu 1", "Agent T1");
	ta::textAgent niezweryfikowanyAgentStatyczny;

	textAgent *agentDynamiczny = new textAgent(12330, 2, "przetwarzacz tekstu 2", "Agnet T2");
	textAgent *niezweryfikowanyAgentDynamiczny = new textAgent();

	try {

		/**
		 * Pokazanie informacji o rezydujacych agentach
		 */
		cout << "Zarejestrowany agent i jego dane:" << endl;
		agentStatyczny.showData();

		cout << endl;

		cout << "Agent oczekujacy na rejestracje:" << endl;
		niezweryfikowanyAgentStatyczny.showData();

		cout << endl;

		cout << "Agent dynamiczny zarejstrowany:" << endl;
		agentDynamiczny->showData();

		cout << endl;

		cout << "Agent dynamiczny niezweryfikowany:" << endl;
		niezweryfikowanyAgentDynamiczny->showData();

		cout << endl;

		/**
		 * Rejestracja modulu (przybornika) do przetwarzania tekstow
		 */
		tt::textTool tt;

		/**
		 * Rejestracja przybornika dla agenta dynamicznego
		 */
		agentDynamiczny->rejestrTextTool(tt);
		agentDynamiczny->rejestrTextTool().extractSegments("Ala ma kota.");

		cout << "Ilosc zliczonych segmentow: " <<  agentDynamiczny->rejestrTextTool().getCountSegments() << endl;
		cout << "Pokaz jakie segmenty zliczyles: " << endl;
		agentDynamiczny->rejestrTextTool().showSegments();

		cout << endl;

		/**
		 * Rejestracja przybornika dla agenta statycznego
		 */
		agentStatyczny.rejestrTextTool(tt);
		agentStatyczny.rejestrTextTool().extractSegments("A ja mam kota. I wiecej tekstu.");

		cout << "Ilosc zliczonych segmentow: " << agentStatyczny.rejestrTextTool().getCountSegments() << endl;
		cout << "Pokaz jakie segmenty zliczyles: " << endl;
		agentStatyczny.rejestrTextTool().showSegments();

		cout << endl;

		cout << "Testowanie usowania spacji:" << endl;

		std::string testString1 = " kota ";
		cout << "- Tekst przed filtracja: " << testString1 << endl;
		cout << "- Filtracja: " << "Tekst odfiltrowany: " << agentStatyczny.rejestrTextTool().stripWhiteSpace(testString1) << endl;
		cout << "- Filtracja: " << "Tekst pierwotny " << testString1 << endl;

		std::string *pTestString1 = &testString1;
		cout << "- Tekst przed filtracja wskaznik / zmienna: " << *pTestString1 << " / " << testString1 << endl;
		agentStatyczny.rejestrTextTool().stripWhiteSpace(pTestString1);
		cout << "- Filtracja: " << "Tekst odfiltrowany " << *pTestString1 << endl;
		cout << "- Filtracja: " << "Tekst pierwotny " << testString1 << endl;

		cout << endl;

		cout << "Testowanie tokenizacji:" << endl;
		std::string testString2 = "Ala ma kota. A kot ma na imie Ala.";
		cout << "- Tekst podlegajacy tokenizacji: " << testString2 << endl;
		agentStatyczny.rejestrTextTool().tokenize(testString2);
		cout << "- Ilosc tokenow: " <<  agentStatyczny.rejestrTextTool().getCountTokens() << endl;
		cout << "- Ilosc unikatowych tokenow: " <<  agentStatyczny.rejestrTextTool().getCountUniqueTokens();

		delete niezweryfikowanyAgentDynamiczny;
		delete agentDynamiczny;

	} catch (std::string exception) {
		cout<<"Wyjatek: "<< exception;

		delete niezweryfikowanyAgentDynamiczny;
		delete agentDynamiczny;
	}

	return 0;
}

Interfejs agenta który rejestruje moduł do przetwarzania tekstu i za pośrednictwem którego odbywają się wszelkie modyfikacja przedstawia listing poniżej:

/*
 * textAgent.h
 *
 *  Created on: 21-12-2011
 *  Author: Marcin Mirończuk
 *  Licenc: GPL
 *
 *  Klas modelujaca podstawowe elementy agenta do przetwarzania tekstu.
 *  Agent ma mozliwosc rejestrowania u siebie modulu do przetwarzania tekstu za omoca ktorego przetwarza tekst.
 *
 */

#include 
#include "textTool.h"

#ifndef TA_H_
#define TA_H_

/**
 * Definicja przestrzeni nazw
 */
namespace ta {

	/**
	 *  Definicja klasy
	 */
	class textAgent {

		/**
		 * Skladowe i metody prywatne klasy
		 */
		private:

			/**
			 * @type int timeCreate Czas w sekundach  Unix timestamp
			 */
			int timeCreate;

			/**
			 * @type float priority Priorytet agebta
			 */
			int priority;

			/**
			 * @type string task Zadanie/praca do wykonania przez agebta
			 */
			std::string task;

			/**
			 * @type string name Nazwa agenta
			 */
			std::string name;

			/**
			 * @type bool isTextTool Flaga rejestracji modulu tekstu
			 */
			bool isTextTool;

			/**
			 * @type textTool textTool Uchwyt do modulu przetwarzajacego tekst
			 */
			tt::textTool textTool;

		/**
		 * Skladowe i metody publiczne klasy
		 */
		public:

			/**
			 * Konstruktor podstawowy domyslny
			 */
			textAgent();

			/**
			 * Konstruktor rozszerzony
			 */
			textAgent(float ptimeCreate, float ppriority, std::string ptask, std::string pname);

			/**
			 * Pobranie wieku agenta
			 *
			 * @return float
			 */
			int getTimeCreate();

			/**
			 * Pobranie wagi agenta
			 *
			 * @return float
			 */
			int getPriority();

			/**
			 * Pobranie zadania agenta
			 *
			 * @return string
			 */
			std::string getTask();

			/*
			 * Pobranie nazwy agenta
			 *
			 * @return string
			 */
			std::string getName();

			/**
			 * Pokazanie danych o agencie
			 *
			 * @return void
			 */
			void showData();

			/**
			 * Rejestracja modulu do przetwarzania tekstu
			 *
			 * @return tt::textTool
			 */
			const tt::textTool & rejestrTextTool(tt::textTool tt);

			/**
			 * Rejestracja, pobranie modulu do przetwarzania tekstu
			 *
			 * @return tt::textTool
			 * @thorw exception
			 */
			tt::textTool & rejestrTextTool();

			/**
			 * Destruktor
			 */
			virtual ~textAgent();
	};

} /* namespace textagent */
#endif /* TA_H_ */

Interfejs programu (modułu) do przetwarzania strumienia danych tekstowych przedstawia listing poniżej:

/*
 * textAgent.cpp
 *
 *  Created on: 21-12-2011
 *  Author: Marcin Mirończuk
 *  Licenc: GPL
 *
 *  Implementacja interfejsu agenta do przetwarzania tekstu @see textAgent.h
 *
 */

#include 
#include "textAgent.h"
#include "textTool.h"

namespace ta {

	textAgent::textAgent() {
		this->timeCreate = 0;
		this->priority = 0;
		this->task = "unknown";
		this->name = "inkognito";

		this->isTextTool = false;
	}

	textAgent::textAgent(float ptimeCreate, float ppriority, std::string ptask, std::string pname) {
		this->timeCreate = ptimeCreate;
		this->priority = ppriority;
		this->task = ptask;
		this->name = pname;

		this->isTextTool = false;
	}

	int textAgent::getTimeCreate() {
		return this->timeCreate;
	}

	int textAgent::getPriority() {
		return this->priority;
	}

	std::string textAgent::getTask() {
		return this->task;
	}

	std::string textAgent::getName() {
		return this->name;
	}

	void textAgent::showData() {
		std::cout << "Time create: " << this->timeCreate << std::endl;
		std::cout << "Priority: " << this->priority << std::endl;
		std::cout << "Name: " << this->name << std::endl;
		std::cout << "Task: " << this->task << std::endl;
	}

	const tt::textTool & textAgent::rejestrTextTool(tt::textTool tt) {
		if(this->isTextTool == false) {
			this->textTool = tt;

			this->isTextTool = true;

			return this->textTool;
		} else {
			return this->textTool;
		}
	}

	tt::textTool & textAgent::rejestrTextTool() {
		if(this->isTextTool == false) {
			std::string exception = "Unregister text tool!";

			throw exception;
		} else {
			return this->textTool;
		}
	}

	textAgent::~textAgent() {

	}

} /* namespace ta */

Implementację interfejsu programu do przetwarzania tekstu zawiera listing poniżej:

/*
 * textTool.h
 *
 *  Created on: 21-12-2011
 *  Author: Marcin Mirończuk
 *  Licenc: GPL
 *
 *  Klas modelujaca modul (przybornik) do przetwarzania tekstu.
 *
 */

#include 
#include 
#include 

#ifndef TT_H_
#define TT_H_

/**
 * Definicja przestrzeni nazw
 */
namespace tt {

	/**
	 *  Definicja klasy
	 */
	class textTool {

		/**
		 * Skladowe i metody prywatne klasy
		 */
		private:

			/**
			 * @type vector segment Wektor segmentow
			 */
			std::vector segments;

			/**
			 * @type vector tokens Wektor tokenow (wyrazen)
			 */
			std::vector tokens;

			/**
			 * @type vector uniqueTokens Wektor unikalnych tokenow (wyrazen)
			 */
			std::vector uniqueTokens;

			/**
			 * @type vector tokensFrequ Tablica klucz=wartosc czestotliwosci wyrazen
			 */
			std::map tokensFrequ;

			/**
			 * Usowanie duplikatow wyrazen z wektora wyrazen
			 *
			 * @see http://learningcppisfun.blogspot.com/2008/04/remove-duplicates-from-vector.html
			 * @see http://stackoverflow.com/questions/1041620/most-efficient-way-to-erase-duplicates-and-sort-a-c-vector
			 *
			 * @param vector vec
			 *
			 * @return vector
			 */
			std::vector removeDuplicates(std::vector vec);

		public:

			/**
			 * Domyslny konstruktor
			 */
			textTool();

			/**
			 * Wydobywanie segmentow z tekstu.
			 *
			 * @param string &text
			 *
			 * @return vector
			 */
			std::vector extractSegments(const std::string &text);

			/**
			 * Pobranie ilosci wydobytych segmentow z tekstu.
			 *
			 * @return int
			 */
			int getCountSegments();

			/**
			 * Pokazanie wydobytych segmentow z tekstu.
			 *
			 * @return void
			 */
			void showSegments();

			/**
			 * Usuniecie spacji z poczatku jak i z konca lancucha znakow.
			 *
			 * @param string text
			 *
			 * @return string
			 */
			std::string stripWhiteSpace(std::string text);

			/**
			 * Przeciazona wersja usuniecia spacji z poczatku jak i z konca lancucha znakow.
			 *
			 * @param string *text
			 *
			 * @return void
			 */
			void stripWhiteSpace(std::string *text);

			/**
			 * Kalkulacja, wyznaczanie macierzy czetotliwosci wystepowania wyrazen w pojedynczym dokumencie tekstowym.
			 *
			 * @param string &text
			 *
			 * @return map
			 */
			std::map computeTokensFrequ(const std::string &text);

			/**
			 * Tokenizacja tekstu tj. rozbicie tekstu na wektor wyrazen.
			 * @see http://oopweb.com/CPP/Documents/CPPHOWTO/Volume/C++Programming-HOWTO-7.html
			 *
			 * @param string &text
			 *
			 * @return vector
			 */
			std::vector tokenize(const std::string &text);

			/**
			 * Pobranie ilosci wyrazen.
			 *
			 * @return int
			 */
			int textTool::getCountTokens();

			/**
			 * Pobranie ilosci unikalnych wyrazen.
			 *
			 * @return int
			 */
			int textTool::getCountUniqueTokens();

			/**
			 * Domyslny destruktor
			 */
			virtual ~textTool();
		};

	} /* namespace tt */
#endif /* TT_H_ */

Implementację powyżej zaprezentowanego interfejsu programu do przetwarzania tekstu zawiera listing poniżej:

/*
 * textTool.cpp
 *
 *  Created on: 21-12-2011
 *  Author: Marcin Mirończuk
 *  Licenc: GPL
 *
 *  Implementacja interfejsu modulu do przetwarzania tekstu @see textTool.h
 *
 */

#include 
#include 
#include 
#include 
#include 
#include "textTool.h"

namespace tt {

	textTool::textTool() {
	}

	/**
	 * Bardzo naiwna, prezentacyja wersji algorytmu do rozbijania tekstu na segmenty (zdania)
	 */
	std::vector textTool::extractSegments(const std::string &text) {

		std::string tempSegment;

		for(int i = 0; i < text.length(); i++) {
			if(text[i] == '.' || text[i] == '?' || text[i] == '!') {
				tempSegment = (std::string) tempSegment;
				this->segments.push_back(this->stripWhiteSpace(tempSegment));
				tempSegment.clear();
			} else {
				tempSegment += text[i];
			}
		}

		return this->segments;
	}

	int textTool::getCountSegments() {
		return this->segments.size();
	}

	std::string textTool::stripWhiteSpace(std::string text) {

		if(text[0] == ' ') {
			text.replace(0, 1, "");
		}

		if(text[text.length()-1] == ' ') {
			text.replace(text.length()-1, 1, "");
		}

		return text;
	}

	void textTool::stripWhiteSpace(std::string *text) {
		std::string::iterator it;

		it = text->begin();

		if(*it == ' ') {
			text->replace(0, 1, "");
		}

		it = text->end();

		if(*(it-1) == ' ') {
			text->replace(text->length()-1, 1, "");
		}
	}

	void textTool::showSegments() {
		for(int i = 0; i < this->segments.size(); i++) {
			std::cout << this->segments[i] << std::endl;
		}
	}

	std::map textTool::computeTokensFrequ(const std::string &text) {
		this->tokenize(text);
		this->removeDuplicates(this->tokens);

		std::vector::iterator it;

		for (it = this->uniqueTokens.begin(); it < this->uniqueTokens.end(); it++) {
		    std::cout << " " << *it;
		}

		return this->tokensFrequ;
	}

	std::vector textTool::tokenize(const std::string &text) {

		// Buforowany string
	    std::string buf;

	    // Wstawienie stringu z potoku
	    std::stringstream ss(text);

	    while (ss >> buf) {
	    	this->tokens.push_back(buf);
		}

		return this->tokens;
	}

	int textTool::getCountTokens() {
		return this->tokens.size();
	}

	int textTool::getCountUniqueTokens() {
		if(this->tokens.size() != 0 && this->uniqueTokens.size() == 0) {
			this->removeDuplicates(this->tokens);

			return this->uniqueTokens.size();
		} else {
			return this->uniqueTokens.size();
		}
	}

	std::vector textTool::removeDuplicates(std::vector vec) {
		 std::sort(vec.begin(), vec.end());
	     vec.erase(std::unique(vec.begin(), vec.end()), vec.end());

	     this->uniqueTokens = vec;

	     return this->uniqueTokens;
	 }

	textTool::~textTool() {

	}

} /* namespace tt */

R rozszerzenia i R paczki

Marcin — Thu, 15 Dec 2011 18:54:08 +0000

Osoby zainteresowane opublikowaniem swego kodu utworzonego w R project, zarówno w czystym R jak i w postaci rozszerzeń w innych językach, na pewno zainteresują materiały na stronie http://cran.r-project.org/doc/manuals/R-exts.html. Materiały tam zebrane omawiają szczegółowo i wyczerpująco temat tworzenia własnych dodatków do R. Osobom które początkują w tym temacie polecam nieco bardziej „lżejsze” lektóry w postaci:

- opracowania krok po kroku jak tworzyć paczki w R http://cran.r-project.org/doc/contrib/Leisch-CreatingPackages.pdf

- w googlu albo http://search.carrot2.org/stable/search wstukać frazę Writing R Extensions

Osobiście korzystałem z pierwszego jak i drugiego linku. Natomiast projekt który utworzyłem związany z implementacją softu do kalsyfikacji umieściłem na platformie http://r-forge.r-project.org/.

Artykuły

Marcin — Fri, 09 Dec 2011 09:51:56 +0000

Na koniec roku spłynęły recenzje artykułów oddanych do czasopism. Trochę się tego nazbierało a sam rok był bardzo owocny w badania i eksperymenty, przynoszące dość zaskakujące rezultaty.

Zainteresowane osoby tematyką eksploracji danych a dokładniej eksploracją danych tekstowych miło mi jest poinformować, że na ten temat będą mogły poczytać w czasopiśmie Metod Informatyki Stosowanej (http://www.pan.wi.zut.edu.pl/). Artykuł opisujący dziedzinę eksploracji danych tekstowych wraz z jej zastosowaniem w Państwowej Straży Pożarnej PSP nosi tytuł Proces i metody eksploracji danych tekstowych do przetwarzania raportów z akcji ratowniczo-gaśniczych i ukarze się w numerze 4/2011 ww. czasopisma. Z tematyką tą związany jest też następny artykuł pt. System informacyjny na temat sieci hydrantów dla krajowego systemu ratowniczo-gaśniczego: metoda segmentacji tekstu i jej ocena, który także zostanie wydany w tym czasopiśmie i ukaże się w numerze 1/2012. W artykule tym opisano szczegółową realizację eksperymentu opisującą podział tekstu na segmenty. Zajawka tego jak i poprzedniego artykułu w postaci abstraktów dostępne są w dziale Abstrakty, życzę miłej lektury.

Ostatnim nadesłanym do ww. czasopisma artykuł stanowił opis projektu związanego z rozwijaną koncepcją Systemu Wspomagania Decyzji dla PSP z wykorzystaniem komponentów platformy do planowania zasobów przedsiębiorstwa ERP. Artykuł ten ukaże się pod tytułem Wykorzystanie komponentów platformy ERP do budowy drugiej generacji hybrydowego systemu wspomagania decyzji dla PSP, w numerze 3/2011. Również jego zajawkę można zobaczyć w dziale Abstrakty.

Aktualnie cały czas oczekuje na decyzje z wydawnictwa CNBOP „Bezpieczeństwo i Technika Pożarnicza” w którym umieściłem dość interesujące przemyślenia i badania z zakresu inżynierii oprogramowania jak i eksploracji i segmentacji raportów. Niestety na ich ukazanie jak i recenzje jeszcze widać trochę będzie trzeba poczekać.

R stronki

Marcin — Wed, 30 Nov 2011 10:18:18 +0000

Poniżej umieszczam kilka przydatnych linków do stron internetowych opisujących pewne zagadnienia które często wymagają rozwiązania lub zastosowania podczas badań wspieranych pakietem R project. Na stronach tych można uzyskać informacje na temat:

- sortowania oraz grupowania danych (http://www.ats.ucla.edu/stat/r/faq/sort.htm, http://stackoverflow.com/questions/1296646/how-to-sort-a-dataframe-by-columns-in-r). Przy czym pierwszy link jest także krótkim kursem wprowadzającym do R,

- profilowania aplikacji napisanych w R, w szczególności tych które wymagają użycia dużych zasobów pamięci. Czasami warto wiedzieć co aktualnie rezyduje na stosie pamięci (http://developer.r-project.org/memory-profiling.html, http://heuristically.wordpress.com/2010/01/04/r-memory-usage-statistics-variable/),

- tworzenia wykresów Pareto informacje można znaleźć na stronie http://www.oga-lab.net/RGM2/func.php?rd_id=qcc:pareto.chart opisującej pakiet i metody które służą do tego celu.

Życzę miłego korzystania z wyżej przedstawionych rozwiązań.

R mapy i R geotagowanie

Marcin — Sun, 20 Nov 2011 20:20:04 +0000

Ostatnio poszukiwałem rozwiązania do geotagowania. Proces ten chciałem wykonać za pomocą nie API google map dla java scriptu lecz web serwisów i r project. Podyktowane to było tym aby utrzymać jednolite rozwiązanie programistyczne tj. jednolitą platformę eksperymentalną do przetwarzania tekstów w postaci raportów zaimplementowaną w jednym języku, bez różnego rodzaju miksów. Na początku rozpatrywałem użycie PHP i Java Scriptu niemniej po przeszperaniu internetu natknąłem się dość ciekawe rozwiązanie dla r project. Poniżej prezentuje listę linków związanych z zastosowaniem API google map w połączeniu z r project:

- http://www.r-chart.com/2010/07/maps-geocoding-and-r-user-conference.html

- http://cran.r-project.org/web/packages/RgoogleMaps/vignettes/RgoogleMaps-intro.pdf

- http://cran.r-project.org/web/packages/RgoogleMaps/RgoogleMaps.pdf

- http://cran.r-project.org/web/packages/RgoogleMaps/index.html

- http://cran.r-project.org/web/packages/gooJSON/gooJSON.pdf

- http://cran.r-project.org/web/packages/googleVis/vignettes/googleVis.pdf

- http://cran.r-project.org/web/packages/plotGoogleMaps/plotGoogleMaps.pdf

Powodzenia w stosowaniu ww. rozwiązań.

R project – obiektowość

Marcin — Sun, 20 Nov 2011 18:50:09 +0000

R project posiada trzy systemy obiektowe: S3, S4 i S5. Odniesienia i opisy tych systemów można znaleźć na stronach:

- https://github.com/hadley/devtools/wiki/R5 – opisującej nowy system S5,

- http://biecek.pl/R/RC/Jakub%20Derbisz%20R%20reference%20card%20classes.pdf, opisującej podstawowe operatory klas,

- http://stat.ethz.ch/R-manual/R-devel/library/methods/html/refClass.html, manual opisujący system S5 i funkcję setRefClass() służącą do tworzenia interfejsu klasy,

- http://www.youtube.com/watch?v=UZkaZhsOfT4, prezentacja zawierająca opis trzech ww. systemów oraz opis integracji R project z C++ poprzez pakiet Rcpp.

Zainteresowanym życzę miłej lektury. Poniżej natomiast przedtsawiam próbke kodu opisującej interfejs klasy account zaczerpniętej z prezentacji, do której link znajduje się na ostatniej pozycji ww. stron.

account <- setRefClass("Account_R5",
	fields = list(
		balance = "numeric",
		overdraft = "numeric"
	),
	methods = list(
		withdraw = function(amount) {
			print("Compute withdraw...")
		},
		deposit = function(amount) {
			print("Compute deposit...")
		}
	)
)

x <- account$new(balance = 10.0, overdraft = 0.0)

x$withdraw(5)
x$deposit(10)

R strony

Marcin — Sun, 20 Nov 2011 16:05:25 +0000

Ostatnio szperając po internecie za materiałami o języku R (w którym aktualnie wytwarzam większość softu do badań i eksperymentów) natknąłem się na świetny blog popularyzujący ten język, czy też platformę do obliczeń statystycznych i nie tylko. Polecam dla osób zainteresowanych tym tematem wejście na http://www.r-bloggers.com/. Znajdziecie tam najświeższe informacje o zastosowaniach języka R i nie tylko, życzę miłej lektury.

Czas wyruszyć na konferencję – Technologie Eksploracji i Reprezentacji Wiedzy 2011

Marcin — Tue, 06 Sep 2011 07:33:27 +0000

Jutro 07.08.2011 wyruszam po raz kolejny na konferencję pt. “Technologie Eksploracji i Reprezentacji Wiedzy” osoby zainteresowane tą tematyką mogą odnaleźć materiały konferencyjne na stronie głównej konferencji (http://irys.wi.pb.edu.pl/terw2011/pl/index.html). Osobiście będę prezentował temat pt. “Segmentator regułowy do segmentacji raportów z akcji ratowniczo-gaśniczych PSP: metoda projektowania i ocena rozwiązania”. Tak więc zostanie zaprezentowany kolejny etap prowadzonych przeze mnie badań nad analizą raportów Państwowej Straży Pożarnej (PSP). Streszczenie odczytu który zostanie przeze mnie wygłoszony można znaleźć pod następującym linkiem streszczenie odczytu(referatu).