// ----------------------------------------------------------------
f2poly_t f2poly_random(int deg)
{
	if (deg < 0) {
		std::cerr << "f2poly_random:  degree " << deg
			<< " should be non-negative.\n";
		exit(1);
	}

	f2poly_t rv(0);
	rv.set_bit(deg);
	for (int i = deg-1; i >= 0; i--) {
		int bit = (get_random_unsigned() >> 17) & 1;
		if (bit)
			rv.set_bit(i);
	}
	return rv;
}

QoreValue QoreHashMapOperatorNode::mapIterator(AbstractIteratorHelper& h, ExceptionSink* xsink) const {
   ReferenceHolder<QoreHashNode> rv(ref_rv ? new QoreHashNode : 0, xsink);

   qore_size_t i = 0;
   // set offset in thread-local data for "$#"
   while (true) {
      bool has_next = h.next(xsink);
      if (*xsink)
         return QoreValue();
      if (!has_next)
	 break;

      ImplicitElementHelper eh(i++);

      ReferenceHolder<> iv(h.getValue(xsink), xsink);
      if (*xsink)
         return QoreValue();

      // check if value can be mapped
      SingleArgvContextHelper argv_helper(*iv, xsink);

      {
	 ValueEvalRefHolder ekey(e[0], xsink);
	 if (*xsink)
	    return QoreValue();
	 
	 // we have to convert to a string in the default encoding to use a hash key
	 QoreStringValueHelper key(*ekey, QCS_DEFAULT, xsink);
	 if (*xsink)
	    return QoreValue();
	 
	 ValueEvalRefHolder val(e[1], xsink);
	 if (*xsink)
	    return QoreValue();
	 
	 if (ref_rv)
	    rv->setKeyValue(key->getBuffer(), val.getReferencedValue(), xsink);
      }
      // if there is an exception dereferencing one of the evaluted nodes above, then exit the loop
      if (*xsink)
	 return QoreValue();
   }
   
   return rv.release();
}

	SSMProcess* SceneModeler::compute(){
		setProgressText("starting computation");
		setProgressMax(100);
		setProgressValue(1);
		this->captureSceneLimits();
		this->calculateClasses();
		this->computeIndexSequence();
		for(int i = Lb(*this->transitionDataStates); i <= Ub(*this->transitionDataStates); i++){
			(*this->transitionDataStates)[i] += 1;
		}
		
		intvector rv(Lb(*this->transitionDataStates) , Ub(*this->transitionDataStates) );
		for(int i = Lb(rv) ; i <= Ub(rv) ; i++){
			rv[i] = (*this->transitionDataStates)[i];
		}
		setProgressText("creating model");
		return modelFromIndexSequence(rv);
	}

std::string randStr(int len)
{
	srand(GetTickCount());

	auto randChar = []() {
		char c = '\0';
		do {
			c = rand() % 0xFF;
		} while (!::isalpha(c));
		return c;
	};

	std::string rv(len, '\0');
	for (int i = 0; i < len; ++i)
		rv[i] = randChar();

	return rv;
}

std::string HTTPRequest::ReadBody()
{
    struct evbuffer* buf = evhttp_request_get_input_buffer(req);
    if (!buf)
        return "";
    size_t size = evbuffer_get_length(buf);
    /** Trivial implementation: if this is ever a performance bottleneck,
     * internal copying can be avoided in multi-segment buffers by using
     * evbuffer_peek and an awkward loop. Though in that case, it'd be even
     * better to not copy into an intermediate string but use a stream
     * abstraction to consume the evbuffer on the fly in the parsing algorithm.
     */
    const char* data = (const char*)evbuffer_pullup(buf, size);
    if (!data) // returns NULL in case of empty buffer
        return "";
    std::string rv(data, size);
    evbuffer_drain(buf, size);
    return rv;
}

