diff --git a/.gitignore b/.gitignore
index 3c4efe206bd0e7230ad0ae8396a3c883c8207906..3841c880282137946fdc9f19a481e373ec0bb16d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -258,4 +258,7 @@ paket-files/
 
 # Python Tools for Visual Studio (PTVS)
 __pycache__/
-*.pyc
\ No newline at end of file
+*.pyc
+
+vscode/*
+/.vscode
diff --git a/SequenceComparison/calcul.cpp b/SequenceComparison/calcul.cpp
index 003448de2db40551dd94d5fd26a34983110a086e..3d1d8b256ed10f9e6c1d974d00d8657aa882a45c 100644
--- a/SequenceComparison/calcul.cpp
+++ b/SequenceComparison/calcul.cpp
@@ -9,7 +9,7 @@
 
 using namespace std;
 
-double calcul::getManyDistances(vtr2D const &points)
+double calcul::distancesMany_dtw(vtr2<double> const &points)
 {
 	double sum = 0;
 
@@ -17,14 +17,14 @@ double calcul::getManyDistances(vtr2D const &points)
 	{
 		for (size_t j = i + 1; j < points.size(); j++)
 		{
-			sum += getDistance_dtw(points[i], points[j]);
+			sum += distance_dtw(points[i], points[j]);
 		}
 	}
 
 	return sum;
 }
 
-double calcul::getDistance_dtw(vector<double> const &u, vector<double> const &v)
+double calcul::distance_dtw(vtr<double> const &u, vector<double> const &v)
 {
 	double sum = 0;
 
@@ -50,7 +50,7 @@ double calcul::getDistance_dtw(vector<double> const &u, vector<double> const &v)
 	return sum;
 }
 
-double calcul::getDistance_lcss(vector<double> const &u, vector<double> const &v, int idx)
+double calcul::distance_lcss(vector<double> const &u, vector<double> const &v, int idx)
 {
 	if (u.size() == 0 || v.size() == 0)
 		return 0;
@@ -103,7 +103,7 @@ double calcul::scorePair_dtw_s5(double ratioRaw, double ratioRawMax, double coef
     return (/*1 -*/ sqrt(ratioRaw) / sqrt(ratioRawMax)) * coeficient;
 }
 
-double calcul::scorePair_dtw_max(vtr2D const &A, vtr2D const &B)
+double calcul::scorePair_dtw_max(vtr2<double> const &A, vtr2<double> const &B)
 {
     double minA = numeric_limits<double>::max();
     double maxB = numeric_limits<double>::min();
@@ -123,25 +123,12 @@ double calcul::scorePair_dtw_max(vtr2D const &A, vtr2D const &B)
     return pow(maxB - minA, 2) * std::max(A.size(), B.size());
 }
 
-//double score::GetPairRatioDtw2(size_t lenA, size_t lenB, size_t lenPath)
-//{
-//    //int diff = abs((int)(lenA - lenB));
-//
-//    return (lenA / (double)lenPath + lenB / (double)lenPath) / 2;
-//    //return (lenA + lenB + diff) / (double)(lenPath * 2);
-//}
-
 double calcul::getPairRatio_lcss(int lenIN, int rawscore)
 {
     return rawscore / (lenIN / 2.0);
 }
 
-//public static double GetPairRatiolcssLocal(int lenA, int lenB, int raw)
-//{
-//    return (double)raw / ((lenA + lenB) / 2.0);
-//}
-
-double calcul::getMultiRatio_dtw(vtr3D const &input, vtr3D const &output)
+double calcul::getMultiRatio_dtw(vtr3<double> const &input, vtr3<double> const &output)
 {
     size_t sumA = 0;
     for (auto s : input)
@@ -154,7 +141,7 @@ double calcul::getMultiRatio_dtw(vtr3D const &input, vtr3D const &output)
     return sumA / static_cast<double>(sumB);
 }
 
-//double calcul::GetMRRratio(vtr2I const &orderMatrix, map<int, int> &clusters)
+//double calcul::GetMRRratio(vtr2<int> const &orderMatrix, map<int, int> &clusters)
 //{
 //    double mapRatio = 0;
 //    for (size_t i = 0; i < orderMatrix.size(); i++)         //query (ref sequence) //column
@@ -175,7 +162,7 @@ double calcul::getMultiRatio_dtw(vtr3D const &input, vtr3D const &output)
 //    return (orderMatrix.size() - 1);
 //}
 
