help.cpp

#include "stdafx.h"

#include "help.h"
#include <bitset>
#include <random>
#include <experimental/filesystem>

using namespace std;

#undef min

bool help::pathExists(std::string path)
{
	std::experimental::filesystem::path p = path;
	return std::experimental::filesystem::exists(p);
}

bool help::isFolder(std::string path)
{
	std::experimental::filesystem::path p = path;
	return std::experimental::filesystem::is_directory(p);
}

bool help::isFile(std::string path)
{
	std::experimental::filesystem::path p = path;
	
	if (std::experimental::filesystem::is_directory(p))
		return false;

	return true;
}

string help::stripFileNameFromPath(std::string path)
{
	string folder = path.substr(0, path.find_last_of("\\/"));

	return folder;
}

void help::trimLeft(string &s, string const &delimiters)
{
	const size_t startpos = s.find_first_not_of(delimiters);
	if (string::npos != startpos)
	{
		//s = s.substr(startpos, s.end);
		s.erase(s.begin(), s.begin() + startpos);
	}
}

void help::trimRight(string &s, string const &delimiters)
{
	const size_t endpos = s.find_last_not_of(delimiters);
	if (string::npos != endpos)
	{
		//s = s.substr(0, endpos + 1);
		s.erase(s.begin() + endpos + 1, s.end());
	}
}