NS_IMETHODIMP MaemoLocationProvider::Startup()
{
  nsresult rv(NS_OK);

  nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
  if (!prefs)
    return NS_ERROR_FAILURE;

  rv = StartControl();
  NS_ENSURE_SUCCESS(rv, rv);

  rv = StartDevice();
  NS_ENSURE_SUCCESS(rv, rv);

  prefs->GetBoolPref("geo.herror.ignore.big", &mIgnoreBigHErr);

  if (mIgnoreBigHErr)
    prefs->GetIntPref("geo.herror.max.value", &mMaxHErr);

  prefs->GetBoolPref("geo.verror.ignore.big", &mIgnoreBigVErr);

  if (mIgnoreBigVErr)
    prefs->GetIntPref("geo.verror.max.value", &mMaxVErr);

  if (mUpdateTimer)
    return NS_OK;

  PRInt32 update = 0; //0 second no timer created
  prefs->GetIntPref("geo.default.update", &update);

  if (!update)
    return NS_OK;

  mUpdateTimer = do_CreateInstance("@mozilla.org/timer;1", &rv);

  if (NS_FAILED(rv))
    return NS_ERROR_FAILURE;

  if (update)
    mUpdateTimer->InitWithCallback(this, update, nsITimer::TYPE_REPEATING_SLACK);

  return NS_OK;
}

std::auto_ptr<ImageChange>
    Canvas::getContents() const
{
    std::auto_ptr<ImageChange> rv
        ( new ImageChange() );
    if ( contents.get() == NULL )
        return rv;

    rv->new_image = dStorm::display::Image( mkImgSize(getSize()) );
    unsigned char *d = contents->GetData();
    dStorm::display::Image::iterator i;
    for (i = rv->new_image.begin(); i != rv->new_image.end(); i++) {
        i->red() = *d++;
        i->green() = *d++;
        i->blue() = *d++;
    }

    return rv;
}

std::auto_ptr< input::Traits<engine::ImageStack> >
OpenFile::getTraits()
{
    char readsif_error[4096];
    dataSet->error_buffer = readsif_error;

    std::auto_ptr< engine::InputTraits > 
        rv( new engine::InputTraits() );
    /* Read the additional information file from the SIF file
     * and store it in SIF info structure. */
    std::stringstream ss;

    rv->push_back( engine::InputPlane() );
    rv->plane(0).image.size.x() = 
            readsif_imageWidth( dataSet, 0 ) * camera::pixel;
    rv->plane(0).image.size.y() = readsif_imageHeight( dataSet, 0 )
            * camera::pixel;
    if ( dataSet->instaImage.kinetic_cycle_time > 1E-8 ) {
        rv->frame_rate = 1.0f * camera::frame / ( dataSet->instaImage.kinetic_cycle_time
                * boost::units::si::second );
    }
    rv->image_number().range().second =
        (readsif_numberOfImages(dataSet) - 1) * camera::frame;

    boost::units::quantity<boost::units::celsius::temperature,int> temp
        = (int(dataSet->instaImage.temperature) * boost::units::celsius::degrees);
    Reader r(rv->infos[DataSetTraits::CameraTemperature]);
    static_cast<std::ostream&>(r) << temp;

    if ( dataSet->instaImage.OutputAmp == 0 )
        rv->infos[DataSetTraits::OutputAmplifierType] = "Electron multiplication";
    else
        rv->infos[DataSetTraits::OutputAmplifierType] = "Conventional amplification";

    Reader(rv->infos[DataSetTraits::VerticalShiftSpeed]) 
        << dataSet->instaImage.data_v_shift_speed*1E6 << " µs";
    Reader(rv->infos[DataSetTraits::HorizontalShiftSpeed]) 
        << 1E-6/dataSet->instaImage.pixel_readout_time << " MHz";
    Reader(rv->infos[DataSetTraits::PreamplifierGain]) 
        << dataSet->instaImage.PreAmpGain;

    return rv;
}

// ****************************************************************************
//  Method: DBOptionsAttributes::GetEnumStrings
//
//  Purpose:
//     Finds the index of a member.
//
//  Programmer: Hank Childs (assumed)
//  Creation:   Unknown
//
//  Modifications:
//    Mark C. Miller, Tue Apr 29 17:39:39 PDT 2008
//    Made it a const method
// ****************************************************************************
std::vector<std::string>
DBOptionsAttributes::GetEnumStrings(const std::string &name) const
{
    int  i;

    int eIndex = FindIndex(name);
    if (eIndex < 0)
        EXCEPTION0(BadDeclareFormatString);

    int start = 0;
    for (i = 0 ; i < eIndex ; i++)
        start += enumStringsSizes[i];

    std::vector<std::string> rv(enumStringsSizes[eIndex]);
    for (i = 0 ; i < enumStringsSizes[eIndex] ; i++)
        rv[i] = enumStrings[start+i];

    return rv;
}

