Beispiel #1
0
void indri::collection::Repository::_merge(index_state& state) {
  // this is only legal if we're not readOnly
  if (_readOnly) return;

  size_t memoryBound = (size_t) (0.75 * _memory);
  std::vector<indri::index::Index*>* result = new std::vector<indri::index::Index*>;

  if (state->size() <= 2 || 
      (_mergeMemory(*state) < memoryBound && 
       _mergeFiles(*state) < MERGE_FILE_LIMIT)) {
    indri::index::Index* index = _mergeStage(state);
    result->push_back(index);
  } else {
    // divide and conquer
    index_state first = new std::vector<indri::index::Index*>;
    index_state second = new std::vector<indri::index::Index*>;

    first->assign(state->begin(), state->begin() + state->size() / 2);
    second->assign(state->begin() + state->size() / 2, state->end());

    // release the previous state object
    state = 0;

    _merge(second);
    _merge(first);

    std::copy(first->begin(), first->end(), std::back_inserter(*result));
    std::copy(second->begin(), second->end(), std::back_inserter(*result));
  }

  state = result;
}
Beispiel #2
0
      // a step
      void epoch() {
        // this->_pop.clear();
        // _pareto_front.clear();
        _selection (_parent_pop, _child_pop);
        parallel::p_for(parallel::range_t(0, _child_pop.size()),
                        mutate<crowd::Indiv<Phen> >(_child_pop));
#ifndef EA_EVAL_ALL
        _eval_subpop(_child_pop);
        _merge(_parent_pop, _child_pop, _mixed_pop);
#else
        _merge(_parent_pop, _child_pop, _mixed_pop);
        _eval_subpop(_mixed_pop);
#endif
        _apply_modifier(_mixed_pop);
#ifndef NDEBUG
        BOOST_FOREACH(indiv_t& ind, _mixed_pop)
        for (size_t i = 0; i < ind->fit().objs().size(); ++i) {
          assert(!std::isnan(ind->fit().objs()[i]));
        }
#endif
        _fill_nondominated_sort(_mixed_pop, _parent_pop);
        _mixed_pop.clear();
        _child_pop.clear();

        _convert_pop(_parent_pop, this->_pop);

        assert(_parent_pop.size() == Params::pop::size);
        assert(_pareto_front.size() <= Params::pop::size * 2);
        assert(_mixed_pop.size() == 0);
        //	assert(_child_pop.size() == 0);
        assert(this->_pop.size() == Params::pop::size);
      }
Beispiel #3
0
int main (int argc, char *argv[]) {

  graph_t  gin;
  graph_t  gout;
  args_t   args;

  startup("cmerge", argc, argv, NULL, NULL);
  
  memset(&args, 0, sizeof(args_t));
  _parse_opt(argc, argv, &args);

  if (ngdb_read(args.input, &gin)) {
    printf("Could not read in %s\n", args.input);
    goto fail;
  }

  printf("merging...\n");
  if (_merge(&gin, &gout, args.mergesets, args.nmergesets)) {
    printf("Could not perform merge\n");
    goto fail;
  }

  if (ngdb_write(&gout, args.output)) {
    printf("Could not write to %s\n", args.output);
    goto fail;
  }

  return 0;

fail:
  return 1;
}
Beispiel #4
0
void _split(T A[], T temp[], int begin, int end)
{
	if ((end - begin) < 2)
		return;
	
	
	// recursively split into halves until size is 1,
	// then merge and go back up.
	int mid = (end + begin) / 2;

	// I chose 16 because it's a power of 2 and precedence.
	if ((end - mid) <= 16)
	{
		insertion_sort(A, end, mid);	// mid included.
		insertion_sort(A, mid, begin);	// mid excluded.
	}
	// Split if large enough.
	else
	{
		_split(A, temp, begin, mid);	// mid will be excluded.
		_split(A, temp, mid, end);		// mid will be included.
	}
	_merge(A, temp, begin, mid, end);	// merge them back again.
	_copy (A, temp, begin, end);		// Copy sorted array to original array.
}
 /* [begin, end)区间
  * 归并排序
  */
 void _sort(ListNode *begin, ListNode *end)
 {
     //处理0~1个节点
     if (begin == NULL || begin->next == end)
     {
         return ;
     }
     //处理两个节点,交换数据
     else if (begin->next->next == end)
     {
         if ( begin->val > begin->next->val)
         {
             int t = begin->val;
             begin->val = begin->next->val;
             begin->next->val = t;
         }
         return ;
     }
     // 寻找中间节点
     ListNode * p1 = begin, *p2 = begin->next;
     while(p2 != end)
     {
         p1 = p1->next;
         p2 = p2->next;
         if(p2 != end)
         {
             p2 = p2->next;
         }
     }
     //排序
     _sort(begin, p1);
     _sort(p1, end);
     _merge(begin, p1, end);
 }
