void Palette::mouseMoveEvent(QMouseEvent* ev)
      {
      if ((currentIdx != -1) && (dragIdx == currentIdx) && (ev->buttons() & Qt::LeftButton)
         && (ev->pos() - dragStartPosition).manhattanLength() > QApplication::startDragDistance()) {
            PaletteCell* cell = cells[currentIdx];
            if (cell && cell->element) {
                  QDrag* drag = new QDrag(this);
                  QMimeData* mimeData = new QMimeData;
                  Element* el  = cell->element;
                  qreal mag    = PALETTE_SPATIUM * extraMag / gscore->spatium();
                  QPointF spos = QPointF(dragStartPosition) / mag;
                  spos        -= QPointF(cells[currentIdx]->x, cells[currentIdx]->y);

                  // DEBUG:
                  spos.setX(0.0);
                  mimeData->setData(mimeSymbolFormat, el->mimeData(spos));
                  drag->setMimeData(mimeData);

                  dragSrcIdx = currentIdx;
                  emit startDragElement(el);
                  if (_readOnly) {
                        drag->start(Qt::CopyAction);
                        }
                  else {
                        /*Qt::DropAction action = */
                        drag->start(Qt::DropActions(Qt::CopyAction | Qt::MoveAction));
                        }
                  }
            }
      else {
            QRect r;
            if (currentIdx != -1)
                  r = idxRect(currentIdx);
            currentIdx = idx(ev->pos());
            if (currentIdx != -1) {
                  if (cells[currentIdx] == 0)
                        currentIdx = -1;
                  else
                        r |= idxRect(currentIdx);
                  }
            update(r);
            }
      }

MatHandler CreateMat(int cols, int rows, TYPE *nums){
	matrix_t *m = (matrix_t *)calloc(1, sizeof(matrix_t));
	if (m){
		assert(cols > 0 && rows > 0);
		m->cols = cols; m->rows = rows;
		m->data = (TYPE *)calloc(cols*rows, sizeof(TYPE));
		if (m->data){
			if (nums){
				for (int i = 0; i < cols; ++i){
					for (int j = 0; j < rows; ++j){
						m->data[idx(i, cols, j)] = *(nums + j*cols + i);
					}
				}
			}
			return (MatHandler *)m;
		}
	}
	return NULL;
}

int IndexedTriangleIO::insertFlattenedVertexVTN(const int v, const int t, const  int n)
{
  Vec3i idx(v,t,n);
  std::map<Vec3i,size_t>::iterator it = mIndicesCache.find(idx);

  //vertex does not exist
  if(it==mIndicesCache.end())
  {
    it = (mIndicesCache.insert(std::make_pair(idx,mVertexPosition.size()))).first;
    mVertexPosition.push_back(mVertexPositionCache[v-1]);

    // copy / duplicate texcoords and normals if appropriate
    if(t >= 0)
      mVertexTextureCoordinate.push_back(mVertexTextureCoordinateCache[t-1]);
    if(n >= 0)
      mVertexNormal.push_back(mVertexNormalCache[n-1]);
  }
  return int(it->second);
}

STD1::uint32_t Document::writeNameMap( std::FILE* out )
{
    STD1::uint32_t offset( 0 );
    if( !isInf() && !nameMap.empty() ) {
        offset = std::ftell( out );
        ConstNameMapIter itr;
        for( itr = nameMap.begin(); itr != nameMap.end(); ++itr ) {
            STD1::uint16_t index( itr->first->index() );
            if( std::fwrite( &index, sizeof( STD1::uint16_t ), 1, out ) != 1 )
                throw FatalError( ERR_WRITE );
        }
        for( itr = nameMap.begin(); itr != nameMap.end(); ++itr ) {
            STD1::uint16_t idx( itr->second.index() );
            if( std::fwrite( &idx, sizeof( STD1::uint16_t ), 1, out ) != 1 )
                throw FatalError( ERR_WRITE );
        }
    }
    return offset;
}