// static
LLSocket::ptr_t LLSocket::create(apr_status_t& status, LLSocket::ptr_t& listen_socket)
{
	if (!listen_socket->getSocket())
	{
		status = APR_ENOSOCKET;
		return LLSocket::ptr_t();
	}
	LLSocket::ptr_t rv(new LLSocket);
	LL_DEBUGS() << "accepting socket" << LL_ENDL;
	status = apr_socket_accept(&rv->mSocket, listen_socket->getSocket(), rv->mPool());
	if (status != APR_SUCCESS)
	{
		rv->mSocket = NULL;
		rv.reset();
		return rv;
	}
	rv->mPort = PORT_EPHEMERAL;
	rv->setNonBlocking();
	return rv;
}

cv::Mat GoodFrame::getRT(std::vector<cv::Point3f> &modelPoints_min)
{
    cv::Mat img = this->getCapturesImage();
    std::vector<cv::Point2f> imagePoints;
    for (size_t i = 0; i < 68; ++i)
    {
        imagePoints.push_back(cv::Point2f((float)(this->getDetected_landmarks().at<double>(i)),
                                          (float)(this->getDetected_landmarks().at<double>(i+68))));
    }

    /////
    int max_d = MAX(img.rows,img.cols);
    cv::Mat camMatrix = (Mat_<double>(3,3) << max_d, 0,     img.cols/2.0,
                         0,	 max_d, img.rows/2.0,
                         0,	 0,	    1.0);

    cv::Mat ip(imagePoints);
    cv::Mat op(modelPoints_min);
    std::vector<double> rv(3), tv(3);
    cv::Mat rvec(rv),tvec(tv);
    double _dc[] = {0,0,0,0};
    //    std::cout << ip << std::endl << std::endl;
    //    std::cout << op << std::endl << std::endl;
    //    std::cout << camMatrix << std::endl << std::endl;
    solvePnP(op, ip, camMatrix, cv::Mat(1,4,CV_64FC1,_dc), rvec, tvec, false, CV_EPNP);

    double rot[9] = {0};
    cv::Mat rotM(3, 3, CV_64FC1, rot);
    cv::Rodrigues(rvec, rotM);
    double* _r = rotM.ptr<double>();
    //    printf("rotation mat: \n %.3f %.3f %.3f\n%.3f %.3f %.3f\n%.3f %.3f %.3f\n",_r[0],_r[1],_r[2],_r[3],_r[4],_r[5],_r[6],_r[7],_r[8]);

    //    printf("trans vec: \n %.3f %.3f %.3f\n",tv[0],tv[1],tv[2]);

    cv::Mat _pm(3, 4, CV_64FC1);
    _pm.at<double>(0,0) = _r[0]; _pm.at<double>(0,1) = _r[1]; _pm.at<double>(0,2) = _r[2]; _pm.at<double>(0,3) = tv[0];
    _pm.at<double>(1,0) = _r[3]; _pm.at<double>(1,1) = _r[4]; _pm.at<double>(1,2) = _r[5]; _pm.at<double>(1,3) = tv[1];
    _pm.at<double>(2,0) = _r[6]; _pm.at<double>(2,1) = _r[7]; _pm.at<double>(2,2) = _r[8]; _pm.at<double>(2,3) = tv[2];

    return _pm;
}