void help::trim(string &s, string const &delimiters)
{
	trimLeft(s, 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;
}

void help::correctBomLine(string &s)
{
	if (s.compare(0, 3, "\xEF\xBB\xBF") == 0)  // Is the file marked as UTF-8?
	{
		s.erase(0, 3);                  // Now get rid of the BOM.
	}
	else if (s.compare(0, 2, "\xFE\xFF") == 0)  // Is the file marked as UTF-16 BE?
	{
		s.erase(0, 2);                  // Now get rid of the BOM.
	}
	else if (s.compare(0, 2, "\xFF\xFE") == 0)  // Is the file marked as UTF-16 LE
	{
		s.erase(0, 2);                  // Now get rid of the BOM.
	}
	else if (s.compare(0, 4, "\x00\x00\xFE\xFF") == 0)  // Is the file marked as UTF-32 BE?
	{
		s.erase(0, 4);                  // Now get rid of the BOM.
	}
	else if (s.compare(0, 4, "\xFF\xFE\x00\x00") == 0)  // Is the file marked as UTF-32 LE?
	{
		s.erase(0, 4);                  // Now get rid of the BOM.
	}
}

double help::random_real(int min, int max)
{
	std::random_device rd;
	std::mt19937 gen(rd());
	std::uniform_real_distribution<double> dis(min, max);

	return dis(gen);
}

int help::random_int(int min, int max)
{
	std::random_device rd;
	std::mt19937 gen(rd());
	std::uniform_int_distribution<int> dis(min, max);

	return dis(gen);
}

vtr2<double> help::random_sequence(int len, int dims, int min, int max)
{
	vtr2<double> ts(len);

	for (int i = 0; i < len; i++)
	{
		vtr<double> point(dims);
		for (int j = 0; j < dims; j++)
		{
			point[j] = help::random_real(min, max);
			ts[i] = (point);
		}
	}

	return ts;
}

template<class T>
vtr<T> help::vtr_init(size_t size)
{
	return vtr<T>(size);
}

template<class T>
vtr2<T> help::vtr_init(size_t size1, size_t size2)
{
	vtr2<T> tmp(size1);
	for (size_t i = 0; i < size1; i++)
		tmp[i] = vtr<T>(size2);

	return tmp;
}

template<class T>
void help::vtr_init(vtr2<T> &m, size_t size1, size_t size2, T value)
{
	m.reserve(size1);
	for (size_t i = 0; i < size1; i++)
	{
		m[i] = vtr<T>(size2);
		std::fill(m[i].begin(), m[i].end(), value);
	}
}
template void help::vtr_init<float>(vtr2<float> &m, size_t size1, size_t size2, float value);

template<class T>
vtr3<T> help::vtr_init(size_t size1, size_t size2, size_t size3)
{
	vtr3<T> tmp(size1);
	for (size_t i = 0; i < size1; i++)
		tmp[i] = help::vtr_init<T>(size2, size3);

	return tmp;
}
template vtr3<int> help::vtr_init<int>(size_t size1, size_t size2, size_t size3);
template vtr3<double> help::vtr_init<double>(size_t size1, size_t size2, size_t size3);

template<class T>
vtr3<T> help::vtr_initPartial(size_t size1, size_t size2)
{
	vtr3<T> tmp(size1);
	for (size_t i = 0; i < size1; i++)
		tmp[i] = vtr2<T>(size2);

	return tmp;
}
template vtr3<double> help::vtr_initPartial<double>(size_t size1, size_t size2);

template <typename T>
T help::vtr_findMax(vtr2<T> const &input)
{
	double max = constant::MIN_double;

	for (auto &&i : input)
		for (auto &&j : i)
			if (j > max)
				max = j;

	return max;
}
template double help::vtr_findMax<double>(vtr2<double> const &input);

template <typename T>
T help::vtr_findMax(vtr3<T> const &input)
{
	double max = constant::MIN_double;

	for (auto &i : input) {
		auto tmp = vtr_findMax(i);

		if (tmp > max)
			max = tmp;
	}

	return max;
}

template <typename T>
T help::vtr_findMin(vtr2<T> const &input)
{
	double min = constant::MAX_double;

	for (auto &&i : input)
		for (auto &&j : i)
			if (j < min)
				min = j;

	return min;
}
template double help::vtr_findMin<double>(vtr2<double> const &input);

void help::normalizeMany(vtr3<double> &input)
{
	for (size_t i = 0; i < input.size(); i++) //dims
	{
		normalize(input[i]);
	}
}

void help::normalize(vtr2<double> &input)
{
	for (size_t i = 0; i < input[0].size(); i++) //dims
	{
		double mean = 0;
		for (size_t j = 0; j < input.size(); j++) //lenght of sequence
		{
			mean += input[j][i];
		}
		mean = mean / (double)input.size();
		//mean = abs(mean);
				
		for (size_t j = 0; j < input.size(); j++) //lenght of sequence
		{
			input[j][i] = input[j][i] / mean;
		}
	}
}

void help::normalizeZeroOne(vtr3<double> &input, double max)
{
	for (size_t i = 0; i < input.size(); i++)
	{
		for (size_t j = 0; j < input[i].size(); j++)
		{
			for (size_t k = 0; k < input[i][j].size(); k++)
			{
				input[i][j][k] /= max;
			}
		}
	}
}

vtr2<double> help::normalize(vtr2<double> const &input, double coef)
{
	vtr2<double> output(input.size());

	for (size_t i = 0; i < input.size(); i++) //dims
	{
		vtr<double> el(input[i].size());
		for (size_t j = 0; j < input[i].size(); j++) //lenght of sequence
		{
			el[j] = input[i][j] * coef;
		}
		output[i] = el;
	}

	return output;
}

vtr3<double> help::separateSequence(vtr3<double> const &input, int size)
{
	vtr3<double> output;

	for (int i = 0; i < size; i++)
	{
		auto tmp = separateSequenceOne(input[i]);
		output.insert(output.end(), tmp.begin(), tmp.end());
	}

	return output;
}

vtr3<double> help::separateSequenceOne(vtr2<double> const &input)
{
	vtr3<double> output;

	const size_t dims = input[0].size();

	for (size_t i = 0; i < dims; i++)
	{
		vtr2<double> sequence;
		sequence.reserve(input.size());
		for (size_t j = 0; j < input.size(); j++)
		{
			vector<double> el(1);
			el[0] = input[j][i];
			sequence.push_back(el);
		}
		output.push_back(sequence);
	}

	return output;
}

//void help::reduce(vtr3<double> &input, size_t skip)
//void help::paa(vtr3<double> &input, size_t ratio)
//void help::sax(vtr3<double> &input, size_t numClasses)
//void help::smooth(vtr3<double> &input, size_t width)


vtr2<double> help::convert_arrd(double* const &series, size_t len)
{
	vtr2<double> out(len);
	for (size_t i = 0; i < len; i++)
	{
		vtr<double> point(1);
		point[0] = series[i];

		out[i] = point;
	}

	return out;
}

vtr2<double> help::convert_arr2d(double* const &series, size_t len, size_t dims)
{
	vtr2<double> out(len);
	for (size_t i = 0; i < len; i++)
	{
		vtr<double> point(&series[0] + (i * dims), &series[0] + ((i + 1) * dims));
		//cout << point.size() << endl;
		out[i] = point;
	}

	return out;
}

vtr2<double> help::convert_arr3d(double* const &input, size_t len, size_t dims)
{
	vtr2<double> out(len);
	for (size_t i = 0; i < len; i++)
	{
		//int size = (sizeof(input[i]) / sizeof(double)) / dims;
		//auto tseries = convert_arr2d(input[i], size);
	}

	return out;
}

//vtr<coords> help::convert_toCoords(result_path const &warping)
//{
//	vtr<coords> pathCoords(warping.path.size());
//	
//	int row = -1, col = -1;
//	for (size_t i = 0; i < warping.path.size(); i++)
//	{
//		if (warping.path[i] == 'M') {
//			row++;
//			col++;
//		}
//		else if (warping.path[i] == 'L')
//			col++;
//		else if (warping.path[i] == 'U')
//			row++;
//
//		pathCoords[i] = coords(row + 1, col + 1); //x,y(i,j)
//	}
//
//	return pathCoords;
//}

void help::sortFollow(vtr<double> &lead, vtr<int> &follow, bool reversed)
{
	for (size_t i = 0; i < lead.size() - 1; i++)
	{
		for (int j = 0; j < (int)follow.size() - 1; j++)
		{

			if (reversed ? lead[j + 1] > lead[j] : lead[j + 1] < lead[j])
			{
				double tmp = lead[j];
				lead[j] = lead[j + 1];
				lead[j + 1] = tmp;

				int fTmp = follow[j];
				follow[j] = follow[j + 1];
				follow[j + 1] = fTmp;
			}
		}
	}
}

template <typename T>
vtr2<T> help::vtr_degrade(vtr3<T> const &input)
{
	size_t sum = 0;

	for (auto &i : input)
		sum += i.size();


	vtr2<double> v;
	v.reserve(sum);
	for (auto &i : input)
		v.insert(v.end(), i.begin(), i.end());

	return v;
}

template <typename T>
void help::interpolate(vtr3<T> &input)
{
	int maxLen = -1;

	for (auto &&s : input)
	{
		if ((int)s.size() > maxLen)
			maxLen = (int)s.size();
	}

	for (size_t i = 0; i < input.size(); i++)
	{
		if (input[i].size() == 1)
		{
			vtr2<T> row(maxLen);
			fill(row.begin(), row.end(), input[i][0]);
			input[i] = row;
		}

		int diff = maxLen - (int)input[i].size();
		while (diff > 0)
		{
			vtr2<T> row;

			int c = 0;
			for (size_t j = 0; j < input[i].size() && diff > 0; j++)
			{
				vtr<T> point;

				if (j % 2 == 1)
				{
					for (size_t k = 0; k < input[i][j].size(); k++)
					{
						double tmp = (input[i][c - 1][k] + input[i][c][k]) / 2.0;
						point.push_back(tmp);
					}

					row.push_back(point);
					diff--;
				}
				else
				{
					row.push_back(input[i][c]);
					c++;
				}

			}
			row.insert(row.end(), input[i].begin() + c, input[i].end());
			input[i] = row;
		}
	}
}
template void help::interpolate<double>(vtr3<double> &input);

template <typename T>
void help::interpolate2(vtr3<double> &input)
{
	int maxLen = -1;

	for (auto &&s : input)
	{
		if ((int)s.size() > maxLen)
			maxLen = (int)s.size();
	}

	for (auto &&i : input)
	{
		int diff = maxLen - (int)i.size();

		while (diff > 0)
		{
			int c = 0;
			vtr2<T> row;
			for (size_t k = 0; k < i.size() - 1 && diff > 0; k++)
			{
				vtr<T> el;

				if (k % 2 == 1)
				{
					for (size_t j = 0; j <i[k].size(); j++)
					{
						T tmp = (i[c - 1][j] + i[c][j]) / 2.0;
						el.push_back(tmp);
					}

					row.push_back(el);
					diff--;
				}
				else
				{
					row.push_back(i[c]);
					c++;
				}

			}
			row.insert(row.end(), i.begin() + c, i.end());
			i = row;
		}
	}
}

template <typename T>
void help::paa(vtr3<T> &input, size_t ratio)
{
	vtr3<T> output(input.size());

	for (size_t i = 0; i < input.size(); i++)
	{
		vtr2<T> s;
		for (size_t j = 0; j < input[i].size(); j += ratio)// sequence
		{
			vtr<T> dim(input[i][j].size());

			const size_t end = j + ratio >= input[i].size() ? input[i].size() : j + ratio;
			for (size_t k = 0; k < input[i][j].size(); k++) //all dims
			{
				double sum = 0;
				int merged = 0;
				for (size_t l = j; l < end; l++) //sum individual groups of dims 
				{
					sum += input[i][l][k];
					merged++;
				}
				dim[k] = (T)(sum / merged);
			}
			s.push_back(dim);
		}
		output[i] = s;
	}

	input = output;
}
template void help::paa<double>(vtr3<double> &input, size_t ratio);
template void help::paa<int>(vtr3<int> &input, size_t ratio);

void help::sax(vtr3<double> &input, size_t numClasses)
{
	double max = constant::MIN_double;
	double min = constant::MAX_double;
	for (auto &&i : input)
	{
		double tmpMax = help::vtr_findMax(i);
		if (tmpMax > max)
			max = tmpMax;

		double tmpMin = help::vtr_findMin(i);
		if (tmpMin < min)
			min = tmpMin;
	}

	double step = (max - min) / static_cast<double>(numClasses);

	for (auto &&i : input)
	{
		for (auto &&j : i)
		{
			for (auto &&k : j)
			{
				int c = 1;
				double stepCount = min;
				while (stepCount < max + step)
				{
					if (k <= min + c * step)
					{
						k = min + (c - 1) * step + step / 2;
						break;
					}
					stepCount += step;
					c++;
				}
			}
		}
	}
}

//Returns shortened input sequence by skiping some of their elements.
template <typename T>
void help::reduce(vtr3<T> &input, size_t skip)
{
	for (auto &&i : input)
	{
		vtr2<T> row;
		for (size_t j = skip - 1; j < i.size(); j += skip)
		{
			row.push_back(i[j]);
		}
		i = row;
	}
}
template void help::reduce<double>(vtr3<double> &input, size_t skip);
template void help::reduce<int>(vtr3<int> &input, size_t skip);

template <typename T>
void help::prolong(vtr3<T> &input, size_t times)
{
	for (size_t i = 0; i < input.size(); i++) //every sequence
	{
		size_t dims = (int)input[0][0].size();

		for (size_t j = 0; j < times; j++) //times to prolong
		{
			size_t alloc = 2 * input[i].size() - 1;

			int counter = 0;
			vtr2<T> row(alloc);
			for (size_t k = 0; k < 2 * input[i].size() - 1; k++)
			{
				vtr<T> point(dims);
				for (size_t l = 0; l < dims; l++)
				{
					if (k % 2 == 1)
						point[l] = (input[i][counter - 1][l] + input[i][counter][l]) / 2;
					else
					{
						point[l] = input[i][counter][l];
					}
				}
				if (k % 2 != 1)
					counter++;

				row[k] = point;
			}
			input[i] = row;
		}
	}
}
template void help::prolong<double>(vtr3<double> &input, size_t times);
template void help::prolong<int>(vtr3<int> &input, size_t times);

//Returns smoothed sekvence by moving window average.
void help::smooth(vtr3<double> &input, size_t width)
{
	vtr3<double> output(input.size());

	for (size_t i = 0; i < input.size(); i++)
	{
		const int dims = (int)input[0][0].size();

		vtr2<double> s;
		for (size_t j = 0; j < width - 1; j++)
		{
			s.push_back(input[i][j]);
		}

		for (size_t j = 0; j < input[i].size() - width + 1; j++)// sequence
		{
			vtr<double> sums(dims);
			for (size_t k = 0; k < width; k++) //all dims
			{
				for (int l = 0; l < dims; l++)
				{
					sums[l] += static_cast<double>(input[i][j + k][l] / width);
				}
			}
			s.push_back(sums);
		}
		output[i] = s;
	}

	input = output;
}

template<typename T>
vtr3<T> help::alterStructure(vtr3<T> const &matrix) 
{
	vtr3<T> m = help::vtr_init<T>(matrix[0][0].size(), matrix.size(), matrix[0].size());
	for (size_t i = 0; i < matrix.size(); i++)
	{
		for (size_t j = 0; j < matrix[0].size(); j++)
		{
			for (size_t k = 0; k < matrix[0][0].size(); k++)
			{
				m[k][i][j] = matrix[i][j][k];
			}
		}
	}

	return m;
}
template vtr3<double> help::alterStructure(vtr3<double> const &matrix);
template vtr3<int> help::alterStructure(vtr3<int> const &matrix);

//Returns sorted 2D vector by columns.
//template<class T, class T2>
//static void Sort2dVectorByColumns(vtr2<T> &matrix, vtr2<T2> &order, bool reversed)
//{
//	for (size_t i = 0; i < matrix.size(); i++)   //col //sorting for every column
//	{
//		for (size_t k = 0; k < matrix.size(); k++)
//		{
//			for (size_t j = 1; j < matrix.size() - 1; j++) //row
//			{
//				if(reversed ? matrix[j][i] < matrix[j + 1][i] : matrix[j][i] > matrix[j + 1][i])
//				{
//					T tmp = matrix[j][i];
//					matrix[j][i] = matrix[j + 1][i];
//					matrix[j + 1][i] = tmp;

//					T2 tmpI = order[j][i];
//					order[j][i] = order[j + 1][i];
//					order[j + 1][i] = tmpI;
//				}
//			}
//		}
//	}
//}