Beispiel #6
0
static SdbListIter * _merge_sort(SdbListIter *head, SdbListComparator cmp) {
	SdbListIter *second;
	if (!head || !head->n) {
		return head;
	}
	second = _sdb_list_split (head);
	head = _merge_sort (head, cmp);
	second = _merge_sort (second, cmp);
	return _merge (head, second, cmp);
}
Beispiel #7
0
void _mergesort(std::vector<T>& arr, int64_t begin, int64_t end,
                std::vector<T>& scratch) {
  // trivially sorted since it is 1
  if (end - begin <= 1)
    return;
  int64_t mid = (begin + end) / 2;
  _mergesort(arr, begin, mid, scratch);
  _mergesort(arr, mid, end, scratch);
  _merge(arr, begin, mid, end, scratch);
  _copy(scratch, begin, end, arr);
}
Beispiel #8
0
	node<V>* _cut(node<V>* heap,node<V>* n) {
		if(n->next==n) {
			n->parent->child=NULL;
		} else {
			n->next->prev=n->prev;
			n->prev->next=n->next;
			n->parent->child=n->next;
		}
		n->next=n->prev=n;
		n->marked=false;
		return _merge(heap,n);
	}
Beispiel #9
0
      int _MergeSort(int li, int ls) {
 
           if(li==ls) return vec[ li ];

           else {

                int middle = (li+ls)>>1;

                _MergeSort(li, middle); 
                _MergeSort(middle + 1, ls);
                _merge(li, middle, ls);
           }  
      };
Beispiel #10
0
/* Substring sort */
void
substringsort(const sauchar_t *T, const saidx_t *PA,
              saidx_t *first, saidx_t *last,
              saidx_t *buf, saidx_t bufsize,
              saidx_t depth, saint_t lastsuffix) {
  saidx_t *a, *b;
  saidx_t *curbuf;
  saidx_t i, j, k;
  saidx_t curbufsize;

  if(lastsuffix != 0) { ++first; }
  for(a = first, i = 0; (a + SS_BLOCKSIZE) < last; a += SS_BLOCKSIZE, ++i) {
    _multikey_introsort(T, PA, a, a + SS_BLOCKSIZE, depth);
    curbuf = a + SS_BLOCKSIZE;
    curbufsize = last - (a + SS_BLOCKSIZE);
    if(curbufsize <= bufsize) { curbufsize = bufsize, curbuf = buf; }
    for(b = a, k = SS_BLOCKSIZE, j = i; j & 1; b -= k, k <<= 1, j >>= 1) {
      _merge(T, PA, b - k, b, b + k, curbuf, curbufsize, depth);
    }
  }
  _multikey_introsort(T, PA, a, last, depth);
  for(k = SS_BLOCKSIZE; i != 0; k <<= 1, i >>= 1) {
    if(i & 1) {
      _merge(T, PA, a - k, a, last, buf, bufsize, depth);
      a -= k;
    }
  }

  if(lastsuffix != 0) {
    /* Insert last type B* suffix. */
    for(a = first, i = *(first - 1);
        (a < last) && ((*a < 0) || (0 < _compare(T, PA + i, PA + *a, depth)));
        ++a) {
      *(a - 1) = *a;
    }
    *(a - 1) = i;
  }
}
Beispiel #11
0
	node<V>* _removeMinimum(node<V>* n) {
		_unMarkAndUnParentAll(n->child);
		if(n->next==n) {
			n=n->child;
		} else {
			n->next->prev=n->prev;
			n->prev->next=n->next;
			n=_merge(n->next,n->child);
		}
		if(n==NULL)return n;
		node<V>* trees[64]={NULL};

		while(true) {
			if(trees[n->degree]!=NULL) {
				node<V>* t=trees[n->degree];
				if(t==n)break;
				trees[n->degree]=NULL;
				if(n->value<t->value) {
					t->prev->next=t->next;
					t->next->prev=t->prev;
					_addChild(n,t);
				} else {
					t->prev->next=t->next;
					t->next->prev=t->prev;
					if(n->next==n) {
						t->next=t->prev=t;
						_addChild(t,n);
						n=t;
					} else {
						n->prev->next=t;
						n->next->prev=t;
						t->next=n->next;
						t->prev=n->prev;
						_addChild(t,n);
						n=t;
					}
				}
				continue;
			} else {
				trees[n->degree]=n;
			}
			n=n->next;
		}
		node<V>* min=n;
		do {
			if(n->value<min->value)min=n;
			n=n->next;
		} while(n!=n);
		return min;
	}
