Newer
Older
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);
vtr3<double> help::separateSequence(vtr3<double> const &input, int size)
{
auto tmp = separateSequenceOne(input[i]);
output.insert(output.end(), tmp.begin(), tmp.end());
}
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;
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];
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;
}
//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;
//}
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
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>
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];
}
}
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
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;
// }
// }
// }
// }
//}
//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;