static int pyGeometrySpan_setIndices(pyGeometrySpan* self, PyObject* value, void*) {
    if (value == NULL || !PySequence_Check(value)) {
        PyErr_SetString(PyExc_TypeError, "indices should be a sequence of unsigned shorts");
        return -1;
    }
    size_t count = PySequence_Size(value);
    for (size_t i = 0; i < count; ++i) {
        if (!PyInt_Check(PySequence_Fast_GET_ITEM(value, i))) {
            PyErr_SetString(PyExc_TypeError, "indices should be a sequence of unsigned shorts");
            return -1;
        }
    }

    std::vector<unsigned short> idx(PySequence_Size(value));
    for (size_t i = 0; i < idx.size(); ++i)
        idx[i] = PyInt_AsLong(PySequence_Fast_GET_ITEM(value, i));
    self->fThis->setIndices(idx);
    return 0;
}

void update_map_pos()
{
    // z (blender x) 100m
    // x (blender y) 100m

    float ratio = (float) screen_map_len / 100;
    float half = screen_map_len / 2;

    map_pos_u = mypos.x * ratio + half;
    map_pos_v =-mypos.z * ratio + half;

    float mu = (float) map_len_u / screen_map_len;
    float mv = (float) map_len_v / screen_map_len;

    iu = map_pos_u * mu;
    iv = map_pos_v * mv;

	altura_terreno = idx();
}

SparseMatrix* MainWindow::buildModel(const QImage &img)
{
    SparseMatrix *ret = new SparseMatrix(5,this); //Dims: 0=north 1=south 2=east 3=west 4=pos
    for(int row = 0; row<img.height(); row++)
    {
        for(int col = 0; col<img.width(); col++)
        {
            Vector_t idx(5);
            idx[0] = (row == 0) ? 5 : QColor(img.pixel(col,row-1)).lightness()&0xFF;
            idx[1] = (row+1 == img.height()) ? 5 : QColor(img.pixel(col,row+1)).lightness()&0xFF;
            idx[2] = (col == 0) ? 5 : QColor(img.pixel(col-1,row)).lightness()&0xFF;
            idx[3] = (col+1 == img.width()) ? 5 : QColor(img.pixel(col+1,row)).lightness()&0xFF;
            idx[4] = QColor(img.pixel(col,row)).lightness()&0xFF;
            if(!idx.contains(5)) //ignore edge pixels
                ret->inc(idx);
        }
    }
    return ret;
}

int CreateMinorMat(MatHandler mat, int icol, int jrow, MatHandler *ans){ /*	Создает минор только n-1-ого порядка*/
	matrix_t *a, *m = (matrix_t *)mat;
	assert(m->cols > 1 && m->rows > 1);
	a = (matrix_t *)(*ans) = (matrix_t *)CreateMat(m->cols - 1, m->rows - 1, NULL);
	if (!a) return M_ERR_ALLOC;
	a->cols = m->cols - 1;
	a->rows = m->rows - 1;
	int id = 0;
	for (int i = 0; i < m->cols; ++i){
		if (i == icol) continue;
		for (int j = 0; j < m->rows; ++j){
			if (j == jrow) continue;
			int r = idx(i, m->cols, j);
			a->data[id] = m->data[r];
			++id;
		}
	}
	return M_OK;
}

