std::pair<std::vector<float>, std::vector<int> > make_fake_dataset(std::vector<Signal>& signals, std::vector<Systematic>& systematics, std::vector<Observable>& observables, std::vector<double> params, bool poisson, int maxsamples) { std::cout << "make_fake_dataset: Generating dataset..." << std::endl; std::vector<double> syst_vals; for (size_t i=signals.size();i<signals.size()+systematics.size();i++){ syst_vals.push_back(params[i]); } std::vector<float> upper; std::vector<float> lower; for (size_t i=0;i<observables.size();i++){ upper.push_back(observables[i].upper); lower.push_back(observables[i].lower); } std::vector<float> events; std::vector<int> weights; std::vector<unsigned> observed(signals.size()); for (size_t i=0;i<signals.size();i++){ observed[i] = \ dynamic_cast<pdfz::EvalHist*>(signals[i].histogram)->RandomSample(events,weights,params[i], syst_vals,upper,lower,poisson,maxsamples); std::cout << "make_fake_dataset: " << signals[i].name << ": " << observed[i] << " events (" << signals[i].nexpected << " expected)" << std::endl; } return std::make_pair(events,weights); }
Type objective_function<Type>::operator() () { DATA_VECTOR(observed); PARAMETER_VECTOR(population); PARAMETER(log_process_error); PARAMETER(log_obs_error); Type process_error = exp(log_process_error); Type obs_error = exp(log_obs_error); int n_obs = observed.size(); // number of observations Type nll = 0; // negative log likelihood // likelihood for state transitions for(int y=1; y<n_obs; y++){ Type m = population[y-1]; nll -= dnorm(population(y), m, process_error, true); } // likelihood for observations for(int y=0; y<n_obs; y++){ nll -= dnorm(observed(y), population(y), obs_error, true); } ADREPORT(process_error); ADREPORT(obs_error); return nll; }
void HostedObject::handleLocationUpdate(const SpaceObjectReference& observer, const LocUpdate& lu) { ProxyManagerPtr proxy_manager = this->getProxyManager(observer.space(), observer.object()); if (!proxy_manager) { HO_LOG(warn,"Hosted Object received a message for a presence without a proxy manager."); return; } SpaceObjectReference observed(observer.space(), ObjectReference(lu.object())); ProxyObjectPtr proxy_obj = proxy_manager->getProxyObject(observed); assert(proxy_obj); this->processLocationUpdate( observer, proxy_obj, lu); }
TEST(TermTableBuilder, GeneralCases) { // Construct a test environment that provides the ITermTreatment // and DocumentFrequencyTable to be used by the TermTableBuilder. // The test environment also provides a hand-constructed expected // TermTable for verification purposes. TestEnvironment environment; // Run the TermTableBuilder to configure a TermTable. ITermTreatment const & treatment = environment.GetTermTreatment(); DocumentFrequencyTable const & terms = environment.GetDocFrequencyTable(); IFactSet const & facts = environment.GetFactSet(); TermTable termTable; double density = 0.1; double adhocFrequency = 0.0001; unsigned c_randomSkipDistance = 0; TermTableBuilder builder(density, adhocFrequency, treatment, terms, facts, termTable, c_randomSkipDistance); // builder.Print(std::cout); // // Verify that configured TermTable is the same as the expected // TermTable provided by the environment. // // Ensure that all known terms have the same RowIdSequences. // NOTE: This test relies on the existence of a separate unit test // for TermTable that ensures that RowIds and Terms are added // correctly. Without such a test, a bogus TermTable that ignores // all RowId additions would allow TermTableBuilderTest to pass // (because they will both return the empty set of rows). for (auto term : terms) { RowIdSequence expected(term.GetTerm(), environment.GetTermTable()); RowIdSequence observed(term.GetTerm(), termTable); EXPECT_TRUE(std::equal(observed.begin(), observed.end(), expected.begin())); EXPECT_TRUE(std::equal(expected.begin(), expected.end(), observed.begin())); } // NOTE: This test relies on the existence of a separate unit test // for TermTable that ensures that row counts are recorded // correctly. Without such a test, a bogus TermTable that ignores // all SetRowCounts would allow TermTableBuilderTest to pass. for (Rank rank = 0; rank <= c_maxRankValue; ++rank) { EXPECT_EQ(environment.GetTermTable().GetTotalRowCount(rank), termTable.GetTotalRowCount(rank)); } // TODO: Verify adhoc // TODO: Verify facts // TODO: Verify row counts. }
/*! * @if jp * @brief RTObjectへのリスナ接続処理 * @else * @brief Connectiong listeners to RTObject * @endif */ void ComponentObserverConsumer::setListeners(coil::Properties& prop) { if (prop["observed_status"].empty()) { prop["observed_status"] = "ALL"; } coil::vstring observed(coil::split(prop["observed_status"], ",")); bool flags[OpenRTM::STATUS_KIND_NUM]; for (int i(0); i < OpenRTM::STATUS_KIND_NUM; ++i) { flags[i] = false; } for (size_t i(0); i < observed.size(); ++i) { coil::toUpper(observed[i]); if (observed[i] == "COMPONENT_PROFILE") { flags[OpenRTM::COMPONENT_PROFILE] = 1; } else if (observed[i] == "RTC_STATUS") { flags[OpenRTM::RTC_STATUS] = 1; } else if (observed[i] == "EC_STATUS") { flags[OpenRTM::EC_STATUS] = 1; } else if (observed[i] == "PORT_PROFILE") { flags[OpenRTM::PORT_PROFILE] = 1; } else if (observed[i] == "CONFIGURATION") { flags[OpenRTM::CONFIGURATION] = 1; } else if (observed[i] == "ALL") { for (int j(0); j < OpenRTM::STATUS_KIND_NUM; ++j) { flags[j] = true; } break; } } switchListeners(flags[OpenRTM::COMPONENT_PROFILE], m_observed[OpenRTM::COMPONENT_PROFILE], &ComponentObserverConsumer::setComponentProfileListeners, &ComponentObserverConsumer::unsetComponentProfileListeners); switchListeners(flags[OpenRTM::RTC_STATUS], m_observed[OpenRTM::RTC_STATUS], &ComponentObserverConsumer::setComponentStatusListeners, &ComponentObserverConsumer::unsetComponentStatusListeners); switchListeners(flags[OpenRTM::EC_STATUS], m_observed[OpenRTM::EC_STATUS], &ComponentObserverConsumer::setExecutionContextListeners, &ComponentObserverConsumer::unsetExecutionContextListeners); switchListeners(flags[OpenRTM::PORT_PROFILE], m_observed[OpenRTM::PORT_PROFILE], &ComponentObserverConsumer::setPortProfileListeners, &ComponentObserverConsumer::unsetPortProfileListeners); switchListeners(flags[OpenRTM::CONFIGURATION], m_observed[OpenRTM::CONFIGURATION], &ComponentObserverConsumer::setConfigurationListeners, &ComponentObserverConsumer::unsetConfigurationListeners); }