void runComparisions(nemo::Network* net) { /* No need to always test all these, so just skip some random proportion of * these */ rng_t rng; rng.seed(uint32_t(std::time(0))); brng_t skip(rng, boost::bernoulli_distribution<double>(0.8)); unsigned duration = 2; /* simulations should produce repeatable results both with the same * partition size and with different ones. */ { bool stdp_conf[2] = { false, true }; unsigned psize_conf[3] = { 1024, 512, 256 }; for(unsigned si=0; si < 2; ++si) for(unsigned pi1=0; pi1 < 3; ++pi1) for(unsigned pi2=0; pi2 < 3; ++pi2) { if(skip()) { continue; } nemo::Configuration conf1 = configuration(stdp_conf[si], psize_conf[pi1]); nemo::Configuration conf2 = configuration(stdp_conf[si], psize_conf[pi2]); compareSimulations(net, conf1, net, conf2, duration, stdp_conf[si]); } } }
QString AMScanActionInfo::dbLoadWarnings() const { if(configuration()) { return configuration()->dbLoadWarnings(); } else { return QString("An unknown error occured loading the scan configuration"); } }
bool WServer::start() { if (isRunning()) { LOG_ERROR_S(this, "start(): server already started!"); return false; } LOG_INFO_S(this, "initializing " << (impl_->sessionId_.empty() ? "shared" : "dedicated") << " wtfcgi session process"); if (configuration().webSockets()) { LOG_ERROR_S(this, "FastCGI does not support web-sockets, disabling"); configuration().setWebSockets(false); } configuration().setNeedReadBodyBeforeResponse(true); if (signal(SIGTERM, Wt::handleSigTerm) == SIG_ERR) LOG_ERROR_S(this, "cannot catch SIGTERM: signal(): " << strerror(errno)); if (signal(SIGUSR1, Wt::handleSigUsr1) == SIG_ERR) LOG_ERROR_S(this, "cannot catch SIGUSR1: signal(): " << strerror(errno)); if (signal(SIGHUP, Wt::handleSigHup) == SIG_ERR) LOG_ERROR_S(this, "cannot catch SIGHUP: signal(): " << strerror(errno)); webController_ = new Wt::WebController(*this, impl_->sessionId_, false); impl_->run(); return false; }
bool WServer::start() { setCatchSignals(!impl_->serverConfiguration_->gdb()); if (isRunning()) { LOG_ERROR("start(): server already started!"); return false; } LOG_INFO("initializing built-in wthttpd"); #ifndef WIN32 srand48(getpid()); #endif // Override configuration settings configuration().setRunDirectory(std::string()); configuration().setUseSlashExceptionForInternalPaths (impl_->serverConfiguration_->defaultStatic()); if (!impl_->serverConfiguration_->sessionIdPrefix().empty()) configuration().setSessionIdPrefix(impl_->serverConfiguration_ ->sessionIdPrefix()); configuration().setDefaultEntryPoint(impl_->serverConfiguration_ ->deployPath()); if (impl_->serverConfiguration_->threads() != -1) configuration().setNumThreads(impl_->serverConfiguration_->threads()); try { impl_->server_ = new http::server::Server(*impl_->serverConfiguration_, *this); #ifndef WT_THREADED LOG_WARN("No boost thread support, running in main thread."); #endif // WT_THREADED webController_->start(); ioService().start(); #ifndef WT_THREADED delete impl_->server_; impl_->server_ = 0; ioService().stop(); return false; #else return true; #endif // WT_THREADED } catch (asio_system_error& e) { throw Exception(std::string("Error (asio): ") + e.what()); } catch (std::exception& e) { throw Exception(std::string("Error: ") + e.what()); } }
void Field::write(const H5::CommonFG &loc, const H5::H5Location &parent) const { assert(invariant()); auto group = loc.createGroup(name()); H5::createAttribute(group, "type", project()->enumtype, "Field"); H5::createAttribute(group, "name", name()); // H5::createHardLink(group, "project", parent, "."); H5::createHardLink(group, "..", parent, "."); H5::createSoftLink(group, "project", ".."); // H5::createHardLink(group, "configuration", parent, // "configurations/" + configuration->name()); H5::createSoftLink(group, "configuration", "../configurations/" + configuration()->name()); H5::createHardLink(group, "project/configurations/" + configuration()->name() + "/fields", name(), group, "."); // H5::createHardLink(group, "manifold", parent, // "manifolds/" + manifold->name()); H5::createSoftLink(group, "manifold", "../manifolds/" + manifold()->name()); H5::createHardLink(group, "project/manifolds/" + manifold()->name() + "/fields", name(), group, "."); // H5::createHardLink(group, "tangentspace", parent, // "tangentspaces/" + tangentspace->name()); H5::createSoftLink(group, "tangentspace", "../tangentspaces/" + tangentspace()->name()); H5::createHardLink(group, "project/tangentspaces/" + tangentspace()->name() + "/fields", name(), group, "."); // H5::createHardLink(group, "tensortype", parent, // "tensortypes/" + tensortype->name()); H5::createSoftLink(group, "tensortype", "../tensortypes/" + tensortype()->name()); H5::createGroup(group, "discretefields", discretefields()); }
void ShowHistoryAction::actionInstanceCreated(Action *action) { ChatEditBox *chatEditBox = qobject_cast<ChatEditBox *>(action->parent()); if (!chatEditBox || !chatEditBox->chatWidget()) return; QVariant chatWidgetData = QVariant::fromValue(chatEditBox->chatWidget()); action->setData(chatWidgetData); // not a menu if (action->context()->chat() != chatEditBox->actionContext()->chat()) return; // no parents for menu as it is destroyed manually by Action class QMenu *menu = new QMenu(); if (configuration()->deprecatedApi()->readNumEntry("History", "ChatHistoryCitation", 10) > 0) { int prune = configuration()->deprecatedApi()->readNumEntry("History", "ChatHistoryCitation", 10); menu->addAction(tr("Show last %1 messages").arg(prune), this, SLOT(showPruneMessages()))->setData(chatWidgetData); menu->addSeparator(); } menu->addAction(tr("Show messages since yesterday"), this, SLOT(showOneDayMessages()))->setData(chatWidgetData); menu->addAction(tr("Show messages from last 7 days"), this, SLOT(show7DaysMessages()))->setData(chatWidgetData); menu->addAction(tr("Show messages from last 30 days"), this, SLOT(show30DaysMessages()))->setData(chatWidgetData); menu->addAction(tr("Show whole history"), this, SLOT(showAllMessages()))->setData(chatWidgetData); action->setMenu(menu); }
Array DifferentialEvolution::getMutationProbabilities( const std::vector<Candidate> & population) const { Array mutationProbabilities = currGenCrossover_; switch (configuration().crossoverType) { case Normal: break; case Binomial: mutationProbabilities = currGenCrossover_ * (1.0 - 1.0 / population.front().values.size()) + 1.0 / population.front().values.size(); break; case Exponential: for (Size coIter = 0;coIter< currGenCrossover_.size(); coIter++){ mutationProbabilities[coIter] = (1.0 - std::pow(currGenCrossover_[coIter], (int) population.front().values.size())) / (population.front().values.size() * (1.0 - currGenCrossover_[coIter])); } break; default: QL_FAIL("Unknown crossover type (" << Integer(configuration().crossoverType) << ")"); break; } return mutationProbabilities; }
trainer_result_t batch_trainer_t::train( const task_t& task, const fold_t& fold, const loss_t& loss, size_t nthreads, const string_t& criterion, model_t& model) const { if (fold.second != protocol::train) { log_error() << "batch trainer: can only train models with training samples!"; return trainer_result_t(); } // initialize the model model.resize(task, true); model.random_params(); // prune training & validation data sampler_t tsampler(task); tsampler.setup(fold).setup(sampler_t::atype::annotated); sampler_t vsampler(task); tsampler.split(80, vsampler); if (tsampler.empty() || vsampler.empty()) { log_error() << "batch trainer: no annotated training samples!"; return trainer_result_t(); } // parameters const size_t iterations = math::clamp(text::from_params<size_t>(configuration(), "iters", 1024), 4, 4096); const scalar_t epsilon = math::clamp(text::from_params<scalar_t>(configuration(), "eps", 1e-4), 1e-8, 1e-3); const optim::batch_optimizer optimizer = text::from_string<optim::batch_optimizer> (text::from_params<string_t>(configuration(), "opt", "lbfgs")); // train the model const trainer_result_t result = ncv::batch_train( model, task, tsampler, vsampler, nthreads, loss, criterion, optimizer, iterations, epsilon); const trainer_state_t state = result.optimum_state(); log_info() << "optimum [train = " << state.m_tvalue << "/" << state.m_terror_avg << ", valid = " << state.m_vvalue << "/" << state.m_verror_avg << ", epoch = " << result.optimum_epoch() << ", config = " << text::concatenate(result.optimum_config(), "/") << "]."; // OK if (result.valid()) { model.load_params(result.optimum_params()); } return result; }
void xmppClient::slotHostInfoFinished(const QHostInfo &hostInfo) { if (!hostInfo.addresses().isEmpty()) { info(QString("Found TURN server %1 port %2 for domain %3").arg(hostInfo.addresses().first().toString(), QString::number(m_turnPort), configuration().domain())); callManager->setTurnServer(hostInfo.addresses().first(), m_turnPort); callManager->setTurnUser(configuration().user()); callManager->setTurnPassword(configuration().password()); } m_turnFinished = true; startCall(); }
void CppEditorDocument::setPreprocessorSettings(const CppTools::ProjectPart::Ptr &projectPart, const QByteArray &defines) { const auto parser = processor()->parser(); QTC_ASSERT(parser, return); if (parser->projectPart() != projectPart || parser->configuration().editorDefines != defines) { CppTools::BaseEditorDocumentParser::Configuration config = parser->configuration(); config.manuallySetProjectPart = projectPart; config.editorDefines = defines; parser->setConfiguration(config); emit preprocessorSettingsChanged(!defines.trimmed().isEmpty()); } }
void ChatClient::_q_hostInfoFinished(const QHostInfo &hostInfo) { if (hostInfo.addresses().isEmpty()) { warning(QString("Could not lookup TURN server %1").arg(hostInfo.hostName())); return; } QXmppCallManager *callManager = findExtension<QXmppCallManager>(); if (callManager) { callManager->setTurnServer(hostInfo.addresses().first(), d->turnPort); callManager->setTurnUser(configuration().user()); callManager->setTurnPassword(configuration().password()); } }
/** * Sets any parameter in a user configuration file. Also creates a configuration file if it is missing. * * @param paramName name of parameter that needs to be changed or created. * @param value value for changing or adding to a given parameter. If value is an empty string, the walue for a given parameter will be erased. * @throws IOException exception is thrown if reading, writing or creating of a user configuration file fails. */ void digidoc::XmlConf::setUserConf(const std::string ¶mName, const std::string &value) throw(IOException) { Param newParam(value, paramName); std::auto_ptr< ::Configuration > conf; Configuration::ParamSequence paramSeq; try { if(util::File::fileExists(USER_CONF_LOC)) { //open user conf file conf = configuration (USER_CONF_LOC, xml_schema::Flags::dont_initialize); paramSeq = conf->param(); Configuration::ParamSequence::iterator it; for( it = paramSeq.begin(); it != paramSeq.end(); it++) { if (paramName.compare(it->name()) == 0) { paramSeq.erase(it); break; } } if (value.size()) //if it's a new parameter paramSeq.push_back(newParam); } else { //Check if directory exists if (!util::File::directoryExists(getUserConfDir())) util::File::createDirectory(getUserConfDir()); //create a new file //copy global conf and erase data conf = configuration (DEFAULT_CONF_LOC, xml_schema::Flags::dont_initialize); Configuration::OcspSequence ocspSeq; paramSeq.push_back(newParam); conf->ocsp(ocspSeq); //replace all ocsp data with empty ocsp sequence } conf->param(paramSeq); //replace all param data with new modified param sequence } catch (const xml_schema::Exception& e) { std::ostringstream oss; oss << e; THROW_IOEXCEPTION("(in set %s) Failed to parse configuration: %s", paramName.c_str(), oss.str().c_str()); } serializeUserConf(*conf); }
/** * Sets OCSP configuration parmeters in a user configuration file. Also creates a configuration file if it is missing. * * @param ocspData OCSP configuration structure defined in Conf.h (OCSPConf). Contains: OCSP issuer, OCSP URL and OCSP certificate location. Empty URL or cert location will erase this parameter for given issuer. * @throws IOException exception is thrown if reading, writing or creating of a user configuration file fails. */ void digidoc::XmlConf::setUserOCSP(const Conf::OCSPConf &ocspData) throw(IOException) { Ocsp newOcsp(ocspData.url, ocspData.cert, ocspData.issuer); std::auto_ptr< ::Configuration > conf; Configuration::OcspSequence ocspSeq; try { if(util::File::fileExists(USER_CONF_LOC)) { conf = configuration (USER_CONF_LOC, xml_schema::Flags::dont_initialize); ocspSeq = conf->ocsp(); Configuration::OcspSequence::iterator it; for(it = ocspSeq.begin(); it != ocspSeq.end(); ++it) { if (ocspData.issuer.compare(it->issuer()) == 0) { ocspSeq.erase(it); if (ocspData.url.size() || ocspData.cert.size()) //if we do not want to just erase ocspSeq.insert(it, newOcsp); break; } } if (it == ocspSeq.end() && (ocspData.url.size() || ocspData.cert.size())) //if it's a new parameter ocspSeq.push_back(newOcsp); } else { //Check if directory exists if (!util::File::directoryExists(getUserConfDir())) util::File::createDirectory(getUserConfDir()); //create a new file //copy global conf and erase data conf = configuration (DEFAULT_CONF_LOC, xml_schema::Flags::dont_initialize); Configuration::ParamSequence paramSeq; conf->param(paramSeq); //replace all param data with empty param sequence ocspSeq.push_back(newOcsp); } conf->ocsp(ocspSeq); //replace all ocsp data with new modified ocsp sequence } catch(const xml_schema::Exception& e) { std::ostringstream oss; oss << e; THROW_IOEXCEPTION("(in set OCSP) Failed to parse configuration: %s", oss.str().c_str()); } serializeUserConf(*conf); }
bool LatencyTest::SetDevice(LatencyTestDevice* device) { if (device != Device) { if (device != NULL) { if (device->GetMessageHandler() != NULL) { OVR_DEBUG_LOG( ("LatencyTest::AttachToDevice failed - device %p already has handler", device)); return false; } } if (Device != NULL) { Device->SetMessageHandler(0); } Device = device; if (Device != NULL) { Device->SetMessageHandler(&Handler); // Set trigger threshold. LatencyTestConfiguration configuration(SENSOR_DETECT_THRESHOLD, false); // No samples streaming. Device->SetConfiguration(configuration, true); } } return true; }
void testNonContigousNeuronIndices(backend_t backend, unsigned n0, unsigned nstep) { unsigned ncount = 1000; bool stdp = false; boost::scoped_ptr<nemo::Network> net0(createRing(ncount, 0, false, nstep)); boost::scoped_ptr<nemo::Network> net1(createRing(ncount, n0, false, nstep)); std::vector<unsigned> cycles0, cycles1; std::vector<unsigned> fired0, fired1; unsigned seconds = 2; nemo::Configuration conf = configuration(false, 1024, backend); runSimulation(net0.get(), conf, seconds, &cycles0, &fired0, stdp, std::vector<unsigned>(1, 0)); runSimulation(net1.get(), conf, seconds, &cycles1, &fired1, stdp, std::vector<unsigned>(1, n0)); /* The results should be the same, except firing indices * should have the same offset. */ BOOST_REQUIRE_EQUAL(cycles0.size(), cycles1.size()); BOOST_REQUIRE_EQUAL(fired0.size(), seconds*ncount); BOOST_REQUIRE_EQUAL(fired1.size(), seconds*ncount); for(unsigned i = 0; i < cycles0.size(); ++i) { BOOST_REQUIRE_EQUAL(cycles0.at(i), cycles1.at(i)); BOOST_REQUIRE_EQUAL(fired0.at(i), fired1.at(i) - n0); } //! \todo also add ring networks with different steps. }
void rawDisplayMatrixStream(const Matrix *inputMatrix) { const Ring *R = inputMatrix->get_ring(); const PolyRing *P = R->cast_to_PolyRing(); if (P == 0) { ERROR("expected a polynomial ring"); return; } int charac = P->charac(); int nvars = P->n_vars(); #if defined(HAVE_MATHICGB) mgb::GroebnerConfiguration configuration(charac, nvars); mgb::GroebnerInputIdealStream input(configuration); std::ostringstream computedStr; mgb::IdealStreamLog<> computed(computedStr, charac, nvars); mgb::IdealStreamChecker<decltype(computed)> checked(computed); matrixToStream(inputMatrix, checked); std::cout << "result: " << std::endl; std::cout << computedStr.str() << std::endl; #endif }
void runRing(backend_t backend, unsigned ncount, unsigned delay) { /* Make sure we go around the ring at least a couple of times */ const unsigned duration = ncount * 5 / 2; nemo::Configuration conf = configuration(false, 1024); setBackend(backend, conf); boost::scoped_ptr<nemo::Network> net(createRing(ncount, 0, false, 1, delay)); boost::scoped_ptr<nemo::Simulation> sim(nemo::simulation(*net, conf)); /* Stimulate a single neuron to get the ring going */ sim->step(std::vector<unsigned>(1, 0)); for(unsigned ms=1; ms < duration; ++ms) { const std::vector<unsigned>& fired = sim->step(); if(delay == 1) { BOOST_CHECK_EQUAL(fired.size(), 1U); BOOST_REQUIRE_EQUAL(fired.front(), ms % ncount); } else if(ms % delay == 0) { BOOST_CHECK_EQUAL(fired.size(), 1U); BOOST_REQUIRE_EQUAL(fired.front(), (ms / delay) % ncount); } else { BOOST_CHECK_EQUAL(fired.size(), 0U); } } }
void QXmppOutgoingClient::handleStream(const QDomElement &streamElement) { if (d->state == QXmppOutgoingClientPrivate::Unset || d->state == QXmppOutgoingClientPrivate::TLSStarted || d->state == QXmppOutgoingClientPrivate::Authenticated) { d->state = QXmppOutgoingClientPrivate::WaitingForStreamFeatures; } else { warning("handleStart in invalid state - disconnecting"); disconnectFromHost(); return; } if(d->streamId.isEmpty()) d->streamId = streamElement.attribute("id"); if (d->streamFrom.isEmpty()) d->streamFrom = streamElement.attribute("from"); if(d->streamVersion.isEmpty()) { d->streamVersion = streamElement.attribute("version"); // no version specified, signals XMPP Version < 1.0. // switch to old auth mechanism if enabled if(d->streamVersion.isEmpty() && configuration().useNonSASLAuthentication()) { sendNonSASLAuthQuery(); } } }
auto_release_ptr<Configuration> BaseConfigurationFactory::create_base_final() { auto_release_ptr<Configuration> configuration(new Configuration("base_final")); ParamArray& parameters = configuration->get_parameters(); parameters.insert("spectrum_mode", "rgb"); parameters.insert("sampling_mode", "qmc"); parameters.insert("passes", 1); parameters.insert("frame_renderer", "generic"); parameters.insert("tile_renderer", "generic"); parameters.insert("pixel_renderer", "uniform"); parameters.dictionaries().insert( "uniform_pixel_renderer", ParamArray() .insert("samples", "64")); parameters.insert("sample_renderer", "generic"); parameters.insert("lighting_engine", "pt"); return configuration; }
/// \cond void QXmppOutgoingClient::handleStart() { QXmppStream::handleStart(); // reset stream information d->streamId.clear(); d->streamFrom.clear(); d->streamVersion.clear(); // reset authentication step if (d->saslClient) { delete d->saslClient; d->saslClient = 0; } // reset session information d->bindId.clear(); d->sessionId.clear(); d->sessionAvailable = false; d->sessionStarted = false; // start stream QByteArray data = "<?xml version='1.0'?><stream:stream to='"; data.append(configuration().domain().toUtf8()); data.append("' xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' version='1.0'>"); sendData(data); }
bool LatencyTest::SetDevice(LatencyTestDevice* device) { if (device != Device) { Handler.RemoveHandlerFromDevices(); Device = device; if (Device != NULL) { Device->AddMessageHandler(&Handler); // Set trigger threshold. LatencyTestConfiguration configuration(SENSOR_DETECT_THRESHOLD, false); // No samples streaming. Device->SetConfiguration(configuration, true); // Set display to initial (3 dashes). LatencyTestDisplay ltd(2, 0x40400040); Device->SetDisplay(ltd); } } return true; }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); creation(); configuration(); loadSettings(); }
void xmppClient::slotPresenceReceived(const QXmppPresence &presence) { const QLatin1String recipient("*****@*****.**"); // if we are the recipient, or if the presence is not from the recipient, // do nothing if (jidToBareJid(configuration().jid()) == recipient || jidToBareJid(presence.from()) != recipient || presence.type() != QXmppPresence::Available) return; // send the file and connect to the job's signals QXmppTransferJob *job = transferManager->sendFile(presence.from(), "xmppClient.cpp"); bool check = connect( job, SIGNAL(error(QXmppTransferJob::Error)), this, SLOT(slotError(QXmppTransferJob::Error)) ); Q_ASSERT(check); check = connect( job, SIGNAL(finished()), this, SLOT(slotFinished()) ); Q_ASSERT(check); check = connect( job, SIGNAL(progress(qint64,qint64)), this, SLOT(slotProgress(qint64,qint64)) ); Q_ASSERT(check); }
void read3DConfiguration(const std::string &filename, bool omitOtherTags) { mOmitOtherTags = omitOtherTags; cv::FileStorage configuration(filename, cv::FileStorage::READ); if (!configuration.isOpened()) { std::cerr << "Could not open " << filename << std::endl; return; } mId2Configuration.clear(); for(const auto &objectConfig : configuration.root()) { for(const auto &tagConfig : objectConfig) { int id; tagConfig["tag"] >> id; float size; tagConfig["size"] >> size; int keep; tagConfig["keep"] >> keep; cv::Vec3f translation; cv::Vec3f rotation; for (int i : {0,1,2}) { tagConfig["translation"][i] >> translation[i]; tagConfig["rotation"] [i] >> rotation [i]; } mId2Configuration[id] = std::make_pair( objectConfig.name(), TagConfig(id, size, keep, cv::Vec3f(translation), cv::Vec3f(rotation))); } } }
void interpolator::connect(std::string symbolic_name_base) { // Connect to the config object. hpx::naming::id_type cfg_gid = hpx::agas::resolve_name(symbolic_name_base).get(); cfg_ = configuration(cfg_gid); config_data data = cfg_.get(); if (data.symbolic_name_[data.symbolic_name_.size()-1] != '/') data.symbolic_name_ += "/"; // Connect to the partitions. partitions_.reserve(data.num_instances_); for (std::size_t i = 0; i < data.num_instances_; ++i) { partitions_.push_back(hpx::naming::id_type()); hpx::naming::id_type id = hpx::agas::resolve_name( data.symbolic_name_ + std::to_string(i)).get(); } // Read required data from given file. num_values_[dimension::ye] = extract_data_range(data.datafile_name_, "ye", minval_[dimension::ye], maxval_[dimension::ye], delta_[dimension::ye]); num_values_[dimension::temp] = extract_data_range(data.datafile_name_, "logtemp", minval_[dimension::temp], maxval_[dimension::temp], delta_[dimension::temp]); num_values_[dimension::rho] = extract_data_range(data.datafile_name_, "logrho", minval_[dimension::rho], maxval_[dimension::rho], delta_[dimension::rho]); num_partitions_per_dim_ = static_cast<std::size_t>( std::exp(std::log(double(data.num_instances_)) / 3)); }
void testCurrentStimulus(backend_t backend) { unsigned ncount = 1500; unsigned duration = ncount * 2; nemo::Configuration conf = configuration(false, 1024, backend); boost::scoped_ptr<nemo::Network> net(createRing(ncount)); boost::scoped_ptr<nemo::Simulation> sim(nemo::simulation(*net, conf)); nemo::Simulation::current_stimulus istim; // add some noise before and after istim.push_back(std::make_pair(5U, 0.001f)); istim.push_back(std::make_pair(8U, 0.001f)); istim.push_back(std::make_pair(0U, 1000.0f)); istim.push_back(std::make_pair(100U, 0.001f)); istim.push_back(std::make_pair(1U, 0.001f)); /* Simulate a single neuron to get the ring going */ sim->step(istim); for(unsigned ms=1; ms < duration; ++ms) { const std::vector<unsigned>& fired = sim->step(); BOOST_CHECK_EQUAL(fired.size(), 1U); BOOST_REQUIRE_EQUAL(fired.front(), ms % ncount); } }
/* Run a regular ring network test, but with an additional variable-sized * population of unconnected neurons of a different type. * * The additional Poisson source neurons should not have any effect on the * simulation but should expose errors related to mixing local/global partition * indices. */ void testNeuronTypeMixture(backend_t backend, unsigned szOthers, bool izFirst) { const unsigned szRing = 1024; boost::scoped_ptr<nemo::Network> net(new nemo::Network()); if(izFirst) { createRing(net.get(), szRing); } unsigned poisson = net->addNeuronType("PoissonSource"); float p = 0.001f; for(unsigned n=szRing; n<szRing+szOthers; ++n) { net->addNeuron(poisson, n, 1, &p); } if(!izFirst) { createRing(net.get(), szRing); } nemo::Configuration conf = configuration(false, 1024, backend); boost::scoped_ptr<nemo::Simulation> sim; BOOST_REQUIRE_NO_THROW(sim.reset(nemo::simulation(*net, conf))); /* Stimulate a single neuron to get the ring going */ sim->step(std::vector<unsigned>(1, 0)); const unsigned duration = 1000; for(unsigned ms=1; ms < duration; ++ms) { std::vector<unsigned> fired = sim->step(); BOOST_REQUIRE(fired.size() > 0); std::sort(fired.begin(), fired.end()); BOOST_REQUIRE_EQUAL(fired[0], ms % szRing); if(fired.size() > 1) { BOOST_REQUIRE(fired[1] >= szRing); } } }
ConnectionsConfigurationDialog::ConnectionsConfigurationDialog(int lang, QWidget *parent) : QDialog(parent), ui(new Ui::ConnectionsConfigurationDialog), language(lang) { ui->setupUi(this); configuration(); loadSettings(); }
void main() { configuration(); //InitializeLEDs(); //InitializeTimer(); //EnableTimerInterrupt(); initializeClock(); initializeAlarm(); initializeModifyTime(); configureExternalInterrupts_4(); configureExternalInterrupts_9_5(); configureExternalInterrupts_15_10(); ticks = 1; pause_flag = 1; doNotTriggerButton = 0; //testPtr = 0; state = RunNormal; testNumber = 0; mp3PlayingFlag = 0; while(1) { //if(mp3PlayingFlag == 1) audioToMp3(); } }
::int64_t StockReply::contentLength() { std::string full_path(configuration().errRoot() + stock_replies::toName(status())); std::string original_url; std::string content = ""; std::string line; size_t clen = content_.length(); std::ifstream ifstr(full_path.c_str(), std::ios::in | std::ios::binary); while (ifstr.good() && !ifstr.eof()) { std::getline(ifstr, line); size_t index = 0; while ((index = line.find("<-- SPECIAL CONTENT -->", index)) != line.npos) { line.replace(index,sizeof("<-- SPECIAL CONTENT -->")-1, content_); index += clen; } index = line.find("<-- ORIGINAL URL -->"); if (index != line.npos) { stock_replies::buildOriginalURL(request_, original_url); clen = original_url.length(); do { line.replace(index,sizeof("<-- ORIGINAL URL -->")-1, original_url); index += clen; } while((index = line.find("<-- ORIGINAL URL -->", index) != line.npos)); } index = line.find("<-- ORIGINAL URL ESCAPED -->"); if (index != line.npos) { if (original_url.empty()) stock_replies::buildOriginalURL(request_, original_url); std::string escapedUrl = Wt::Utils::urlEncode(original_url); clen = escapedUrl.length(); do { line.replace(index,sizeof("<-- ORIGINAL URL ESCAPED -->") - 1, escapedUrl); index += clen; } while((index = line.find("<-- ORIGINAL URL ESCAPED -->", index) != line.npos)); } content += line + "\r\n"; } ifstr.close(); if (content.empty()) content_ = stock_replies::toText(status()) + content_; else content_ = content; return content_.length(); }