int main(int narg, char* arg[]) {
  Kokkos::initialize (narg, arg);

  int size = 1000000;

  idx_type idx("Idx",size,64);
  idx_type_host h_idx = Kokkos::create_mirror_view (idx);

  view_type dest ("Dest", size);
  view_type src ("Src", size);

  srand(134231);

  for (int i = 0; i < size; i++) {
    for (view_type::size_type j = 0; j < h_idx.dimension_1 (); ++j) {
      h_idx(i,j) = (size + i + (rand () % 500 - 250)) % size;
    }
  }

  // Deep copy the initial data to the device
  Kokkos::deep_copy(idx,h_idx);
  // Run the first kernel to warmup caches
  Kokkos::parallel_for(size,localsum<view_type,view_type_rnd>(idx,dest,src));
  Kokkos::fence();

  // Run the localsum functor using the RandomAccess trait. On CPUs there should
  // not be any different in performance to not using the RandomAccess trait.
  // On GPUs where can be a dramatic difference
  Kokkos::Impl::Timer time1;
  Kokkos::parallel_for(size,localsum<view_type,view_type_rnd>(idx,dest,src));
  Kokkos::fence();
  double sec1 = time1.seconds();

  Kokkos::Impl::Timer time2;
  Kokkos::parallel_for(size,localsum<view_type,view_type>(idx,dest,src));
  Kokkos::fence();
  double sec2 = time2.seconds();

  printf("Time with Trait RandomAccess: %f with Plain: %f \n",sec1,sec2);

  Kokkos::finalize();
}

