コード例 #1
0
ファイル: dbms.c プロジェクト: nithinmohan/Euler-problems
// Deletes an entry from the B+ tree.
 node * delete_entry( node * root, node * n, int key, void * pointer ) {
 
    int min_keys;
    node * neighbor;
    int neighbor_index;
    int k_prime_index, k_prime;
    int capacity;
 
    // Remove key and pointer from node.
 
    n = remove_entry_from_node(n, key, pointer);
 
    /* Case:  deletion from the root.
     */
 
    if (n == root)
        return adjust_root(root);
 
 
    // Case:  deletion from a node below the root.
    
    // Determine minimum allowable size of node, to be preserved after deletion.
 
 
    min_keys = n->is_leaf ? cut(order - 1) : cut(order) - 1;
 
    // Case:  node stays at or above minimum.
    
    if (n->num_keys >= min_keys)
        return root;
 
    /* Find the appropriate neighbor node with which
     * to merge.
     * Also find the key (k_prime) in the parent
     * between the pointer to node n and the pointer
     * to the neighbor.
     */
 
    neighbor_index = get_neighbor_index( n );
    k_prime_index = neighbor_index == -1 ? 0 : neighbor_index;
    k_prime = n->parent->keys[k_prime_index];
    neighbor = neighbor_index == -1 ? n->parent->pointers[1] :
        n->parent->pointers[neighbor_index];
 
    capacity = n->is_leaf ? order : order - 1;
 
    /* mergence. */
 
    if (neighbor->num_keys + n->num_keys < capacity)
        return merge_nodes(root, n, neighbor, neighbor_index, k_prime);
 
    /* Redistribution. */
 
    else
        return redistribute_nodes(root, n, neighbor, neighbor_index, k_prime_index, k_prime);
}
コード例 #2
0
ファイル: borodin_tree.c プロジェクト: angelortega/borodin
static off_t merge_nodes(brtr_t *b, off_t left, off_t right)
{
    off_t id = 0;
    struct brtr_node *l;

    if ((l = brtr_node(b, left)) != NULL) {
        struct brtr_node *r;

        if ((r = brtr_node(b, right)) != NULL) {

            if (l->c > r->c)
                id = set_right(b, left, merge_nodes(b, l->right, right));
            else
                id = set_left(b, right, merge_nodes(b, left, r->left));
        }
        else
            id = left;
    }
    else
        id = right;

    return id;
}
コード例 #3
0
ファイル: overlap.cpp プロジェクト: akonskarm/avdpp
/*void merge_nodes(QNode *ag, QNode *it) {
  if ((ag->children != 0) && (it->children !=0)) {
    for (int i=0; i<Globals::pow2dim; i++) {
      merge_nodes(ag->children[0] + i, it->children[0] + i);
    }
  } else if ((ag->children == 0) && (it->children !=0)) {
    if (ag->representatives != 0) {
      ag->remove_representatives();
    }
    ag->bear_children();
    for (int i=0; i<Globals::pow2dim; i++) {
      merge_nodes(ag->children[0] + i, it->children[0] + i);
    }
  } else if ((ag->children==0) && (it->children==0)) {
    myset union_reprs;
    if (ag->representatives!=0) {
      for (myset::iterator i = ag->representatives[0].begin(); i != ag->representatives[0].end(); i++) {
        union_reprs.insert(*i);
      }
    }
    if (it->representatives!=0) {
      for (myset::iterator i = it->representatives[0].begin(); i != it->representatives[0].end(); i++) {
        union_reprs.insert(*i);
      }
    }

    if (Globals::sets[0].count(union_reprs) == 0) {
      ag->representatives = new myset(union_reprs);
      Globals::sets[0][union_reprs] = ag->representatives;
    } else {
      ag->representatives = Globals::sets[0][union_reprs];
    }
    //std::cout << union_reprs.size() << " " << ag->representatives[0].size() << std::endl;
  }
}*/
void merge_nodes(QNode *ag, QNode *it) {
  if ((ag->depth != 0) && (it->depth != 0)) {
    ag->depth = std::max(ag->depth,it->depth);
  } else if ((ag->depth == 0) && (it->depth != 0)) {
    if (ag->children != 0) {
      std::cout << "error merging?" <<std::endl;
    }
    ag->depth = it->depth; //MERGE with previous
  } else if ((ag->children==0) && (it->children==0)) {
    for (int i=0; i<Globals::pow2dim; i++) {
      merge_nodes(ag->children[0]+i,it->children[0]+i);
    }
  }
}
コード例 #4
0
ファイル: prog_question_1.c プロジェクト: SunyDays/coursera
int find_min_cut(int **adj_list, int *lengths, int adj_list_len)
{
  int nodes_num = adj_list_len;
  while(nodes_num > 2)
  {
    int node_1, node_2;
    do
    {
      node_1 = get_rand_int(adj_list_len);
    }
    while(lengths[node_1] == 0);    
    node_2 = adj_list[node_1][ get_rand_int(lengths[node_1]) ];  
    
    merge_nodes(adj_list, lengths, adj_list_len, node_1, node_2);
    --nodes_num;
  }  

  /* find cut */
  int i;
  for(i = 0; lengths[i] == 0; ++i)
    ;
  return lengths[i];
}
コード例 #5
0
// delete the specified key from the Btree
RC deleteKey(BTreeHandle *tree, Value *key) {

	Btree* leaf      = NULL;
	// get the desired leaf
	leaf = find_leaf(tree, key);

	// get the left node
	Btree* childLeft = NULL;
	childLeft = leaf->prev;

	// get the tree stastistics data
	Btree_stat *info = NULL;
	info = tree->mgmtData;

	if (leaf != NULL) {

		if (childLeft == NULL) {

			// no child
			// delete the entry and adjust the tree if needed
			delete_entry(tree, leaf, key);

			// done
			return RC_OK;
		}

		if (key->v.intV == leaf->keys[0]) {

			// the key exists in this leaf node
			// delete it
			delete_entry(tree, leaf, key);

			// check if there is underflow in the node capacity
			if (leaf->num_keys == 0) {

				// merge with the left sibling
				childLeft->next = leaf->next;

				// check if we need to propagate this change up the tree
				delete_parent_nodes_inital(info, leaf, key);

				// done
				return RC_OK;
			}

			// update the prent node
			updateFirst(leaf, key);

			return RC_OK;

		} else {

			delete_entry(tree, leaf, key);

			if (leaf) {

				// see of there is underflow
				if (checkUnderflow(info, leaf)) {

					// if yes, merge with left sibling
					if (childLeft) {

						// check the number of keys even after splitting
						if (childLeft->num_keys > splitNode(info->order)
						&&  childLeft->num_keys != info->order) {

							// we need to redistribute the keys
							// to balance out
							redistribute(info, childLeft, leaf);

						} else {
							// just merge
							merge_nodes(info, childLeft, leaf);
						}
					}
				}
			}

			return RC_OK;
		}
	}

	// all ok
	return RC_OK;
}
コード例 #6
0
ファイル: QSlpatMake.cpp プロジェクト: anguszhou/Qsplat_win32
int _tmain(int argc, _TCHAR* argv[])
{
#ifdef WIN32
	_fmode = _O_BINARY;
#endif
	printf("This is QSplatMake version %s.\n", QSPLATMAKE_VERSION);

	// Parse command-line params
	//strncasecmp(char*s1,char*s2,size_t n):compare first n chars of s1 and s2
	//ignore case and return 0 if equal else if s1>s2 return >0 else if s1<s2 return <0;
	if ((argc < 4) ||
		!strncasecmp(argv[1], "-h", 2) ||
		!strncasecmp(argv[1], "--h", 3))
		usage(argv[0]);
	bool is_pointfile = false;
	int i = strncasecmp(argv[1], "point" , 5);
	if(!strncasecmp(argv[1], "point" , 5))
		is_pointfile = true;
	const char *infilename = argv[2];
	const char *outfilename = argv[3];
	float threshold = 0;
	printf("argv2:%s\n",infilename);
	printf("argv3:%s\n",outfilename);

	if (argc >= 5 && !strncasecmp(argv[1], "-m", 2)) {
		threshold = atof(argv[2]);
		infilename = argv[3];
		outfilename = argv[4];
	}


	// Read the .ply file
	int numleaves, numfaces;
	face *faces;
	bool havecolor;
	QTree_Node *leaves;
	std::string comments;

	if (!read_ply(infilename, numleaves, leaves, numfaces, faces, havecolor, comments)) {
		fprintf(stderr, "Couldn't read input file %s\n", infilename);
		exit(1);
	}
	if (numleaves < 4) {
		fprintf(stderr, "Ummm...  That's an awfully small mesh you've got there...\n");
		exit(1);
	}
	if(!is_pointfile)
		if (numfaces < 4) {
			fprintf(stderr, "Ummm... I need a *mesh* as input.  That means triangles 'n stuff...\n");
			exit(1);
		}
	
	// Compute per-vertex normals
	if(!is_pointfile)
	{
		find_normals(numleaves, leaves, numfaces, faces);
		// Merge nodes
		merge_nodes(numleaves, leaves, numfaces, faces, havecolor, threshold);

		// Compute initial splat sizes
		find_splat_sizes(numleaves, leaves, numfaces, faces);
	}
	else
	{
		compute_splat_sizes(numleaves, leaves);
	}
	
	

	// Don't need face data any more
	delete [] faces;

	// Initialize the tree
	QTree qt(numleaves, leaves, havecolor);

	// Build the tree...
	qt.BuildTree();

	// ... and write it out
	qt.Write(outfilename, comments);
	system("PAUSE");
	return 0;
}
コード例 #7
0
ファイル: btree.c プロジェクト: amagar/hammerspace
int tree_chop(struct btree *btree, struct delete_info *info, millisecond_t deadline)
{
	int depth = btree->root.depth, level = depth - 1, suspend = 0;
	struct cursor *cursor;
	struct buffer_head *leafbuf, **prev, *leafprev = NULL;
	struct btree_ops *ops = btree->ops;
	struct sb *sb = btree->sb;
	int ret;

	cursor = alloc_cursor(btree, 0);
	prev = malloc(sizeof(*prev) * depth);
	memset(prev, 0, sizeof(*prev) * depth);

	down_write(&btree->lock);
	probe(btree, info->resume, cursor);
	leafbuf = level_pop(cursor);

	/* leaf walk */
	while (1) {
		ret = (ops->leaf_chop)(btree, info->key, bufdata(leafbuf));
		if (ret) {
			mark_buffer_dirty(leafbuf);
			if (ret < 0)
				goto error_leaf_chop;
		}

		/* try to merge this leaf with prev */
		if (leafprev) {
			struct vleaf *this = bufdata(leafbuf);
			struct vleaf *that = bufdata(leafprev);
			/* try to merge leaf with prev */
			if ((ops->leaf_need)(btree, this) <= (ops->leaf_free)(btree, that)) {
				trace(">>> can merge leaf %p into leaf %p", leafbuf, leafprev);
				(ops->leaf_merge)(btree, that, this);
				remove_index(cursor, level);
				mark_buffer_dirty(leafprev);
				brelse_free(btree, leafbuf);
				//dirty_buffer_count_check(sb);
				goto keep_prev_leaf;
			}
			brelse(leafprev);
		}
		leafprev = leafbuf;
keep_prev_leaf:

		//nanosleep(&(struct timespec){ 0, 50 * 1000000 }, NULL);
		//printf("time remaining: %Lx\n", deadline - gettime());
//		if (deadline && gettime() > deadline)
//			suspend = -1;
		if (info->blocks && info->freed >= info->blocks)
			suspend = -1;

		/* pop and try to merge finished nodes */
		while (suspend || level_finished(cursor, level)) {
			/* try to merge node with prev */
			if (prev[level]) {
				assert(level); /* node has no prev */
				struct bnode *this = cursor_node(cursor, level);
				struct bnode *that = bufdata(prev[level]);
				trace_off("check node %p against %p", this, that);
				trace_off("this count = %i prev count = %i", bcount(this), bcount(that));
				/* try to merge with node to left */
				if (bcount(this) <= sb->entries_per_node - bcount(that)) {
					trace(">>> can merge node %p into node %p", this, that);
					merge_nodes(that, this);
					remove_index(cursor, level - 1);
					mark_buffer_dirty(prev[level]);
					brelse_free(btree, level_pop(cursor));
					//dirty_buffer_count_check(sb);
					goto keep_prev_node;
				}
				brelse(prev[level]);
			}
			prev[level] = level_pop(cursor);
keep_prev_node:

			/* deepest key in the cursor is the resume address */
			if (suspend == -1 && !level_finished(cursor, level)) {
				suspend = 1; /* only set resume once */
				info->resume = from_be_u64((cursor->path[level].next)->key);
			}
			if (!level) { /* remove depth if possible */
				while (depth > 1 && bcount(bufdata(prev[0])) == 1) {
					trace("drop btree level");
					btree->root.block = bufindex(prev[1]);
					mark_btree_dirty(btree);
					brelse_free(btree, prev[0]);
					//dirty_buffer_count_check(sb);
					depth = --btree->root.depth;
					vecmove(prev, prev + 1, depth);
					//set_sb_dirty(sb);
				}
				//sb->snapmask &= ~snapmask; delete_snapshot_from_disk();
				//set_sb_dirty(sb);
				//save_sb(sb);
				ret = suspend;
				goto out;
			}
			level--;
			trace_off(printf("pop to level %i, block %Lx, %i of %i nodes\n", level, bufindex(cursor->path[level].buffer), cursor->path[level].next - cursor_node(cursor, level)->entries, bcount(cursor_node(cursor, level))););
		}

		/* push back down to leaf level */
		while (level < depth - 1) {
			struct buffer_head *buffer = sb_bread(vfs_sb(sb), from_be_u64(cursor->path[level++].next++->block));
			if (!buffer) {
				ret = -EIO;
				goto out;
			}
			level_push(cursor, buffer, ((struct bnode *)bufdata(buffer))->entries);
			trace_off(printf("push to level %i, block %Lx, %i nodes\n", level, bufindex(buffer), bcount(cursor_node(cursor, level))););
		}
コード例 #8
0
ファイル: overlap.cpp プロジェクト: akonskarm/avdpp
void overlap() { 
  Globals::qbs = new QNode*[Globals::threads_num];
  Globals::sets = new std::map<myset,myset*>[Globals::threads_num];
  for (int i = 0; i<Globals::threads_num; i++) {
    Globals::qbs[i] = new QNode();
  }

  denominator = Globals::c2 * Globals::gamma; 
  denominator /= Globals::side_multiplier;
  
  boost::thread* thr[Globals::threads_num];
  for (int i = 0; i < Globals::threads_num; ++i)
    thr[i] = new boost::thread(Worker(i));
  for (int i = 0; i < Globals::threads_num; ++i) {
    thr[i]->join();
    delete thr[i];
  }
 
//  for (int i=0; i<Globals::threads_num; i++) {
//    rec_count(Globals::qbs[i], 1.0);
//    std::cout << Globals::ov_nodes << " " << Globals::ov_leaves << std::endl;
//    Globals::ov_nodes=1;
//    Globals::ov_leaves=0;
//  }
 
  double merging_timer = GetTimeMs();
  for (int i=1; i<Globals::threads_num; i++) {
    std::cout << "Merging " << i << std::endl;
    merge_nodes(Globals::qbs[0],Globals::qbs[i]);
    delete Globals::qbs[i];
  }
  Globals::qb = Globals::qbs[0];
  //depth_all_reprs(Globals::qb);
  make_it_deeper(Globals::qb);

  //TODO
  //std::cout << "start filling" << std::endl;

//  std::cout << "before fill vectors" << std::endl;
//  fill_vectors(Globals::qb, &Globals::hypercube_center, 1.0);

/*  for (int i=0; i<10; i++) {
    printPt(std::cout,*Globals::qt_centers[i]);
    std::cout<<std::endl;
    std::cout << Globals::qt_sides[i] << std::endl;
  }*/

  Globals::ov_nodes=1;
  Globals::ov_leaves=0;
  rec_count(Globals::qb);
  //TODO
  ////std::cout << " ovnodes " << Globals::ov_nodes << " " << Globals::ov_leaves << std::endl;
  ////std::cout << "LEAF: " << couter << std::endl;

  dothereprs();

ANNmin_k* asdf = new ANNmin_k(1);

//  fill_in_reprs(Globals::qb, &Globals::hypercube_center, 1.0, Globals::kdtree, asdf);
  find_all_reprs(Globals::qbs[0], &Globals::hypercube_center, 1.0, Globals::kdtree, asdf,0);

  Globals::merging_time = GetTimeMs() - merging_timer;

  ANNidxArray  nnIdx = new ANNidx[Globals::reprs_num];
  ANNdistArray dists = new ANNdist[Globals::reprs_num];
  //replace_reprs(Globals::qb, &Globals::hypercube_center, 1.0, nnIdx, dists); CHANGE
  delete[] nnIdx;
  delete[] dists; 
//TODO
//  std::cout << "done replacing" << std::endl; 
  /*std::map<myset,myset*>::iterator it;
  for (int i=0; i<Globals::threads_num; i++) {
    for (it=Globals::sets[i].begin(); it!=Globals::sets[i].end(); it++) {
      delete (*it).second;
    }
  }*/
  delete[] Globals::sets;

  //representatives();
}