AST_Decl *
ast_visitor_tmpl_module_inst::reify_type (AST_Decl *d)
{
  if (d == 0)
    {
      return 0;
    }

  if (this->ref_only_)
    {
      // If d is a param holder, the lookup will return a heap
      // allocation, which we need since this node's destination
      // owns param holders.
      if (d->node_type () == AST_Decl::NT_param_holder)
        {
          return
            idl_global->scopes ().top ()->lookup_by_name (
              d->name (),
              true);
        }
      else
        {
          return d;
        }
    }

  ast_visitor_reifying rv (this->ctx_);

  if (d->ast_accept (&rv) != 0)
    {
      ACE_ERROR ((LM_ERROR,
                  ACE_TEXT ("ast_visitor_tmpl_module_inst::")
                  ACE_TEXT ("reify_type() - reifying ")
                  ACE_TEXT ("visitor failed on %C\n"),
                  d->full_name ()));

      return 0;
    }

  return rv.reified_node ();
}

		const Vector operator()(const Vector &v) const
		{
			assert(v.size() == 3u);
			Vector rv(v);

			switch (_axis)
			{
				case X: rv[Y] = v[Y] * cosA - v[Z] * sinA;
					rv[Z] = v[Y] * sinA + v[Z] * cosA;
					break;
				case Y: rv[X] = v[Z] * sinA + v[X] * cosA;
					rv[Z] = v[Z] * cosA - v[X] * sinA;
					break;
				case Z: rv[X] = v[X] * cosA - v[Y] * sinA;
					rv[Y] = v[X] * sinA + v[Y] * cosA;
					break;
				default: assert(false);
			}

			return rv;
		}

// ----------------------------------------------------------------
f2npoly_t f2npoly_random(f2poly_t m, int deg)
{
	if (deg < 0) {
		std::cerr << "f2npoly_random:  degree " << deg
			<< " should be non-negative.\n";
		exit(1);
	}

	f2poly_t a0(0);
	f2poly_t a1(1);
	f2polymod_t am0(a0, m);
	f2polymod_t am1(a1, m);
	f2npoly_t rv(am0);
	for (int i = deg; i >= 0; i--) {
		f2polymod_t am = f2polymod_random(m);
		if ((i == deg) && (am == am0))
			am = am1;
		rv.set_coeff(i, am);
	}
	return rv;
}

  DiracDeterminantBase::GradType 
    DiracDeterminantBase::evalGradSource(ParticleSet& P, ParticleSet& source,
					 int iat)
  {
    Phi->evaluateGradSource (P, FirstIndex, LastIndex,
			     source, iat, grad_source_psiM);
      
//     Phi->evaluate(P, FirstIndex, LastIndex, psiM, dpsiM, d2psiM);
//     LogValue=InvertWithLog(psiM.data(),NumPtcls,NumOrbitals,WorkSpace.data(),Pivot.data(),PhaseValue);

    const ValueType* restrict yptr=psiM[0];
    const GradType* restrict dyptr=grad_source_psiM[0];
    GradType rv(0.0,0.0,0.0);
    for (int i=0; i<NumPtcls; i++)
      for(int j=0; j<NumOrbitals; j++) 
	//rv += (*yptr++) *(*dyptr++);
	rv += grad_source_psiM(i,j) * psiM(i,j);
    // HACK HACK
    //return (grad_source_psiM(1,3));
    return rv;
  }

// static
LLSocket::ptr_t LLSocket::create(apr_status_t& status, LLSocket::ptr_t& listen_socket)
{
	LLMemType m1(LLMemType::MTYPE_IO_TCP);
	if (!listen_socket->getSocket())
	{
		status = APR_ENOSOCKET;
		return LLSocket::ptr_t();
	}
	LLSocket::ptr_t rv(new LLSocket);
	lldebugs << "accepting socket" << llendl;
	status = apr_socket_accept(&rv->mSocket, listen_socket->getSocket(), rv->mPool());
	if (status != APR_SUCCESS)
	{
		rv->mSocket = NULL;
		rv.reset();
		return rv;
	}
	rv->mPort = PORT_EPHEMERAL;
	rv->setNonBlocking();
	return rv;
}

