diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs/parameterized_absolute_value.cpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs/parameterized_absolute_value.cpp
index f08bc7abe7d1dbe2d20f22374ed87e60e7f97157..376253117cb85cb4d959b66d1baa5779c49dcff3 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs/parameterized_absolute_value.cpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs/parameterized_absolute_value.cpp
@@ -6,7 +6,7 @@ void generateAbsParamNode(std::vector<node_ptr>& feat_list, node_ptr feat, int&
node_ptr new_feat = std::make_shared<AbsParamNode>(feat, feat_ind, prop);
new_feat->set_value();
- if(new_feat->is_nan() || new_feat->is_const() || (*std::min_element(new_feat->value_ptr(), new_feat->value_ptr() + new_feat->n_samp()) > 0) || (util_funcs::max_abs_val<double>(new_feat->value_ptr(), new_feat->n_samp()) > u_bound) || (util_funcs::max_abs_val<double>(new_feat->value_ptr(), new_feat->n_samp()) < l_bound))
+ if(new_feat->is_nan() || new_feat->is_const() || (util_funcs::max_abs_val<double>(new_feat->value_ptr(), new_feat->n_samp()) > u_bound) || (util_funcs::max_abs_val<double>(new_feat->value_ptr(), new_feat->n_samp()) < l_bound))
return;
feat_list.push_back(new_feat);
@@ -21,7 +21,7 @@ AbsParamNode::AbsParamNode(node_ptr feat, int feat_ind, double l_bound, double u
_params.resize(n_params(), 0.0);
get_parameters(prop);
- if(is_nan() || is_const() || (*std::min_element(value_ptr(), value_ptr() + n_samp()) > 0) || (util_funcs::max_abs_val<double>(value_ptr(), _n_samp) > u_bound) || (util_funcs::max_abs_val<double>(value_ptr(), _n_samp) < l_bound))
+ if(is_nan() || is_const() || (util_funcs::max_abs_val<double>(value_ptr(), _n_samp) > u_bound) || (util_funcs::max_abs_val<double>(value_ptr(), _n_samp) < l_bound))
throw InvalidFeatureException();
}
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs/parameterized_absolute_value.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs/parameterized_absolute_value.hpp
index 685cf68010f32adf91e4131c78adb78a99d91e82..dda13a1c8ffa1421ca69161fbd2ccf804990a0df 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs/parameterized_absolute_value.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs/parameterized_absolute_value.hpp
@@ -172,9 +172,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[0]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs_diff/parameterized_absolute_difference.cpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs_diff/parameterized_absolute_difference.cpp
index 76e9a0f23254527d2faef104fc0799efc5a4d34c..f10c7cf533a8409293cbac9724607e2013811546 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs_diff/parameterized_absolute_difference.cpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs_diff/parameterized_absolute_difference.cpp
@@ -6,7 +6,7 @@ void generateAbsDiffParamNode(std::vector<node_ptr>& feat_list, node_ptr feat_1,
node_ptr new_feat = std::make_shared<AbsDiffParamNode>(feat_1, feat_2, feat_ind, prop);
new_feat->set_value();
- if(new_feat->is_nan() || new_feat->is_const() || (*std::min_element(new_feat->value_ptr(), new_feat->value_ptr() + new_feat->n_samp()) > 0) || (util_funcs::max_abs_val<double>(new_feat->value_ptr(), new_feat->n_samp()) > u_bound) || (util_funcs::max_abs_val<double>(new_feat->value_ptr(), new_feat->n_samp()) < l_bound))
+ if(new_feat->is_nan() || new_feat->is_const() || (util_funcs::max_abs_val<double>(new_feat->value_ptr(), new_feat->n_samp()) > u_bound) || (util_funcs::max_abs_val<double>(new_feat->value_ptr(), new_feat->n_samp()) < l_bound))
return;
feat_list.push_back(new_feat);
@@ -21,7 +21,7 @@ AbsDiffParamNode::AbsDiffParamNode(node_ptr feat_1, node_ptr feat_2, int feat_in
_params.resize(n_params(), 0.0);
get_parameters(prop);
- if(is_nan() || is_const() || (*std::min_element(value_ptr(), value_ptr() + n_samp()) > 0) || (util_funcs::max_abs_val<double>(value_ptr(), _n_samp) > u_bound) || (util_funcs::max_abs_val<double>(value_ptr(), _n_samp) < l_bound))
+ if(is_nan() || is_const()|| (util_funcs::max_abs_val<double>(value_ptr(), _n_samp) > u_bound) || (util_funcs::max_abs_val<double>(value_ptr(), _n_samp) < l_bound))
throw InvalidFeatureException();
}
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs_diff/parameterized_absolute_difference.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs_diff/parameterized_absolute_difference.hpp
index ad68673d08d3d73a6e5ae2e62890bc6e176cb7df..ba2382094fa34a5a8e0f430e3775ae04cd6aeab8 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs_diff/parameterized_absolute_difference.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/abs_diff/parameterized_absolute_difference.hpp
@@ -172,9 +172,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[1]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/add/parameterized_add.cpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/add/parameterized_add.cpp
index 70d62de21677f9c64e939c93d00b023b0be6f0c1..f4156fec649a1bb014e622d9fe8b82319c5d38eb 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/add/parameterized_add.cpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/add/parameterized_add.cpp
@@ -6,6 +6,7 @@ void generateAddParamNode(std::vector<node_ptr>& feat_list, node_ptr feat_1, nod
node_ptr new_feat = std::make_shared<AddParamNode>(feat_1, feat_2, feat_ind, prop);
new_feat->set_value();
+
if(new_feat->is_nan() || new_feat->is_const() || (util_funcs::max_abs_val<double>(new_feat->value_ptr(), new_feat->n_samp()) > u_bound) || (util_funcs::max_abs_val<double>(new_feat->value_ptr(), new_feat->n_samp()) < l_bound))
return;
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/add/parameterized_add.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/add/parameterized_add.hpp
index 67509116156e9a4c488d0b5228f02773ca013400..aaa0a5a55272e3473e4743ff0df403f6f303ac88 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/add/parameterized_add.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/add/parameterized_add.hpp
@@ -171,9 +171,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[1]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cb/parameterized_cube.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cb/parameterized_cube.hpp
index 7acb52949855f968f2661f57c1589a328565e49d..8ac3b85d167bd5646163d636ed08052548bb1bef 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cb/parameterized_cube.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cb/parameterized_cube.hpp
@@ -172,9 +172,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[0]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cbrt/parameterized_cube_root.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cbrt/parameterized_cube_root.hpp
index 842177c94a56225ebb2c3dbb6290e57274c405c1..93672e7bab6b2d5158e990f20bdb9df0a1197ca5 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cbrt/parameterized_cube_root.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cbrt/parameterized_cube_root.hpp
@@ -171,9 +171,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[0]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cos/parameterized_cos.cpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cos/parameterized_cos.cpp
index a6c66709e2602337c2b6d1cdb8334d931a917291..951fdaf2216ad76047662b5fc8a749da2f50207e 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cos/parameterized_cos.cpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cos/parameterized_cos.cpp
@@ -72,10 +72,10 @@ void CosParamNode::get_parameters(std::vector<double>& prop)
try
{
- nlopt::result result = opt.optimize(_params, minf);
- result = opt_global.optimize(_params, minf);
+ // nlopt::result result = opt.optimize(_params, minf);
+ // result = opt_global.optimize(_params, minf);
opt.set_xtol_rel(1e-6);
- result = opt.optimize(_params, minf);
+ nlopt::result result = opt.optimize(_params, minf);
}
catch(std::exception &e)
{
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cos/parameterized_cos.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cos/parameterized_cos.hpp
index a30d640d228d1229be013d596063da0be78800b0..9dc37289bbae829e3b1a4a73b32254bb0c598ee1 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cos/parameterized_cos.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/cos/parameterized_cos.hpp
@@ -172,9 +172,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[0]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/div/parameterized_divide.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/div/parameterized_divide.hpp
index f9e854b6a239531500409a7f54015bcf1139f21f..344341e0361cfa3c54f51e1c5ecc9305aeb6b1be 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/div/parameterized_divide.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/div/parameterized_divide.hpp
@@ -171,9 +171,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[1]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/exp/parameterized_exponential.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/exp/parameterized_exponential.hpp
index c78c5a3a594d94713642f87a423220acacd44879..313ee288e1c689779563e9b1e00277b4832a8d2f 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/exp/parameterized_exponential.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/exp/parameterized_exponential.hpp
@@ -171,9 +171,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[0]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/inv/parameterized_inverse.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/inv/parameterized_inverse.hpp
index 5c4ab6ed918aba884caf1cb32c9ef47f75b8903a..0510c669ab6b099d9c53ba9de231f0ad23bf7ae0 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/inv/parameterized_inverse.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/inv/parameterized_inverse.hpp
@@ -171,9 +171,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[0]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/log/parameterized_log.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/log/parameterized_log.hpp
index af187b4f78ca4d92778f221e3b623d2d05b4dd88..80d5aafe0d4b2d34752f6618daa37f3bca758281 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/log/parameterized_log.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/log/parameterized_log.hpp
@@ -172,9 +172,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[0]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/mult/parameterized_multiply.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/mult/parameterized_multiply.hpp
index 2de8040d870a02f17361c422df90cd2ff8b5617b..9732009ca28addac6bef70dc6f8123f324540c13 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/mult/parameterized_multiply.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/mult/parameterized_multiply.hpp
@@ -169,9 +169,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[1]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/neg_exp/parameterized_negative_exponential.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/neg_exp/parameterized_negative_exponential.hpp
index 3eade9a1c0a56a9243dd794903c4dee1b4464088..58699cc6ac23d8917dff185ae553153d713873fb 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/neg_exp/parameterized_negative_exponential.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/neg_exp/parameterized_negative_exponential.hpp
@@ -171,9 +171,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[0]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sin/parameterized_sin.cpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sin/parameterized_sin.cpp
index 915228540ef282d0b3f1bd9ea22f4db105c6ec2e..c04257d7f8733e1a92d1f819513df2bd5422cd9b 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sin/parameterized_sin.cpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sin/parameterized_sin.cpp
@@ -72,10 +72,10 @@ void SinParamNode::get_parameters(std::vector<double>& prop)
try
{
- nlopt::result result = opt.optimize(_params, minf);
- result = opt_global.optimize(_params, minf);
+ // nlopt::result result = opt.optimize(_params, minf);
+ // result = opt_global.optimize(_params, minf);
opt.set_xtol_rel(1e-6);
- result = opt.optimize(_params, minf);
+ nlopt::result result = opt.optimize(_params, minf);
}
catch(std::exception &e)
{
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sin/parameterized_sin.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sin/parameterized_sin.hpp
index 0592e64ec27bb461641b06ef54f85c43b93497a0..2cccc6b3b053c88f8097e50342970ef4ca3b13fa 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sin/parameterized_sin.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sin/parameterized_sin.hpp
@@ -171,9 +171,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[0]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/six_pow/parameterized_sixth_power.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/six_pow/parameterized_sixth_power.hpp
index 99db7b3cb86f543a53977f59b2478b65a79d34df..c42fbb52b8d91cb5932b793b318555a103a91b70 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/six_pow/parameterized_sixth_power.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/six_pow/parameterized_sixth_power.hpp
@@ -172,9 +172,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[0]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sq/parameterized_square.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sq/parameterized_square.hpp
index bdbeb2e345f5cbc4d1a1bbefb0c34dbfbbae40b4..d924d39395c991196e55b9a0f2f8df24a3f42e44 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sq/parameterized_square.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sq/parameterized_square.hpp
@@ -171,9 +171,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[0]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sqrt/parameterized_square_root.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sqrt/parameterized_square_root.hpp
index ad5a8e024f959733adccb80e0f5d3b3812288eb4..5bf034b0ae550f8153358b4d7e7074d7c75bdb4c 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sqrt/parameterized_square_root.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sqrt/parameterized_square_root.hpp
@@ -171,9 +171,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[0]->update_postfix(cur_expr, false);
diff --git a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sub/parameterized_subtract.hpp b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sub/parameterized_subtract.hpp
index 4bc7b1ceca27e3c7c304a576d07422c36b34e0fe..657f99217d0a51b5b897da3d6f081c1d7d737f31 100644
--- a/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sub/parameterized_subtract.hpp
+++ b/src/feature_creation/node/operator_nodes/allowed_operator_nodes/sub/parameterized_subtract.hpp
@@ -171,9 +171,9 @@ public:
postfix << get_postfix_term();
if(add_params)
{
- postfix << ":" << std::to_string(_params[0]);
+ postfix << ":" << _params[0];
for(int pp = 1; pp < _params.size(); ++pp)
- postfix << "," << std::to_string(_params[pp]);
+ postfix << "," << _params[pp];
}
cur_expr = postfix.str() + "|" + cur_expr;
_feats[1]->update_postfix(cur_expr, false);
diff --git a/tests/googletest/feature_creation/parameterization/test_abs_diff_node.cc b/tests/googletest/feature_creation/parameterization/test_abs_diff_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f95bfa358c0ba9afaa27da199502b91965c38811
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_abs_diff_node.cc
@@ -0,0 +1,145 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/abs_diff/parameterized_absolute_difference.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class AbsDiffParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(90, 10, 3);
+
+ _task_sizes_train = {90};
+
+ std::vector<double> value_1(90, 0.0);
+ std::vector<double> value_2(90, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-50.0, 50.0);
+ std::uniform_real_distribution<double> distribution_params(-2.50, 2.50);
+
+ for(int ii = 0; ii < 90; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = distribution_feats(generator);
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = distribution_feats(generator);
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("[-50.0, 50.0]"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("[-50.0, 50.0]"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = distribution_params(generator);
+ _alpha = distribution_params(generator);
+ _prop = std::vector<double>(90, 0.0);
+
+ allowed_op_funcs::abs_diff(90, _phi[0]->value_ptr(), _phi[1]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _abs_diff_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(AbsDiffParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateAbsDiffParamNode(_phi, _phi[0], _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (AbsDiffParamNode created with an absolute value above the upper bound)";
+
+ generateAbsDiffParamNode(_phi, _phi[0], _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (AbsDiffParamNode created with an absolute value below the lower bound)";
+
+ generateAbsDiffParamNode(_phi, _phi[0], _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (AbsDiffParamNode created with only one primary feature present)";
+
+ generateAbsDiffParamNode(_phi, _phi[0], _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-10);
+ }
+
+ TEST_F(AbsDiffParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _abs_diff_test = std::make_shared<AbsDiffParamNode>(_phi[0], _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (AbsDiffParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _abs_diff_test = std::make_shared<AbsDiffParamNode>(_phi[0], _phi[1], feat_ind, 1e3, 1e50, _prop);
+ EXPECT_TRUE(false) << " (AbsDiffParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _abs_diff_test = std::make_shared<AbsDiffParamNode>(_phi[0], _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_TRUE(false) << " (AbsDiffParamNode created with only one primary feature present)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _abs_diff_test = std::make_shared<AbsDiffParamNode>(_phi[0], _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _abs_diff_test->value_ptr(), 90), 1e-10);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(AbsDiffParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _abs_diff_test = std::make_shared<AbsDiffParamNode>(_phi[0], _phi[1], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_abs_diff_test->rung(), 1);
+
+ std::vector<double> expected_val(90, 0.0);
+
+ allowed_op_funcs::abs_diff(90, _phi[0]->value_ptr(), _phi[1]->value_ptr(), _abs_diff_test->parameters()[0], _abs_diff_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_abs_diff_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_abs_diff_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::abs_diff(10, _phi[0]->test_value_ptr(), _phi[1]->test_value_ptr(), _abs_diff_test->parameters()[0], _abs_diff_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_abs_diff_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_abs_diff_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "0|1|abd:" <<_abs_diff_test->parameters()[0] << ',' << _abs_diff_test->parameters()[1];
+ EXPECT_STREQ(_abs_diff_test->unit().toString().c_str(), "m");
+ EXPECT_STREQ(_abs_diff_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_abs_node.cc b/tests/googletest/feature_creation/parameterization/test_abs_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d1d4c1b975118df12ef51cee67c3948fef6168a7
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_abs_node.cc
@@ -0,0 +1,123 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/abs/parameterized_absolute_value.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class AbsParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(90, 10, 3);
+
+ _task_sizes_train = {90};
+
+ std::vector<double> value_1(90, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-50.0, 50.0);
+ std::uniform_real_distribution<double> distribution_params(-2.50, 2.50);
+
+ for(int ii = 0; ii < 90; ++ii)
+ value_1[ii] = distribution_feats(generator);
+
+ for(int ii = 0; ii < 10; ++ii)
+ test_value_1[ii] = distribution_feats(generator);
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("[-50.0, 50.0]"), Unit("m"));
+ _phi = {_feat_1};
+
+ _a = distribution_params(generator);
+ _alpha = distribution_params(generator);
+
+ _prop = std::vector<double>(90, 0.0);
+ allowed_op_funcs::abs(90, _phi[0]->value_ptr(), _alpha, _a, _prop.data());
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _abs_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(AbsParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateAbsParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 1) << " (AbsParamNode created with an absolute value above the upper bound)";
+
+ generateAbsParamNode(_phi, _phi[0], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 1) << " (AbsParamNode created with an absolute value below the lower bound)";
+
+ generateAbsParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-10);
+ }
+
+ TEST_F(AbsParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _abs_test = std::make_shared<AbsParamNode>(_phi[0], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (AbsParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _abs_test = std::make_shared<AbsParamNode>(_phi[0], feat_ind, 1e40, 1e50, _prop);
+ EXPECT_TRUE(false) << " (AbsParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _abs_test = std::make_shared<AbsParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _abs_test->value_ptr(), 90), 1e-10);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(AbsParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _abs_test = std::make_shared<AbsParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_abs_test->rung(), 1);
+
+ std::vector<double> expected_val(90, 0.0);
+
+ allowed_op_funcs::abs(90, _phi[0]->value_ptr(), _abs_test->parameters()[0], _abs_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_abs_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_abs_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::abs(10, _phi[0]->test_value_ptr(), _abs_test->parameters()[0], _abs_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_abs_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_abs_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "0|abs:" <<_abs_test->parameters()[0] << ',' << _abs_test->parameters()[1];
+ EXPECT_STREQ(_abs_test->unit().toString().c_str(), "m");
+ EXPECT_STREQ(_abs_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_add_node.cc b/tests/googletest/feature_creation/parameterization/test_add_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b7621c73a4b85840a25859d17a5ffaae59bd9547
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_add_node.cc
@@ -0,0 +1,133 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/add/parameterized_add.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class AddParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(90, 10, 3);
+
+ _task_sizes_train = {90};
+
+ std::vector<double> value_1(90, 0.0);
+ std::vector<double> value_2(90, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-50.0, 50.0);
+ std::uniform_real_distribution<double> distribution_params(-2.50, 2.50);
+
+ for(int ii = 0; ii < 90; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = distribution_feats(generator);
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = distribution_feats(generator);
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("[-50.0, 50.0]"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("[-50.0, 50.0]"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = distribution_params(generator);
+ _alpha = distribution_params(generator);
+ _prop = std::vector<double>(90, 0.0);
+ allowed_op_funcs::add(90, _phi[0]->value_ptr(), _phi[1]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _add_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(AddParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateAddParamNode(_phi, _phi[0], _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (AddParamNode created with an absolute value above the upper bound)";
+
+ generateAddParamNode(_phi, _phi[0], _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (AddParamNode created with an absolute value below the lower bound)";
+
+ generateAddParamNode(_phi, _phi[0], _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-10);
+ }
+
+ TEST_F(AddParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _add_test = std::make_shared<AddParamNode>(_phi[0], _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (AddParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _add_test = std::make_shared<AddParamNode>(_phi[0], _phi[1], feat_ind, 1e3, 1e50, _prop);
+ EXPECT_TRUE(false) << " (AddParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _add_test = std::make_shared<AddParamNode>(_phi[0], _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _add_test->value_ptr(), 90), 1e-10);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(AddParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _add_test = std::make_shared<AddParamNode>(_phi[0], _phi[1], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_add_test->rung(), 1);
+
+ std::vector<double> expected_val(90, 0.0);
+
+ allowed_op_funcs::add(90, _phi[0]->value_ptr(), _phi[1]->value_ptr(), _add_test->parameters()[0], _add_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_add_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_add_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::add(10, _phi[0]->test_value_ptr(), _phi[1]->test_value_ptr(), _add_test->parameters()[0], _add_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_add_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_add_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "0|1|add:" <<_add_test->parameters()[0] << ',' << _add_test->parameters()[1];
+ EXPECT_STREQ(_add_test->unit().toString().c_str(), "m");
+ EXPECT_STREQ(_add_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_cb_node.cc b/tests/googletest/feature_creation/parameterization/test_cb_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e4a10836256d511f1428883035a4505e5d5513ce
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_cb_node.cc
@@ -0,0 +1,144 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/cb/parameterized_cube.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class CbParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(90, 10, 3);
+
+ _task_sizes_train = {90};
+
+ std::vector<double> value_1(90, 0.0);
+ std::vector<double> value_2(90, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-50.0, 50.0);
+ std::uniform_real_distribution<double> distribution_params(1e-10, 2.50);
+
+ for(int ii = 0; ii < 90; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("(-inf, inf)"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("(0.0, 50.0]"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = distribution_params(generator);
+ _alpha = distribution_params(generator);
+ _prop = std::vector<double>(90, 0.0);
+ allowed_op_funcs::cb(90, _phi[1]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _exp_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(CbParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateCbParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (CbParamNode created with an absolute value above the upper bound)";
+
+ generateCbParamNode(_phi, _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (CbParamNode created with an absolute value below the lower bound)";
+
+ // generateCbParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ // EXPECT_EQ(_phi.size(), 2) << " (CbParamNode created with a negative valued feature in the denominator)";
+
+ generateCbParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-10);
+ }
+
+ TEST_F(CbParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _exp_test = std::make_shared<CbParamNode>(_phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (CbParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _exp_test = std::make_shared<CbParamNode>(_phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_TRUE(false) << " (CbParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ // try
+ // {
+ // _exp_test = std::make_shared<CbParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+ // EXPECT_TRUE(false) << " (CbParamNode created with a negative valued feature in the denominator)";
+ // }
+ // catch(const InvalidFeatureException& e)
+ // {}
+
+ try
+ {
+ _exp_test = std::make_shared<CbParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _exp_test->value_ptr(), 90), 1e-10);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(CbParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _exp_test = std::make_shared<CbParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_exp_test->rung(), 1);
+
+ std::vector<double> expected_val(90, 0.0);
+
+ allowed_op_funcs::cb(90, _phi[1]->value_ptr(), _exp_test->parameters()[0], _exp_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_exp_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_exp_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::cb(10, _phi[1]->test_value_ptr(), _exp_test->parameters()[0], _exp_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_exp_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_exp_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "1|cb:" <<_exp_test->parameters()[0] << ',' << _exp_test->parameters()[1];
+ EXPECT_STREQ(_exp_test->unit().toString().c_str(), "s^3");
+ EXPECT_STREQ(_exp_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_cbrt_node.cc b/tests/googletest/feature_creation/parameterization/test_cbrt_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..eb154638e1b4cf5bd08fa2bf270bc852246e8369
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_cbrt_node.cc
@@ -0,0 +1,144 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/cbrt/parameterized_cube_root.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class CbrtParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(90, 10, 3);
+
+ _task_sizes_train = {90};
+
+ std::vector<double> value_1(90, 0.0);
+ std::vector<double> value_2(90, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-50.0, 50.0);
+ std::uniform_real_distribution<double> distribution_params(1e-10, 2.50);
+
+ for(int ii = 0; ii < 90; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("(-inf, inf)"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("(0.0, 50.0]"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = distribution_params(generator);
+ _alpha = distribution_params(generator);
+ _prop = std::vector<double>(90, 0.0);
+ allowed_op_funcs::cbrt(90, _phi[1]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _cbrt_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(CbrtParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateCbrtParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (CbrtParamNode created with an absolute value above the upper bound)";
+
+ generateCbrtParamNode(_phi, _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (CbrtParamNode created with an absolute value below the lower bound)";
+
+ generateCbrtParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (CbrtParamNode created with a negative valued feature in the denominator)";
+
+ generateCbrtParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-10);
+ }
+
+ TEST_F(CbrtParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _cbrt_test = std::make_shared<CbrtParamNode>(_phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (CbrtParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _cbrt_test = std::make_shared<CbrtParamNode>(_phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_TRUE(false) << " (CbrtParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _cbrt_test = std::make_shared<CbrtParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_TRUE(false) << " (CbrtParamNode created with a negative valued feature in the denominator)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _cbrt_test = std::make_shared<CbrtParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _cbrt_test->value_ptr(), 90), 1e-10);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(CbrtParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _cbrt_test = std::make_shared<CbrtParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_cbrt_test->rung(), 1);
+
+ std::vector<double> expected_val(90, 0.0);
+
+ allowed_op_funcs::cbrt(90, _phi[1]->value_ptr(), _cbrt_test->parameters()[0], _cbrt_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_cbrt_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_cbrt_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::cbrt(10, _phi[1]->test_value_ptr(), _cbrt_test->parameters()[0], _cbrt_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_cbrt_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_cbrt_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "1|cbrt:" <<_cbrt_test->parameters()[0] << ',' << _cbrt_test->parameters()[1];
+ EXPECT_STREQ(_cbrt_test->unit().toString().c_str(), "s^0.333333");
+ EXPECT_STREQ(_cbrt_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_cos_node.cc b/tests/googletest/feature_creation/parameterization/test_cos_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..71b53f487bdcdfd95b32568f931623360f692171
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_cos_node.cc
@@ -0,0 +1,144 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/cos/parameterized_cos.hpp>
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/sin/parameterized_sin.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class CosParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(900, 10, 3);
+
+ _task_sizes_train = {900};
+
+ std::vector<double> value_1(900, 0.0);
+ std::vector<double> value_2(900, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-6.23, 6.23);
+
+ for(int ii = 0; ii < 900; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = distribution_feats(generator);
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = distribution_feats(generator);
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("(-6.23, 6.23)"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("(-6.23, 6.23)"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = 0.143;
+ _alpha = 1.05;
+ _prop = std::vector<double>(900, 0.0);
+ allowed_op_funcs::cos(900, _phi[0]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _cos_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(CosParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateCosParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (CosParamNode created with an absolute value above the upper bound)";
+
+ generateCosParamNode(_phi, _phi[0], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (CosParamNode created with an absolute value below the lower bound)";
+
+ // generateCosParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ // EXPECT_EQ(_phi.size(), 2) << " (CosParamNode created with a negative valued feature in the denominator)";
+
+ generateCosParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-5);
+ }
+
+ TEST_F(CosParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _cos_test = std::make_shared<CosParamNode>(_phi[0], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (CosParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _cos_test = std::make_shared<CosParamNode>(_phi[0], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_TRUE(false) << " (CosParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ // try
+ // {
+ // _cos_test = std::make_shared<CosParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+ // EXPECT_TRUE(false) << " (CosParamNode created with a negative valued feature in the denominator)";
+ // }
+ // catch(const InvalidFeatureException& e)
+ // {}
+
+ try
+ {
+ _cos_test = std::make_shared<CosParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _cos_test->value_ptr(), 90), 1e-5);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(CosParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _cos_test = std::make_shared<CosParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_cos_test->rung(), 1);
+
+ std::vector<double> expected_val(900, 0.0);
+
+ allowed_op_funcs::cos(900, _phi[1]->value_ptr(), _cos_test->parameters()[0], _cos_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_cos_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_cos_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::cos(10, _phi[1]->test_value_ptr(), _cos_test->parameters()[0], _cos_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_cos_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_cos_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "1|cos:" <<_cos_test->parameters()[0] << ',' << _cos_test->parameters()[1];
+ EXPECT_STREQ(_cos_test->unit().toString().c_str(), "Unitless");
+ EXPECT_STREQ(_cos_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_div_node.cc b/tests/googletest/feature_creation/parameterization/test_div_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a7e0b26b20d4385e224c0bf293679fcb59d906a6
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_div_node.cc
@@ -0,0 +1,144 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/div/parameterized_divide.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class DivParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(90, 10, 3);
+
+ _task_sizes_train = {90};
+
+ std::vector<double> value_1(90, 0.0);
+ std::vector<double> value_2(90, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-50.0, 50.0);
+ std::uniform_real_distribution<double> distribution_params(1e-10, 2.50);
+
+ for(int ii = 0; ii < 90; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("(-inf, inf)"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("(0.0, 50.0]"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = distribution_params(generator);
+ _alpha = distribution_params(generator);
+ _prop = std::vector<double>(90, 0.0);
+ allowed_op_funcs::div(90, _phi[0]->value_ptr(), _phi[1]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _div_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(DivParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateDivParamNode(_phi, _phi[0], _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (DivParamNode created with an absolute value above the upper bound)";
+
+ generateDivParamNode(_phi, _phi[0], _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (DivParamNode created with an absolute value below the lower bound)";
+
+ generateDivParamNode(_phi, _phi[1], _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (DivParamNode created with a zero valued feature in the denominator)";
+
+ generateDivParamNode(_phi, _phi[0], _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-10);
+ }
+
+ TEST_F(DivParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _div_test = std::make_shared<DivParamNode>(_phi[0], _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (DivParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _div_test = std::make_shared<DivParamNode>(_phi[0], _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_TRUE(false) << " (DivParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _div_test = std::make_shared<DivParamNode>(_phi[1], _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_TRUE(false) << " (DivParamNode created with a zero valued feature in the denominator)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _div_test = std::make_shared<DivParamNode>(_phi[0], _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _div_test->value_ptr(), 90), 1e-10);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(DivParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _div_test = std::make_shared<DivParamNode>(_phi[0], _phi[1], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_div_test->rung(), 1);
+
+ std::vector<double> expected_val(90, 0.0);
+
+ allowed_op_funcs::div(90, _phi[0]->value_ptr(), _phi[1]->value_ptr(), _div_test->parameters()[0], _div_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_div_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_div_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::div(10, _phi[0]->test_value_ptr(), _phi[1]->test_value_ptr(), _div_test->parameters()[0], _div_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_div_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_div_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "0|1|div:" <<_div_test->parameters()[0] << ',' << _div_test->parameters()[1];
+ EXPECT_STREQ(_div_test->unit().toString().c_str(), "m * s^-1");
+ EXPECT_STREQ(_div_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_exp_node.cc b/tests/googletest/feature_creation/parameterization/test_exp_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..57c316921693b0b1c0d244d8fe4b25e884180d82
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_exp_node.cc
@@ -0,0 +1,146 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/exp/parameterized_exponential.hpp>
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/log/parameterized_log.hpp>
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/neg_exp/parameterized_negative_exponential.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class ExpParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(90, 10, 3);
+
+ _task_sizes_train = {90};
+
+ std::vector<double> value_1(90, 0.0);
+ std::vector<double> value_2(90, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-50.0, 50.0);
+ std::uniform_real_distribution<double> distribution_params(1e-10, 2.50);
+
+ for(int ii = 0; ii < 90; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("(-inf, inf)"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("(0.0, 50.0]"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = distribution_params(generator);
+ _alpha = distribution_params(generator);
+ _prop = std::vector<double>(90, 0.0);
+ allowed_op_funcs::exp(90, _phi[1]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _exp_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(ExpParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateExpParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (ExpParamNode created with an absolute value above the upper bound)";
+
+ generateExpParamNode(_phi, _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (ExpParamNode created with an absolute value below the lower bound)";
+
+ // generateExpParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ // EXPECT_EQ(_phi.size(), 2) << " (ExpParamNode created with a negative valued feature in the denominator)";
+
+ generateExpParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-10);
+ }
+
+ TEST_F(ExpParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _exp_test = std::make_shared<ExpParamNode>(_phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (ExpParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _exp_test = std::make_shared<ExpParamNode>(_phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_TRUE(false) << " (ExpParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ // try
+ // {
+ // _exp_test = std::make_shared<ExpParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+ // EXPECT_TRUE(false) << " (ExpParamNode created with a negative valued feature in the denominator)";
+ // }
+ // catch(const InvalidFeatureException& e)
+ // {}
+
+ try
+ {
+ _exp_test = std::make_shared<ExpParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _exp_test->value_ptr(), 90), 1e-10);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(ExpParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _exp_test = std::make_shared<ExpParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_exp_test->rung(), 1);
+
+ std::vector<double> expected_val(90, 0.0);
+
+ allowed_op_funcs::exp(90, _phi[1]->value_ptr(), _exp_test->parameters()[0], _exp_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_exp_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_exp_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::exp(10, _phi[1]->test_value_ptr(), _exp_test->parameters()[0], _exp_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_exp_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_exp_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "1|exp:" <<_exp_test->parameters()[0] << ',' << _exp_test->parameters()[1];
+ EXPECT_STREQ(_exp_test->unit().toString().c_str(), "Unitless");
+ EXPECT_STREQ(_exp_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_inv_node.cc b/tests/googletest/feature_creation/parameterization/test_inv_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ec32644a7a4a618f2e8085981d0ab0fe25233f24
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_inv_node.cc
@@ -0,0 +1,144 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/inv/parameterized_inverse.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class InvParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(90, 10, 3);
+
+ _task_sizes_train = {90};
+
+ std::vector<double> value_1(90, 0.0);
+ std::vector<double> value_2(90, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-50.0, 50.0);
+ std::uniform_real_distribution<double> distribution_params(1e-10, 2.50);
+
+ for(int ii = 0; ii < 90; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("(-inf, inf)"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("(0.0, 50.0]"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = distribution_params(generator);
+ _alpha = distribution_params(generator);
+ _prop = std::vector<double>(90, 0.0);
+ allowed_op_funcs::inv(90, _phi[1]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _inv_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(InvParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateInvParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (InvParamNode created with an absolute value above the upper bound)";
+
+ generateInvParamNode(_phi, _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (InvParamNode created with an absolute value below the lower bound)";
+
+ generateInvParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (InvParamNode created with a zero valued feature in the denominator)";
+
+ generateInvParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-10);
+ }
+
+ TEST_F(InvParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _inv_test = std::make_shared<InvParamNode>(_phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (InvParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _inv_test = std::make_shared<InvParamNode>(_phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_TRUE(false) << " (InvParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _inv_test = std::make_shared<InvParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_TRUE(false) << " (InvParamNode created with a zero valued feature in the denominator)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _inv_test = std::make_shared<InvParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _inv_test->value_ptr(), 90), 1e-10);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(InvParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _inv_test = std::make_shared<InvParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_inv_test->rung(), 1);
+
+ std::vector<double> expected_val(90, 0.0);
+
+ allowed_op_funcs::inv(90, _phi[1]->value_ptr(), _inv_test->parameters()[0], _inv_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_inv_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_inv_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::inv(10, _phi[1]->test_value_ptr(), _inv_test->parameters()[0], _inv_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_inv_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_inv_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "1|inv:" <<_inv_test->parameters()[0] << ',' << _inv_test->parameters()[1];
+ EXPECT_STREQ(_inv_test->unit().toString().c_str(), "s^-1");
+ EXPECT_STREQ(_inv_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_log_node.cc b/tests/googletest/feature_creation/parameterization/test_log_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..54f454bc1469ce35f94a06d1dce17cced5263982
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_log_node.cc
@@ -0,0 +1,144 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/log/parameterized_log.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class LogParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(90, 10, 3);
+
+ _task_sizes_train = {90};
+
+ std::vector<double> value_1(90, 0.0);
+ std::vector<double> value_2(90, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-50.0, 50.0);
+ std::uniform_real_distribution<double> distribution_params(1e-10, 2.50);
+
+ for(int ii = 0; ii < 90; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("(-inf, inf)"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("(0.0, 50.0]"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = distribution_params(generator);
+ _alpha = distribution_params(generator);
+ _prop = std::vector<double>(90, 0.0);
+ allowed_op_funcs::log(90, _phi[1]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _log_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(LogParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateLogParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (LogParamNode created with an absolute value above the upper bound)";
+
+ generateLogParamNode(_phi, _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (LogParamNode created with an absolute value below the lower bound)";
+
+ generateLogParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (LogParamNode created with a negative valued feature in the denominator)";
+
+ generateLogParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-10);
+ }
+
+ TEST_F(LogParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _log_test = std::make_shared<LogParamNode>(_phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (LogParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _log_test = std::make_shared<LogParamNode>(_phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_TRUE(false) << " (LogParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _log_test = std::make_shared<LogParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_TRUE(false) << " (LogParamNode created with a negative valued feature in the denominator)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _log_test = std::make_shared<LogParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _log_test->value_ptr(), 90), 1e-10);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(LogParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _log_test = std::make_shared<LogParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_log_test->rung(), 1);
+
+ std::vector<double> expected_val(90, 0.0);
+
+ allowed_op_funcs::log(90, _phi[1]->value_ptr(), _log_test->parameters()[0], _log_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_log_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_log_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::log(10, _phi[1]->test_value_ptr(), _log_test->parameters()[0], _log_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_log_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_log_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "1|log:" <<_log_test->parameters()[0] << ',' << _log_test->parameters()[1];
+ EXPECT_STREQ(_log_test->unit().toString().c_str(), "Unitless");
+ EXPECT_STREQ(_log_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_mult_node.cc b/tests/googletest/feature_creation/parameterization/test_mult_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c5d743e4852010ffbee087fbcdb63aa3b35c45c4
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_mult_node.cc
@@ -0,0 +1,133 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/mult/parameterized_multiply.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class MultParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(90, 10, 3);
+
+ _task_sizes_train = {90};
+
+ std::vector<double> value_1(90, 0.0);
+ std::vector<double> value_2(90, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-50.0, 50.0);
+ std::uniform_real_distribution<double> distribution_params(-2.50, 2.50);
+
+ for(int ii = 0; ii < 90; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = distribution_feats(generator);
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = distribution_feats(generator);
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("[-50.0, 50.0]"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("[-50.0, 50.0]"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = distribution_params(generator);
+ _alpha = distribution_params(generator);
+ _prop = std::vector<double>(90, 0.0);
+ allowed_op_funcs::mult(90, _phi[0]->value_ptr(), _phi[1]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _mult_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(MultParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateMultParamNode(_phi, _phi[0], _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (MultParamNode created with an absolute value above the upper bound)";
+
+ generateMultParamNode(_phi, _phi[0], _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (MultParamNode created with an absolute value below the lower bound)";
+
+ generateMultParamNode(_phi, _phi[0], _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-10);
+ }
+
+ TEST_F(MultParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _mult_test = std::make_shared<MultParamNode>(_phi[0], _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (MultParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _mult_test = std::make_shared<MultParamNode>(_phi[0], _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_TRUE(false) << " (MultParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _mult_test = std::make_shared<MultParamNode>(_phi[0], _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _mult_test->value_ptr(), 90), 1e-10);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(MultParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _mult_test = std::make_shared<MultParamNode>(_phi[0], _phi[1], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_mult_test->rung(), 1);
+
+ std::vector<double> expected_val(90, 0.0);
+
+ allowed_op_funcs::mult(90, _phi[0]->value_ptr(), _phi[1]->value_ptr(), _mult_test->parameters()[0], _mult_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_mult_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_mult_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::mult(10, _phi[0]->test_value_ptr(), _phi[1]->test_value_ptr(), _mult_test->parameters()[0], _mult_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_mult_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_mult_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "0|1|mult:" <<_mult_test->parameters()[0] << ',' << _mult_test->parameters()[1];
+ EXPECT_STREQ(_mult_test->unit().toString().c_str(), "m * s");
+ EXPECT_STREQ(_mult_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_neg_exp_node.cc b/tests/googletest/feature_creation/parameterization/test_neg_exp_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..90117c855a91d15b89a7d169c3a82f9fa7bd98ad
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_neg_exp_node.cc
@@ -0,0 +1,146 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/exp/parameterized_exponential.hpp>
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/log/parameterized_log.hpp>
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/neg_exp/parameterized_negative_exponential.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class NegExpParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(90, 10, 3);
+
+ _task_sizes_train = {90};
+
+ std::vector<double> value_1(90, 0.0);
+ std::vector<double> value_2(90, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-50.0, 50.0);
+ std::uniform_real_distribution<double> distribution_params(1e-10, 2.50);
+
+ for(int ii = 0; ii < 90; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("(-inf, inf)"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("(0.0, 50.0]"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = distribution_params(generator);
+ _alpha = distribution_params(generator);
+ _prop = std::vector<double>(90, 0.0);
+ allowed_op_funcs::neg_exp(90, _phi[1]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _exp_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(NegExpParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateNegExpParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (NegExpParamNode created with an absolute value above the upper bound)";
+
+ generateNegExpParamNode(_phi, _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (NegExpParamNode created with an absolute value below the lower bound)";
+
+ // generateNegExpParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ // EXPECT_EQ(_phi.size(), 2) << " (NegExpParamNode created with a negative valued feature in the denominator)";
+
+ generateNegExpParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-10);
+ }
+
+ TEST_F(NegExpParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _exp_test = std::make_shared<NegExpParamNode>(_phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (NegExpParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _exp_test = std::make_shared<NegExpParamNode>(_phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_TRUE(false) << " (NegExpParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ // try
+ // {
+ // _exp_test = std::make_shared<NegExpParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+ // EXPECT_TRUE(false) << " (NegExpParamNode created with a negative valued feature in the denominator)";
+ // }
+ // catch(const InvalidFeatureException& e)
+ // {}
+
+ try
+ {
+ _exp_test = std::make_shared<NegExpParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _exp_test->value_ptr(), 90), 1e-10);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(NegExpParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _exp_test = std::make_shared<NegExpParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_exp_test->rung(), 1);
+
+ std::vector<double> expected_val(90, 0.0);
+
+ allowed_op_funcs::neg_exp(90, _phi[1]->value_ptr(), _exp_test->parameters()[0], _exp_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_exp_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_exp_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::neg_exp(10, _phi[1]->test_value_ptr(), _exp_test->parameters()[0], _exp_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_exp_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_exp_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "1|nexp:" <<_exp_test->parameters()[0] << ',' << _exp_test->parameters()[1];
+ EXPECT_STREQ(_exp_test->unit().toString().c_str(), "Unitless");
+ EXPECT_STREQ(_exp_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_sin_node.cc b/tests/googletest/feature_creation/parameterization/test_sin_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..54ed0a058f48eda0e12872fc7edfd1ef15a75de1
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_sin_node.cc
@@ -0,0 +1,144 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/cos/parameterized_cos.hpp>
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/sin/parameterized_sin.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class SinParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(900, 10, 3);
+
+ _task_sizes_train = {900};
+
+ std::vector<double> value_1(900, 0.0);
+ std::vector<double> value_2(900, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-6.23, 6.23);
+
+ for(int ii = 0; ii < 900; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = distribution_feats(generator);
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = distribution_feats(generator);
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("(-6.23, 6.23)"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("(-6.23, 6.23)"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = 0.143;
+ _alpha = 1.05;
+ _prop = std::vector<double>(900, 0.0);
+ allowed_op_funcs::sin(900, _phi[0]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _sin_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(SinParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateSinParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (SinParamNode created with an absolute value above the upper bound)";
+
+ generateSinParamNode(_phi, _phi[0], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (SinParamNode created with an absolute value below the lower bound)";
+
+ // generateSinParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ // EXPECT_EQ(_phi.size(), 2) << " (SinParamNode created with a negative valued feature in the denominator)";
+
+ generateSinParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-5);
+ }
+
+ TEST_F(SinParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _sin_test = std::make_shared<SinParamNode>(_phi[0], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (SinParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _sin_test = std::make_shared<SinParamNode>(_phi[0], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_TRUE(false) << " (SinParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ // try
+ // {
+ // _sin_test = std::make_shared<SinParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+ // EXPECT_TRUE(false) << " (SinParamNode created with a negative valued feature in the denominator)";
+ // }
+ // catch(const InvalidFeatureException& e)
+ // {}
+
+ try
+ {
+ _sin_test = std::make_shared<SinParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _sin_test->value_ptr(), 90), 1e-5);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(SinParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _sin_test = std::make_shared<SinParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_sin_test->rung(), 1);
+
+ std::vector<double> expected_val(900, 0.0);
+
+ allowed_op_funcs::sin(900, _phi[0]->value_ptr(), _sin_test->parameters()[0], _sin_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_sin_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_sin_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::sin(10, _phi[0]->test_value_ptr(), _sin_test->parameters()[0], _sin_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_sin_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_sin_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "0|sin:" <<_sin_test->parameters()[0] << ',' << _sin_test->parameters()[1];
+ EXPECT_STREQ(_sin_test->unit().toString().c_str(), "Unitless");
+ EXPECT_STREQ(_sin_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_six_pow_node.cc b/tests/googletest/feature_creation/parameterization/test_six_pow_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..62671fdd8f08c5d8f46c9644933e63280ba87f7b
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_six_pow_node.cc
@@ -0,0 +1,144 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/six_pow/parameterized_sixth_power.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class SixPowParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(90, 10, 3);
+
+ _task_sizes_train = {90};
+
+ std::vector<double> value_1(90, 0.0);
+ std::vector<double> value_2(90, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-50.0, 50.0);
+ std::uniform_real_distribution<double> distribution_params(1e-10, 2.50);
+
+ for(int ii = 0; ii < 90; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("(-inf, inf)"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("(0.0, 50.0]"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = distribution_params(generator);
+ _alpha = distribution_params(generator);
+ _prop = std::vector<double>(90, 0.0);
+ allowed_op_funcs::sixth_pow(90, _phi[1]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _exp_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(SixPowParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateSixPowParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (SixPowParamNode created with an absolute value above the upper bound)";
+
+ generateSixPowParamNode(_phi, _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (SixPowParamNode created with an absolute value below the lower bound)";
+
+ // generateSixPowParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ // EXPECT_EQ(_phi.size(), 2) << " (SixPowParamNode created with a negative valued feature in the denominator)";
+
+ generateSixPowParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-10);
+ }
+
+ TEST_F(SixPowParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _exp_test = std::make_shared<SixPowParamNode>(_phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (SixPowParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _exp_test = std::make_shared<SixPowParamNode>(_phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_TRUE(false) << " (SixPowParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ // try
+ // {
+ // _exp_test = std::make_shared<SixPowParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+ // EXPECT_TRUE(false) << " (SixPowParamNode created with a negative valued feature in the denominator)";
+ // }
+ // catch(const InvalidFeatureException& e)
+ // {}
+
+ try
+ {
+ _exp_test = std::make_shared<SixPowParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _exp_test->value_ptr(), 90), 1e-10);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(SixPowParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _exp_test = std::make_shared<SixPowParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_exp_test->rung(), 1);
+
+ std::vector<double> expected_val(90, 0.0);
+
+ allowed_op_funcs::sixth_pow(90, _phi[1]->value_ptr(), _exp_test->parameters()[0], _exp_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_exp_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_exp_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::sixth_pow(10, _phi[1]->test_value_ptr(), _exp_test->parameters()[0], _exp_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_exp_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_exp_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "1|sp:" <<_exp_test->parameters()[0] << ',' << _exp_test->parameters()[1];
+ EXPECT_STREQ(_exp_test->unit().toString().c_str(), "s^6");
+ EXPECT_STREQ(_exp_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_sq_node.cc b/tests/googletest/feature_creation/parameterization/test_sq_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..11d640c3a6f25f8ea334c308482bb40b1d0dfb87
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_sq_node.cc
@@ -0,0 +1,144 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/sq/parameterized_square.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class SqParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(90, 10, 3);
+
+ _task_sizes_train = {90};
+
+ std::vector<double> value_1(90, 0.0);
+ std::vector<double> value_2(90, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-50.0, 50.0);
+ std::uniform_real_distribution<double> distribution_params(1e-10, 2.50);
+
+ for(int ii = 0; ii < 90; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("(-inf, inf)"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("(0.0, 50.0]"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = distribution_params(generator);
+ _alpha = distribution_params(generator);
+ _prop = std::vector<double>(90, 0.0);
+ allowed_op_funcs::sq(90, _phi[1]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _exp_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(SqParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateSqParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (SqParamNode created with an absolute value above the upper bound)";
+
+ generateSqParamNode(_phi, _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (SqParamNode created with an absolute value below the lower bound)";
+
+ // generateSqParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ // EXPECT_EQ(_phi.size(), 2) << " (SqParamNode created with a negative valued feature in the denominator)";
+
+ generateSqParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-10);
+ }
+
+ TEST_F(SqParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _exp_test = std::make_shared<SqParamNode>(_phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (SqParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _exp_test = std::make_shared<SqParamNode>(_phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_TRUE(false) << " (SqParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ // try
+ // {
+ // _exp_test = std::make_shared<SqParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+ // EXPECT_TRUE(false) << " (SqParamNode created with a negative valued feature in the denominator)";
+ // }
+ // catch(const InvalidFeatureException& e)
+ // {}
+
+ try
+ {
+ _exp_test = std::make_shared<SqParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _exp_test->value_ptr(), 90), 1e-10);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(SqParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _exp_test = std::make_shared<SqParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_exp_test->rung(), 1);
+
+ std::vector<double> expected_val(90, 0.0);
+
+ allowed_op_funcs::sq(90, _phi[1]->value_ptr(), _exp_test->parameters()[0], _exp_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_exp_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_exp_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::sq(10, _phi[1]->test_value_ptr(), _exp_test->parameters()[0], _exp_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_exp_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_exp_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "1|sq:" <<_exp_test->parameters()[0] << ',' << _exp_test->parameters()[1];
+ EXPECT_STREQ(_exp_test->unit().toString().c_str(), "s^2");
+ EXPECT_STREQ(_exp_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_sqrt_node.cc b/tests/googletest/feature_creation/parameterization/test_sqrt_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..882de5340b2fd168cd7c56a9a70353b390db4ef4
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_sqrt_node.cc
@@ -0,0 +1,144 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/sqrt/parameterized_square_root.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class SqrtParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(90, 10, 3);
+
+ _task_sizes_train = {90};
+
+ std::vector<double> value_1(90, 0.0);
+ std::vector<double> value_2(90, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-50.0, 50.0);
+ std::uniform_real_distribution<double> distribution_params(1e-10, 2.50);
+
+ for(int ii = 0; ii < 90; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = std::abs(distribution_feats(generator)) + 1e-10;
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("(-inf, inf)"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("(0.0, 50.0]"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = distribution_params(generator);
+ _alpha = distribution_params(generator);
+ _prop = std::vector<double>(90, 0.0);
+ allowed_op_funcs::sqrt(90, _phi[1]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _sqrt_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(SqrtParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateSqrtParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (SqrtParamNode created with an absolute value above the upper bound)";
+
+ generateSqrtParamNode(_phi, _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (SqrtParamNode created with an absolute value below the lower bound)";
+
+ generateSqrtParamNode(_phi, _phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (SqrtParamNode created with a negative valued feature in the denominator)";
+
+ generateSqrtParamNode(_phi, _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-10);
+ }
+
+ TEST_F(SqrtParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _sqrt_test = std::make_shared<SqrtParamNode>(_phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (SqrtParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _sqrt_test = std::make_shared<SqrtParamNode>(_phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_TRUE(false) << " (SqrtParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _sqrt_test = std::make_shared<SqrtParamNode>(_phi[0], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_TRUE(false) << " (SqrtParamNode created with a negative valued feature in the denominator)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _sqrt_test = std::make_shared<SqrtParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _sqrt_test->value_ptr(), 90), 1e-10);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(SqrtParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _sqrt_test = std::make_shared<SqrtParamNode>(_phi[1], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_sqrt_test->rung(), 1);
+
+ std::vector<double> expected_val(90, 0.0);
+
+ allowed_op_funcs::sqrt(90, _phi[1]->value_ptr(), _sqrt_test->parameters()[0], _sqrt_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_sqrt_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_sqrt_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::sqrt(10, _phi[1]->test_value_ptr(), _sqrt_test->parameters()[0], _sqrt_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_sqrt_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_sqrt_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "1|sqrt:" <<_sqrt_test->parameters()[0] << ',' << _sqrt_test->parameters()[1];
+ EXPECT_STREQ(_sqrt_test->unit().toString().c_str(), "s^0.5");
+ EXPECT_STREQ(_sqrt_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}
diff --git a/tests/googletest/feature_creation/parameterization/test_sub_node.cc b/tests/googletest/feature_creation/parameterization/test_sub_node.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d6cfb80d2202409ed7a939f6908823da5efffdf4
--- /dev/null
+++ b/tests/googletest/feature_creation/parameterization/test_sub_node.cc
@@ -0,0 +1,133 @@
+#include <feature_creation/node/operator_nodes/allowed_operator_nodes/sub/parameterized_subtract.hpp>
+#include <feature_creation/node/value_storage/nodes_value_containers.hpp>
+#include <feature_creation/node/FeatureNode.hpp>
+#include "gtest/gtest.h"
+
+#include <random>
+
+namespace
+{
+ class SubParamNodeTest : public ::testing::Test
+ {
+ protected:
+ void SetUp() override
+ {
+ node_value_arrs::initialize_values_arr(90, 10, 3);
+
+ _task_sizes_train = {90};
+
+ std::vector<double> value_1(90, 0.0);
+ std::vector<double> value_2(90, 0.0);
+
+ std::vector<double> test_value_1(10, 0.0);
+ std::vector<double> test_value_2(10, 0.0);
+
+ std::default_random_engine generator;
+ std::uniform_real_distribution<double> distribution_feats(-50.0, 50.0);
+ std::uniform_real_distribution<double> distribution_params(-2.50, 2.50);
+
+ for(int ii = 0; ii < 90; ++ii)
+ {
+ value_1[ii] = distribution_feats(generator);
+ value_2[ii] = distribution_feats(generator);
+ }
+
+ for(int ii = 0; ii < 10; ++ii)
+ {
+ test_value_1[ii] = distribution_feats(generator);
+ test_value_2[ii] = distribution_feats(generator);
+ }
+
+ _feat_1 = std::make_shared<FeatureNode>(0, "A", value_1, test_value_1, Domain("[-50.0, 50.0]"), Unit("m"));
+ _feat_2 = std::make_shared<FeatureNode>(1, "B", value_2, test_value_2, Domain("[-50.0, 50.0]"), Unit("s"));
+
+ _phi = {_feat_1, _feat_2};
+ _a = distribution_params(generator);
+ _alpha = distribution_params(generator);
+ _prop = std::vector<double>(90, 0.0);
+ allowed_op_funcs::sub(90, _phi[0]->value_ptr(), _phi[1]->value_ptr(), _alpha, _a, _prop.data());
+
+ nlopt_wrapper::set_objective("regression", _prop.data(), _task_sizes_train);
+ }
+
+ node_ptr _feat_1;
+ node_ptr _feat_2;
+ node_ptr _sub_test;
+
+ std::vector<node_ptr> _phi;
+ std::vector<double> _prop;
+ std::vector<int> _task_sizes_train;
+
+ double _a;
+ double _alpha;
+ };
+
+ TEST_F(SubParamNodeTest, GeneratorTest)
+ {
+ int feat_ind = _phi.size();
+
+ generateSubParamNode(_phi, _phi[0], _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (SubParamNode created with an absolute value above the upper bound)";
+
+ generateSubParamNode(_phi, _phi[0], _phi[1], feat_ind, 1e49, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 2) << " (SubParamNode created with an absolute value below the lower bound)";
+
+ generateSubParamNode(_phi, _phi[0], _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_EQ(_phi.size(), 3) << " (Failure to create a valid feature)";
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _phi.back()->value_ptr(), 90), 1e-10);
+ }
+
+ TEST_F(SubParamNodeTest, ConstructorTest)
+ {
+ int feat_ind = _phi.size();
+
+ try
+ {
+ _sub_test = std::make_shared<SubParamNode>(_phi[0], _phi[1], feat_ind, 1e-50, 1e-40, _prop);
+ EXPECT_TRUE(false) << " (SubParamNode created with an absolute value above the upper bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _sub_test = std::make_shared<SubParamNode>(_phi[0], _phi[1], feat_ind, 1e3, 1e50, _prop);
+ EXPECT_TRUE(false) << " (SubParamNode created with an absolute value below the lower bound)";
+ }
+ catch(const InvalidFeatureException& e)
+ {}
+
+ try
+ {
+ _sub_test = std::make_shared<SubParamNode>(_phi[0], _phi[1], feat_ind, 1e-50, 1e50, _prop);
+ EXPECT_LT(1.0 - util_funcs::r2(_prop.data(), _sub_test->value_ptr(), 90), 1e-10);
+ }
+ catch(const InvalidFeatureException& e)
+ {
+ EXPECT_TRUE(false) << " (Failure to create a valid feature)";
+ }
+ }
+
+ TEST_F(SubParamNodeTest, AttributesTest)
+ {
+ int feat_ind = _phi.size();
+ _sub_test = std::make_shared<SubParamNode>(_phi[0], _phi[1], feat_ind, 1e-50, 1e50, _prop);
+
+ EXPECT_EQ(_sub_test->rung(), 1);
+
+ std::vector<double> expected_val(90, 0.0);
+
+ allowed_op_funcs::sub(90, _phi[0]->value_ptr(), _phi[1]->value_ptr(), _sub_test->parameters()[0], _sub_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_sub_test->value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_sub_test->value()[0] - expected_val[0]), 1e-10);
+
+ allowed_op_funcs::sub(10, _phi[0]->test_value_ptr(), _phi[1]->test_value_ptr(), _sub_test->parameters()[0], _sub_test->parameters()[1], expected_val.data());
+ EXPECT_LT(std::abs(_sub_test->test_value_ptr()[0] - expected_val[0]), 1e-10);
+ EXPECT_LT(std::abs(_sub_test->test_value()[0] - expected_val[0]), 1e-10);
+
+ std::stringstream postfix;
+ postfix << "0|1|sub:" <<_sub_test->parameters()[0] << ',' << _sub_test->parameters()[1];
+ EXPECT_STREQ(_sub_test->unit().toString().c_str(), "m");
+ EXPECT_STREQ(_sub_test->postfix_expr().c_str(), postfix.str().c_str());
+ }
+}