Beispiel #12
0
list_t mergesort_l(list_t src, comparator_t cmp)
{
    if (!src || !src->cdr)
	return src;
    _queue_t qs[2] = { {NULL, NULL}
    , {NULL, NULL}
    };
    size_t i;
    for (i = 0; src; i++) {
	enqueue(&qs[i & 1], shift(&src), NULL);
    }
    return _merge(mergesort_l(qs[0].head, cmp),
		  mergesort_l(qs[1].head, cmp), cmp);
}
void _mergesort(int left, int right) {

    if(right == left) return;

    else {

         uint middle = (left + right) >> 1;

         _mergesort(left, middle); 

         _mergesort(middle + 1, right);

         _merge(left, middle, right);
    } 
};
Beispiel #14
0
void mergeSort(int *input, int n) {
    int *bak = malloc(sizeof(int)*n);
    int *handle = input;
    int *store = bak;
    int width,i;
    for(width=1; width<n; width=2*width) {
        for(i=0; i<n; i=i+2*width) {
            _merge(handle, i, MIN(i+width,n), MIN(i+2*width,n),store);
        }
        if (handle==input) handle = bak;
        else if (handle==bak) handle = input;
        if (store==input) store = bak;
        else if (store==bak) store = input;
    }
    free(bak);
}
Beispiel #15
0
void merge_sort(int* const a,const int high)
{
	const int LOW=0;
	const int TMPSIZE=high-LOW;
	const int STACKSIZE=log2(TMPSIZE)*2+3;
	int sort_count=0;
	strct_prms2 stack_prms[STACKSIZE];
	std::unique_ptr<int[]> buff(new int[TMPSIZE]);
	int* _buff = buff.get();
	stack_prms[0].low=LOW;
	stack_prms[0].high=high-1;
	strct_prms2* _ptr=nullptr;
	int _low=-1;
	int _high=-1;
	int _mid=-1;
	while(sort_count>=0)
	{
		strct_prms2* _ptr=stack_prms+sort_count;
		_low=_ptr->low;
		_high=_ptr->high;
		if((_ptr->check_))
		{
			_merge(a,_buff,_low,_high);
			_ptr->check_=0;
			--sort_count;
		}
		else
		{
			if(_low<_high)
				{	
					
					_ptr->check_=1;
					_mid=(_low+_high)>>1;
					++sort_count;++_ptr;
					_ptr->low=_mid+1;
					_ptr->high=_high;
					++sort_count;++_ptr;
					_ptr->low=_low;
					_ptr->high=_mid;
				}
			else
				--sort_count;
		}
Beispiel #16
0
/**
 * \brief Merge pairs of nodes and reverse the order.
 *
 * Given a list of \p src nodes, merge adjacent pairs and reverse the ordering
 * of the result. The resulting merged nodes are stored in \p dst. This is the
 * first merge pass when deleting the minimum node from the heap.
 *
 * \param [in] ph Pairing heap containing the nodes to merge.
 * \param [out] dst List into which the nodes are merged.
 * \param [in] src List from which to merge nodes.
 *
 * \post \c list_isempty(src)
 *
 * \note This operation has a time complexity of O(n) with respect to the length
 * of \p src.
 */
static void _merge_pairs_reverse(const struct pheap *ph, struct list *dst,
        struct list *src)
{
    struct pheap_elem *left, *right;

    /* Move left to right, merging pairs */
    while (!list_isempty(src))
    {
        left = containerof(list_popfront(src),
                struct pheap_elem, child_le);
        if (!list_isempty(src))
        {
            right = containerof(list_popfront(src),
                    struct pheap_elem, child_le);
            left = _merge(ph, left, right);
        }

        /* Push the merged element onto the front of the destination, so that
         * the result is in reverse order.
         */
        list_pushfront(dst, &left->child_le);
    }
Beispiel #17
0
void indri::collection::Repository::_merge() {
  // this is only legal if we're not readOnly
  if (_readOnly)
    return;

  // grab a copy of the current state
  index_state state = indexes();
  index_state mergers = state;

  if (state->size() && state->back()->documentCount() == 0) {
    // if the current index is empty, don't need to add a new one; write the others
    mergers = new index_vector;
    mergers->assign(state->begin(), state->end() - 1);
  } else {
    // current index isn't empty, so add a new one and write the old ones
    _addMemoryIndex();
  }

  // no need to merge when there's only one index (or none)
  bool needsWrite = (mergers->size() > 1) ||
    (mergers->size() == 1 && dynamic_cast<indri::index::MemoryIndex*>((*mergers)[0]));

  if (!needsWrite)
    return;

  state = 0;

  // merge all the indexes together
  while (needsWrite) {
    _merge(mergers);

    needsWrite = (mergers->size() > 1) ||
      (mergers->size() == 1 && dynamic_cast<indri::index::MemoryIndex*>((*mergers)[0]));

  }
  _checkpoint();
}
Beispiel #18
0
void indri::collection::Repository::_write() {
  // this is only legal if we're not readOnly
  if (_readOnly) return;
  
  // grab a copy of the current state
  index_state state = indexes();
  
  // if the current index is empty, don't need to write it
  if (state->size() && state->back()->documentCount() == 0) return;
  
  // make a new MemoryIndex, cutting off the old one from updates
  _addMemoryIndex();
  
  // if we just added the first, no need to write the "old" one
  if (state->size() == 0) return;
  
  // write out the last index
  index_state lastState = new std::vector<indri::index::Index*>;
  lastState->push_back(state->back());
  state = 0;

  _merge(lastState);
  _checkpoint();
}
Beispiel #19
0
	void _addChild(node<V>* parent,node<V>* child) {
		child->prev=child->next=child;
		child->parent=parent;
		parent->degree++;
		parent->child=_merge(parent->child,child);
	}
Beispiel #20
0
void indri::collection::Repository::_trim() {
  // this is only legal if we're not readOnly
  if (_readOnly)
    return;

  // grab a copy of the current state
  index_state state = indexes();

  if (state->size() <= 3)
    return;

  size_t count = state->size();
  int position;

  // here's how this works:
  //   we're trying to just 'trim' the indexes so that we merge
  //   together the small indexes, leaving the large ones as they are.
  //   We merge together a minimum of 3 indexes every time.  We may merge
  //   more, however.  We start at the most recent indexes, and search
  //   backward in time.  When we get to an index that is significantly
  //   larger than the previous index, we stop.
  //

  // have to merge at least the last three indexes
  int firstDocumentCount = (int)(*state)[count-1]->documentCount();
  int lastDocumentCount = (int)(*state)[count-3]->documentCount();
  int documentCount = 0;
 
  // move back until we find a really big index--don't merge with that one
  for(position = count-4; position>=0; position--) {
    // compute the average number of documents in the indexes we've seen so far
    documentCount = (int)(*state)[position]->documentCount();

    // break if we find an index more than 8 times as large 
    // as the preceding one.
    if (documentCount > lastDocumentCount*8.0)
      {
        position++;
        break;
      }

    lastDocumentCount = documentCount;
  }

  // make sure position is greater than or equal to 0
  position = lemur_compat::max<int>(position, 0);

  // make a new MemoryIndex, cutting off the old one from updates
  _addMemoryIndex();

  // write out the last index
  index_state substate = new std::vector<indri::index::Index*>;
  substate->assign(state->begin() + position, state->end());
  state = 0;

  // substate may be larger than 1 if we didn't have enough 
  // memory to merge everything together.  That's okay,
  // because we were just trimming.
  _merge(substate);
  _checkpoint();
}
Beispiel #21
0
shared_ptr<Way> WayAverager::average()
{
  _sumMovement1 = 0.0;
  _sumMovement2 = 0.0;
  _moveCount1 = 0;
  _moveCount2 = 0;
  _maxMovement1 = 0.0;
  _maxMovement2 = 0.0;

  if (DirectionFinder::isSimilarDirection(_map.shared_from_this(), _w1, _w2) == false)
  {
    if (_w1->isOneWay() == true)
    {
      _w2->reverseOrder();
    }
    else
    {
      _w1->reverseOrder();
    }
  }

  shared_ptr<const LineString> ls1 = ElementConverter(_map.shared_from_this()).
      convertToLineString(_w1);
  shared_ptr<const LineString> ls2 = ElementConverter(_map.shared_from_this()).
      convertToLineString(_w2);

  // All of the fancy stats here are compliments of Mike Porter.

  // calculate standard deviation in meters
  Meters sd1 = _w1->getCircularError() / 2.0;
  Meters sd2 = _w2->getCircularError() / 2.0;
  // calculate variance;
  double v1 = sd1 * sd1;
  double v2 = sd2 * sd2;
  // calculate weights for averaging.
  double weight1 = 1 - v1 / (v1 + v2);
  double weight2 = 1 - v2 / (v1 + v2);

  Meters newAcc = 2.0 * sqrt(weight1 * weight1 * v1 + weight2 * weight2 * v2);

  shared_ptr<Way> result(new Way(_w1->getStatus(), _map.createNextWayId(),
                                 newAcc));

  _map.addWay(result);

  result->addNode(_merge(_w1->getNodeIds()[0], weight1, _w2->getNodeIds()[0], weight2));

  // we're getting the vectors affter the above merge because the merge will change node ids.
  const std::vector<long>& ns1 = _w1->getNodeIds();
  const std::vector<long>& ns2 = _w2->getNodeIds();

  size_t i1 = 1;
  size_t i2 = 1;

  // while there is more than one point available in each line
  while (i1 < ns1.size() - 1 || i2 < ns2.size() - 1)
  {
    // if we're all out of cs1 points
    if (i1 == ns1.size() - 1)
    {
      result->addNode(_moveToLine(ns2[i2++], weight2, ls1.get(), weight1, 2));
    }
    // if we're all out of cs2 points
    else if (i2 == ns2.size() - 1)
    {
      result->addNode(_moveToLine(ns1[i1++], weight1, ls2.get(), weight2, 1));
    }
    else
    {
      const Coordinate& last = _map.getNode(result->getLastNodeId())->toCoordinate();

      const Coordinate& nc1 = _moveToLineAsCoordinate(ns1[i1], weight1, ls2.get(), weight2);
      const Coordinate& nc2 = _moveToLineAsCoordinate(ns2[i2], weight2, ls1.get(), weight1);

      if (nc1.distance(last) < nc2.distance(last))
      {
        result->addNode(_moveToLine(ns1[i1++], weight1, ls2.get(), weight2, 1));
      }
      else
      {
        result->addNode(_moveToLine(ns2[i2++], weight2, ls1.get(), weight1, 2));
      }
    }
  }

  // merge the last two nodes and move to the average location
  result->addNode(_merge(ns1[i1], weight1, ns2[i2], weight2));

  // use the default tag merging mechanism
  Tags tags = TagMergerFactory::mergeTags(_w1->getTags(), _w2->getTags(), ElementType::Way);

  result->setTags(tags);

  _map.removeWay(_w1->getId());
  _map.removeWay(_w2->getId());

  _meanMovement1 = _sumMovement1 / (double)_moveCount1;
  _meanMovement2 = _sumMovement2 / (double)_moveCount2;

  return result;
}
Beispiel #22
0
	void merge(FibonacciHeap& other) {
		heap=_merge(heap,other.heap);
		other.heap=_empty();
	}
Beispiel #23
0
	node<V>* insert(V value) {
		node<V>* ret=_singleton(value);
		heap=_merge(heap,ret);
		return ret;
	}