diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..378eac2
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+build
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..7d0835f
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,18 @@
+language: cpp
+only: 
+  - calculator
+
+addons:
+  apt:
+    sources:
+    - ubuntu-toolchain-r-test
+    packages:
+    - gcc-4.9
+    - g++-4.9
+
+script:
+  - mkdir build && cd build && g++ -std=c++0x -o Calculator ../CalculatorSources/Source.cpp ../CalculatorSources/Calculator.cpp
+
+notifications:
+  email:
+    - valera.malkof@gmail.com
\ No newline at end of file
diff --git a/CalculatorSources/Calculator.cpp b/CalculatorSources/Calculator.cpp
new file mode 100755
index 0000000..a97cddf
--- /dev/null
+++ b/CalculatorSources/Calculator.cpp
@@ -0,0 +1,217 @@
+#include"Calculator.h"
+double Calculator::calculate(const char* s)
+{
+	char strochka[255];
+	Stack<char> operations;
+	int i = 0;
+	while (*s)
+	{
+		while (!isCorrect(*s))s++;
+		if (isdigit(*s))
+		{
+			while (*s == '.' || isdigit(*s))
+			{
+				strochka[i] = *s;
+				i++;
+				s++;
+			}
+			strochka[i] = ' ';
+			i++;
+			if (!operations.isEmpty())
+			{
+				if (*s != '^'&&*s != '*'&&*s != '/')
+				{
+					if (operations.popReturn() == '-')
+					{
+						strochka[i] = operations.pop();
+						i++;
+					}
+				}
+
+			}
+		}
+		else if (*s == ')')
+		{
+
+			while (operations.popReturn() != '(')
+			{
+				strochka[i] = operations.pop();
+				i++;
+			}
+			s++;
+			if (*s == '^')
+			{
+				operations.push(*s);
+				s++;
+				if (isdigit(*s))
+				{
+					while (*s == '.' || isdigit(*s))
+					{
+						strochka[i] = *s;
+						i++;
+						s++;
+					}
+				}
+				strochka[i] = operations.pop();
+				i++;
+			}
+            if (*s == '/')
+            {
+                operations.push(*s);
+                s++;
+                if (isdigit(*s))
+                {
+                    while (*s == '.' || isdigit(*s))
+                    {
+                        strochka[i] = *s;
+                        i++;
+                        s++;
+                    }
+                }
+                strochka[i] = operations.pop();
+                i++;
+            }
+            if (*s == '*')
+            {
+                operations.push(*s);
+                s++;
+                if (isdigit(*s))
+                {
+                    while (*s == '.' || isdigit(*s))
+                    {
+                        strochka[i] = *s;
+                        i++;
+                        s++;
+                    }
+                }
+                strochka[i] = operations.pop();
+                i++;
+            }
+			operations.pop();
+			if (!operations.isEmpty())
+			{
+				if (operations.popReturn() == '*' || operations.popReturn() == '/' || operations.popReturn() == '-')
+				{
+					strochka[i] = operations.pop();
+					i++;
+				}
+			}
+
+			strochka[i] = ' ';
+			i++;
+		}
+		else if (*s == '(')
+		{
+			operations.push(*s);
+			s++;
+		}
+		else if (*s == '*' || *s == '/' || *s == '^')
+		{
+			operations.push(*s);
+			s++;
+		}
+		else if (*s == '+' || *s == '-')
+		{
+			char op;
+			if (!operations.isEmpty())
+			{
+				if (operations.popReturn() == '*' || operations.popReturn() == '/' || operations.popReturn() == '^')
+				{
+					while (!operations.isEmpty())
+					{
+						if (operations.popReturn() == '*' || operations.popReturn() == '/' || operations.popReturn() == '^')
+						{
+							strochka[i] = operations.pop();
+							i++;
+						}
+						else break;
+					}
+					operations.push(*s);
+					s++;
+				}
+				else
+				{
+					operations.push(*s);
+					s++;
+				}
+			}
+			else
+			{
+				operations.push(*s);
+				s++;
+			}
+		}
+	}
+	while (!operations.isEmpty())
+	{
+
+		strochka[i] = operations.pop();
+		i++;
+	}
+	if (strochka[i - 1] == ' ')
+		strochka[i - 1] = '\0';
+	else strochka[i] = '\0';
+	cout << endl;
+	return postFix(strochka);
+}
+double Calculator::postFix(const char* s)
+{
+	double a = 0;
+	double b = 0;
+	Stack<double> numbers;
+	while (*s)
+	{
+		while (!isCorrect(*s))s++;
+		if (isdigit(*s))
+		{
+			double d = atof(s);
+			numbers.push(d);
+			while (*s == '.' || isdigit(*s))s++;
+		}
+		else if (*s == '+')
+		{
+			b = numbers.pop();
+			a = numbers.pop();
+			numbers.push(a + b);
+			s++;
+
+		}
+		else if (*s == '-')
+		{
+			b = numbers.pop();
+			a = numbers.pop();
+			numbers.push(a - b);
+			s++;
+		}
+		else if (*s == '*')
+		{
+			b = numbers.pop();
+			a = numbers.pop();
+			numbers.push(a * b);
+			s++;
+		}
+		else if (*s == '/')
+		{
+			b = numbers.pop();
+			a = numbers.pop();
+			numbers.push(a / b);
+			s++;
+		}
+		else if (*s == '^')
+		{
+			b = numbers.pop();
+			a = numbers.pop();
+			numbers.push(pow(a, b));
+			s++;
+		}
+	}
+	
+	return numbers.pop();
+}
+bool Calculator::isCorrect(const char s)
+{
+	return isdigit(s) || s == '.' ||
+		s == '+' || s == '-' || s == '*' ||
+		s == '/' || s == '^' || s == '(' ||
+		s == ')';
+}
\ No newline at end of file
diff --git a/CalculatorSources/Calculator.h b/CalculatorSources/Calculator.h
new file mode 100755
index 0000000..ce0fb67
--- /dev/null
+++ b/CalculatorSources/Calculator.h
@@ -0,0 +1,16 @@
+#ifndef CALCULATOR_H
+#define CALCULATOR_H
+#include"Stack.h"
+#include<iostream>
+#include <cmath>
+using namespace std;
+class Calculator
+{
+public:
+	static double calculate(const char* s);
+private:
+	static double postFix(const char* s);
+	static bool isCorrect(const char s);
+};
+
+#endif;
diff --git a/CalculatorSources/Double_list.h b/CalculatorSources/Double_list.h
new file mode 100755
index 0000000..dd04b88
--- /dev/null
+++ b/CalculatorSources/Double_list.h
@@ -0,0 +1,300 @@
+#ifndef DOUBLE_LIST
+#define DOUBLE_LIST
+#include <iostream>
+#include"Node.h"
+#include"Iterator.h"
+using namespace std;
+
+template<typename T=int>
+class CDoubleList
+{
+public:
+	CDoubleList();
+	CDoubleList(const CDoubleList & object);
+	CDoubleList(CDoubleList && obj);
+	CDoubleList& operator=(const CDoubleList& object);
+	CDoubleList & operator=(CDoubleList && obj);
+	T & operator[](size_t index);
+	~CDoubleList();
+public:
+	unsigned int getSize();
+	void addToStart(const T & v);
+	void addToEnd(const T & v);
+	void addToIndex(size_t index, const T & v);
+	void removeFromIndex(size_t index);
+	void removeAll();
+	void removeFromStart();
+	void removeFromEnd();
+	CIterator<T> getBegin() { return CIterator<T>(start); }
+	CIterator<T> getEnd() { return CIterator<T>(nullptr); }
+private:
+	
+	List::Node<T>* start;
+	List::Node<T>* end;
+	unsigned int count;
+private:
+	List::Node<T>* getNode(unsigned int index)
+	{
+		if (index >= count)
+			exit(1);
+		List::Node<T> * node;
+		if (index < count / 2)
+		{
+			node = start;
+			for (size_t i = 0; i < index; i++)
+			{
+				node = node->next;
+			}
+		}
+		else
+		{
+			node = end;
+			for (size_t i = count - 1; i > index; i--)
+			{
+				node = node->previous;
+			}
+		}
+		return node;
+	}
+};
+
+template<typename T>
+CDoubleList<T>::CDoubleList()
+{
+	//cout << "Default constr"<<endl;
+	start = end = nullptr;
+	count = 0;
+}
+
+template<typename T>
+CDoubleList<T>::CDoubleList(CDoubleList&& obj)
+{
+	//cout << "Move constr"<<endl;
+	this->start = obj.start;
+	this->end = obj.end;
+	this->count = obj.count;
+	obj.start = nullptr;
+}
+template<typename T>
+CDoubleList<T>::CDoubleList(const CDoubleList& object):CDoubleList()
+{
+	//cout << "Copy constr" << endl;
+	List::Node<T> * node = object.start;
+	while (node)
+	{
+		this->addToEnd(node->value);
+		node = node->next;
+	}
+}
+
+template<typename T>
+T& CDoubleList<T>::operator[](size_t index)
+{
+	return getNode(index)->value;
+}
+
+template<typename T>
+CDoubleList<T>& CDoubleList<T>::operator=(const CDoubleList& object)
+{
+	//cout << "operator= copy" << endl;
+	if (this == &object)
+		return *this;
+	this->removeAll();
+	List::Node<T> * node = object.start;
+	while (node)
+	{
+		this->addToEnd(node->value);
+		node = node->next;
+	}
+	return *this;
+}
+
+template<typename T>
+CDoubleList<T> & CDoubleList<T>::operator=(CDoubleList && obj)
+{
+	//cout << "operator= move" << endl;
+	if (this == &obj)
+		return *this;
+	this->removeAll();
+
+	this->start = obj.start;
+	this->end = obj.end;
+	this->count = obj.count;
+	obj.start = nullptr;
+
+	return *this;
+}
+
+template<typename T >
+CDoubleList<T>::~CDoubleList()
+{
+	//cout << "Destroy" << endl;
+	this->removeAll();
+}
+
+
+
+template<typename T>
+unsigned int CDoubleList<T>::getSize()
+{
+	return count;
+}
+
+template<typename T>
+void CDoubleList<T>::addToEnd(const T & v)
+{
+	List::Node<T>* node =new List::Node<T>(v);
+	if (count == 0)
+		start = node;
+	else
+		end->next = node;
+	node->previous = end;
+	end = node;
+	count++;
+}
+template<typename T>
+void CDoubleList<T>::addToStart(const T & v)
+{
+	if (count == 0)
+	{
+		this->addToEnd(v);
+		return;
+	}
+	List::Node<T> * node = new List::Node<T>(v);
+	node->next = start;
+	start->previous = node;
+	start = node;
+	count++;
+}
+
+
+template<typename T>
+void CDoubleList<T>::addToIndex(size_t index, const T & v)//����� ���������� �� �������
+{
+	if (count == 0 || index == 0)
+	{
+		this->addToStart(v);
+		return;
+	}
+	if (index == count || index>count)
+	{
+		this->addToEnd(v);
+		return;
+	}
+	List::Node<T> * node = start;
+	count = NULL;
+	start = end = nullptr;
+
+	for (size_t i = 0;i <= index;i++)
+	{
+		if (i < index)
+		{
+			addToEnd(node->value);
+			node = node->next;
+		}
+		if (i == index)
+		{
+			addToEnd(v);
+			while (node)
+			{
+				addToEnd(node->value);
+				node = node->next;
+			}
+			return;
+		}
+	}
+}
+
+template<typename T>
+void CDoubleList<T>::removeFromIndex(size_t index)
+{
+	if (index == 0)
+	{
+		removeFromStart();
+		return;
+	}
+	if (index == count || index > count)
+	{
+		removeFromEnd();
+		return;
+	}
+	List::Node<T> * node = start;
+	count = NULL;
+	start = end = nullptr;
+	for (size_t i = 0;i <= index;i++)
+	{
+		if (i < index)
+		{
+			addToEnd(node->value);
+			node = node->next;
+		}
+		if (i == index)
+		{
+			node = node->next;
+			while (node)
+			{
+				addToEnd(node->value);
+				node = node->next;
+			}
+			return;
+		}
+	}
+}
+
+template<typename T>
+void CDoubleList<T>::removeFromEnd()
+{
+	if (count == 0)
+		return;
+	else if (count == 1)
+	{
+		delete start;
+		start = end = nullptr;
+		count = 0;
+	}
+	else
+	{
+		List::Node<T> * beforeEnd = end->previous;
+		beforeEnd->next = nullptr;
+		delete end;
+		end = beforeEnd;
+		count--;
+	}
+}
+
+template<typename T>
+void CDoubleList<T>::removeFromStart()
+{
+	if (count == 0)
+		return;
+	else if (count == 1)
+	{
+		delete start;
+		start = end = nullptr;
+		count = 0;
+	}
+	else
+	{
+		List::Node<T> * p = start->next;
+		delete start;
+		start = p;
+		start->previous = nullptr;
+		count--;
+	}
+}
+
+template<typename T>
+void CDoubleList<T>::removeAll()
+{
+	List::Node<T> * node = start;
+	while (node)
+	{
+		List::Node<T> * p = node;
+		node = node->next;
+		delete p;
+	}
+	start = end = nullptr;
+	count = 0;
+}
+#endif
+
diff --git a/CalculatorSources/Iterator.h b/CalculatorSources/Iterator.h
new file mode 100755
index 0000000..c9f4d17
--- /dev/null
+++ b/CalculatorSources/Iterator.h
@@ -0,0 +1,62 @@
+#ifndef ITERATOR_H
+#define ITERATOR_H
+#include"Node.h"
+template<typename T>
+class CIterator
+{
+public:
+	CIterator(List::Node<T>* current);
+public:
+	T & operator*();
+	CIterator & operator++();
+	CIterator & operator--();
+	bool operator!=(CIterator & obj);
+	bool hasNext();
+	bool hasPrevious();
+private:
+	List::Node<T> * current;
+};
+template<typename T>
+T &CIterator<T>::operator*()
+{ 
+	return current->value; 
+}
+
+template<typename T>
+CIterator<T>::CIterator(List::Node<T>* current)
+{ 
+	this->current = current;
+}
+
+template<typename T>
+CIterator<T>& CIterator<T>:: operator++()
+{
+	current = current->next;
+	return *this;
+}
+
+template<typename T>
+CIterator<T> &CIterator<T>:: operator--()
+{
+	current = current->prev;
+	return *this;
+}
+
+template<typename T>
+bool CIterator<T>:: operator!=(CIterator & obj)
+{
+	return current != obj.current;
+}
+
+template<class T>
+bool CIterator<T>::hasNext() 
+{
+	return (current->next() != nullptr ? true : false);
+}
+
+template<class T>
+bool CIterator<T>::hasPrevious() 
+{
+	return (current->previous() != nullptr ? true : false);
+}
+#endif;
diff --git a/CalculatorSources/Node.h b/CalculatorSources/Node.h
new file mode 100755
index 0000000..6c194ba
--- /dev/null
+++ b/CalculatorSources/Node.h
@@ -0,0 +1,16 @@
+#ifndef NODE_H
+#define NODE_H
+
+namespace List
+{
+	template<typename T>
+	struct Node
+	{
+		T value;
+		Node* next;
+		Node* previous;
+		Node(const T& val) :value(val), next(nullptr), previous(nullptr) {}
+	};
+}
+
+#endif;
diff --git a/CalculatorSources/Source.cpp b/CalculatorSources/Source.cpp
new file mode 100755
index 0000000..8ac68de
--- /dev/null
+++ b/CalculatorSources/Source.cpp
@@ -0,0 +1,28 @@
+#include"Calculator.h"
+int main()
+{
+	  char stroka1[255] = "((3.36+2.549)/5.03+(3+4*(5-2)-1)/2)^0.5";
+    char stroka2[255] = "3.5+2*5";
+    char stroka9[255] = "(3+2)*5";
+    char stroka3[255] = "(3+4*(5-2)-1)/2";
+    char stroka4[255] = "(3+2)/5 + (3+4*(5-2)-1)/2";
+    char stroka5[255] = "16.8/((3+2)/5 +(3+4*(5-2)-1)/2)";
+    char stroka6[255] = "(64/32)+78-(20/4)+(2*(11-6))+45+2/2";
+    char stroka7[255] = "(3+5)^2-60-2^3";
+    char stroka8[255] = "((3+2)/5 + (3+4*(5-2)-1)/2)^0.5";
+    char stroka10[255]="3*((1+3)*2-((2-1)*(4+2)-2)/2)/4";
+
+    cout << stroka10 << "=" << Calculator::calculate(stroka10) << endl;
+   cout << stroka1 << "=" << Calculator::calculate(stroka1) << endl;
+    cout << stroka2 << "=" << Calculator::calculate(stroka2) << endl;
+    cout << stroka9 << "=" << Calculator::calculate(stroka9) << endl;
+    cout << stroka3 << "=" << Calculator::calculate(stroka3) << endl;
+    cout << stroka4 << "=" << Calculator::calculate(stroka4) << endl;
+    cout << stroka5 << "=" << Calculator::calculate(stroka5) << endl;
+    cout << stroka6 << "=" << Calculator::calculate(stroka6) << endl;
+    cout << stroka7 << "=" << Calculator::calculate(stroka7) << endl;
+    cout << stroka8 << "=" << Calculator::calculate(stroka8);
+	cout << endl;
+	getchar();
+	getchar();
+}
diff --git a/CalculatorSources/Stack.h b/CalculatorSources/Stack.h
new file mode 100755
index 0000000..1572562
--- /dev/null
+++ b/CalculatorSources/Stack.h
@@ -0,0 +1,47 @@
+#ifndef STACK_H
+#define STACK_H
+#include"Double_list.h"
+
+template<typename T=int>
+class Stack
+{
+public:
+	void push(const T & value);
+	T pop();
+	T popReturn();
+	bool isEmpty();
+	T getSize();
+private:
+	CDoubleList<T> list;
+};
+
+template<typename T>
+void Stack<T>::push(const T& value)
+{
+	list.addToEnd(value);
+}
+
+template<typename T>
+T Stack<T>::pop()
+{
+	T buffer = list[list.getSize()-1];
+	list.removeFromEnd();
+	return buffer;
+}
+template<typename T>
+T Stack<T>::popReturn()
+{
+	return  list[list.getSize() - 1];
+}
+template<typename T>
+bool Stack<T>::isEmpty()
+{
+	if (list.getSize() == 0)return true;
+	return false;
+}
+template<typename T>
+T Stack<T>::getSize()
+{
+	return list.getSize();
+}
+#endif;
diff --git a/README.md b/README.md
index f811e88..bbca37f 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,9 @@
-### This repo for studying only
\ No newline at end of file
+### This repo for studying only
+
+# How to build project on like UNIX system
+
+    1. Create `build` directory `mkdir build`
+    2. Checkout to `build` directory `cd build`
+    3. Run `g++` compiler. Use the next command: 
+        `g++ -std=c++0x -o Calculator ../CalculatorSources/Source.cpp ../CalculatorSources/Calculator.cpp`
+    4. If building was succesfull run executable file `Calculator` like `./Calculator`