void test_tree() {
TreeNode *tree = (TreeNode*)malloc(sizeof(TreeNode));
int key = 0;
init_tree(key++, 0, 0, tree);
add_left(key++, 0, tree);
add_right(key++, 0, tree);
add_left(key++, 0, tree->left);
add_right(key++, 0, tree->left);
add_left(key++, 0, tree->right);
add_right(key++, 0, tree->right);
add_left(key++, 0, tree->left->left);
print_tree(tree);
std::cout << std::endl;
std::cout << "max depth: " << max_depth(tree, 0) << std::endl;
std::cout << "min depth: " << min_depth(tree, 0) << std::endl;
std::cout << "Is tree balanced? " << (is_tree_balanced(tree) == 1 ? "yes" : "no") << std::endl;
free_tree(tree);
}
int max_depth(TREE* root)
{
if(root == NULL)
return 0;
return 1 + MAX(max_depth(root->left), max_depth(root->right));
}
uint max_depth(node* t) {
if (!t)
return 0;
int ldepth = max_depth(t->left);
int rdepth = max_depth(t->right);
if (ldepth > rdepth)
return ldepth + 1;
return rdepth + 1;
}
int max_depth(node_t *node)
{
if( node == nullptr ) return 0;
int dlhs = max_depth(node->lhs);
int drhs = max_depth(node->rhs);
if( dlhs >= drhs ) return dlhs + 1;
else return drhs + 1 ;
}
int max_depth(bst *b)
{
if(b->left==NULL && b->right==NULL)
return 0;
int ld,rd;
ld=rd=0;
if(b->left)
ld=max_depth(b->left);
if(b->right)
rd=max_depth(b->right);
return 1+ld<rd?rd:ld;
}
// problem 3
int max_depth(struct node *node)
{
if (node == NULL)
return 0;
else if (node->left == NULL && node->right == NULL)
return 1;
int l = max_depth(node->left);
int r = max_depth(node->right);
int depth = l > r ? l : r;
return 1 + depth;
}
int max_depth(treenode_t *tree){
int leftDepth;
int rightDepth;
if (tree == NULL) return 0;
else
{
leftDepth = max_depth(tree->left);
rightDepth = max_depth(tree->right);
if (leftDepth > rightDepth)
return (leftDepth + 1);
else return (rightDepth + 1);
}
}
int max_depth(struct bst *head)
{
struct bst* temp = head;
int val1, val2;
//Assumption it is either got to be the maximum element depth on left subtree
//or minimum on the right subtree. Let's see
if(head == NULL)
return 0;
val1 = max_depth(head -> left);
val2 = max_depth(head -> right);
if(val1 > val2)
return (val1 +1);
return(val2 + 1);
}
int main()
{
insert(50);
insert(30);
insert(20);
insert(40);
insert(70);
insert(60);
insert(80);
inorder(head);
printf("\nMaximum depth %d", max_depth(head));
/*
printf ("Maximum value is %d \n", maximum(head) -> value);
printf("\n");
printf("The successor is %d ", successor(search(head, 40)) -> value);
printf("Deleting 20\n");
head = deletion(head, 20);
printf("\n");
printf("Deleting 30\n");
head = deletion(head, 30);
printf("Deleting 50\n");
head = deletion(head, 50);
inorder(head);
*/
return 0;
}
void GMSHAdaptiveMeshDensity::getSteinerPoints (std::vector<GeoLib::Point*> & pnts,
std::size_t additional_levels) const
{
// get Steiner points
std::size_t max_depth(0);
_quad_tree->getMaxDepth(max_depth);
std::list<GeoLib::QuadTree<GeoLib::Point>*> leaf_list;
_quad_tree->getLeafs(leaf_list);
for (std::list<GeoLib::QuadTree<GeoLib::Point>*>::const_iterator it(leaf_list.begin()); it
!= leaf_list.end(); ++it) {
if ((*it)->getPoints().empty()) {
// compute point from square
GeoLib::Point ll, ur;
(*it)->getSquarePoints(ll, ur);
if ((*it)->getDepth() + additional_levels > max_depth) {
additional_levels = max_depth - (*it)->getDepth();
}
const std::size_t n_pnts_per_quad_dim = 1 << additional_levels;
const double delta ((ur[0] - ll[0]) / (2 * n_pnts_per_quad_dim));
for (std::size_t i(0); i<n_pnts_per_quad_dim; i++) {
for (std::size_t j(0); j<n_pnts_per_quad_dim; j++) {
pnts.push_back(new GeoLib::Point (ll[0] + (2*i+1) * delta, ll[1] + (2*j+1) * delta, 0.0));
}
}
}
}
}
inline order::result lpo::compare_core(expr_offset s, expr_offset t, unsigned depth) {
s = find(s);
t = find(t);
if (max_depth(depth))
return UNKNOWN;
if (is_var(s.get_expr()))
return s == t ? EQUAL : UNCOMPARABLE;
else if (is_var(t.get_expr()))
return occurs(t, s) ? GREATER : UNCOMPARABLE;
else {
func_decl * f = to_app(s.get_expr())->get_decl();
func_decl * g = to_app(t.get_expr())->get_decl();
if (f_greater(f, g))
return dominates_args(s, t, depth) ? GREATER : NOT_GTEQ;
else if (f != g)
return arg_dominates_expr(s, t, depth) ? GREATER : NOT_GTEQ;
else {
result r = lex_compare(s, t, depth);
if (r == GREATER) {
if (dominates_args(s, t, depth))
return GREATER;
}
else if (r == EQUAL)
return EQUAL;
return to_app(s.get_expr())->get_num_args() > 1 && arg_dominates_expr(s, t, depth) ? GREATER : NOT_GTEQ;
}
}
}
quakelib::Vec<3> quakelib::SimElement::calc_dudy(const Vec<3> &location, const double &unit_slip, const double &loc_lambda, const double &loc_mu) const throw(std::invalid_argument) {
Okada block_okada;
double US, UD, UT, L, W, c, cos_result, sin_result;
if (loc_lambda <= 0 || loc_mu <= 0) {
throw std::invalid_argument("Lambda and mu must be greater than zero.");
}
if (!_is_quad) {
throw std::invalid_argument("Stress tensor calculation currently only supported for rectangular elements.");
}
cos_result = cos(rake());
sin_result = sin(rake());
if (fabs(cos_result) < TRIG_TOLERANCE) {
cos_result = 0.0;
}
if (fabs(sin_result) < TRIG_TOLERANCE) {
sin_result = 0.0;
}
US = unit_slip * cos_result;
UD = unit_slip * sin_result;
UT = 0.0;
L = (_vert[2] - _vert[0]).mag();
W = (_vert[1] - _vert[0]).mag();
c = fabs(max_depth());
return block_okada.calc_dudy(location, c, dip(), L, W, US, UD, UT, loc_lambda, loc_mu);
}
int
max_depth (struct node *root)
{
int depth ;
if (!root)
return 0;
else if (!(root->right) && !(root->left))
return 1;
else
depth = 1 + max(max_depth(root->right) , max_depth(root->left));
return depth;
}
int max_depth(tree_node* T)
{
/*
Compute the "max depth" of a tree -- the number of nodes along
the longest path from the root node down to the farthest leaf node
*/
if(T!=NULL)
{
int l_max_depth = max_depth(T->left);
int r_max_depth = max_depth(T->right);
if(l_max_depth >= r_max_depth)
return l_max_depth + 1;
else
return r_max_depth + 1;
}
else
return 0;
}
int is_bst(bst *b)
{
if(!b || (!b->left && !b->right) )
return 1;
int min = min_value(b->left);
int max = max_depth(b->right);
if( !( b->val >= min && b->val < max))
return 0;
return is_bst(b->left) && is_bst(b->right);
}
void display_helper(node* t, int spaces) {
int width = ceil(log10(max_depth(t)+0.01)) + 2;
wchar_t* sp64 = L" ";
if (!t) {
wprintf(L"\n");
return;
}
display_helper(t->right, spaces + width);
wprintf(L"%*.*s%d\n", 0, spaces, sp64, t->data);
display_helper(t->left, spaces + width);
}
void UniformCostSearch::print_frame_data( int frame_number, float elapsed, Action curr_action, std::ostream& output )
{
output << "frame=" << frame_number;
output << ",expanded=" << expanded_nodes();
output << ",generated=" << generated_nodes();
output << ",pruned=" << pruned();
output << ",depth_tree=" << max_depth();
output << ",tree_size=" << num_nodes();
output << ",best_action=" << action_to_string( curr_action );
output << ",branch_reward=" << get_root_value();
output << ",elapsed=" << elapsed << std::endl;
}
int main()
{
char ch;
int ele;
struct node *root = NULL;
int num;
int depth = 0;
int ret;
while(1) {
printf ("I/i to insert\n");
printf ("P/p to print\n");
printf ("C/c to count\n");
printf ("D/d to max_depth\n");
scanf (" %c", &ch);
switch(ch) {
case 'i': case 'I':
printf ("enter ele\n");
scanf("%d", &ele);
root = insert(root, ele);
break;
case 'p': case 'P':
print_tree(root);
break;
case 'c': case 'C':
num = size(root);
printf ("number of nodes = %d\n", num);
break;
case 'd':
depth = max_depth(root);
printf ("max depth is %d\n", depth);
break;
case 's':
ret = has_path_sum (root, 10);
if (ret == FOUND)
printf ("found\n");
else if (ret == NOT_FOUND)
printf ("not found \n");
else
printf ("unknown\n");
break;
case 't':
print_paths (root);
break;
default: printf ("pls provide proper input\n");
}
}
}
int isBalanced(struct btree *root)
{
if(max_depth(root)-min_depth(root) <= 1)
{
printf("Tree is balanced\n");
return 0;
}
else
{
printf("NOT BALANCED\n");
return 1;
}
}
bool is_balance(TREE* root)
{
int dis;
if(root == NULL)
return true;
dis = max_depth(root) - min(root);
if (dis > 1)
return false;
return is_balance(root->left)&&is_balance(root->right);
}
int max_depth()
{
return max_depth(m_root);
}
int max_depth(struct btree *root)
{
if(root == NULL) {return 0;}
return (1 + max(max_depth(root->left), max_depth(root->right)));
}
/*
* Read the dungeon
*
* The monsters/objects must be loaded in the same order
* that they were stored, since the actual indexes matter.
*
* Note that the size of the dungeon is now hard-coded to
* DUNGEON_HGT by DUNGEON_WID, and any dungeon with another
* size will be silently discarded by this routine.
*
* Note that dungeon objects, including objects held by monsters, are
* placed directly into the dungeon, using "object_copy()", which will
* copy "iy", "ix", and "held_m_idx", leaving "next_o_idx" blank for
* objects held by monsters, since it is not saved in the savefile.
*
* After loading the monsters, the objects being held by monsters are
* linked directly into those monsters.
*/
static errr rd_dungeon(void)
{
int i, y, x;
int by, bx;
s16b town;
s16b dungeon;
s16b depth;
s16b py, px;
s16b ymax, xmax;
byte count;
byte tmp8u;
u16b tmp16u;
u16b limit;
/*** Basic info ***/
/* Header info */
rd_s16b(&depth);
rd_s16b(&dungeon);
rd_s16b(&py);
rd_s16b(&px);
rd_s16b(&ymax);
rd_s16b(&xmax);
rd_s16b(&town);
rd_u16b(&tmp16u);
/* Ignore illegal dungeons */
if (town>=z_info->t_max)
{
note(format("Ignoring illegal dungeon (%d)", dungeon));
return (0);
}
/* Ignore illegal dungeons */
if ((depth < 0) || (depth > max_depth(dungeon)))
{
note(format("Ignoring illegal dungeon depth (%d)", depth));
return (0);
}
/* Ignore illegal dungeons */
if ((ymax != DUNGEON_HGT) || (xmax != DUNGEON_WID))
{
/* XXX XXX XXX */
note(format("Ignoring illegal dungeon size (%d,%d).", ymax, xmax));
return (0);
}
/* Ignore illegal dungeons */
if ((px < 0) || (px >= DUNGEON_WID) ||
(py < 0) || (py >= DUNGEON_HGT))
{
note(format("Ignoring illegal player location (%d,%d).", py, px));
return (1);
}
/*** Run length decoding ***/
/* Load the dungeon data */
for (x = y = 0; y < DUNGEON_HGT; )
{
/* Grab RLE info */
rd_byte(&count);
rd_byte(&tmp8u);
/* Apply the RLE info */
for (i = count; i > 0; i--)
{
/* Extract "info" */
cave_info[y][x] = tmp8u;
/* Advance/Wrap */
if (++x >= DUNGEON_WID)
{
/* Wrap */
x = 0;
/* Advance/Wrap */
if (++y >= DUNGEON_HGT) break;
}
}
}
/* Hack -- not fully dynamic */
dyna_full = FALSE;
/*** Run length decoding ***/
/* Load the dungeon data */
for (x = y = 0; y < DUNGEON_HGT; )
{
/* Grab RLE info */
rd_byte(&count);
if (variant_save_feats) rd_u16b(&tmp16u);
else rd_byte(&tmp8u);
/* Apply the RLE info */
for (i = count; i > 0; i--)
{
/* Save the feat */
if (variant_save_feats) cave_feat[y][x] = tmp16u;
else cave_feat[y][x] = tmp8u;
/* Check for los flag set*/
if (f_info[cave_feat[y][x]].flags1 & (FF1_LOS))
{
cave_info[y][x] &= ~(CAVE_WALL);
}
/* Handle wall grids */
else
{
cave_info[y][x] |= (CAVE_WALL);
}
/* Handle dynamic grids */
if (f_info[cave_feat[y][x]].flags3 & (FF3_DYNAMIC_MASK))
{
if (dyna_n < (DYNA_MAX-1))
{
dyna_g[dyna_n++] = GRID(y,x);
}
else
{
dyna_full = TRUE;
dyna_cent_y = 255;
dyna_cent_x = 255;
}
}
/* Advance/Wrap */
if (++x >= DUNGEON_WID)
{
/* Wrap */
x = 0;
/* Advance/Wrap */
if (++y >= DUNGEON_HGT) break;
}
}
}
/*** Player ***/
/* Fix depth */
if (depth < 1) depth = min_depth(dungeon);
/* Fix depth */
if (depth > max_depth(dungeon)) depth = max_depth(dungeon);
/* Load depth */
p_ptr->depth = depth;
p_ptr->dungeon = dungeon;
p_ptr->town = town;
/* Place player in dungeon */
if (!player_place(py, px))
{
note(format("Cannot place player (%d,%d)!", py, px));
return (-1);
}
/*** Room descriptions ***/
if (!variant_room_info)
{
/* Initialize the room table */
for (by = 0; by < MAX_ROOMS_ROW; by++)
{
for (bx = 0; bx < MAX_ROOMS_COL; bx++)
{
dun_room[by][bx] = 0;
}
}
/* Initialise 'zeroeth' room description */
room_info[0].flags = 0;
}
else
{
for (bx = 0; bx < MAX_ROOMS_ROW; bx++)
{
for (by = 0; by < MAX_ROOMS_COL; by++)
{
rd_byte(&dun_room[bx][by]);
}
}
for (i = 1; i < DUN_ROOMS; i++)
{
int j;
rd_byte(&room_info[i].type);
rd_byte(&room_info[i].flags);
if (room_info[i].type == ROOM_NORMAL)
{
for (j = 0; j < ROOM_DESC_SECTIONS; j++)
{
rd_s16b(&room_info[i].section[j]);
if (room_info[i].section[j] == -1) break;
}
}
}
}
/*** Objects ***/
/* Read the item count */
rd_u16b(&limit);
/* Verify maximum */
if (limit > z_info->o_max)
{
note(format("Too many (%d) object entries!", limit));
return (-1);
}
/* Read the dungeon items */
for (i = 1; i < limit; i++)
{
object_type *i_ptr;
object_type object_type_body;
s16b o_idx;
object_type *o_ptr;
/* Get the object */
i_ptr = &object_type_body;
/* Wipe the object */
object_wipe(i_ptr);
/* Read the item */
if (rd_item(i_ptr))
{
note("Error reading item");
return (-1);
}
/* Make an object */
o_idx = o_pop();
/* Paranoia */
if (o_idx != i)
{
note(format("Cannot place object %d!", i));
return (-1);
}
/* Get the object */
o_ptr = &o_list[o_idx];
/* Structure Copy */
object_copy(o_ptr, i_ptr);
/* Dungeon floor */
if (!i_ptr->held_m_idx)
{
int x = i_ptr->ix;
int y = i_ptr->iy;
/* ToDo: Verify coordinates */
/* Link the object to the pile */
o_ptr->next_o_idx = cave_o_idx[y][x];
/* Link the floor to the object */
cave_o_idx[y][x] = o_idx;
}
}
/*** Monsters ***/
/* Read the monster count */
rd_u16b(&limit);
/* Hack -- verify */
if (limit > z_info->m_max)
{
note(format("Too many (%d) monster entries!", limit));
return (-1);
}
/* Read the monsters */
for (i = 1; i < limit; i++)
{
monster_type *n_ptr;
monster_type monster_type_body;
/* Get local monster */
n_ptr = &monster_type_body;
/* Clear the monster */
(void)WIPE(n_ptr, monster_type);
/* Read the monster */
rd_monster(n_ptr);
/* Place monster in dungeon */
if (monster_place(n_ptr->fy, n_ptr->fx, n_ptr) != i)
{
note(format("Cannot place monster %d", i));
return (-1);
}
}
/*** Holding ***/
/* Reacquire objects */
for (i = 1; i < o_max; ++i)
{
object_type *o_ptr;
monster_type *m_ptr;
/* Get the object */
o_ptr = &o_list[i];
/* Ignore dungeon objects */
if (!o_ptr->held_m_idx) continue;
/* Verify monster index */
if (o_ptr->held_m_idx >= z_info->m_max)
{
note("Invalid monster index");
return (-1);
}
/* Get the monster */
m_ptr = &m_list[o_ptr->held_m_idx];
/* Link the object to the pile */
o_ptr->next_o_idx = m_ptr->hold_o_idx;
/* Link the monster to the object */
m_ptr->hold_o_idx = i;
}
/*** Success ***/
/* The dungeon is ready */
character_dungeon = TRUE;
/* Regenerate town in post 2.9.3 versions */
if (older_than(2, 9, 4) && (p_ptr->depth == 0))
character_dungeon = FALSE;
/* Success */
return (0);
}
void doc_manager::populate(void)
{
add_class_descriptor(ml::k_base);
add_class_descriptors(ml::k_base, {
ml::k_classification,
ml::k_regression
});
add_class_descriptors(ml::k_regression, {
ml::k_ann,
ml::k_linreg,
ml::k_logreg
});
add_class_descriptors(ml::k_classification, {
ml::k_svm,
ml::k_adaboost,
ml::k_anbc,
ml::k_dtw,
ml::k_hmmc,
ml::k_softmax,
ml::k_randforest,
ml::k_mindist,
ml::k_knn,
ml::k_gmm,
ml::k_dtree
});
add_class_descriptors(ml::k_feature_extraction, {
ml::k_peak,
ml::k_minmax,
ml::k_zerox
});
descriptors[ml::k_ann].desc("Artificial Neural Network").url("http://www.nickgillian.com/wiki/pmwiki.php/GRT/MLP");
descriptors[ml::k_linreg].desc("Linear Regression").url("http://www.nickgillian.com/wiki/pmwiki.php/GRT/LinearRegression");
descriptors[ml::k_logreg].desc("Logistic Regression").url("http://www.nickgillian.com/wiki/pmwiki.php/GRT/LogisticRegression");
descriptors[ml::k_peak].desc("Peak Detection").url("").num_outlets(1);
descriptors[ml::k_minmax].desc("Minimum / Maximum Detection").url("").num_outlets(1);
descriptors[ml::k_zerox].desc("Zero Crossings Detection").url("http://www.nickgillian.com/wiki/pmwiki.php/GRT/ZeroCrossingCounter");
descriptors[ml::k_svm].desc("Support Vector Machine").url("http://www.nickgillian.com/wiki/pmwiki.php/GRT/SVM");
descriptors[ml::k_adaboost].desc("Adaptive Boosting").url("http://www.nickgillian.com/wiki/pmwiki.php/GRT/AdaBoost");
descriptors[ml::k_anbc].desc("Adaptive Naive Bayes Classifier").url("http://www.nickgillian.com/wiki/pmwiki.php/GRT/ANBC");
descriptors[ml::k_dtw].desc("Dynamic Time Warping").url("http://www.nickgillian.com/wiki/pmwiki.php/GRT/DTW");
descriptors[ml::k_hmmc].desc("Continuous Hidden Markov Model").url("http://www.nickgillian.com/wiki/pmwiki.php/GRT/HMM");
descriptors[ml::k_softmax].desc("Softmax Classifier").url("http://www.nickgillian.com/wiki/pmwiki.php/GRT/Softmax");
descriptors[ml::k_randforest].desc("Random Forests").url("http://www.nickgillian.com/wiki/pmwiki.php/GRT/RandomForests");
descriptors[ml::k_mindist].desc("Minimum Distance").url("http://www.nickgillian.com/wiki/pmwiki.php/GRT/MinDist");
descriptors[ml::k_knn].desc("K Nearest Neighbour").url("http://www.nickgillian.com/wiki/pmwiki.php/GRT/KNN");
descriptors[ml::k_gmm].desc("Gaussian Mixture Model").url("http://www.nickgillian.com/wiki/pmwiki.php/GRT/GMMClassifier");
descriptors[ml::k_dtree].desc("Decision Trees").url("http://www.nickgillian.com/wiki/pmwiki.php/GRT/DecisionTree");
for (auto& desc : {&descriptors[ml::k_hmmc], &descriptors[ml::k_dtw]})
{
desc->notes(
"add and map messages for time series should be delimited with record messages, e.g. record 1, add 1 40 50, add 1 41 50, record 0"
);
}
// base descriptor
message_descriptor add(
"add",
"list comprising a class id followed by n features, <class> <feature 1> <feature 2> etc",
"1 0.2 0.7 0.3 0.1"
);
message_descriptor train(
"train",
"train the model based on vectors added with 'add'"
);
message_descriptor map(
"map",
"generate the output value(s) for the input feature vector",
"0.2 0.7 0.3 0.1"
);
message_descriptor write(
"write",
"write training data and / or model, first argument gives path to write file",
"/path/to/my_ml-lib_data"
);
message_descriptor read(
"read",
"read training data and / or model, first argument gives path to the read file",
"/path/to/my_ml-lib_data"
);
message_descriptor clear(
"clear",
"clear the stored training data and model"
);
message_descriptor help(
"help",
"post usage statement to the console"
);
valued_message_descriptor<int> scaling(
"scaling",
"sets whether values are automatically scaled",
{0, 1},
1
);
valued_message_descriptor<int> record(
"record",
"start or stop time series recording for a single example of a given class",
{0, 1},
0
);
ranged_message_descriptor<float> training_rate(
"training_rate",
"set the learning rate, used to update the weights at each step of learning algorithms such as stochastic gradient descent.",
0.01,
1.0,
0.1
);
ranged_message_descriptor<float> min_change(
"min_change",
"set the minimum change that must be achieved between two training epochs for the training to continue",
0.0,
1.0,
1.0e-5
);
ranged_message_descriptor<int> max_iterations(
"max_iterations",
"set the maximum number of training iterations",
0,
1000,
100
);
record.insert_before = "add";
descriptors[ml::k_base].add_message_descriptor(add, write, read, train, clear, map, help, scaling, training_rate, min_change, max_iterations);
// generic classification descriptor
valued_message_descriptor<bool> null_rejection(
"null_rejection",
"toggle NULL rejection off or on, when 'on' classification results below the NULL-rejection threshold will be discarded",
{false, true},
true
);
ranged_message_descriptor<float> null_rejection_coeff(
"null_rejection_coeff",
"set a multiplier for the NULL-rejection threshold ",
0.1,
1.0,
0.9
);
valued_message_descriptor<int> probs(
"probs",
"determines whether probabilities are sent from the right outlet",
{0, 1},
0
);
descriptors[ml::k_classification].add_message_descriptor(null_rejection_coeff, probs, null_rejection);
// generic feature extraction descriptor
// descriptors[ml::k_feature_extraction].add_message_descriptor(null_rejection_coeff, null_rejection);
// generic regression descriptor
// descriptors[ml::k_regression].add_message_descriptor(training_rate, min_change, max_iterations);
// Object-specific descriptors
//-- Regressifiers
//---- ann
valued_message_descriptor<ml::data_type> mode("mode",
"set the mode of the ANN, " + std::to_string(ml::LABELLED_CLASSIFICATION) + " for classification, " + std::to_string(ml::LABELLED_REGRESSION) + " for regression",
{ml::LABELLED_CLASSIFICATION, ml::LABELLED_REGRESSION, ml::LABELLED_TIME_SERIES_CLASSIFICATION},
ml::defaults::data_type
);
message_descriptor add_ann(
"add",
"class id followed by n features, <class> <feature 1> <feature 2> etc when in classification mode or N output values followed by M input values when in regression mode (N = num_outputs)",
"1 0.2 0.7 0.3 0.1"
);
ranged_message_descriptor<int> num_outputs(
"num_outputs",
"set the number of neurons in the output layer",
1,
1000,
ml::defaults::num_output_dimensions
);
ranged_message_descriptor<int> num_hidden(
"num_hidden",
"set the number of neurons in the hidden layer",
1,
1000,
ml::defaults::num_hidden_neurons
);
ranged_message_descriptor<int> min_epochs(
"min_epochs",
"setting the minimum number of training iterations",
1,
1000,
10
);
// TODO: check if the "epochs" are still needed or if we can use "iterations" as inherited from ml_regression
ranged_message_descriptor<int> max_epochs(
"max_epochs",
"setting the maximum number of training iterations",
1,
10000,
100
);
ranged_message_descriptor<float> momentum(
"momentum",
"set the momentum",
0.0,
1.0,
0.5
);
ranged_message_descriptor<float> gamma(
"gamma",
"set the gamma",
0.0,
10.0,
2.0
);
// TODO: have optional value_labels for value labels
valued_message_descriptor<int> input_activation_function(
"input_activation_function",
"set the activation function for the input layer, 0:LINEAR, 1:SIGMOID, 2:BIPOLAR_SIGMOID",
{0, 1, 2},
0
);
valued_message_descriptor<int> hidden_activation_function(
"hidden_activation_function",
"set the activation function for the hidden layer, 0:LINEAR, 1:SIGMOID, 2:BIPOLAR_SIGMOID",
{0, 1, 2},
0
);
valued_message_descriptor<int> output_activation_function(
"output_activation_function",
"set the activation function for the output layer, 0:LINEAR, 1:SIGMOID, 2:BIPOLAR_SIGMOID",
{0, 1, 2},
0
);
ranged_message_descriptor<int> rand_training_iterations(
"rand_training_iterations",
"set the number of random training iterations",
0,
1000,
10
);
valued_message_descriptor<bool> use_validation_set(
"use_validation_set",
"set whether to use a validation training set",
{false, true},
true
);
ranged_message_descriptor<int> validation_set_size(
"validation_set_size",
"set the size of the validation set",
1,
100,
20
);
valued_message_descriptor<bool> randomize_training_order(
"randomize_training_order",
"sets whether to randomize the training order",
{false, true},
false
);
descriptors[ml::k_ann].add_message_descriptor(add_ann, probs, mode, null_rejection, null_rejection_coeff, num_outputs, num_hidden, min_epochs, max_epochs, momentum, gamma, input_activation_function, hidden_activation_function, output_activation_function, rand_training_iterations, use_validation_set, validation_set_size, randomize_training_order);
//-- Classifiers
//---- ml.svm
ranged_message_descriptor<int> type(
"type",
"set SVM type,"
" 0:C-SVC (multi-class),"
" 1:nu-SVC (multi-class),"
" 2:one-class SVM,"
// " 3:epsilon-SVR (regression),"
// " 4:nu-SVR (regression)"
,
0,
2,
0
// " 0 -- C-SVC (multi-class classification)\n"
// " 1 -- nu-SVC (multi-class classification)\n"
// " 2 -- one-class SVM\n"
// " 3 -- epsilon-SVR (regression)\n"
// " 4 -- nu-SVR (regression)\n"
);
ranged_message_descriptor<int> kernel(
"kernel",
"set type of kernel function, "
"0:linear, " // (u'*v),"
"1:polynomial, " // (gamma*u'*v + coef0)^degree,"
"2:radial basis function, " //: exp(-gamma*|u-v|^2),"
"3:sigmoid, " // tanh(gamma*u'*v + coef0),"
"4:precomputed kernel (kernel values in training_set_file)",
0,
4,
0
// " 0 -- linear: u'*v\n"
// " 1 -- polynomial: (gamma*u'*v + coef0)^degree\n"
// " 2 -- radial basis function: exp(-gamma*|u-v|^2)\n"
// " 3 -- sigmoid: tanh(gamma*u'*v + coef0)\n"
// " 4 -- precomputed kernel (kernel values in training_set_file)\n"
);
ranged_message_descriptor<float> degree(
"degree",
"set degree in kernel function",
0,
20,
3
);
ranged_message_descriptor<float> svm_gamma(
"gamma",
"set gamma in kernel function",
0.0,
1.0,
0.5
);
ranged_message_descriptor<float> coef0(
"coef0",
"coef0 in kernel function",
INFINITY * -1.f, INFINITY,
0.0
);
ranged_message_descriptor<float> cost(
"cost",
"set the parameter C of C-SVC, epsilon-SVR, and nu-SVR",
INFINITY * -1.f, INFINITY,
1.0
);
ranged_message_descriptor<float> nu(
"nu",
"set the parameter nu of nu-SVC, one-class SVM, and nu-SVR",
INFINITY * -1.f, INFINITY,
0.5
);
message_descriptor cross_validation(
"cross_validation",
"perform cross validation"
);
ranged_message_descriptor<int> num_folds(
"num_folds",
"set the number of folds used for cross validation",
1, 100,
10
);
descriptors[ml::k_svm].add_message_descriptor(cross_validation, num_folds, type, kernel, degree, svm_gamma, coef0, cost, nu);
//---- ml.adaboost
ranged_message_descriptor<int> num_boosting_iterations(
"num_boosting_iterations",
"set the number of boosting iterations that should be used when training the model",
0,
200,
20
);
valued_message_descriptor<int> prediction_method(
"prediction_method",
"set the Adaboost prediction method, 0:MAX_VALUE, 1:MAX_POSITIVE_VALUE",
{GRT::AdaBoost::MAX_VALUE, GRT::AdaBoost::MAX_POSITIVE_VALUE},
GRT::AdaBoost::MAX_VALUE
);
valued_message_descriptor<int> set_weak_classifier(
"set_weak_classifier",
"sets the weak classifier to be used by Adaboost, 0:DECISION_STUMP, 1:RADIAL_BASIS_FUNCTION",
{ml::weak_classifiers::DECISION_STUMP, ml::weak_classifiers::RADIAL_BASIS_FUNCTION},
ml::weak_classifiers::DECISION_STUMP
);
valued_message_descriptor<int> add_weak_classifier(
"add_weak_classifier",
"add a weak classifier to the list of classifiers used by Adaboost",
{ml::weak_classifiers::DECISION_STUMP, ml::weak_classifiers::RADIAL_BASIS_FUNCTION},
ml::weak_classifiers::DECISION_STUMP
);
descriptors[ml::k_adaboost].add_message_descriptor(num_boosting_iterations, prediction_method, set_weak_classifier, add_weak_classifier);
//---- ml.anbc
message_descriptor weights("weights",
"vector of 1 integer and N floating point values where the integer is a class label and the floats are the weights for that class. Sending weights with a vector size of zero clears all weights"
);
descriptors[ml::k_anbc].add_message_descriptor(weights);
//---- ml.dtw
valued_message_descriptor<int> rejection_mode(
"rejection_mode",
"sets the method used for null rejection, 0:TEMPLATE_THRESHOLDS, 1:CLASS_LIKELIHOODS, 2:THRESHOLDS_AND_LIKELIHOODS",
{GRT::DTW::TEMPLATE_THRESHOLDS, GRT::DTW::CLASS_LIKELIHOODS, GRT::DTW::THRESHOLDS_AND_LIKELIHOODS},
GRT::DTW::TEMPLATE_THRESHOLDS
);
ranged_message_descriptor<float> warping_radius(
"warping_radius",
"sets the radius of the warping path, which is used if the constrain_warping_path is set to 1",
0.0,
1.0,
0.2
);
valued_message_descriptor<bool> offset_time_series(
"offset_time_series",
"set if each timeseries should be offset by the first sample in the time series",
{false, true},
false
);
valued_message_descriptor<bool> constrain_warping_path(
"constrain_warping_path",
"sets the warping path should be constrained to within a specific radius from the main diagonal of the cost matrix",
{false, true},
true
);
valued_message_descriptor<bool> enable_z_normalization(
"enable_z_normalization",
"turn z-normalization on or off for training and prediction",
{false, true},
false
);
valued_message_descriptor<bool> enable_trim_training_data(
"enable_trim_training_data",
"enabling data trimming prior to training",
{false, true},
false
);
descriptors[ml::k_dtw].insert_message_descriptor(record);
descriptors[ml::k_dtw].add_message_descriptor(rejection_mode, warping_radius, offset_time_series, constrain_warping_path, enable_z_normalization, enable_trim_training_data);
//---- ml.hmmc
valued_message_descriptor<int> model_type(
"model_type",
"set the model type used, 0:ERGODIC, 1:LEFTRIGHT",
{HMM_ERGODIC, HMM_LEFTRIGHT},
HMM_LEFTRIGHT
);
ranged_message_descriptor<int> delta(
"delta",
"control how many states a model can transition to if the LEFTRIGHT model type is used",
1,
100,
11
);
ranged_message_descriptor<int> max_num_iterations(
"max_num_iterations",
"set the maximum number of training iterations",
1,
1000,
100
);
ranged_message_descriptor<int> committee_size(
"committee_size",
"set the committee size for the number of votes combined to make a prediction",
1,
1000,
5
);
ranged_message_descriptor<int> downsample_factor(
"downsample_factor",
"set the downsample factor for the resampling of each training time series. A factor of 5 will result in each time series being resized (smaller) by a factor of 5",
1,
1000,
5
);
descriptors[ml::k_hmmc].insert_message_descriptor(record);
descriptors[ml::k_hmmc].add_message_descriptor(model_type, delta, max_num_iterations, committee_size, downsample_factor);
//---- ml.softmax
//---- ml.randforest
ranged_message_descriptor<int> num_random_splits(
"num_random_splits",
"set the number of steps that will be used to search for the best spliting value for each node",
1,
1000,
100
);
ranged_message_descriptor<int> min_samples_per_node2(
"min_samples_per_node",
"set the minimum number of samples that are allowed per node",
1,
100,
5
);
ranged_message_descriptor<int> max_depth(
"max_depth",
"sets the maximum depth of the tree, any node that reaches this depth will automatically become a leaf node",
1,
100,
10
);
descriptors[ml::k_randforest].add_message_descriptor(num_random_splits, min_samples_per_node2, max_depth);
//----ml.mindist
ranged_message_descriptor<int> num_clusters(
"num_clusters",
"set how many clusters each model will try to find during the training phase",
1,
100,
10
);
descriptors[ml::k_mindist].add_message_descriptor(num_clusters);
//---- ml.knn
// "best_k_value_search:\tbool (0 or 1) set whether k value search is enabled or not (default 0)\n";
ranged_message_descriptor<int> k(
"k",
"sets the K nearest neighbours that will be searched for by the algorithm during prediction",
1,
500,
10
);
ranged_message_descriptor<int> min_k_search_value(
"min_k_search_value",
"set the minimum K value to use when searching for the best K value",
1,
500,
1
);
ranged_message_descriptor<int> max_k_search_value(
"max_k_search_value",
"set the maximum K value to use when searching for the best K value",
1,
500,
10
);
valued_message_descriptor<bool> best_k_value_search(
"best_k_value_search",
"set whether k value search is enabled or not",
{false, true},
false
);
descriptors[ml::k_knn].add_message_descriptor(k, min_k_search_value, max_k_search_value, best_k_value_search);
//---- ml.gmm
ranged_message_descriptor<int> num_mixture_models(
"num_mixture_models",
"sets the number of mixture models used for class",
1,
20,
2
);
descriptors[ml::k_gmm].add_message_descriptor(num_mixture_models);
//---- ml.dtree
valued_message_descriptor<bool> training_mode(
"training_mode",
"set the training mode",
{GRT::Tree::BEST_ITERATIVE_SPILT, GRT::Tree::BEST_RANDOM_SPLIT},
GRT::Tree::BEST_ITERATIVE_SPILT
);
ranged_message_descriptor<int> num_splitting_steps(
"num_splitting_steps",
"set the number of steps that will be used to search for the best spliting value for each node",
1,
500,
100
);
ranged_message_descriptor<int> min_samples_per_node(
"min_samples_per_node",
"sets the minimum number of samples that are allowed per node, if the number of samples at a node is below this value then the node will automatically become a leaf node",
1,
100,
5
);
ranged_message_descriptor<int> dtree_max_depth(
"max_depth",
"sets the maximum depth of the tree, any node that reaches this depth will automatically become a leaf node",
1,
100,
10
);
valued_message_descriptor<bool> remove_features_at_each_split(
"remove_features_at_each_split",
"set if a feature is removed at each spilt so it can not be used again",
{false, true},
false
);
descriptors[ml::k_dtree].add_message_descriptor(training_mode, num_splitting_steps, min_samples_per_node, dtree_max_depth, remove_features_at_each_split);
//-- Feature extraction
//---- ml.peak
ranged_message_descriptor<int> search_window_size(
"search_window_size",
"set the search window size in values",
1,
500,
5
);
ranged_message_descriptor<float> peak(
"float",
"set the current value of the peak detector, a bang will be output when a peak is detected",
INFINITY * -1.f, INFINITY,
1
);
message_descriptor reset(
"reset",
"reset the peak detector"
);
message_descriptor peak_help(
"help",
"post usage statement to the console"
);
descriptors[ml::k_peak].add_message_descriptor(peak, reset, search_window_size, peak_help);
//---- ml.minmax
message_descriptor input(
"list",
"list of float values in which to find minima and maxima",
"0.1 0.5 -0.3 0.1 0.2 -0.1 0.7 0.1 0.3"
);
ranged_message_descriptor<float> minmax_delta(
"delta",
"setting the minmax delta. Input values will be considered to be peaks if they are greater than the previous and next value by at least the delta value",
0,
1,
0.1
);
descriptors[ml::k_minmax].add_message_descriptor(input, minmax_delta);
//---- ml.zerox
valued_message_descriptor<float> zerox_map(
"map",
"a stream of input values in which to detect zero crossings",
0.5
);
ranged_message_descriptor<float> dead_zone_threshold(
"dead_zone_threshold",
"set the dead zone threshold",
0.f,
1.f,
0.01f
);
ranged_message_descriptor<int> zerox_search_window_size(
"search_window_size",
"set the search window size in values",
1,
500,
20
);
descriptors[ml::k_zerox].add_message_descriptor(zerox_map, dead_zone_threshold, zerox_search_window_size);
}
void rb_tree<T>::print_complete_status() {
print_tree();
std::cout << "Depth: " << max_depth() << std::endl;
std::cout << "Balanced: " << (black_balance() ? "Yes" : "No") << std::endl;
std::cout << "Red-Black property: " << (check_red_black_property() ? "No Violation found" : "Violation found") << std::endl;
}
void print_paths(bst *b)
{
int *path = (int*)malloc(sizeof(int)*max_depth(b));
print_paths_helper(b,0,path);
}
/*
* Go to any level
*/
static void do_cmd_wiz_jump(void)
{
/* Ask for a town */
if (adult_campaign)
{
/* Ask for level */
if (p_ptr->command_arg <= 0)
{
char ppp[80];
char tmp_val[160];
/* Prompt */
sprintf(ppp, "Jump to dungeon (1-%d): ", z_info->t_max-1);
/* Default */
sprintf(tmp_val, "%d", p_ptr->dungeon);
/* Ask for a level */
if (!get_string(ppp, tmp_val, 10)) return;
/* Extract request */
p_ptr->command_arg = atoi(tmp_val);
}
/* Paranoia */
if (p_ptr->command_arg < 1) p_ptr->command_arg = 1;
/* Paranoia */
if (p_ptr->command_arg >= z_info->t_max) p_ptr->command_arg = z_info->t_max -1;
/* Accept request */
msg_format("You jump to %s.", t_name + t_info[p_ptr->command_arg].name);
/* New depth */
p_ptr->dungeon = p_ptr->command_arg;
p_ptr->command_arg = 0;
}
/* Ask for level */
if (p_ptr->command_arg <= 0)
{
char ppp[80];
char tmp_val[160];
/* Prompt */
sprintf(ppp, "Jump to level (0-%d): ", max_depth(p_ptr->dungeon)-min_depth(p_ptr->dungeon));
/* Default */
sprintf(tmp_val, "%d", p_ptr->depth);
/* Ask for a level */
if (!get_string(ppp, tmp_val, 10)) return;
/* Extract request */
p_ptr->command_arg = atoi(tmp_val);
}
/* Paranoia */
if (p_ptr->command_arg < 0) p_ptr->command_arg = 0;
/* Paranoia */
if (p_ptr->command_arg > max_depth(p_ptr->dungeon)-min_depth(p_ptr->dungeon)) p_ptr->command_arg = max_depth(p_ptr->dungeon)-min_depth(p_ptr->dungeon);
/* Accept request */
msg_format("You jump to dungeon level %d.", p_ptr->command_arg);
/* New depth */
p_ptr->depth = p_ptr->command_arg + min_depth(p_ptr->dungeon);
/* Leaving */
p_ptr->leaving = TRUE;
}
