void operator()(R &r, boost::uint8_t value)
{
switch(this->state)
{
case state_t::none:
switch(value)
{
case dle:
this->state = state_t::dle;
break;
default:
r(data_t(value));
break;
}
break;
case state_t::dle:
this->state = state_t::none;
switch(value)
{
case dle:
r(data_t(dle));
break;
case etx:
r(end_t());
break;
default:
r(id_t(value));
break;
}
break;
}
}
static void
generate_vector_array(vector_t p[])
{
data_t (*rand_next[3])();
int dist, i;
for (i = 0; i < 3; i++) {
dist = fixed_flag ? 2 : rand_func()%3;
switch (dist) {
case 0: /* [-1, 1) */
min = -1.0;
max = 1.0;
rand_next[i] = rand_uniform;
break;
case 1: /* N(0, 1) */
m = 0.0;
sigma = 1.0;
rand_next[i] = rand_normal;
break;
default: /* La(0, 1) */
mu = 0.0;
b = 1.0;
rand_next[i] = rand_laplace;
break;
}
}
for (i = 0; i < N; i++) {
p[i].x = rand_next[0]();
p[i].y = rand_next[1]();
p[i].z = rand_next[2]();
}
}
static void
generate_mass_array(data_t a[])
{
data_t (*rand_next)();
int dist, i;
m = mu = 1.0/(data_t)N;
min = m*0.5;
max = m*1.5;
dist = fixed_flag ? 2 : rand_func()%3;
switch (dist) {
case 0: /* [1/2N, 3/2N) */
rand_next = rand_uniform;
break;
case 1: /* N(1/N, 1/10N) */
sigma = m*1e-1;
rand_next = rand_normal;
break;
default: /* La(1/N, 1/10N) */
b = m*1e-1;
rand_next = rand_laplace;
break;
}
for (i = 0; i < N; i++)
do a[i] = rand_next();
while (a[i] < min || a[i] > max);
}
string TH_0x1B::makeStringFromData(const data_t& data, const options_t& options)
{
(void)options;
if (data.size() != dataByteCount)
{
throw invalid_argument("Empty data array. Needs to contain " + to_string(dataByteCount) + " bytes");
}
string coeffR = TH_0x00::makeStringFromData(data_t(data.begin(), data.begin() + TH_0x00::dataByteCount));
string coeffI = TH_0x00::makeStringFromData(data_t(data.begin() + TH_0x00::dataByteCount, data.begin() + 2 * TH_0x00::dataByteCount));
string str = dec2frac(atof(coeffR.c_str())) + "+" + dec2frac(atof(coeffI.c_str())) + "i";
str = regex_replace(str, regex("\\+-"), "-");
return str;
}
Matrix Matrix::m_sqrt(){
Matrix res(rows,cols);
vector<vector<double>> data_t(rows,vector<double>(cols,0));
for(int i=0;i<rows;i++)
for(int j=0;j<cols;j++)
data_t[i][j] = sqrt(data[i][j]);
res.setdata(data_t);
return res;
}
Matrix Matrix::m_power(int p){
Matrix res(rows,cols);
vector<vector<double>> data_t(rows,vector<double>(cols,0));
for(int i = 0; i < rows; i++){
for(int j = 0; j < cols; j++){
data_t[i][j] = pow(data[i][j],p);
}
}
res.setdata(data_t);
return res;
}
string TH_0x02::makeStringFromData(const data_t& data, const options_t& options)
{
(void)options;
size_t byteCount = data.size();
size_t colCount = data[0];
size_t rowCount = data[1];
if (data.size() < 2+TH_0x00::dataByteCount || colCount < 1 || rowCount < 1 || colCount > 255 || rowCount > 255
|| ((byteCount - 2) % TH_0x00::dataByteCount != 0) || (colCount*rowCount != (byteCount - 2) / TH_0x00::dataByteCount))
{
std::cerr << "Invalid data array. Needs to contain 1+1+" << TH_0x00::dataByteCount << "*n bytes" << std::endl;
return "";
}
string str = "[";
for (uint i = 2, num = 0; i < byteCount; i += TH_0x00::dataByteCount, num++)
{
if (num % colCount == 0) // first column
{
str += "[";
}
str += TH_0x00::makeStringFromData(data_t(data.begin()+i, data.begin()+i+TH_0x00::dataByteCount));
if (num % colCount < colCount - 1) // not last column
{
str += ",";
} else {
str += "]";
}
}
str += "]";
// TODO: prettified option
return str;
}
std::string calc_var_content_string(const calc_var_t& var)
{
auto func = tivars::TypeHandlerFuncGetter::getStringFromDataFunc((int)var.type);
return func(data_t(var.data, var.data + var.size), options_t());
}
data_t TH_0x02::makeDataFromString(const string& str, const options_t& options)
{
(void)options;
data_t data(2); // reserve 2 bytes for size fields
if (str.length() < 5 || str.substr(0, 2) != "[[" || str.substr(str.length()-2, 2) != "]]")
{
std::cerr << "Invalid input string. Needs to be a valid matrix" << std::endl;
return data_t();
}
size_t rowCount, colCount;
vector<vector<string>> matrix;
vector<string> rows;
rows = explode(str.substr(2, str.length()-4), "][");
rowCount = rows.size();
matrix.resize(rowCount);
colCount = (size_t) (count(rows[0].begin(), rows[0].end(), ',') + 1);
if (colCount > 0xFF || rowCount > 0xFF)
{
std::cerr << "Invalid input string. Needs to be a valid matrix (max col/row = 255)" << std::endl;
return data_t();
}
uint counter = 0;
for (const auto& row : rows)
{
auto tmp = explode(row, ",");
for (auto& numStr : tmp)
{
numStr = trim(numStr);
if (!is_numeric(numStr))
{
std::cerr << "Invalid input string. Needs to be a valid matrix (real numbers inside)" << std::endl;
return data_t();
}
}
if (tmp.size() != colCount)
{
std::cerr << "Invalid input string. Needs to be a valid matrix (consistent column count)" << std::endl;
return data_t();
}
matrix[counter++] = tmp;
}
data[0] = (uchar)(colCount & 0xFF);
data[1] = (uchar)(rowCount & 0xFF);
for (const vector<string>& row : matrix)
{
for (const auto& numStr : row)
{
const auto& tmp = TH_0x00::makeDataFromString(numStr);
data.insert(data.end(), tmp.begin(), tmp.end());
}
}
return data;
}
void push_back(string_t *data)
{
m_deque.push_back(data_t(*this, data));
}
