// ---------------------------------------------------------------- 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 OGL4ShaderCompiler::ClearVersionComment(const std::string& source) { std::regex r("#version .*"); std::string str = source; std::regex_iterator<std::string::iterator> rit(str.begin(), str.end(), r); std::regex_iterator<std::string::iterator> rend; std::string first = rit->str(); std::regex rv("#version .*"); std::string fmt = ""; std::string result = std::regex_replace(source, rv, fmt); return first + result; }
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::string OGL4ShaderCompiler::AdjustEntryPoint(const std::string& src, const std::string& entry) { if(src.empty()) { return src; } if(entry.empty()) { return src; } std::regex rv("void\\s+" + entry); std::string fmt = "void main"; std::string result = std::regex_replace(src, rv, fmt); return result; }
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; }
void CNrpHUDConfig::Load( const NrpText& fileName ) { INrpConfig::Load( fileName ); IniFile rv( fileName ); IniSection* fonts = rv.GetSection( SECTION_FONTS ); assert( fonts ); if( fonts ) { const IniSection::KeyIndexA& keys = fonts->GetKeys(); for( IniSection::KeyIndexA::const_iterator pIter = keys.begin(); pIter != keys.end(); pIter++ ) RegProperty<NrpText>( (*pIter)->GetShortKey().c_str(), (*pIter)->GetValue().c_str() ); } else Log( HW ) << "Can't find section \"fonts\" in " << fileName << term; }
// 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 ExtensibleGraph::propagate_arguments_in_function_graph( Nodecl::NodeclBase arguments ) { ERROR_CONDITION( _nodecl.is_null( ), "Found a null nodecl for a graph that is supposed to contain a FunctionCode", 0 ); ERROR_CONDITION( !_nodecl.is<Nodecl::FunctionCode>( ), "Expected FunctionCode but '%s' found", ast_print_node_type( _nodecl.get_kind( ) ) ); Symbol func_sym( _nodecl.get_symbol( ) ); ERROR_CONDITION( !func_sym.is_valid( ), "Invalid symbol for a nodecl that is supposed to contain a FunctionCode", 0 ); Nodecl::List args = arguments.as<Nodecl::List>( ); ObjectList<Symbol> params = func_sym.get_function_parameters( ); int n_common_params = std::max( args.size( ), params.size( ) ); sym_to_nodecl_map rename_map; for( int i = 0; i < n_common_params; ++i ) { rename_map[params[i]] = args[i]; } RenameVisitor rv( rename_map ); Node* graph_entry = _graph->get_graph_entry_node( ); propagate_argument_rec( graph_entry, &rv ); ExtensibleGraph::clear_visits( graph_entry ); }
//----------------------------------------------------------- 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(); }
QRegion GfxCanvas::resetDirty() { QRect r = _oldDirty | dirtyItemClip(); for(int ii = 0; ii < _dirtyItems.count(); ++ii) _dirtyItems.at(ii)->clean(); _dirtyItems.clear(); _oldDirty = QRect(); if(gfxFullRepaint) return QRegion(); else if(!_dynArea.isEmpty() || !_dynItems.isEmpty()) { QRegion rv(r); if(rv.isEmpty()) return rv; rv |= _dynArea; for(int ii = 0; ii <_dynItems.count(); ++ii) if(_dynItems.at(ii)->visible().value()) rv |= _dynItems.at(ii)->boundingRect(); return rv; } else return QRegion(r); }
CComBSTR GetCaptionFromFileName(const TCHAR* file_name) { _ASSERT( file_name != NULL ); CONST TCHAR* s = _tcsrchr(file_name, _T('\\')); if (s == NULL) { return CComBSTR(_T("")); } TCHAR* buf = _tcsdup(s + 1); if (buf == NULL) { return CComBSTR(_T("")); } TCHAR* p = _tcsrchr(buf, _T('.')); if (p != NULL) { *p = 0; } CComBSTR rv(buf); free(buf); return rv; }
void CNrpPlant::Load( const NrpText& saveFolder ) { NrpText fileName = OpFileSystem::CheckEndSlash( saveFolder ) + "plant.ini"; assert( OpFileSystem::IsExist( fileName ) ); INrpConfig::Load( fileName ); IniFile rv( fileName ); int maxNumber = (int)Param( WORKNUMBER ) + (int)Param( REKLAMENUMBER ); for( int k=0; k < maxNumber; k++ ) { NrpText type = rv.Get( SECTION_WORKS, CreateKeyType( k ), NrpText("") ); NrpText saveFile = rv.Get( SECTION_WORKS, CreateKeyWork( k ), NrpText("") ); if( OpFileSystem::IsExist( saveFile ) ) { if( type == CNrpPlantWork::ClassName() ) AddWork( new CNrpPlantWork( saveFile, true ) ); else if( type == CNrpReklameWork::ClassName() ) AddReklame( CNrpReklameWork( saveFile ) ); } } }
void LocalH :: FindInnerBoxes ( // int (*sameside)(const Point3d & p1, const Point3d & p2), AdFront3 * adfront, int (*testinner)(const Point3d & p1)) { int i; int nf = adfront->GetNF(); for (i = 0; i < boxes.Size(); i++) boxes[i] -> flags.isinner = 0; root->flags.isinner = 0; Point3d rpmid(root->xmid[0], root->xmid[1], root->xmid[2]); Vec3d rv(root->h2, root->h2, root->h2); Point3d rx2 = rpmid + rv; Point3d rx1 = rpmid - rv; root->flags.pinner = !adfront->SameSide (rpmid, rx2); if (testinner) (*testout) << "inner = " << root->flags.pinner << " =?= " << testinner(Point3d(root->xmid[0], root->xmid[1], root->xmid[2])) << endl; ARRAY<int> faceinds(nf); ARRAY<Box3d> faceboxes(nf); for (i = 1; i <= nf; i++) { faceinds.Elem(i) = i; adfront->GetFaceBoundingBox(i, faceboxes.Elem(i)); } for (i = 0; i < 8; i++) FindInnerBoxesRec2 (root->childs[i], adfront, faceboxes, faceinds, nf); }
//----------------------------------------------------------- void OprtSub::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) { assert(num==2); if (a_pArg[0]->GetType()=='m' && a_pArg[1]->GetType()=='m') { const matrix_type &a1 = a_pArg[0]->GetArray(), &a2 = a_pArg[1]->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) = cmplx_type(a1.At(i).GetFloat() - a2.At(i).GetFloat(), a1.At(i).GetImag() - a2.At(i).GetImag()); } *ret = rv; } else { if (!a_pArg[0]->IsNonComplexScalar()) throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[0]->GetType(), 'f', 1)); if (!a_pArg[1]->IsNonComplexScalar()) throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[1]->GetType(), 'f', 2)); *ret = a_pArg[0]->GetFloat() - a_pArg[1]->GetFloat(); } }
/// Send messages between a client and server asynchronously. /// /// @see overview of zmq socket types https://sachabarbs.wordpress.com/2014/08/21/zeromq-2-the-socket-types-2/ /// @see bounce is based on https://github.com/zeromq/azmq/blob/master/test/socket/main.cpp /// @see flatbuffers https://google.github.io/flatbuffers/md__cpp_usage.html void bounce(std::shared_ptr<AzmqFlatbuffer> sendP, std::shared_ptr<AzmqFlatbuffer> receiveP, bool shouldReceive = true) { receiveP->start_async_receive_buffers(); for (int x = 0; x<1000; ++x) { ///////////////////////////////////////// // Client sends to server asynchronously! { auto fbbP = sendP->GetUnusedBufferBuilder(); grl::flatbuffer::Vector3d rv(x,0,0); auto controlPoint = grl::flatbuffer::CreateVrepControlPoint(*fbbP,&rv); grl::flatbuffer::FinishVrepControlPointBuffer(*fbbP, controlPoint); sendP->async_send_flatbuffer(fbbP); } ////////////////////////////////////////////// // Server receives from client asynchronously! while (shouldReceive && !receiveP->receive_buffers_empty()) { auto rbP = receiveP->get_back_receive_buffer_with_data(); auto rbPstart = &(rbP->begin()[0]); auto verifier = flatbuffers::Verifier(rbPstart,rbP->size()); auto bufOK = grl::flatbuffer::VerifyVrepControlPointBuffer(verifier); if(bufOK) { const grl::flatbuffer::VrepControlPoint* VCPin = grl::flatbuffer::GetVrepControlPoint(rbPstart); std::cout << "received: " << VCPin->position()->x() << "\n"; } else { std::cout << "Failed verification. bufOk: " <<bufOK << "\n"; } } std::this_thread::sleep_for( std::chrono::milliseconds(1) ); } }