-vtrD calcul::getMAPratio(vtr2I const &orderMatrix, map<int, int> const &clusters)
+vtrD calcul::getMAPratio(vtr2<int> const &orderMatrix, map<int, int> const &clusters)
 {
     vtrD ratios;
     double mapRatio = 0;
@@ -214,7 +201,7 @@ vtrD calcul::getMAPratio(vtr2I const &orderMatrix, map<int, int> const &clusters
 //}
 
 
-//double calcul::GetLowerBoundKim(vtr2D const &, vtr2D const &)
+//double calcul::GetLowerBoundKim(vtr2<double> const &, vtr2<double> const &)
 //{
 //    double output;
 //
diff --git a/SequenceComparison/calcul.h b/SequenceComparison/calcul.h
index 14b80c91a4f19e5fa2b716efc6837b8182374754..8e0abbb40da86799324f0efc6a00f768f91667d4 100644
--- a/SequenceComparison/calcul.h
+++ b/SequenceComparison/calcul.h
@@ -7,13 +7,13 @@ class calcul
 {
 public:    
     //Returns distance between 2 sequence elements.
-	static double getDistance_dtw(std::vector<double> const &u, std::vector<double> const &v);
+	static double distance_dtw(vtr<double> const &u, vtr<double> const &v);
     
     //Returns distance between 2 elements.
     //Function used with lcss method for check if all dimensions are under epsilon condition.
-    static double getDistance_lcss(std::vector<double> const &u, std::vector<double> const &v, int idx);
+    static double distance_lcss(vtr<double> const &u, vtr<double> const &v, int idx);
     //Returns distance between N elements of sequence. 
-	static double getManyDistances(vtr2D const &points);
+	static double distancesMany_dtw(vtr2<double> const &points);
     
     //Retruns true if cell of distance matrix is in warping window. 
     static bool isInWindow(int row, int col, float ratio, int percent);
@@ -28,20 +28,20 @@ public:
     static double scorePair_dtw_s4(double ratioRaw, double ratioRawMax);
     static double scorePair_dtw_s5(double ratioRaw, double ratioRawMax, double coeficient);
 
-    static double scorePair_dtw_max(vtr2D const &A, vtr2D const &B);
+    static double scorePair_dtw_max(vtr2<double> const &A, vtr2<double> const &B);
 
     //Returns similarity in <0, 1> interval.
     static double getPairRatio_lcss(int lenIN, int rawscore);
     //Return similarity in <0, 1> interval.
-    static double getMultiRatio_dtw(vtr3D const  &input, vtr3D const &output);
+    static double getMultiRatio_dtw(vtr3<double> const  &input, vtr3<double> const &output);
     //Retruns Mean Average Precision.
-    static vtrD getMAPratio(vtr2I const & orderMatrix, std::map<int, int> const &clusters);
-    //stati`c double GetMRRratio(vtr2D simMatrix);
+    static vtrD getMAPratio(vtr2<int> const & orderMatrix, std::map<int, int> const &clusters);
+    //stati`c double GetMRRratio(vtr2<double> simMatrix);
     
     //new
-    static double getLowerBoundKim(vtr2D const &, vtr2D const &);
-    //static double GetLowerBoundYi(std::vector<double> const &, std::vector<double> const &);
-    //static double GetLowerBoundKeogh(std::vector<double> const &, std::vector<double> const &);
+    static double getLowerBoundKim(vtr2<double> const &, vtr2<double> const &);
+    //static double GetLowerBoundYi(vtr2<double> const &, vtr2<double> const &);
+    //static double GetLowerBoundKeogh(vtr2<double> const &, vtr2<double> const &);
 
 };
 
diff --git a/SequenceComparison/dataParser.cpp b/SequenceComparison/dataParser.cpp
index ab877648a16153ba8bfc687df8e2133af4bd3839..45f2c7dad6e9756d471773c4a0652da8edaa69d3 100644
--- a/SequenceComparison/dataParser.cpp
+++ b/SequenceComparison/dataParser.cpp
@@ -15,7 +15,7 @@
 using namespace std;
 namespace fs = std::experimental::filesystem;
 
-vector<string> dataParser::getFiles(std::vector<string> const &paths)
+vector<string> dataParser::getFiles(vtr<string> const &paths)
 {
     vector<string> files;
 
@@ -181,13 +181,13 @@ vector<string> dataParser::readFileByLine(string const &path)
     return input;
 }
 
-vtr3D dataParser::readData(vector<std::string> const &paths)
+vtr3<double> dataParser::readData(vector<string> const &paths)
 {
-    vtr3D input;
+    vtr3<double> input;
 
     for (size_t i = 0; i < paths.size(); i++)
     {
-        vtr3D tmp;
+        vtr3<double> tmp;
         
         try
         {
@@ -219,9 +219,9 @@ vtr3D dataParser::readData(vector<std::string> const &paths)
     return  input;
 }
 
-vtr2I dataParser::parseByLine(vector<string> const &input)
+vtr2<int> dataParser::parseByLine(vector<string> const &input)
 {
-    vtr2I parsed(input.size());
+    vtr2<int> parsed(input.size());
     
     for (size_t i = 0; i < input.size(); i++)
     {
@@ -235,9 +235,9 @@ vtr2I dataParser::parseByLine(vector<string> const &input)
     return parsed;
 }
 
-vtr3D dataParser::parseRawManyDouble(vector<string> const &input)
+vtr3<double> dataParser::parseRawManyDouble(vector<string> const &input)
 {
-    vector<vector<vector<double>>> output;
+    vtr3<double> output;
 
     for (size_t i = 0; i < input.size(); i++)
     {
@@ -247,7 +247,7 @@ vtr3D dataParser::parseRawManyDouble(vector<string> const &input)
     return output;
 }
 
-vtr2D dataParser::parseRawDouble(string const &input)
+vtr2<double> dataParser::parseRawDouble(string const &input)
 {
     //help::trim(input, " \n\r\t");
 
@@ -267,7 +267,7 @@ vtr2D dataParser::parseRawDouble(string const &input)
 
     //int c = 0;
     vector<string> vS;
-    vector<vector<double>> singleInput;
+    vtr2<double> singleInput;
     singleInput.reserve(S.size());
 
     for (size_t i = 0; i < S.size(); i++)
@@ -323,7 +323,7 @@ map<int, int> dataParser::getClusters(string path)
 
 //Vtr<std::string, 3> dataParser::ParseRawManyString(vector<string> &v)
 //{
-//	vector<vector<vector<string>>> vv;
+//	vtr3<string> vv;
 //	
 //	for (size_t i = 0; i < v.size(); i++)
 //	{
@@ -335,7 +335,7 @@ map<int, int> dataParser::getClusters(string path)
 //
 //Vtr<std::string, 2> dataParser::ParseRawString(string &s)
 //{
-//	vector<vector<string>> singleInput;
+//	vtr2<string> singleInput;
 //
 //	s = help::TrimLeft(s);
 //	s = help::TrimRight(s);
@@ -377,9 +377,9 @@ map<int, int> dataParser::getClusters(string path)
 //	return singleInput;
 //}
 
-//vtr3D dataParser::ParseRawMany(vector<string> inputRaw)
+//vtr3<double> dataParser::ParseRawMany(vector<string> inputRaw)
 //{
-//    vector<vector<vector<double>>> vv;
+//   vtr3<double> vv;
 //    
 //    string type = inputRaw[0];
 //
diff --git a/SequenceComparison/dataParser.h b/SequenceComparison/dataParser.h
index 8723b7320476240443429364dab1848bc79a23e1..20a635d402f44b8c387eaaa7eb4f826b3a5ef483 100644
--- a/SequenceComparison/dataParser.h
+++ b/SequenceComparison/dataParser.h
@@ -5,23 +5,23 @@ class dataParser
 {
 public:
 
-    static std::vector<std::string> getFiles(std::vector<std::string> const &paths);
+    static vtr<std::string> getFiles(vtr<std::string> const &paths);
     //Returns file paths of input files in folder.
-    static std::vector<std::string> getFilesPaths(std::string const &folder);
+    static vtr<std::string> getFilesPaths(std::string const &folder);
     //Returns vector of raw sequence in folder.
-    static std::vector<std::string> readFolder(std::string const &folder);
+    static vtr<std::string> readFolder(std::string const &folder);
     //Returns vector of raw sequence in file.
-	static std::vector<std::string> readFile(std::string const &path);
+	static vtr<std::string> readFile(std::string const &path);
     //Returns vector of lines in file.
-    static std::vector<std::string> readFileByLine(std::string const & path);
+    static vtr<std::string> readFileByLine(std::string const & path);
     //Returns vector of raw sequence in folders/files.
-    static vtr3D readData(std::vector<std::string> const &paths);
+    static vtr3<double> readData(vtr<std::string> const &paths);
     //Returns 2D vector of parsed lines.
-    static vtr2I parseByLine(std::vector<std::string> const &input);
+    static vtr2<int> parseByLine(vtr<std::string> const &input);
     //Returns vector of parsed input sequences.
-    static vtr3D parseRawManyDouble(std::vector<std::string> const &input);
+    static vtr3<double> parseRawManyDouble(vtr<std::string> const &input);
     //Returns one parsed input sequence.
-    static vtr2D parseRawDouble(std::string const &input);
+    static vtr2<double> parseRawDouble(std::string const &input);
     //Returns map of <sequence id, cluster id>.
     static std::map<int, int> getClusters(std::string path);
 };
diff --git a/SequenceComparison/dtw.cpp b/SequenceComparison/dtw.cpp
index 0f4ced52c03dfb3baede99b4f86fde207a9141a6..264c7eee5c2de00ffbaff3c6744a626d96fd6272 100644
--- a/SequenceComparison/dtw.cpp
+++ b/SequenceComparison/dtw.cpp
@@ -13,7 +13,7 @@
 
 using namespace std;
 
-double dtw::main(vtr2D const &A, vtr2D const &B, parameter const &params)
+double dtw::main(vtr2<double> const &A, vtr2<double> const &B, parameter const &params)
 {
 	auto result = alignment(A, B, params);
 
@@ -23,7 +23,7 @@ double dtw::main(vtr2D const &A, vtr2D const &B, parameter const &params)
 	return result;
 }
 
-double dtw::alignment(vtr2D const &A, vtr2D const &B, parameter const &params)
+double dtw::alignment(vtr2<double> const &A, vtr2<double> const &B, parameter const &params)
 {  	
     warpPath backtrack;
     if(params.dmDataType == "double")
@@ -56,7 +56,7 @@ double dtw::alignment(vtr2D const &A, vtr2D const &B, parameter const &params)
 }
 
 template<class T>
-warpPath dtw::createMatrix(vtr2D const &A, vtr2D const &B, parameter const &params)
+warpPath dtw::createMatrix(vtr2<double> const &A, vtr2<double> const &B, parameter const &params)
 {   
     node<T>** m = new node<T>*[A.size() + 1];
     for (int i = 0; i < A.size() + 1; i++)
@@ -193,7 +193,7 @@ warpPath dtw::backtrack(node<T>** const &m, size_t i, size_t j)
 }
 
 template<class T>
-warpPath dtw::createMatrix2(vtr2D const &A, vtr2D const &B, parameter const &params)
+warpPath dtw::createMatrix2(vtr2<double> const &A, vtr2<double> const &B, parameter const &params)
 {
     Vtr<node<T>, 2> m(A.size() + 1);
     for (int i = 0; i < A.size() + 1; i++)
@@ -227,7 +227,7 @@ warpPath dtw::createMatrix2(vtr2D const &A, vtr2D const &B, parameter const &par
             if (minim > d)
                 minim = d;
 
-            m[i][j].value = static_cast<T>(calcul::getDistance_dtw(A[i - 1], B[j - 1]) + minim);
+            m[i][j].value = static_cast<T>(calcul::distance_dtw(A[i - 1], B[j - 1]) + minim);
 
             /* if(m[i - 1][j].value > m[i][j].value && m[i][j - 1].value > m[i][j].value && m[i - 1][j - 1].value > m[i][j].value)
             minim++;
@@ -247,7 +247,7 @@ warpPath dtw::createMatrix2(vtr2D const &A, vtr2D const &B, parameter const &par
 }
 
 template<class T>
-warpPath dtw::backtrack2(vector<vector<node<T>>> const &m, size_t i, size_t j, parameter const &params)
+warpPath dtw::backtrack2(vtr2<node<T>> const &m, size_t i, size_t j, parameter const &params)
 {
     warpPath wp;
     double ratio = j / static_cast<double>(i);
diff --git a/SequenceComparison/dtw.h b/SequenceComparison/dtw.h
index a08b5ff8137453c95c20d6ace68ebf305c4aff49..2bb5cbacfa629ef18dc0774bc5b367cce83260f7 100644
--- a/SequenceComparison/dtw.h
+++ b/SequenceComparison/dtw.h
@@ -7,20 +7,20 @@ public:
 
     //Returns result of dtw function.
     //dtw function should always be called by this method.
-	static double main(vtr2D const &, vtr2D const &, parameter const &params);
+	static double main(vtr2<double> const &, vtr2<double> const &, parameter const &params);
     //Returns alignment similarity.
-    static double alignment(vtr2D const &, vtr2D const &, parameter const &params);
+    static double alignment(vtr2<double> const &, vtr2<double> const &, parameter const &params);
     //Returns 'distance matrix' for 2 input sequence.
     template<class T>
-    static warpPath createMatrix(vtr2D const &, vtr2D const &, parameter const &params);
+    static warpPath createMatrix(vtr2<double> const &, vtr2<double> const &, parameter const &params);
     //Returns 'warping path' generated form distance matrix.
     template<class T>
     static warpPath backtrack(node<T>** const &m, size_t, size_t);
     
     template<class T>
-    static warpPath createMatrix2(vtr2D const &, vtr2D const &, parameter const &params);
+    static warpPath createMatrix2(vtr2<double> const &, vtr2<double> const &, parameter const &params);
     template<class T>
-    static warpPath backtrack2(std::vector<std::vector<node<T>>> const & m, size_t i, size_t j, parameter const &params);
+    static warpPath backtrack2(vtr2<node<T>> const & m, size_t i, size_t j, parameter const &params);
     template<class T>
     static coords findMinEnd(vtr2<node<T>> const &m, int relaxation);
     //Log
@@ -30,7 +30,7 @@ public:
     //EXPERIMENT
     //Returns 'distance matrix' for 2 input sequence.
     //template<class T>
-    //static warpPath CreateMatrix2(vtr2D const &, vtr2D const &, parameter const &params);
+    //static warpPath CreateMatrix2(vtr2<double> const &, vtr2<double> const &, parameter const &params);
     //
     ////Returns 'warping path' generated form distance matrix.
     //template<class T>
diff --git a/SequenceComparison/headerStruct.h b/SequenceComparison/headerStruct.h
index 1d62ea4d7a610e017705be82908843b50cb3e3b7..05f8e256c70151617db2d9ce2a063ea5c10a0481 100644
--- a/SequenceComparison/headerStruct.h
+++ b/SequenceComparison/headerStruct.h
@@ -36,8 +36,8 @@ public:
 
 struct result_operation
 {
-    vtr2<double> simMatrix;
-    vtr2<int> clusterMatrix;    
+    vtr2<double> matrixSimilarity;
+    vtr2<int> matrixCluster;    
 };
 
 struct result_pdtw
diff --git a/SequenceComparison/help.cpp b/SequenceComparison/help.cpp
index 42238af0a8b0a03971fd21062692475be21b1d3d..8887b9c1c49394b8d1f3bfffae577e0978127096 100644
--- a/SequenceComparison/help.cpp
+++ b/SequenceComparison/help.cpp
@@ -1,10 +1,10 @@
 #pragma once
 
 #include "help.h"
+#include "dataParser.h"
 #include <bitset>
 #include <cmath>
 #include <limits>
-#include "dataParser.h"
 
 using namespace std;
 
@@ -36,6 +36,42 @@ void help::trim(string &s, string const &delimiters)
     trimRight(s, delimiters);
 }
 
+vector<string> help::split(string const& s, char const *d)
+{
+    vector<string> output;
+
+    bitset<255> delims;
+    while (*d)
+    {
+        unsigned char code = *d++;
+        delims[code] = true;
+    }
+
+    string::const_iterator beg;
+    bool in_token = false;
+    for (string::const_iterator it = s.begin(), end = s.end(); it != end; ++it)
+    {
+        if (delims[*it])
+        {
+            if (in_token)
+            {
+                //output.push_back(beg, it);
+                output.push_back(vector<string>::value_type(beg, it));
+                in_token = false;
+            }
+        }
+        else if (!in_token)
+        {
+            beg = it;
+            in_token = true;
+        }
+    }
+    if (in_token)
+        output.push_back(vector<string>::value_type(beg, s.end()));
+
+    return output;
+}
+
 vector<string> help::split1(const string &str, const string &delimiter)
 {
     vector<string> tokens;
@@ -54,7 +90,7 @@ vector<string> help::split1(const string &str, const string &delimiter)
 
 vector<string> help::split2(string const &s, string const &delimiters)
 {
-    std::vector<std::string> result;
+    vtr<std::string> result;
     std::string::size_type pos = 0;
     while (std::string::npos != (pos = s.find_first_not_of(delimiters, pos))) {
         auto pos2 = s.find_first_of(delimiters, pos);
@@ -65,14 +101,9 @@ vector<string> help::split2(string const &s, string const &delimiters)
     return result;
 }
 
-//string help::GetColorSdtring(eColors color)
-//{
-//
-//}
-
-vtr2D help::convertToDouble(vtr2S const &strInput)
+vtr2<double> help::convertToDouble(vtr2<string> const &strInput)
 {
-	vtr2D dd;
+	vtr2<double> dd;
 
 	for (size_t i = 0; i < strInput.size(); i++)
 	{
@@ -119,43 +150,7 @@ void help::correctBomLine(string s)
     }
 }
 
-vector<string> help::split(string const& s, char const *d)
-{
-    vector<string> output;
-
-    bitset<255> delims;
-    while (*d)
-    {
-        unsigned char code = *d++;
-        delims[code] = true;
-    }
-    
-    string::const_iterator beg;
-    bool in_token = false;
-    for (string::const_iterator it = s.begin(), end = s.end(); it != end; ++it)
-    {
-        if (delims[*it])
-        {
-            if (in_token)
-            {
-                //output.push_back(beg, it);
-                output.push_back(vector<string>::value_type(beg, it));
-                in_token = false;
-            }
-        }
-        else if (!in_token)
-        {
-            beg = it;
-            in_token = true;
-        }
-    }
-    if (in_token)
-        output.push_back(vector<string>::value_type(beg, s.end()));
-
-    return output;
-}
-
-void help::interpolate(vtr3D &input)
+void help::interpolate(vtr3<double> &input)
 {
     int maxLen = -1;
 
@@ -173,7 +168,7 @@ void help::interpolate(vtr3D &input)
         while (diff > 0)
         {
             int c = 0;
-            vtr2D row;
+            vtr2<double> row;
             for(size_t k = 0; k < input[i].size() - 1 && diff > 0; k++)
             {
                 vector<double> el;
@@ -202,7 +197,7 @@ void help::interpolate(vtr3D &input)
     }
 }
 
-void help::normalizeMany(vtr3D &input)
+void help::normalizeMany(vtr3<double> &input)
 {
     for (int i = 0; i < input.size(); i++) //dims
     {
@@ -210,7 +205,7 @@ void help::normalizeMany(vtr3D &input)
     }
 }
 
-void help::normalize(vtr2D &input)
+void help::normalize(vtr2<double> &input)
 {
     for (int i = 0; i < input[0].size(); i++) //dims
     {
@@ -229,7 +224,7 @@ void help::normalize(vtr2D &input)
     }
 }
 
-void help::normalizeZeroOne(vtr3D &input, double max)
+void help::normalizeZeroOne(vtr3<double> &input, double max)
 {
     for (size_t i = 0; i < input.size(); i++)
     {
@@ -243,9 +238,9 @@ void help::normalizeZeroOne(vtr3D &input, double max)
     }
 }
 
-vtr3D help::separateSequence(vtr3D const &input, int size)
+vtr3<double> help::separateSequence(vtr3<double> const &input, int size)
 {
-    vtr3D output;
+    vtr3<double> output;
 
     for (size_t i = 0; i < size; i++)
     {
@@ -256,15 +251,15 @@ vtr3D help::separateSequence(vtr3D const &input, int size)
     return output;
 }
 
-vtr3D help::separateSequenceOne(vtr2D const &input)
+vtr3<double> help::separateSequenceOne(vtr2<double> const &input)
 {
-    vtr3D output;
+    vtr3<double> output;
 
     const size_t dims = input[0].size();
 
     for (size_t i = 0; i < dims; i++)
     {
-        vtr2D sequence;
+        vtr2<double> sequence;
         sequence.reserve(input.size());
         for (size_t j = 0; j < input.size(); j++)
         {
@@ -278,15 +273,15 @@ vtr3D help::separateSequenceOne(vtr2D const &input)
     return output;
 }
 
-void help::reduce(vtr3D &input, string const &skip)
+void help::reduce(vtr3<double> &input, string const &skip)
 {
-    vtr3D output(input.size());
+    vtr3<double> output(input.size());
 
     for (size_t i = 0; i < input.size(); i++)
     {
         for (int j = 0; j < skip.size(); j++)
         {
-            vtr2D s;
+            vtr2<double> s;
             
             int c = 1;
             int remove = skip.at(j) - '0';
@@ -302,13 +297,13 @@ void help::reduce(vtr3D &input, string const &skip)
     }
 }
 
-vtr3D help::paa(vtr3D const &input, int ratio)
+vtr3<double> help::paa(vtr3<double> const &input, int ratio)
 {
-    vtr3D output(input.size());
+    vtr3<double> output(input.size());
 
     for (size_t i = 0; i < input.size(); i++)
     {
-        vtr2D s;
+        vtr2<double> s;
         for (int j = 0; j < input[i].size(); j+= ratio)// sequence
         {
             vector<double> dim(input[i][j].size());
@@ -333,15 +328,15 @@ vtr3D help::paa(vtr3D const &input, int ratio)
     return output;
 }
 
-vtr3D help::smooth(vtr3D const & input, int width)
+vtr3<double> help::smooth(vtr3<double> const & input, int width)
 {
-    vtr3D output(input.size());
+    vtr3<double> output(input.size());
 
     for (size_t i = 0; i < input.size(); i++)
     {
         const int dims = (int)input[0][0].size();
 
-        vtr2D s;
+        vtr2<double> s;
         for (size_t j = 0; j < width - 1; j++)
         {
             s.push_back(input[i][j]);
diff --git a/SequenceComparison/help.h b/SequenceComparison/help.h
index 1415e05d742451025c6f5cdeaf88bd781967a196..b3805b012a6811aa5faa785a713173ae713d6688 100644
--- a/SequenceComparison/help.h
+++ b/SequenceComparison/help.h
@@ -1,4 +1,5 @@
 #pragma once
+#include "templates.h"
 #include "headerStruct.h"
 
 class help
@@ -16,34 +17,34 @@ public:
     static vtrS split2(std::string const &s, std::string const &delimiters);
 	
     //Returns input sequence interpolated to same length.
-    static void interpolate(vtr3D &input);
+    static void interpolate(vtr3<double> &input);
     
     //Normalize input sequence.
-    static void normalizeMany(vtr3D &input);
+    static void normalizeMany(vtr3<double> &input);
     
     //Normalize 1 input sequence. 
-    static void normalize(vtr2D &input);
+    static void normalize(vtr2<double> &input);
 
     //Retruns normalized sequence between <0,1>.
-    static void normalizeZeroOne(vtr3D &input, double max);
+    static void normalizeZeroOne(vtr3<double> &input, double max);
 
     //Returns shortened input sequence by skiping some of their elements.
-    static void reduce(vtr3D &input, std::string const &skip);
+    static void reduce(vtr3<double> &input, std::string const &skip);
 
     //Returns piecewise aggregate approximation of sequence.
-    static vtr3D paa(vtr3D const &input, int ratio);
+    static vtr3<double> paa(vtr3<double> const &input, int ratio);
 
     //Returns smoothed sekvence by moving window average.
-    static vtr3D smooth(vtr3D const &input, int width);
+    static vtr3<double> smooth(vtr3<double> const &input, int width);
         
     //Checks and fixed string if it contains BOM bytes.
     static void correctBomLine(std::string s);
 
     //Returns sequence separated in theirs dimensions.
-    static vtr3D separateSequence(vtr3D const &input, int size);
+    static vtr3<double> separateSequence(vtr3<double> const &input, int size);
 
     //Returns sequence one sequence with 1 dimension.
-    static vtr3D separateSequenceOne(vtr2D const &input);
+    static vtr3<double> separateSequenceOne(vtr2<double> const &input);
 
     //Trigers when path have split option..was used for debug
     /*template<class T>
@@ -80,8 +81,8 @@ public:
     
 
     //NOT USED
-    static vtr2D convertToDouble(vtr2S const &strInput);
-	static std::vector<double> convertToDouble(std::vector<std::string> const &strInput);
+    static vtr2<double> convertToDouble(vtr2<std::string> const &strInput);
+	static vtr<double> convertToDouble(vtr<std::string> const &strInput);
 
 
 
diff --git a/SequenceComparison/lcss.cpp b/SequenceComparison/lcss.cpp
index e19488ba819ef07c46016341744f523576847dca..5e76f45c81e0fae9a03c6b3f6039f871a3acfcc4 100644
--- a/SequenceComparison/lcss.cpp
+++ b/SequenceComparison/lcss.cpp
@@ -9,7 +9,7 @@
 
 using namespace std;
 
-double lcss::main(vtr2D const &A, vtr2D const &B, parameter const &params)
+double lcss::main(vtr2<double> const &A, vtr2<double> const &B, parameter const &params)
 {
     auto result = alignment(A, B, params);
 
@@ -19,7 +19,7 @@ double lcss::main(vtr2D const &A, vtr2D const &B, parameter const &params)
     return result;
 }
 
-double lcss::alignment(vtr2D const &A, vtr2D const &B, parameter const &params)
+double lcss::alignment(vtr2<double> const &A, vtr2<double> const &B, parameter const &params)
 {
     warpPath backtrack;
     if (params.dmDataType == "double")
@@ -46,7 +46,7 @@ double lcss::alignment(vtr2D const &A, vtr2D const &B, parameter const &params)
 }
 
 template<class T>
-warpPath lcss::createMatrix(vtr2D const &A, vtr2D const &B, parameter const &params)
+warpPath lcss::createMatrix(vtr2<double> const &A, vtr2<double> const &B, parameter const &params)
 {
     Vtr<node<T>, 2> m(A.size() + 1);
     for (int i = 0; i < A.size() + 1; i++)
@@ -68,7 +68,7 @@ warpPath lcss::createMatrix(vtr2D const &A, vtr2D const &B, parameter const &par
             int shorterDim = (int)min(A[i - 1].size(), B[j - 1].size());
             for (int u = 0; u < shorterDim; u++)
             {
-                if (calcul::getDistance_lcss(A[i - 1], B[j - 1], u) > params.epsilon)
+                if (calcul::distance_lcss(A[i - 1], B[j - 1], u) > params.epsilon)
                     epsed = false;                
             }
 
@@ -85,7 +85,7 @@ warpPath lcss::createMatrix(vtr2D const &A, vtr2D const &B, parameter const &par
 }
 
 template<class T>
-warpPath lcss::backtrack(vector<vector<node<T>>> const &m, vtr2D const &A, vtr2D const &B)
+warpPath lcss::backtrack(vector<vector<node<T>>> const &m, vtr2<double> const &A, vtr2<double> const &B)
 {
     int i = (int)A.size();
     int j = (int)B.size();
diff --git a/SequenceComparison/lcss.h b/SequenceComparison/lcss.h
index e84c863594fdd20242e61501644c4a07a6fcd2ec..cfc746c98245ccf1eb716f73e7543c7ac79e655f 100644
--- a/SequenceComparison/lcss.h
+++ b/SequenceComparison/lcss.h
@@ -8,15 +8,15 @@ public:
 	
     //Returns result of lcss function.
     //lcss function should always be called by this method.
-    static double main(vtr2D const &, vtr2D const &, parameter const &params);
+    static double main(vtr2<double> const &, vtr2<double> const &, parameter const &params);
     //Returns alignment similarity.
-    static double alignment(vtr2D const &, vtr2D const &, parameter const &params);
+    static double alignment(vtr2<double> const &, vtr2<double> const &, parameter const &params);
     //Returns 'distance matrix' for 2 input sequence.
     template<class T>
-    static warpPath createMatrix(vtr2D const &A, vtr2D const &B, parameter const &params);
+    static warpPath createMatrix(vtr2<double> const &A, vtr2<double> const &B, parameter const &params);
     //Returns 'warping path' generated form distance matrix.
     template<class T>
-    static warpPath backtrack(std::vector<std::vector<node<T>>> const &m, vtr2D const &A, vtr2D const &B);
+    static warpPath backtrack(vtr2<node<T>> const &m, vtr2<double> const &A, vtr2<double> const &B);
     //Log
     //static std::string Log(result const &, parameter const &);
 };
diff --git a/SequenceComparison/main.cpp b/SequenceComparison/main.cpp
index 86aa898d6c73eeae266882cd481a5dc819b89fcc..83415546bb1426b105c8a810c2742bf00aea7c2c 100644
--- a/SequenceComparison/main.cpp
+++ b/SequenceComparison/main.cpp
@@ -106,20 +106,20 @@ void mainLogic(vtrS const &args)
     auto result = operation::main(input, clusters, params);
     
     if(params.isOutput()){
-        print::write(print::printMatrix(result.simMatrix, params), params.outputPath, false);
+        print::write(print::printMatrix(result.matrixSimilarity, params), params.outputPath, false);
         print::write(print::printParameterString(args) + "</br>" + 
-                     print::printMapRatios(calcul::getMAPratio(result.clusterMatrix, clusters)) + 
-                     print::printHtmlClusters(input, result.clusterMatrix, clusters), params.outputPath, true);
+                     print::printMapRatios(calcul::getMAPratio(result.matrixCluster, clusters)) + 
+                     print::printHtmlClusters(input, result.matrixCluster, clusters), params.outputPath, true);
     }
 
     if (params.isGdf())
-        print::write(print::printGdf(files, input, result.simMatrix, clusters), params.gdf, false);
+        print::write(print::printGdf(files, input, result.matrixSimilarity, clusters), params.gdf, false);
 
     if (params.isOmp()) {
-        if(result.simMatrix.size() > 0)
-            cout << print::printMatrix(result.simMatrix, params);
-        if (result.clusterMatrix.size() > 0)
-            cout << print::printMatrix(result.clusterMatrix, params);
+        if(result.matrixSimilarity.size() > 0)
+            cout << print::printMatrix(result.matrixSimilarity, params);
+        if (result.matrixCluster.size() > 0)
+            cout << print::printMatrix(result.matrixCluster, params);
     }
 }
 
diff --git a/SequenceComparison/operation.cpp b/SequenceComparison/operation.cpp
index 6a2bf8788da3cbf3cd759d0cd26b763732b5092b..0e26f1d06bd32006c1f13bdd3994550c33c43a24 100644
--- a/SequenceComparison/operation.cpp
+++ b/SequenceComparison/operation.cpp
@@ -17,7 +17,7 @@
 
 using namespace std;
 
-result_operation operation::main(vtr3D const &input, mapInt const &clusters, parameter const &params)
+result_operation operation::main(vtr3<double> const &input, mapInt const &clusters, parameter const &params)
 {
     FUNC f1 = dtw::main;
     FUNCM f2 = pdtw::main;
@@ -54,9 +54,9 @@ result_operation operation::main(vtr3D const &input, mapInt const &clusters, par
     return result;
 }
 
-result_operation operation::getSimilarityMatrix(vtr3D const &input, parameter const &params, FUNC f)
+result_operation operation::getSimilarityMatrix(vtr3<double> const &input, parameter const &params, FUNC f)
 {
-    vtr2D matrix(input.size());
+    vtr2<double> matrix(input.size());
     for (size_t i = 0; i < input.size(); i++)
     {
         vector<double> simRow(input.size());
@@ -90,14 +90,14 @@ result_operation operation::getSimilarityMatrix(vtr3D const &input, parameter co
     cout << print::printElapsed("elapsed", params.startStamp) << endl;
         
     result_operation result;
-    result.simMatrix = matrix;
+    result.matrixSimilarity = matrix;
      
     return result;
 }
 
-result_operation operation::getSimilarityMatrix_omp(vtr3D const &input, parameter const &params, FUNC f)
+result_operation operation::getSimilarityMatrix_omp(vtr3<double> const &input, parameter const &params, FUNC f)
 {
-    vtr2D matrix;
+    vtr2<double> matrix;
     vector<double> simRow(input.size());
     for (size_t i = 0; i < input.size(); i++)
     {
@@ -126,15 +126,16 @@ result_operation operation::getSimilarityMatrix_omp(vtr3D const &input, paramete
     cout << print::printElapsed("elapsed", params.startStamp) << endl;
 
     result_operation result;
-    result.simMatrix = matrix;
+    result.matrixSimilarity = matrix;
 
     return result;
 }
 
-result_operation operation::getClusters(vtr3D const &input, parameter const &params, map<int, int> const &clusters, FUNC f)
+result_operation operation::getClusters(vtr3<double> const &input, parameter const &params, map<int, int> const &clusters, FUNC f)
 {
     auto result = getSimilarityMatrix(input, params, f);
-   
+    //resultCopy.clusterMatrix = result.clusterMatrix;
+    
     for (size_t i = 0; i < input.size(); i++)
     {
         vector<int> row;
@@ -142,28 +143,31 @@ result_operation operation::getClusters(vtr3D const &input, parameter const &par
         {
             row.push_back((int)i + 1);
         }
-        result.clusterMatrix.push_back(row);
+        result.matrixCluster.push_back(row);
     }
 
+    auto resultCopy = result;
     for (size_t i = 0; i < input.size(); i++) //row
     {
-        double tmpD = result.simMatrix[i][i];
-        result.simMatrix[i][i] = result.simMatrix[0][i];
-        result.simMatrix[0][i] = tmpD;
+        double tmpD = resultCopy.matrixSimilarity[i][i];
+        resultCopy.matrixSimilarity[i][i] = resultCopy.matrixSimilarity[0][i];
+        resultCopy.matrixSimilarity[0][i] = tmpD;
 
-        int tmpI = result.clusterMatrix[i][i];
-        result.clusterMatrix[i][i] = result.clusterMatrix[0][i];
-        result.clusterMatrix[0][i] = tmpI;
+        int tmpI = resultCopy.matrixCluster[i][i];
+        resultCopy.matrixCluster[i][i] = resultCopy.matrixCluster[0][i];
+        resultCopy.matrixCluster[0][i] = tmpI;
     }
 
-    help::Sort2dVectorByColumns<double, int>(result.simMatrix, result.clusterMatrix, params.scoreReversed);
+    help::Sort2dVectorByColumns<double, int>(resultCopy.matrixSimilarity, resultCopy.matrixCluster, params.scoreReversed);
+
+    cout << print::printMapRatios(calcul::getMAPratio(resultCopy.matrixCluster, clusters));
 
-    cout << print::printMapRatios(calcul::getMAPratio(result.clusterMatrix, clusters));
+    result.matrixCluster = resultCopy.matrixCluster;
 
     return result;
 }
 
-result_operation operation::getClusters_omp(vtr3D const &input, parameter const &params, map<int, int> const &clusters, FUNC f)
+result_operation operation::getClusters_omp(vtr3<double> const &input, parameter const &params, map<int, int> const &clusters, FUNC f)
 {
     auto result = getSimilarityMatrix_omp(input, params, f);
     
@@ -174,37 +178,40 @@ result_operation operation::getClusters_omp(vtr3D const &input, parameter const
         {
             row.push_back((int)i + 1);
         }
-        result.clusterMatrix.push_back(row);
+        result.matrixCluster.push_back(row);
     }
 
+    auto resultCopy = result;
     for (size_t i = 0; i < input.size(); i++) //row
     {
-        double tmpD = result.simMatrix[i][i];
-        result.simMatrix[i][i] = result.simMatrix[0][i];
-        result.simMatrix[0][i] = tmpD;
+        double tmpD = resultCopy.matrixSimilarity[i][i];
+        resultCopy.matrixSimilarity[i][i] = resultCopy.matrixSimilarity[0][i];
+        resultCopy.matrixSimilarity[0][i] = tmpD;
 
-        int tmpI = result.clusterMatrix[i][i];
-        result.clusterMatrix[i][i] = result.clusterMatrix[0][i];
-        result.clusterMatrix[0][i] = tmpI;
+        int tmpI = resultCopy.matrixCluster[i][i];
+        resultCopy.matrixCluster[i][i] = resultCopy.matrixCluster[0][i];
+        resultCopy.matrixCluster[0][i] = tmpI;
     }
 
-    help::Sort2dVectorByColumns<double, int>(result.simMatrix, result.clusterMatrix, params.scoreReversed);
+    help::Sort2dVectorByColumns<double, int>(resultCopy.matrixSimilarity, resultCopy.matrixCluster, params.scoreReversed);
 
-    cout << print::printMapRatios(calcul::getMAPratio(result.clusterMatrix, clusters));
+    cout << print::printMapRatios(calcul::getMAPratio(resultCopy.matrixCluster, clusters));
     
+    result.matrixCluster = resultCopy.matrixCluster;
+
     return result;
 }
 
 
-result_operation operation::getSimilarityMatrix_dimensions(vtr3D const &input, parameter const &params, FUNC f)
+result_operation operation::getSimilarityMatrix_dimensions(vtr3<double> const &input, parameter const &params, FUNC f)
 {
     const size_t dims = input[0][0].size();
 
-    vtr3D inputSeparated;
+    vtr3<double> inputSeparated;
     if (params.operation == 2 || params.operation == 4)
         inputSeparated = help::separateSequence(input, 2);
 
-    vtr2D matrix;
+    vtr2<double> matrix;
 
     //cout << setprecision(params.precision);
     for (size_t i = 0; i < dims; i++)
@@ -229,14 +236,14 @@ result_operation operation::getSimilarityMatrix_dimensions(vtr3D const &input, p
     cout << print::printElapsed("elapsed", params.startStamp);
 
     result_operation result;
-    result.simMatrix = matrix;
+    result.matrixSimilarity = matrix;
 
     return result;
 }
 
-result_operation operation::getBestSimilarityMatrix_dimensions(vtr3D const &input, parameter const &params, FUNC f)
+result_operation operation::getBestSimilarityMatrix_dimensions(vtr3<double> const &input, parameter const &params, FUNC f)
 {
-    vtr2D matrix;
+    vtr2<double> matrix;
 
     cout << setprecision(params.precision);
     for (size_t i = 0; i < input.size(); i++)
@@ -245,19 +252,24 @@ result_operation operation::getBestSimilarityMatrix_dimensions(vtr3D const &inpu
         cout << setw(3) << i + 1 << " ";
         for (size_t j = 0; j < input.size(); j++)
         {
-            vtr3D subInput;
+            vtr3<double> subInput;
             subInput.push_back(input[i]);
             subInput.push_back(input[j]);
             
             if (i >= j)
             {
                 double maxSim = -1;
-                    for (int i = 0; i < matrix.size(); i++)
-                        for (int j = 0; j< matrix[i].size(); j++)
-                            if (maxSim < matrix[i][j])
-                            {
-                                maxSim = matrix[i][j];
-                            }
+                for (int i = 0; i < matrix.size(); i++)
+                {
+                    for (int j = 0; j < matrix[i].size(); j++)
+                    {
+                        if (maxSim < matrix[i][j])
+                        {
+                            maxSim = matrix[i][j];
+                        }
+                    }
+                }
+
                 cout << setw(params.precision + 3) << fixed << maxSim;
                 simRow.push_back(maxSim);
             }
@@ -272,20 +284,20 @@ result_operation operation::getBestSimilarityMatrix_dimensions(vtr3D const &inpu
     cout << print::printElapsed("elapsed", params.startStamp);
 
     result_operation result;
-    result.simMatrix = matrix;
+    result.matrixSimilarity = matrix;
 
     return result;
 }
 
-result_operation operation::getSimilarityMatrix_dimensions_omp(vtr3D const &input, parameter const &params, FUNC f)
+result_operation operation::getSimilarityMatrix_dimensions_omp(vtr3<double> const &input, parameter const &params, FUNC f)
 {
     const int dims = (int)input[0][0].size();
 
-    vtr3D inputSeparated;
+    vtr3<double> inputSeparated;
     if (params.operation == 2 || params.operation == 4)
         inputSeparated = help::separateSequence(input, 2);
 
-    vtr2D matrix(dims);
+    vtr2<double> matrix(dims);
     for (size_t i = 0; i < dims; i++)
     {
         vector<double> simRow(dims);
@@ -320,14 +332,14 @@ result_operation operation::getSimilarityMatrix_dimensions_omp(vtr3D const &inpu
     cout << print::printElapsed("elapsed", params.startStamp);
 
     result_operation result;
-    result.simMatrix = matrix;
+    result.matrixSimilarity = matrix;
 
     return result;
 }
 
-result_operation operation::getBestSimilarityMatrix_dimensions_omp(vtr3D const &input, parameter const &params, FUNC f)
+result_operation operation::getBestSimilarityMatrix_dimensions_omp(vtr3<double> const &input, parameter const &params, FUNC f)
 {
-    vtr2D matrix(input.size());
+    vtr2<double> matrix(input.size());
     for (size_t i = 0; i < input.size(); i++)
     {
         vector<double> simRow(input.size());
@@ -340,7 +352,7 @@ result_operation operation::getBestSimilarityMatrix_dimensions_omp(vtr3D const &
         vector<double> simRow;
         for (size_t j = 0; j < input.size(); j++)
         {
-            vtr3D subInput;
+            vtr3<double> subInput;
             subInput.push_back(input[i]);
             subInput.push_back(input[j]);
 
@@ -367,7 +379,7 @@ result_operation operation::getBestSimilarityMatrix_dimensions_omp(vtr3D const &
     cout << print::printElapsed("elapsed", params.startStamp);
 
     result_operation result;
-    result.simMatrix = matrix;
+    result.matrixSimilarity = matrix;
 
     return result;
 }
\ No newline at end of file
diff --git a/SequenceComparison/operation.h b/SequenceComparison/operation.h
index e3d1bbc63ebc08a53083f7a33222cd09bed61e8a..2cfb7815908cc0fcae5876c7d91a77dffeec487a 100644
--- a/SequenceComparison/operation.h
+++ b/SequenceComparison/operation.h
@@ -2,29 +2,29 @@
 #include "headerStruct.h"
 #include "parameter.h"
 
-typedef double(*FUNC)(vtr2D const &A, vtr2D const &B, parameter const &params);
-typedef double(*FUNCM)(vtr3D const &input, parameter const &params);
+typedef double(*FUNC)(vtr2<double> const &A, vtr2<double> const &B, parameter const &params);
+typedef double(*FUNCM)(vtr3<double> const &input, parameter const &params);
 
 class operation
 {
 public:
 
-    static result_operation main(vtr3D const &input, mapInt const &clusters, parameter const &params);
+    static result_operation main(vtr3<double> const &input, mapInt const &clusters, parameter const &params);
     //Returns similarity matrix between N sequence.
-    static result_operation getSimilarityMatrix(vtr3D const &input, parameter const &params, FUNC f);
-    static result_operation getSimilarityMatrix_omp(vtr3D const &input, parameter const &params, FUNC f);
+    static result_operation getSimilarityMatrix(vtr3<double> const &input, parameter const &params, FUNC f);
+    static result_operation getSimilarityMatrix_omp(vtr3<double> const &input, parameter const &params, FUNC f);
     //Returns similarity metrix sorted by columns.
-    static result_operation getClusters(vtr3D const &input, parameter const &params, std::map<int, int> const &clusters, FUNC f);
-    static result_operation getClusters_omp(vtr3D const &input, parameter const &params, std::map<int, int> const &clusters, FUNC f);
+    static result_operation getClusters(vtr3<double> const &input, parameter const &params, std::map<int, int> const &clusters, FUNC f);
+    static result_operation getClusters_omp(vtr3<double> const &input, parameter const &params, std::map<int, int> const &clusters, FUNC f);
     
     //Returns similarity matrix between dimensions of two sequence.
-    static result_operation getSimilarityMatrix_dimensions(vtr3D const &input, parameter const &params, FUNC f);
-    static result_operation getSimilarityMatrix_dimensions_omp(vtr3D const &input, parameter const &params, FUNC f);
+    static result_operation getSimilarityMatrix_dimensions(vtr3<double> const &input, parameter const &params, FUNC f);
+    static result_operation getSimilarityMatrix_dimensions_omp(vtr3<double> const &input, parameter const &params, FUNC f);
     //Returns best similarity from similarity metrix of dimensions. 
-    /*static double getBestDimSim(vtr3D const &input, parameter const &params, FUNC f);*/
+    /*static double getBestDimSim(vtr3<double> const &input, parameter const &params, FUNC f);*/
     //Returns similarity matrix of best similarities from metrcies of dimensions.
-    static result_operation getBestSimilarityMatrix_dimensions(vtr3D const &input, parameter const &params, FUNC f);
-    static result_operation getBestSimilarityMatrix_dimensions_omp(vtr3D const &input, parameter const &params, FUNC f);
+    static result_operation getBestSimilarityMatrix_dimensions(vtr3<double> const &input, parameter const &params, FUNC f);
+    static result_operation getBestSimilarityMatrix_dimensions_omp(vtr3<double> const &input, parameter const &params, FUNC f);
 
 
    
diff --git a/SequenceComparison/parameter.cpp b/SequenceComparison/parameter.cpp
index e2a7d7e206bebafc2ae116f9beedecc2fc5f120c..f7d28c10f6db4868091e7d4108c66a2853f4f0a2 100644
--- a/SequenceComparison/parameter.cpp
+++ b/SequenceComparison/parameter.cpp
@@ -155,10 +155,10 @@ void parameter::checkParameters(map<string, string> &map)
             throw runtime_error("Invalid data type for distance matrix");
         }
     
-    if (!map.count("-gdf"))
+    /*if (map.count("-gdf"))
     {
         throw runtime_error("Invalid cluster info file path.");
-    }
+    }*/
 
     if (map.count("-c") && !fs::exists(map["-c"]))
     {
@@ -289,9 +289,11 @@ void parameter::printHelp()
     cout << "-d [size] - Set parameter delta for method lcss." << endl;
     cout << "RESULT options" << endl;
     cout << "-s [score calculation] - different score calculation (default: -s 1)" << endl;
-    cout << "-s 1 = sqrt(rawScore) / len(path)" << endl;
-    cout << "-s 2 = ( len(A) + len(B) ) / ( len(A') + len(B') )" << endl;
-    cout << "-s 3 = sqrt( SUM(path elements) ) / len(path)" << endl;
+    cout << "-s 1 = sqrt(rawScore) / |path|" << endl;
+    cout << "-s 2 = (|A|+|B|) / (|newA|+|newB|)" << endl;
+    cout << "-s 3 = sqrt(ratioRaw)" << endl;
+    cout << "-s 4 = sqrt(dtw(A,B)) / sqrt(dtvMax(A,B))" << endl;
+    cout << "-s 5 = sqrt(dtw(A,B)) / sqrt(dtvMax(A,B)) * (min(|A|,|B|) / max(|A|,|B|)" << endl;
     cout << "-p [precision] - Set floting point precision <0,10> for print." << endl;
     cout << "-op [op] - choose operation you want" << endl;
     cout << "-op 1 - Similarity matrix between N sequence." << endl;
diff --git a/SequenceComparison/parameter.h b/SequenceComparison/parameter.h
index 670b9a7a59577baa2223e14da8885bf0ddbee0fa..8836ce2b667f9205dd379f5454ea5ded25f9f4f8 100644
--- a/SequenceComparison/parameter.h
+++ b/SequenceComparison/parameter.h
@@ -18,7 +18,7 @@ public:
     int relaxation;             //size of relaxation (relaxation of endpoints)
     
     // I/O
-    std::vector<std::string> inPath;   //input paths
+    vtr<std::string> inPath;   //input paths
     std::string outputPath;             //outpath path for log
     std::string gdf;                    //path of gdf file generation
     std::string clusterInfoPath;            //path of cluster info file
diff --git a/SequenceComparison/pdtw.cpp b/SequenceComparison/pdtw.cpp
index ebc2cc1724598b2f57ab98bf6068c8ca353837cb..e9c22dd870d7c0e5c73411642c3c0302c89080da 100644
--- a/SequenceComparison/pdtw.cpp
+++ b/SequenceComparison/pdtw.cpp
@@ -9,7 +9,7 @@
 
 using namespace std;
 
-double pdtw::main(vtr3D const &input, parameter const &params)
+double pdtw::main(vtr3<double> const &input, parameter const &params)
 {
     auto result = alignment(input, params);
     
@@ -18,9 +18,9 @@ double pdtw::main(vtr3D const &input, parameter const &params)
     return result.normScore;
 }
 
-result_pdtw pdtw::alignment(vtr3D const &input, parameter const &params)
+result_pdtw pdtw::alignment(vtr3<double> const &input, parameter const &params)
 {
-    vtr2I clusters(input.size());    
+    vtr2<int> clusters(input.size());    
     vector<closest> tree;
            
     for (int i = 0; i < input.size(); i++)
@@ -91,9 +91,9 @@ result_pdtw pdtw::alignment(vtr3D const &input, parameter const &params)
     return r; //calcul::GetMultiRatioDtw(input, map[0]);
 }
 
-vtr2D pdtw::createDiagMatrix(vtr3D const &input, parameter const &params)
+vtr2<double> pdtw::createDiagMatrix(vtr3<double> const &input, parameter const &params)
 {
-    vtr2D dm;
+    vtr2<double> dm;
 
     for (int i = 0; i < input.size(); i++)
     {
@@ -111,7 +111,7 @@ vtr2D pdtw::createDiagMatrix(vtr3D const &input, parameter const &params)
     return dm;
 }
 
-closest pdtw::getShortestDistance(vtr2D const &dm)
+closest pdtw::getShortestDistance(vtr2<double> const &dm)
 {
     int one = 0;
     int two = 0;
@@ -150,7 +150,7 @@ closest pdtw::getShortestDistance(vtr2D const &dm)
     }
 }
 
-void pdtw::revalueAndMark(vtr2D &dm, vtr2I const &clusters, closest const &p)
+void pdtw::revalueAndMark(vtr2<double> &dm, vtr2<int> const &clusters, closest const &p)
 {
     const int keep = p.i;
     const int discard = p.j;
diff --git a/SequenceComparison/pdtw.h b/SequenceComparison/pdtw.h
index cba840dd8c7f9f2081e02cd74e50b56c8299e7de..ceb50785b25dc1b4e4c709fc46d74ef2c4017eb2 100644
--- a/SequenceComparison/pdtw.h
+++ b/SequenceComparison/pdtw.h
@@ -5,13 +5,13 @@
 class pdtw
 {
 public: 
-    static double main(vtr3D const &input, parameter const &params);
-    static result_pdtw alignment(vtr3D const &input, parameter const &params);
-    //static double GetEdits(vtr2D const &A, vtr2D const &B);
-    static vtr2D createDiagMatrix(vtr3D const &input, parameter const &params);
+    static double main(vtr3<double> const &input, parameter const &params);
+    static result_pdtw alignment(vtr3<double> const &input, parameter const &params);
+    //static double GetEdits(vtr2<double> const &A, vtr2<double> const &B);
+    static vtr2<double> createDiagMatrix(vtr3<double> const &input, parameter const &params);
     //Returns tuple with most similar pair of sequence. (pdtw)
-    static closest getShortestDistance(vtr2D const &dm);
+    static closest getShortestDistance(vtr2<double> const &dm);
     //Returns revalued similarity matrix. (pdtw)
-    static void revalueAndMark(vtr2D &dm, vtr2I const &clusters, closest const &p);
+    static void revalueAndMark(vtr2<double> &dm, vtr2<int> const &clusters, closest const &p);
 };
 
diff --git a/SequenceComparison/print.cpp b/SequenceComparison/print.cpp
index 1b3aefa0af639b8b16e2dda314b39ecc325d4fe4..4f3ba983c7ec09850581948510a86775f2b54336 100644
--- a/SequenceComparison/print.cpp
+++ b/SequenceComparison/print.cpp
@@ -21,7 +21,7 @@ string print::printElapsed(string const &flag, chrono::steady_clock::time_point
     return ss.str();
 }
 
-string print::printInput(vtr3D const &input, int len, bool IsPair)
+string print::printInput(vtr3<double> const &input, int len, bool IsPair)
 {
     stringstream ss("");
     ss.str("");
@@ -71,7 +71,7 @@ void print::write(vtrS const &output, string const &path)
     f.close();
 }
 
-string print::printGdf(vtrS const &files, vtr3D const &input, vtr2D const &sim, map<int, int> const &clusters)
+string print::printGdf(vtrS const &files, vtr3<double> const &input, vtr2<double> const &sim, map<int, int> const &clusters)
 {    
     stringstream ss;
 
@@ -112,7 +112,7 @@ string print::printGdf(vtrS const &files, vtr3D const &input, vtr2D const &sim,
     return ss.str();
 }
 
-string print::printMatrix(vtr2D const &simM, parameter const &params)
+string print::printMatrix(vtr2<double> const &simM, parameter const &params)
 {
     std::stringstream stream;
 
@@ -129,7 +129,7 @@ string print::printMatrix(vtr2D const &simM, parameter const &params)
     return stream.str();
 }
 
-string print::printMatrix(vtr2I const &simM, parameter const &params)
+string print::printMatrix(vtr2<int> const &simM, parameter const &params)
 {
     std::stringstream stream;
 
@@ -159,7 +159,7 @@ string print::printTree(vector<closest> const &tree)
 
 string print::printPathShape(string const &path, coords p, int lenA, int lenB)
 {
-    vtr2I tmp(lenA);
+    vtr2<int> tmp(lenA);
     for (size_t i = 0; i < lenA; i++)
         tmp[i] =  vtrI(lenB);
     
@@ -197,7 +197,7 @@ string print::printPathShape(string const &path, coords p, int lenA, int lenB)
     return ss.str();
 }
 
-void print::printResults(vtr2D const & matrix, vtr2I const & order, parameter const & params)
+void print::printResults(vtr2<double> const & matrix, vtr2<int> const & order, parameter const & params)
 {/*
     if (params::isMeasure())
     {
@@ -209,7 +209,7 @@ void print::printResults(vtr2D const & matrix, vtr2I const & order, parameter co
         cout << params.startStamp*/
 }
 
-string print::printHtmlClusters(vtr3D const &input, vtr2I const &order, mapInt const &clusters)
+string print::printHtmlClusters(vtr3<double> const &input, vtr2<int> const &order, mapInt const &clusters)
 {
     stringstream ss;
     ss << "<html><body>";
diff --git a/SequenceComparison/print.h b/SequenceComparison/print.h
index 209b81043bf31836c45e1756491ea92651afde11..b38b1238459d1e33505efe2d15ffec4720910f31 100644
--- a/SequenceComparison/print.h
+++ b/SequenceComparison/print.h
@@ -11,26 +11,26 @@ public:
     static std::string printElapsed(std::string const &flag, std::chrono::steady_clock::time_point point);
 
     //Returns formated input for print.
-	static std::string printInput(vtr3D const &input, int = 0, bool = false);
+	static std::string printInput(vtr3<double> const &input, int = 0, bool = false);
     //Returns formated similarity matrix for print.
-    static std::string printMatrix(vtr2D const &simMatrix, parameter const &params);
+    static std::string printMatrix(vtr2<double> const &simMatrix, parameter const &params);
     //Returns formated matrix for print.
-    static std::string printMatrix(vtr2I const &simM, parameter const &params);
+    static std::string printMatrix(vtr2<int> const &simM, parameter const &params);
     //Returns formated tree for pdtw method.
-	static std::string printTree(std::vector<closest> const &tree);
+	static std::string printTree(vtr<closest> const &tree);
 
     static std::string printPathShape(std::string const & path, coords p, int lenA, int lenB);
     
     //Prints results
-    static void printResults(vtr2D const &matrix, vtr2I const &order, parameter const &params);
+    static void printResults(vtr2<double> const &matrix, vtr2<int> const &order, parameter const &params);
 
-    static std::string printHtmlClusters(vtr3D const &input, vtr2I const &order, mapInt const &clusters);
+    static std::string printHtmlClusters(vtr3<double> const &input, vtr2<int> const &order, mapInt const &clusters);
 
     static std::string printParameterString(vtrS const & parameters);
 
     static std::string printMapRatios(vtrD const &ratios);
     //Writes data to a gdf file.
-    static std::string printGdf(vtrS const &files, vtr3D const &input, vtr2D const &sim, std::map<int, int> const &clusters);
+    static std::string printGdf(vtrS const &files, vtr3<double> const &input, vtr2<double> const &sim, std::map<int, int> const &clusters);
 
     static std::string printVector(vtrS const &vtr);
     
diff --git a/SequenceComparison/templates.h b/SequenceComparison/templates.h
index 7ce114ed960da684278d18d7594c126592b36a69..62eaa2f188811216c44834b928eabf20b176ed63 100644
--- a/SequenceComparison/templates.h
+++ b/SequenceComparison/templates.h
@@ -35,7 +35,7 @@ typedef std::vector<std::vector<std::vector<int>>> vtr3I;
 typedef std::vector<std::vector<int>> vtr2I;
 typedef std::vector<int> vtrI;
 typedef Vtr<std::string, 3> vtr3S;
-typedef Vtr<std::string, 2> vtr2S;
+typedef Vtr<std::string, 2> vtr2S;  
 typedef std::vector<std::string> vtrS;
 
 template<class T>
@@ -45,10 +45,10 @@ using vtr2 = std::vector<std::vector<T>>;
 template<class T>
 using vtr3 = std::vector<std::vector<std::vector<T>>>;
 
-typedef Vtr<double, 3> vtr3D2;
-typedef Vtr<double, 2> vtr2D2;
-typedef Vtr<int, 3> vtr3I2;
-typedef Vtr<int, 2> vtr2I2;
+typedef Vtr<double, 3> vtr3D;
+typedef Vtr<double, 2> vtr2D;
+typedef Vtr<int, 3> vtr3I;
+typedef Vtr<int, 2> vtr2I;