local_mirror_t<Object>::local_mirror_t(fh_map_t *map_, Object b, 
				       boost::uint32_t v, const std::string &migr_svc) : 
    version(v), snapshot_marker(v), blob(b), fh_map(map_), blob_size(b->get_size(v)), 
    page_size(b->get_page_size()), chunk_map(blob_size / page_size, CHUNK_UNTOUCHED), 
    written_map(blob_size / page_size, false),
    async_io_thread(boost::bind(&local_mirror_t<Object>::async_io_exec, this)),
    migration_thread(boost::bind(&migration_wrapper::migr_exec, blob.get(),
				 (migration_wrapper::updater_t)
				 boost::bind(&local_mirror_t<Object>::schedule_chunk, this, _1),
				 (migration_wrapper::updater_t)
				 boost::bind(&local_mirror_t<Object>::cancel_chunk, this, _1),
				 boost::cref(migr_svc))), migr_flag(false)
{

    std::stringstream ss;
    ss << "/tmp/blob-mirror-" << b->get_id() << "-" << version;
    local_name = ss.str();
    
    if ((fd = open(local_name.c_str(), 
		   O_RDWR | O_CREAT | O_NOATIME, 0666)) == -1)
	throw std::runtime_error("could not open temporary file: " + local_name);
    flock lock;
    lock.l_type = F_WRLCK; lock.l_whence = SEEK_SET;
    lock.l_start = 0; lock.l_len = blob_size;
    if (fcntl(fd, F_SETLK, &lock) == -1) {
	close(fd);
	throw std::runtime_error("could not lock temporary file: " + local_name);
    }
    if (lseek(fd, 0, SEEK_END) != (off_t)blob_size) {
	lseek(fd, blob_size - 1, SEEK_SET);
	if (::write(fd, &blob_size, 1) != 1) {
	    close(fd);
	    throw std::runtime_error("could not adjust temporary file: " + local_name);
	}
    }

    std::ifstream idx((local_name + ".idx").c_str(), 
		      std::ios_base::in | std::ios_base::binary);
    if (idx.good()) {
	boost::archive::binary_iarchive ar(idx);
	ar >> chunk_map >> written_map;
    }

static bool chunk_visitor(
  const RBTree_Node *node,
  RBTree_Direction dir,
  void *visitor_arg
)
{
  rtems_rbheap_chunk *chunk = rtems_rbheap_chunk_of_node(node);
  chunk_visitor_context *context = visitor_arg;

  rtems_test_assert(context->index_current != context->index_end);
  rtems_test_assert(context->free_current != context->free_end);

  rtems_test_assert(idx(chunk) == *context->index_current);
  rtems_test_assert(rtems_rbheap_is_chunk_free(chunk) == *context->free_current);

  ++context->index_current;
  ++context->free_current;

  return false;
}

vector<int> sort_indexes(const vector<double> &v) {

  // initialize original index locations
  vector<int> idx(v.size());
  for (int i = 0; i != idx.size(); ++i) idx[i] = i;

  // sort indexes based on comparing values in v
	//I can't use std::sort because c++ is super gay
	int temp;
	for(int j=idx.size();j>0;j--){
		for(int i=0;i<j-1;i++){
			if(v[idx[i]]>v[idx[i+1]]){
				 temp=idx[i];
				 idx[i]=idx[i+1];
				 idx[i+1]=temp;
			}
		}
	}
  return idx;
}

Thesaurus::Thesaurus(agi::fs::path const& dat_path, agi::fs::path const& idx_path)
: dat(io::Open(dat_path))
{
	std::unique_ptr<std::ifstream> idx(io::Open(idx_path));

	std::string encoding_name;
	getline(*idx, encoding_name);
	std::string unused_entry_count;
	getline(*idx, unused_entry_count);

	// Read the list of words and file offsets for those words
	for (line_iterator<std::string> iter(*idx, encoding_name), end; iter != end; ++iter) {
		std::vector<std::string> chunks;
		boost::split(chunks, *iter, _1 == '|');
		if (chunks.size() == 2)
			offsets[chunks[0]] = atoi(chunks[1].c_str());
	}

	conv.reset(new charset::IconvWrapper(encoding_name.c_str(), "utf-8"));
}

Thesaurus::Thesaurus(agi::fs::path const& dat_path, agi::fs::path const& idx_path)
: dat(make_unique<read_file_mapping>(dat_path))
{
	read_file_mapping idx_file(idx_path);
	boost::interprocess::ibufferstream idx(idx_file.read(), static_cast<size_t>(idx_file.size()));

	std::string encoding_name;
	getline(idx, encoding_name);
	std::string unused_entry_count;
	getline(idx, unused_entry_count);

	conv = make_unique<charset::IconvWrapper>(encoding_name.c_str(), "utf-8");

	// Read the list of words and file offsets for those words
	for (auto const& line : line_iterator<std::string>(idx, encoding_name)) {
		auto pos = line.find('|');
		if (pos != line.npos && line.find('|', pos + 1) == line.npos)
			offsets[line.substr(0, pos)] = static_cast<size_t>(atoi(line.c_str() + pos + 1));
	}
}

double pcac_correlation_function(int t)
{
  complex double C = 0;
  for (int x = 0; x < X1; x ++)
  {
    int index = idx(x, t, X1);
    complex double a = R1[index].s1;
    complex double b = R1[index].s2;
    complex double c = R2[index].s1;
    complex double d = R2[index].s2;
    //C += I * (a * cconj(c) - c * cconj(a) + b * cconj(d) - d * cconj(b));
    C += -cimag(a * cconj(c)) - cimag(b * cconj(d));
    //C += -cimag(c);
    //C += -cimag(a * cconj(b)) - cimag(c * cconj(d));
  }
  C *= 2;
  if (fabs(cimag(C)) > 1e-6)
    printf("\nImaginary part of PCAC correlation function detected!\n");
  return fabs(C);
}

        void getAllData(Container& vals, int rank) const
        {
            assert(this->rank == rank);

            for (int i = 0;i < ndim;i++)
            {
                if (len[i] == 0)
                {
                    vals.clear();
                    return;
                }
            }

            std::vector<tkv_pair<T> > pairs;
            std::vector<int> idx(ndim, 0);

            first_packed_indices(ndim, len.data(), sym.data(), idx.data());

            do
            {
                int64_t key = 0, stride = 1;
                for (int i = 0;i < ndim;i++)
                {
                    key += idx[i]*stride;
                    stride *= len[i];
                }
                pairs.push_back(tkv_pair<T>(key, (T)0));
            }
            while (next_packed_indices(ndim, len.data(), sym.data(), idx.data()));

            dt->read(pairs.size(), pairs.data());

            sort(pairs.begin(), pairs.end());
            size_t npair = pairs.size();
            vals.resize(npair);

            for (size_t i = 0;i < npair;i++)
            {
                vals[i] = pairs[i].d;
            }
        }

  TYPED_TEST(EvaluationDomainTest, FFT) {

    const size_t m = 4;
    std::vector<TypeParam> f = { 2, 5, 3, 8 };

    std::shared_ptr<evaluation_domain<TypeParam> > domain;
    for (int key = 0; key < 5; key++)
    {
      try
      {
        if (key == 0) domain.reset(new basic_radix2_domain<TypeParam>(m));
        else if (key == 1) domain.reset(new extended_radix2_domain<TypeParam>(m));
        else if (key == 2) domain.reset(new step_radix2_domain<TypeParam>(m));
        else if (key == 3) domain.reset(new geometric_sequence_domain<TypeParam>(m));
        else if (key == 4) domain.reset(new arithmetic_sequence_domain<TypeParam>(m));

        std::vector<TypeParam> a(f);
        domain->FFT(a);

        std::vector<TypeParam> idx(m);
        for (size_t i = 0; i < m; i++)
        {
          idx[i] = domain->get_domain_element(i);
        }

        for (size_t i = 0; i < m; i++)
        {
          TypeParam e = evaluate_polynomial(m, f, idx[i]);
          EXPECT_TRUE(e == a[i]);
        }
      }
      catch(DomainSizeException &e)
      {
        printf("%s - skipping\n", e.what());
      }
      catch(InvalidSizeException &e)
      {
        printf("%s - skipping\n", e.what());
      }
    }
  }

 void check( const BSONObj &spec ) {
     _c.ensureIndex( ns(), idx() );
     Client::Context ctx( ns() );
     FieldRangeSet frs( ns(), spec );
     boost::shared_ptr< FieldRangeVector > frv( new FieldRangeVector( frs, idx(), direction() ) );
     BtreeCursor c( nsdetails( ns() ), 1, nsdetails( ns() )->idx( 1 ), frv, direction() );
     Matcher m( spec );
     int count = 0;
     while( c.ok() ) {
         ASSERT( m.matches( c.current() ) );
         c.advance();
         ++count;
     }
     int expectedCount = 0;
     for( vector< BSONObj >::const_iterator i = _objs.begin(); i != _objs.end(); ++i ) {
         if ( m.matches( *i ) ) {
             ++expectedCount;
         }
     }
     ASSERT_EQUALS( expectedCount, count );
 }

void
AccountListWidget::updateEntries( const QModelIndex& topLeft, const QModelIndex& bottomRight )
{
    for( int row = topLeft.row(); row <= bottomRight.row(); ++row )
    {
        QPersistentModelIndex idx( m_model->index( row, 0 ) );

        int newCount = idx.data( Tomahawk::Accounts::AccountModel::ChildrenOfFactoryRole )
                            .value< QList< Tomahawk::Accounts::Account* > >().count();

        if( m_entries.value( idx ).count() == newCount )
        {
            updateEntry( idx );
        }
        else
        {
            removeEntries( idx.parent(), idx.row(), idx.row() );
            insertEntries( idx.parent(), idx.row(), idx.row() );
        }
    }
}

void QgsMapToolAddCircularString::createCenterPointRubberBand()
{
  if ( !mShowCenterPointRubberBand || mPoints.size() < 2 || mPoints.size() % 2 != 0 )
  {
    return;
  }

  mCenterPointRubberBand = createGeometryRubberBand( Qgis::Polygon );
  mCenterPointRubberBand->show();

  if ( mTempRubberBand )
  {
    const QgsAbstractGeometryV2* rubberBandGeom = mTempRubberBand->geometry();
    if ( rubberBandGeom )
    {
      QgsVertexId idx( 0, 0, 2 );
      QgsPointV2 pt = rubberBandGeom->vertexAt( idx );
      updateCenterPointRubberBand( pt );
    }
  }
}