// ----------------------------------------------------------------
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) );
}
}