MyVector<T>
TridiagonalMatrix<T>::operator*(const MyVector<T>& vec) const
{
        if(size != vec.getSize())
	{
		throw typename Matrix<T>::
		      IncompatibleMatrixSizes(size, size,
		                              vec.getSize(), vec.getSize());
	}

	MyVector<T> rv(size);
	if(size == 1)
	{
		rv[0] = getNonZeroElement(0,0) * vec[0];
	}
	else
	{
		// add the appropriate sums from the first column of the matrix
		rv[0] += getNonZeroElement(0, 0) * vec[0];
		rv[1] += getNonZeroElement(1, 0) * vec[0];

		// add the appropriate sums from the second through n-1 columns
		// of the matrix
		for(size_t j = 1; j < size - 1; ++j)
		{
			for(size_t i = j - 1; i <= j + 1; ++i)
			{
				rv[i] += getNonZeroElement(i, j) * vec[j];
			}
		}

		// add the appropriate sums from the last column of the matrix
		rv[size - 2] += 
			getNonZeroElement(size - 2, size - 1) * vec[size - 1];
		rv[size - 1] += 
			getNonZeroElement(size - 1, size - 1) * vec[size - 1];
	}

	return rv;
}

  //-----------------------------------------------------------
  void OprtAdd::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int num)
  { 
    assert(num==2);

    const IValue *arg1 = a_pArg[0].Get();
    const IValue *arg2 = a_pArg[1].Get();
    if (arg1->GetType()=='m' && arg2->GetType()=='m')
    {
      // Vector + Vector
      const matrix_type &a1 = arg1->GetArray(),
                       &a2 = arg2->GetArray();
      if (a1.GetRows()!=a2.GetRows())
        throw ParserError(ErrorContext(ecARRAY_SIZE_MISMATCH, -1, GetIdent(), 'm', 'm', 2));
      
      matrix_type rv(a1.GetRows());
      for (int i=0; i<a1.GetRows(); ++i)
      {
        if (!a1.At(i).IsNonComplexScalar())
          throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a1.At(i).GetType(), 'f', 1)); 

        if (!a2.At(i).IsNonComplexScalar())
          throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a2.At(i).GetType(), 'f', 1)); 

        rv.At(i) = a1.At(i).GetFloat() + a2.At(i).GetFloat();
      }

      *ret = rv; 
    }
    else
    {
      if (!arg1->IsNonComplexScalar())
        throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), arg1->GetType(), 'f', 1)); 

      if (!arg2->IsNonComplexScalar())
        throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), arg2->GetType(), 'f', 2)); 
      
      *ret = arg1->GetFloat() + arg2->GetFloat(); 
    }
  }

	size_t copy(Iterator &&out, size_t n, size_t skip) const
	{
		if (!base_ptr)
			return 0;

		auto last(base_ptr->node_ptr.load());
		auto last_cnt(std::min(last->pos.load(), BlockSize));
		node_type *p(&base_ptr->first_node);

		for (; skip >= BlockSize; skip -= BlockSize) {
			if (p == last)
				return 0;
			p = p->next;
		}

		size_t rv(0);
		while (n && (p != last)) {
			auto cnt(std::min(BlockSize - skip, n));
			for (size_t c(0); c < cnt; ++c)
				*out++ = p->items[c + skip];

			rv += cnt;
			n -= cnt;
			skip = 0;
			p = p->next;
		}

		if (n && (p == last)) {
			if (skip >= last_cnt)
				return 0;
			auto cnt(std::min(last_cnt - skip, n));
			for (auto c(0); c < cnt; ++c)
				*out++ = p->items[c + skip];

			rv += cnt;
		}

		return rv;
	}

AbstractQoreNode *command::read_rows(const Placeholders *ph, ExceptionSink* xsink) {
   if (ensure_colinfo(xsink)) return 0;

   ReferenceHolder<AbstractQoreNode> rv(xsink);
   QoreListNode *l = 0;
   while (fetch_row_into_buffers(xsink)) {
      ReferenceHolder<QoreHashNode> h(output_buffers_to_hash(ph, xsink), xsink);
      if (*xsink) return 0;
      if (rv) {
	 if (!l) {
	    ReferenceHolder<QoreListNode> lholder(new QoreListNode(), xsink);
	    l = *lholder;
	    l->push(rv.release());
	    rv = lholder.release();
	 }
	 l->push(h.release());
      }
      else
	 rv = h.release();
   }
   return rv.release();
}