void FMM2D::recalculate()
{
if (!m_tree) {
build_tree();
}
reset();
upward_pass();
downward_pass();
}
void FMM2D::calculate(bool precond)
{
reset();
m_make_prec = precond;
build_tree();
upward_pass();
downward_pass();
m_make_prec = false;
}
BihTree(
const InputIterator & first,
const InputIterator & last,
unsigned max_depth = 32,
unsigned items_per_leaf = 1 ) :
MAX_DEPTH(max_depth), ITEMS_PER_LEAF(items_per_leaf), m_range(), m_root(), m_depth(0), m_num_nodes(0)
{
m_range.insert(m_range.begin(),first,last);
build_tree(m_root, m_range.begin(), m_range.end(), 0);
}
void build_tree(int root, int prev)
{
for(int k = head[root]; k != -1; k = edge[k].next) {
int v = edge[k].v;
if(prev == v) continue;
father[v] = root;
build_tree(v, root);
f[root] += f[v];
}
}
sv::id3_tree::id3_tree(std::vector<sample> d, std::vector<std::string> f) : data(std::move(d)), features(std::move(f))
{
//map features to set of values
for (std::size_t i = 0; i < features.size(); ++i)
{
for (const auto& s : data) { feature_to_values[features[i]].insert(s.feature_values[i]); }
}
root = build_tree(data, features);
}
NumArray(vector<int> &nums) {
this->nums = vector<int>(nums);
n = (int)nums.size();
if (n != 0){
tree = new TreeNode[4*n];
build_tree(1, 0, n-1);
if (n < 15)
print_tree();
}
}
Node* build_tree(FILE* input){
int bit = read_bit(input);
if (bit == EOF){
printf("%s\n", "Error: build_tree shouldn't encounter EOF");
}
if (bit == 1){
char c = read_char(input);
Node* node = my_malloc(sizeof(Node));
node->left = NULL;
node->right = NULL;
node->next = NULL;
node->char_val = c;
return node;
} else {
Node* tree = my_malloc(sizeof(Node));
tree->left = build_tree(input);
tree->right = build_tree(input);
return tree;
}
}
void build_tree(int now, int l, int r)
{
if(l == r)
{
int v;
std::scanf("%d", &v);
node[now].ans = node[now].sum = v;
node[now].ans.l = node[now].ans.r = l;
node[now].left = node[now].right = node[now].ans;
node_m[now] = node[now];
return;
}
int m = (l + r) >> 1;
int a = now << 1, b = a + 1;
build_tree(a, l, m);
build_tree(b, m + 1, r);
merge(node[now], node[a], node[b], max_cmp);
merge(node_m[now], node_m[a], node_m[b], min_cmp);
}
int main(int argc, char **argv)
{
int **tree = build_tree();
for(int i = TREE_SIZE-2; i >= 0; i--)
for(int j = 0; j <= i; j++)
tree[i][j] += MAX(tree[i+1][j], tree[i+1][j+1]);
printf("%d\n", tree[0][0]);
return 0;
}
void
build_tree(int root, int left, int right)
{
int mid;
tree[root].left = left;
tree[root].right = right;
if (left == right)
{
tree[root].max = tree[root].min = num[left];
}
else
{
mid = (left + right) / 2;
build_tree(root * 2, left, mid);
build_tree(root * 2 + 1, mid + 1, right);
tree[root].max = max(tree[root * 2].max, tree[root * 2 + 1].max);
tree[root].min = min(tree[root * 2].min, tree[root * 2 + 1].min);
}
}
void test_data_data_is_retained(void)
{
int tree_data[] = { 4 };
node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));
TEST_ASSERT_NOT_NULL(tree);
TEST_ASSERT_EQUAL_INT(4, tree->data);
TEST_ASSERT_NULL(tree->left);
TEST_ASSERT_NULL(tree->right);
free_tree(tree);
}
void kd_tree::build_tree(array_2d<double> &mm){
array_1d<double> i_min,i_max;
int i;
for(i=0;i<mm.get_cols();i++){
i_min.set(i,0.0);
i_max.set(i,1.0);
}
build_tree(mm,i_min,i_max);
}
void quadtree::build_tree(const epng::png & source, std::unique_ptr<node> & subroot, uint64_t resolution, uint64_t x, uint64_t y)
{
subroot.reset(new node());
if(resolution == 1){
subroot->element = *source(x,y);
return;
}
build_tree(source, subroot->northwest, resolution/2, x, y);
build_tree(source, subroot->northeast, resolution/2, x+resolution/2, y);
build_tree(source, subroot->southwest, resolution/2, x, y+resolution/2);
build_tree(source, subroot->southeast, resolution/2, x+resolution/2, y+resolution/2);
int tmp;
tmp = (subroot->northwest->element.red + subroot->northeast->element.red + subroot->southwest->element.red + subroot->southeast->element.red)/4;
subroot->element.red = tmp;
tmp = (subroot->northwest->element.green + subroot->northeast->element.green + subroot->southwest->element.green + subroot->southeast->element.green)/4;
subroot->element.green = tmp;
tmp = (subroot->northwest->element.blue + subroot->northeast->element.blue + subroot->southwest->element.blue + subroot->southeast->element.blue)/4;
subroot->element.blue = tmp;
}
node * build_tree(int left,int right)
{
char ch;
int i;
if(left > right) return NULL;
ch = preorder[pre_index];
for(i=0; inorder[i] != ch; i++);
pre_index++;
node *t= new node;
t->c = inorder[i];
t->left = build_tree(left,i-1);
t->right = build_tree(i+1,right);
return t;
}
int
main()
{
NODE *TPTR = NULL;
q.nele=0;
if ((TPTR = build_tree(5)) == NULL) {
printf ("build tree failed\n");
err_exit ("btree failed\n");
}
bfs(TPTR);
}
int main_test(void){
BiTree *T = NULL;
init_tree(&T);
process_input(T);
build_tree(T);
traverse_tree(T);
return 0;
}
void test_sorted_data_can_sort_single_number(void)
{
TEST_IGNORE();
int tree_data[] = { 2 };
node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));
int expected[] = { 2 };
int *actual = sorted_data(tree);
TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, ARRAY_SIZE(expected));
free_tree(tree);
free(actual);
}
void test_sorted_data_can_sort_if_second_number_is_greater_than_first(void)
{
TEST_IGNORE();
int tree_data[] = { 2, 3 };
node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));
int expected[] = { 2, 3 };
int *actual = sorted_data(tree);
TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, ARRAY_SIZE(expected));
free_tree(tree);
free(actual);
}
void test_sorted_data_can_sort_complex_tree(void)
{
TEST_IGNORE();
int tree_data[] = { 2, 1, 3, 6, 7, 5 };
node_t *tree = build_tree(tree_data, ARRAY_SIZE(tree_data));
int expected[] = { 1, 2, 3, 5, 6, 7 };
int *actual = sorted_data(tree);
TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, ARRAY_SIZE(expected));
free_tree(tree);
free(actual);
}
void build_tree(int node,int a,int b)
{
if(a==b)
{
T[node].lval=node;
T[node].rval=node;
T[node].maxv=arr[a];
T[node].sum=arr[a];
return;
}
int m=(a+b)/2;
build_tree(2*node,a,m);
build_tree(2*node+1,m+1,b);
T[node].maxv=max2(T[2*node].maxv,T[2*node+1].maxv);
if(T[2*node+1].lval!=T[2*node+1].rval)
T[node].sum=max3(T[2*node].maxv+T[2*node+1].maxv,T[2*node].sum,T[2*node+1].sum);
else if(T[2*node+1].lval==T[2*node+1].rval)
T[node].sum=max2(T[2*node].maxv+T[2*node+1].maxv,T[2*node].sum);
T[node].lval=2*node;
T[node].rval=2*node+1;
}
static int read_offset_tree(LHAPM2Decoder *decoder,
unsigned int num_offsets)
{
uint8_t offset_lengths[8];
unsigned int off;
unsigned int single_offset, num_codes;
int len;
if (!decoder->need_offset_tree) {
return 1;
}
// Read 'num_offsets' 3-bit length values. For each offset
// value 'off', offset_lengths[off] is the length of the
// code that will represent 'off', or 0 if it will not
// appear within the tree.
num_codes = 0;
single_offset = 0;
for (off = 0; off < num_offsets; ++off) {
len = read_bits(&decoder->bit_stream_reader, 3);
if (len < 0) {
return 0;
}
offset_lengths[off] = (uint8_t) len;
// Track how many actual codes were in the tree.
if (len != 0) {
single_offset = off;
++num_codes;
}
}
// If there was a single code, this is a single node tree.
if (num_codes == 1) {
set_tree_single(decoder->offset_tree, single_offset);
return 1;
}
// Build the tree.
build_tree(decoder->offset_tree, sizeof(decoder->offset_tree),
offset_lengths, num_offsets);
return 1;
}
static int acsmBuildMatchStateTrees( ACSM_STRUCT * acsm,
int (*build_tree)(void * id, void **existing_tree),
int (*neg_list_func)(void *id, void **list) )
{
int i, cnt = 0;
ACSM_PATTERN * mlist;
/* Find the states that have a MatchList */
for (i = 0; i < acsm->acsmMaxStates; i++)
{
for ( mlist=acsm->acsmStateTable[i].MatchList;
mlist!=NULL;
mlist=mlist->next )
{
if (mlist->udata->id)
{
if (mlist->negative)
{
neg_list_func(mlist->udata->id, &acsm->acsmStateTable[i].MatchList->neg_list);
}
else
{
build_tree(mlist->udata->id, &acsm->acsmStateTable[i].MatchList->rule_option_tree);
}
}
cnt++;
}
if (acsm->acsmStateTable[i].MatchList)
{
/* Last call to finalize the tree */
build_tree(NULL, &acsm->acsmStateTable[i].MatchList->rule_option_tree);
}
}
return cnt;
}
// 参考construct_binary_tree_from_preorder_and_inorder_traversal.cpp
TreeNode* build_tree(vector<int> &inorder,
int in_start,
int in_end,
vector<int> &postorder,
int post_start,
int post_end) {
if (post_start > post_end) {
return NULL;
}
else if (post_start == post_end) {
return new TreeNode(postorder[post_start]);
}
int i = 0;
for ( ; (in_start + i) <= in_end; ++i) {
if (inorder[in_start + i] == postorder[post_end]) {
break;
}
}
TreeNode *root = new TreeNode(postorder[post_end]);
root->left = build_tree(inorder,
in_start,
in_end + (i - 1),
postorder,
post_start,
post_start + (i - 1));
root->right = build_tree(inorder,
in_start + (i + 1),
in_end,
postorder,
post_start + i,
post_end - 1);
return root;
}
KMCentersNode *KMCentersTree::build_tree(int start_ind,int end_ind,
int level) {
IMP_LOG(VERBOSE,"build tree for point indexes: " <<
start_ind << " to " << end_ind << std::endl);
if (end_ind-start_ind<=1){
Ints curr_inds;
for(int i=start_ind;i<=end_ind;i++) {
curr_inds.push_back(i);
}
return new KMCentersNodeLeaf(level,*bnd_box_,centers_,curr_inds);
}
int cd=0; //the cutting dimension
double cv;//the cutting value
int n_lo; // number on low side of cut
KMCentersNode *lo, *hi; // low and high children
//split the data points along a dimension. The split data is stored in pidx
split_by_mid_point(start_ind, end_ind, cd, cv, n_lo);
IMP_LOG(VERBOSE,"splitting points with indexes : " << start_ind << " to "
<< end_ind << " the splitting dimension is: " << cd << " with value: "<< cv
<< " the last point for the left side is: " << n_lo << std::endl);
KMPoint *lo_p,*hi_p;
lo_p = bnd_box_->get_point(0);
hi_p = bnd_box_->get_point(1);
double lv = (*lo_p)[cd];
double hv = (*hi_p)[cd];
(*hi_p)[cd] = cv;
//build left subtree from p_id[0,...,n_lo-1]
lo = build_tree(start_ind,n_lo-1,level+1);
(*hi_p)[cd] = hv;// restore bounds
(*lo_p)[cd] = cv;// modify bounds for right subtree
// build right subtree from p_id[n_lo..n-1]
hi = build_tree(n_lo, end_ind,level+1);
(*lo_p)[cd] = lv;
// create the splitting node
KMCentersNodeSplit *ptr =
new KMCentersNodeSplit(level,*bnd_box_, centers_,cd, cv, lv, hv, lo, hi);
return ptr;
}
int build_tree(int node,int a,int b)
{
if(a==b)
{
T[node].maxv=arr[a];
return 1;
}
int m=(a+b)/2;
hold=build_tree(2*node,a,m);
hold=build_tree(2*node+1,m+1,b);
if(hold==1)
{
T[node].maxv=T[2*node].maxv | T[2*node+1].maxv;
return 0;
}
else if(hold==0)
{
T[node].maxv=T[2*node].maxv ^ T[2*node+1].maxv;
return 1;
}
}
static void
build_tree (PopplerDocument *document,
GtkTreeModel *model,
GtkTreeIter *parent,
PopplerLayersIter *iter)
{
do {
GtkTreeIter tree_iter;
PopplerLayersIter *child;
PopplerLayer *layer;
gboolean visible;
gchar *markup;
gint rb_group = 0;
layer = poppler_layers_iter_get_layer (iter);
if (layer) {
markup = g_markup_escape_text (poppler_layer_get_title (layer), -1);
visible = poppler_layer_is_visible (layer);
rb_group = poppler_layer_get_radio_button_group_id (layer);
} else {
gchar *title;
title = poppler_layers_iter_get_title (iter);
markup = g_markup_escape_text (title, -1);
g_free (title);
visible = FALSE;
layer = NULL;
}
gtk_tree_store_append (GTK_TREE_STORE (model), &tree_iter, parent);
gtk_tree_store_set (GTK_TREE_STORE (model), &tree_iter,
LAYERS_TITLE_COLUMN, markup,
LAYERS_VISIBILITY_COLUMN, visible,
LAYERS_ENABLE_COLUMN, TRUE, /* FIXME */
LAYERS_SHOWTOGGLE_COLUMN, (layer != NULL),
LAYERS_RB_GROUP_COLUMN, rb_group,
LAYERS_LAYER_COLUMN, layer,
-1);
if (layer)
g_object_unref (layer);
g_free (markup);
child = poppler_layers_iter_get_child (iter);
if (child)
build_tree (document, model, &tree_iter, child);
poppler_layers_iter_free (child);
} while (poppler_layers_iter_next (iter));
}
struct TreeNode *sortedListToBST(struct ListNode *head)
{
if (!head)
return(NULL);
int *num, size;
struct TreeNode *root;
num = list_to_arr(head, &size);
root = build_tree(num, 0, size - 1);
free(num);
return(root);
}
PyObject *build_tree(CNode *n, Linkage linkage) {
CNode * m;
int word_num = 1;
PyObject *output;
PyObject *temp;
//PyObject *t2;
//PyObject *t1;
output = PyList_New(0);
// sentence_get_word(Sentence sent, int wordnum)
//static char * spacer=" ";
if (n == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
for (m=n->child; m!=NULL; m=m->next) {
//PyObject *t1;
//t1 = PyList_New(0);
if (m->child == NULL) {
temp = PyString_FromString(m->label);
//PyList_Append(t1, temp);
}
else {
temp = build_tree(m, linkage);
//PyList_Append(t1, temp);
}
/*PyObject *temp_list;
PyObject *temp2_list;
temp_list = PyList_New(0);
temp2_list = PyList_New(0);
const char *t3 = linkage_get_link_llabel(linkage, word_num);
const char *t4 = linkage_get_link_rlabel(linkage, word_num);
t1 = PyString_FromString(t3);
t2 = PyString_FromString(t4);
PyList_Append(temp_list, t1);
PyList_Append(temp_list, t2);
PyList_Append(temp2_list, temp);
PyList_Append(temp2_list, temp_list);
//PyDict_SetItem(output, temp, t2);
PyList_Append(output, temp2_list);
*/
PyList_Append(output, temp);
word_num++;
}
Py_XINCREF(output);
return output;
}
static int read_offset_table(LHANewDecoder *decoder)
{
int i, n, len, code;
uint8_t code_lengths[HISTORY_BITS];
// How many codes?
n = read_bits(&decoder->bit_stream_reader, OFFSET_BITS);
if (n < 0) {
return 0;
}
// n=0 is a special case, meaning only a single code that
// is of zero length.
if (n == 0) {
code = read_bits(&decoder->bit_stream_reader, OFFSET_BITS);
if (code < 0) {
return 0;
}
set_tree_single(decoder->offset_tree, code);
return 1;
}
// Enforce a hard limit on the number of codes.
if (n > HISTORY_BITS) {
n = HISTORY_BITS;
}
// Read the length of each code.
for (i = 0; i < n; ++i) {
len = read_length_value(decoder);
if (len < 0) {
return 0;
}
code_lengths[i] = len;
}
build_tree(decoder->offset_tree, MAX_TEMP_CODES * 2, code_lengths, n);
return 1;
}
void
render(struct page *p)
{
int depth;
FILE *out;
struct lacy_env env;
struct page_stack p_stack;
struct ut_str outfile;
str_init(&curtok);
if (NULL == p)
return;
str_init(&outfile);
str_append_str(&outfile, conf.output_dir.s);
str_append(&outfile, '/');
str_append_str(&outfile, p->file_path);
/* depth - 1 since we added output dir to path */
depth = build_depth(outfile.s) - 1;
if (NULL == (out = fopen(outfile.s, "w")))
fatal("Unable to open: %: ", outfile.s);
p_stack.size = 0;
p_stack.pos = 0;
/* Build Environment */
env.depth = depth;
env.p_stack = &p_stack;
env.sym_tbl = NULL;
env_build(p, &env);
/* set stack back to top */
p_stack.pos = 0;
/* do it already */
build_tree(&env);
write_tree(out, &env);
env_free(&env);
fclose(out);
str_free(&curtok);
if (verbosity > 0) {
printf("Rendered %s\n", outfile.s);
}
str_free(&outfile);
}
