//------------------------------------------------------------------------------ void ResourceVisitor::apply( osg::Node& node ) { if( _currentMode == NONE ) { ///////////// // COLLECT // ///////////// if( _mode & COLLECT ) { _currentMode = COLLECT; collect(node); osg::NodeVisitor::traverse( node ); } //////////////// // DISTRIBUTE // //////////////// if( _mode & DISTRIBUTE ) { _currentMode = DISTRIBUTE; distribute(node); osg::NodeVisitor::traverse( node ); } ////////////// // EXCHANGE // ////////////// if( _mode & EXCHANGE ) { _currentMode = EXCHANGE; exchange(node); osg::NodeVisitor::traverse( node ); } //////////// // FINISH // //////////// _currentMode = NONE; if( _mode & RESET ) { reset(); } } else { switch( _currentMode ) { case COLLECT: collect(node); break; case DISTRIBUTE: distribute(node); break; case EXCHANGE: distribute(node); break; } osg::NodeVisitor::traverse( node ); } }
// This method will do the main data processing job. ModuleState::MODULE_EXITCODE Proxy::body() { uint32_t captureCounter = 0; while (getModuleState() == ModuleState::RUNNING) { // Capture frame. if (m_camera != NULL) { core::data::image::SharedImage si = m_camera->capture(); Container c(Container::SHARED_IMAGE, si); distribute(c); captureCounter++; } Container containerVehicleControl = getKeyValueDataStore().get(Container::VEHICLECONTROL); VehicleControl vc = containerVehicleControl.getData<VehicleControl>(); cerr << "Speed: '" << vc.getSpeed() << "'" << endl; cerr << "Angle: '" << vc.getSteeringWheelAngle() << "'" << endl; // TODO: Here, you need to implement the data links to the embedded system // to read data from IR/US. // Test *************************** // Markus Erlach string in = ""; string rec; char command[10]; cout << "Enter command to send, " << endl; cout << "Command alternatives: w, f, s, r, n, h, v, m" << endl; cin >> in; /* w, f, s, r, n, h, v w = set speed to 1560, f = accelerate by 10 s = slow down, r = reverse, n = neutral h = turn right, v = turn left */ strcpy(command, in.c_str()); write(port, command, 10); cout << "Proxy2 wrote: "<< command << endl; rec = msv::readSerial(); decode(rec); Container c = Container(Container::USER_DATA_0, sensorBoardData); distribute(c); /*int IR1Data = sensorBoardData.getValueForKey_MapOfDistances(0); cout << "SBD IR1: " << IR1Data << endl; */ //flushes the input queue, which contains data that have been received but not yet read. tcflush(port, TCIFLUSH); } cout << "Proxy: Captured " << captureCounter << " frames." << endl; return ModuleState::OKAY; }
sql_rel * rel_distribute(mvc *sql, sql_rel *rel) { rel = distribute(sql, rel); rel = replica(sql, rel, NULL); return rel_remote_func(sql, rel); }
void RectangleUtils::distribute(RectanglePointers& rects, ofAlignHorz horzAnchor, ofAlignVert vertAnchor) { ofRectangle boundingRect = getBoundingBox(rects); distribute(rects,boundingRect,horzAnchor,vertAnchor); }
//---------------------------- PUBLIC -----------------------------// void RNG::repool() { wxLogDebug(wxT("RNG repool")); // See the RNG with the current time. It's lame, but what other better way // is there? base_generator_type generator(time(NULL)); // Since we are just creating a pool of values, we want them to be the raw // values reported by Mersenne. pooled_distribution_type distribute(0, (std::numeric_limits<wxUint32>::max)()); pooled_generator_type pool(generator, distribute); // Fill the pool. mPool.reset(new wxUint32[POOL_SIZE]); for(size_t i = 0; i < POOL_SIZE; ++i) { mPool[i] = pool(); } // Start at the beginning again. mIndex = 0; }
void ParallelizablePlanOperation::splitInput() { const auto& tables = input.getTables(); if (_count > 0 && !tables.empty()) { auto r = distribute(tables[0]->size(), _part, _count); input.setTable(storage::TableRangeView::create(std::const_pointer_cast<AbstractTable>(tables[0]), r.first, r.second), 0); } }
int main(){ initialDistributor(); distribute(); exit(EXIT_SUCCESS); }
void _PlanOperation::splitInput() { const auto& tables = input.getTables(); if (_count > 0 && !tables.empty()) { u_int64_t first, last; distribute(tables[0]->size(), first, last); input.setTable( TableRangeViewFactory::createView(std::const_pointer_cast<AbstractTable>(tables[0]), first, last), 0); } }
bool reedSolomonCoder::encode(QByteArray &ba,QString extension,eRSType rsType) { int i,j; unsigned char dataByte; QByteArray temp; tr_buf=ba; fileType=rsType; rs_bsize=RSBSIZE; switch (fileType) { case RST1: rs_dsize=RSDSIZERS1; break; case RST2: rs_dsize=RSDSIZERS2; break; case RST3: rs_dsize=RSDSIZERS3; break; case RST4: rs_dsize=RSDSIZERS4; break; case RSTNONE: return FALSE; } init_rs(rs_dsize); got = tr_buf.size(); chunks = (got+7) / rs_dsize ; if (((got+7) % rs_dsize ) > 0) chunks++ ; bep_size=chunks; // ec_buf.resize(bep_size*RSBSIZE); ec_buf.clear(); bk_buf.resize(bep_size*RSBSIZE); dataByte = (unsigned char) ( rs_dsize - ( got % rs_dsize)) ; /* surplus in filelength */ ec_buf.append(dataByte); dataByte = (unsigned char) ( chunks % 256) ; ec_buf.append(dataByte); dataByte = (unsigned char) (chunks/256) ; ec_buf.append(dataByte); ec_buf.append(extension.toLatin1().at(0)); ec_buf.append(extension.toLatin1().at(1)); ec_buf.append(extension.toLatin1().at(2)); dataByte=0; ec_buf.append(dataByte); ec_buf.append(tr_buf.left(rs_dsize-7)); ec_buf.resize(ec_buf.count()+RSBSIZE-rs_dsize); rse32(((byte *)ec_buf.data()),((byte *)ec_buf.data()+(rs_dsize))); for (i=1;i<bep_size;i++) { temp=tr_buf.mid(i*rs_dsize-7,rs_dsize); if(temp.count()==0) break; ec_buf.append(temp); if(temp.count()<rs_dsize) { for(j=0;j<(rs_dsize-temp.count());j++) { ec_buf.append((char)0); } } ec_buf.resize(ec_buf.count()+RSBSIZE-rs_dsize); rse32(((byte *)ec_buf.data()+i*rs_bsize),((byte *)ec_buf.data()+i*rs_bsize+rs_dsize)); } ba.resize(ec_buf.count()); distribute((byte *)ec_buf.data(),(byte *)ba.data(),bep_size,rs_bsize,ENCODE); return TRUE; }
int main() { static unsigned char inbuf[1048576]; register unsigned char *inp; int i, r, v, m, d; mktab(); inbuf[read(0, inp = inbuf, sizeof(inbuf))] = 0; #define READ(var) { \ while (!isdigz[*inp]) inp++; \ if (*inp == 0) return 0; \ for (var = *inp++ - '0'; isdig[*inp];) \ var = var * 10 + *inp++ - '0'; \ } for (adjfree = 1, i = 1; i < MAXM; i++) adjnext[i] = i + 1; adjnext[MAXM - 1] = 0; for (;;) { READ(n); if (n == 0) break; memset(vert, '\0', sizeof(vert[0]) * (n + 1)); for (i = 0; i < n; i++) { READ(v); READ(m); READ(d); vert[v].count = m; while (d-- > 0) { READ(m); vert[v].adj = insert(vert[v].adj, m); vert[m].parent = v; } } for (i = 1; i <= n; i++) if (vert[i].count >= 2) distribute(i); for (r = 0, i = 1; i <= n; i++) if (vert[i].use >= 0) r += vert[i].use; else r -= vert[i].use; printf("%d\n", r); for (i = 1; i <= n; i++) release(vert[i].adj); } return 0; }
void InferenceEngineBP::distribute(BPNode* xi, BPNode* xj, dVector* phi_i, dMatrix** phi_ij, dVector** m) { std::list<BPNode*>::iterator it; sendMessage(xi,xj,phi_i,phi_ij,m); for(it=xj->neighbors.begin(); it!=xj->neighbors.end(); it++) { if( xi->equal(*it) ) continue; distribute(xj,*it,phi_i,phi_ij,m); } }
void PrForwardStrategy::do_timeslot() { Lock lock(mx); is_scheduled = false; if (distribute(context->prng) <= threshold) if (!llayer->forward_one()) return; schedule_timeslot(); }
void GroupByScan::splitInput() { hash_table_list_t hashTables = input.getHashTables(); if (_count > 0 && !hashTables.empty()) { uint64_t first, last; distribute(hashTables[0]->numKeys(), first, last); if ((_indexed_field_definition.size() + _named_field_definition.size()) == 1) input.setHash(std::dynamic_pointer_cast<const SingleAggregateHashTable>(hashTables[0])->view(first, last), 0); else input.setHash(std::dynamic_pointer_cast<const AggregateHashTable>(hashTables[0])->view(first, last), 0); } }
//radix sort start from here. void radix_sort(sl_list *p_SL) { int i = 0; array_t start; array_t end; for (i = 0; i < (*p_SL).keynum; i++) { distribute(p_SL, i, start, end); collect(p_SL, i, start, end); printf("the %d time sorting,result:\n", i + 1); display(*p_SL); } }
void LinearRegression::flush() { double sum_x = 0, sum_y = 0, sum_xy = 0, sum_x2 = 0, sum_y2 = 0, sxx, syy, sxy; double slope, slope_error, intercept; int n = 0; /* Initialize our post- and preprocessor functions */ for (int i = 0; i < SPACE_DIMS; i++) { string s = "box" + string(1, 'X'+i); m_prefn.constant(s) = m_simulation->phase()->boundary()->boundingBox().size()[i]; m_postfn.constant(s) = m_simulation->phase()->boundary()->boundingBox().size()[i]; } m_prefn.FromString(m_str_prefn); m_postfn.FromString(m_str_postfn); /* Apply m_prefn and do the linear regression */ for (list<data_sp>::iterator i = m_data.begin(); i != m_data.end(); i++) { double x, y; x = (*i)->doubleByIndex(m_idx_x); y = m_prefn.value((*i)->doubleByIndex(m_idx_y)); sum_x += x; sum_y += y; sum_xy += x*y; sum_x2 += x*x; sum_y2 += y*y; n++; } if(n < 3) throw gError ("LinearRegression::flush", "I need at least 3 values, but have only " + ObjToString(n)); sxy = sum_xy - sum_x*sum_y/n; sxx = sum_x2 - sum_x*sum_x/n; syy = sum_y2 - sum_y*sum_y/n; slope = sxy/sxx; slope_error = sqrt((syy - (slope*slope*sxx)) / (n - 2)); intercept = sum_y/n - slope*sum_x/n; data_sp data = m_output.newData(); data->doubleByIndex(IDX_SLOPE) = slope; // data->doubleByIndex(IDX_SLOPE_ERROR) = slope_error; data->doubleByIndex(IDX_INTERCEPT) = intercept; // data->doubleByIndex(IDX_INTERCEPT_ERROR) = 0; data->doubleByIndex(IDX_VALUE) = m_postfn.value(slope); distribute(data); }
const wxUint32 RNG::unpooled(const wxUint32 n) const { wxUint32 val = 0; if(1 < n) { unpooled_distribution_type distribute(0, n - 1); unpooled_generator_type gen(sUnpooledGenerator, distribute); val = gen(); } wxLogDebug(wxT("RNG unpooled returns %u"), val); return val; }
int zmq::dist_t::send (zmq_msg_t *msg_, int flags_) { // Is this end of a multipart message? bool msg_more = msg_->flags & ZMQ_MSG_MORE; // Push the message to active pipes. distribute (msg_, flags_); // If multipart message is fully sent, activate all the eligible pipes. if (!msg_more) active = eligible; more = msg_more; return 0; }
void Client::streamReadyRead() { // HACK HACK HACK QGuardedPtr<ClientStream> pstream = d->stream; while(pstream && d->stream->stanzaAvailable()) { Stanza s = d->stream->read(); QString out = s.toString(); debug(QString("Client: incoming: [\n%1]\n").arg(out)); xmlIncoming(out); QDomElement x = oldStyleNS(s.element()); distribute(x); } }
int zmq::dist_t::send_to_matching (msg_t *msg_) { // Is this end of a multipart message? bool msg_more = msg_->flags () & msg_t::more ? true : false; // Push the message to matching pipes. distribute (msg_); // If multipart message is fully sent, activate all the eligible pipes. if (!msg_more) active = eligible; more = msg_more; return 0; }
int main(int argv, char** argc) { File* hw; Marker* markers; Marker* it; const char* markersPath; const char* hwPath; FILE* outFile; if (argv != 3) { printf("Usage: %s markers homeworks\n", argc[0]); printf("markers: Markers file path.\n"); printf("files: HW files path.\n"); exit(EXIT_FAILURE); } markersPath = argc[1]; hwPath = argc[2]; markers = readMarkers(markersPath); srand(time(NULL)); rand(); rand(); hw = makeFileList(hwPath); markers = distribute(hw, markers); markers = sortMarkers(markers, numMarkers(markers)); for (it = markers; it; it = it->next) { it->files = sortFiles(it->files, numFiles(it->files)); } printMarkers(markers); for (it = markers; it; it = it->next) { free((void*)it->name); } freeMarkers(markers); freeFiles(hw); return 0; }
//#include"split_file_mode_a.c" int main(int argc, char *argv[]) { /* if(argv[3][0]=='a') distribute(argv[1], atoi(argv[2]), 0, split_file_mode_a); else if(argv[3][0]=='b') distribute(argv[1], atoi(argv[2]), 0, split_file_mode_b); return 0; */ //distribute("~/news", 4, 80, split_file_mode_c); distribute( argv[1], argv[2], atoi(argv[3]), atoi(argv[4]), split_file_mode_c ); return 0; }
//排序函数 void sort(int numbers[]){ int bucket[10][SIZE] = {0}; // 定义10个桶 //每个桶第0号记录桶内数字个数 int maxDigit; // 最长几位 int i = 0; //获得最多位数,确定排序次数 maxDigit = getMaxDigit(numbers); //printf("maxDigit = %d\n", maxDigit); for(i = 0; i < maxDigit; i++){ //进行第i位排序 distribute(i, bucket, numbers); //按序归位 collect(bucket, numbers); //debug(numbers); } }
void RandomBattery::runAll(int trials){ result_t rslt; std::cout << "distribution over N buckets:" << std::endl; rslt = distribute(trials); std::cout << "stdev: " << rslt.stdev << " mean: " << rslt.mean << " spread: " << (rslt.stdev / rslt.mean) << std::endl; std::cout << "distribution of bits:" << std::endl; rslt = bitHistogram(trials); std::cout << "stdev: " << rslt.stdev << " mean: " << rslt.mean << " spread: " << (rslt.stdev / rslt.mean) << std::endl; std::cout << "distribution of bytes:" << std::endl; rslt = byteHistogram(trials); std::cout << "stdev: " << rslt.stdev << " mean: " << rslt.mean << " spread: " << (rslt.stdev / rslt.mean) << std::endl; double t = speed(trials); std::cout << "time: " << t << " (" << (trials/t) << " words/sec)" << std::endl; }
int main(int argc, char *argv[]) { /* Declarations */ int c, option_index = 0; struct option long_options[] = { {"max-concurrent-transfers", required_argument, 0, 'm'}, {"help", no_argument, 0, 'h'}, {"version", no_argument, 0, 'v'}, {0, 0, 0, 0} }; unsigned int max_concurrent_transfers = 2; /* Parse command-line options */ while((c = getopt_long(argc, argv, "m:hv", long_options, &option_index)) != -1) { switch(c) { case 'm': max_concurrent_transfers = atoi(optarg); break; case 'h': case '?': print_usage(argv[0]); return 0; case 'v': print_version(argv[0]); return 0; } } /* Validate options */ if(optind >= argc) { fprintf(stderr, "ERROR: No manifest specified!\n"); return 1; } else return distribute(argv[optind], max_concurrent_transfers); /* Execute distribute operation */ }
void Guest::ReqProc(HttpReqHeader* req) { LOGD(DHTTP, "guest ReqProc %s: Status:%u\n", getsrc(nullptr), Status_flags); assert((Status_flags & GUEST_CONNECT_F) == 0 && (Status_flags & GUEST_SEND_F) == 0); assert((Status_flags == GUEST_IDELE_F) || (Status_flags & GUEST_REQ_COMPLETED)); req->index = (void *)1; auto res_ptr = distribute(req, responser_ptr); if(!res_ptr.expired()){ if(req->ismethod("CONNECT")){ Status_flags |= GUEST_CONNECT_F; }else if(req->ismethod("SEND")){ Status_flags |= GUEST_SEND_F; } Status_flags |= GUEST_PROCESSING_F; Status_flags &= ~GUEST_RES_COMPLETED; void* res_index = res_ptr.lock()->request(req); if(!responser_ptr.expired() && (res_ptr.lock() != responser_ptr.lock() || res_index != responser_index)){ responser_ptr.lock()->finish(PEER_LOST_ERR, responser_index); } responser_ptr = res_ptr; responser_index = res_index; }else{ delete req; } }
Pkmn::Pkmn(std::string name,unsigned int level, unsigned int mode){ poke = Master::getInstance()->dexter.getPoke(name); if(level > 100){ std::cout<<"Level over 100. Level = 100"<<std::endl; level = 100; } atkList.clear(); c_lvl = level; added.resize(6,0); c_stages.resize(6,0); c_stats.resize(6,0); c_dmg = 0; c_exp = Master::getInstance()->levelChart[level]; c_add = level-1; setNature(); levelingMode = mode; distribute(c_add); c_add = 0; // poke.print(); }
static rc_t bogotune(void) { bool skip; result_t *best; int beg, end; uint cnt, scan; rc_t status = RC_OK; beg = time(NULL); ham_cutoff = 0.0; spam_cutoff = 0.1; /* Note: memory usage highest while reading messages */ /* usage decreases as distribute() converts to count format */ /* read all messages, merge training sets, look up scoring sets */ ns_cnt = filelist_read(REG_GOOD, ham_files); sp_cnt = filelist_read(REG_SPAM, spam_files); cnt = ns_cnt + sp_cnt; end = time(NULL); if (verbose >= TIME) { show_elapsed_time(beg, end, ns_cnt + sp_cnt, (double)cnt/(end-beg), "messages", "msg/sec"); } distribute(REG_GOOD, ns_msglists); distribute(REG_SPAM, sp_msglists); create_countlists(ns_msglists); create_countlists(sp_msglists); if (verbose >= TIME && time(NULL) - end > 2) { end = time(NULL); show_elapsed_time(beg, end, ns_cnt + sp_cnt, (double)cnt/(end-beg), "messages", "msg/sec"); } if (verbose > PARMS+1) { tunelist_print(ns_and_sp); tunelist_print(ns_msglists); tunelist_print(sp_msglists); } ns_cnt = count_messages(ns_msglists); sp_cnt = count_messages(sp_msglists); if (ds_flag == DS_DSK && !check_msg_counts()) exit(exit_zero ? EX_OK : EX_ERROR); fflush(stdout); check_percent = CHECK_PCT; /* for checking low scoring spam ** and high scoring non-spam */ ns_scores = xcalloc(ns_cnt, sizeof(double)); sp_scores = xcalloc(sp_cnt, sizeof(double)); robs = DEFAULT_ROBS; robx = DEFAULT_ROBX; min_dev = DEFAULT_MIN_DEV; if (check_for_high_ns_scores() | check_for_low_sp_scores()) scoring_error(); /* ** 5. Calculate x and cache size ** Calculate x with bogoutil's -r option (a new addition). ** Bound the calculated value within [0.4, 0.6] and set the range to be ** investigated to [x-0.1, x+0.1]. */ robx = get_robx(); if (ds_flag == DS_DSK) { db_cachesize = calc_db_cachesize(); printf("Recommended db cache size is %u MB\n", db_cachesize); } /* ** 6. Calculate fp target ** The fp target will be derived thus: score non-spams with s and md as ** shipped, and determine the count that will result from a spam cutoff ** of 0.95; if that is < 0.25%, try 0.9375 etc. */ min_dev = 0.02; /* set target and spam_cutoff */ if (coerced_target == 0) set_thresh(ns_cnt, ns_scores); else { /* if coerced target ... */ target = coerced_target; spam_cutoff = ns_scores[target-1]; } skip = ROUND(spam_cutoff,100000) < SCAN_CUTOFF; printf("False-positive target is %u (cutoff %8.6f)\n", target, spam_cutoff); #ifdef TEST if (test) { printf("m: %8.6f, s: %8.6f, x: %0.16f\n", min_dev, robs, robx); if (verbose < PARMS) print_ns_scores(target-2, target+2, 0); } #endif if (!esf_flag && (sp_esf < 1.0 || ns_esf < 1.0)) fprintf(stderr, "Warning: Using ESF values (sp=%8.6f, ns=%8.6f) from config file.\n", sp_esf, ns_esf); /* No longer needed */ wordhash_free(train); train = NULL; for (scan=0; scan <= 1 && !skip; scan ++) { uint r_count; uint rsi, rxi, mdi, spi, nsi; result_t *results, *r, *sorted; printf("Performing %s scan:\n", scan==0 ? "coarse" : "fine"); switch (scan) { case 0: /* COARSE */ /* ** 7. Coarsely scan s, md and x ** The coarse s scan will range from 1 to 0.01 in half decades, and the ** coarse md scan will range from 0.05 to 0.45 in steps of 0.05. The ** coarse x scan will use steps of 0.05. The trough must be surrounded on ** six sides by values below the 33% quantile (unless bounded on one or ** more sides). */ init_coarse(robx); break; case 1: /* FINE */ /* ** 8. Finely scan the peak region ** The fine s scan will range over the estimated s +/- half a decade in ** steps of a quarter decade, and the fine md scan will range over the ** estimated md +/- 0.075 in steps of 0.015. The fine x scan will range ** over the estimated x +/- 0.04 in steps of 0.02. Scans of s and md ** are bounded by the limits of the coarse scan. Again, the trough must ** be surrounded on six sides by values below the 33% quantile. If no ** such trough exists, a warning is given. */ init_fine(robs, min_dev, robx, spex, nsex); break; } r_count = rsval->cnt * mdval->cnt * rxval->cnt * spexp->cnt * nsexp->cnt; results = (result_t *) xcalloc(r_count, sizeof(result_t)); print_all_parms(r_count); if (verbose >= SUMMARY) { if (verbose >= SUMMARY+1) printf("%3s ", "cnt"); if (verbose >= SUMMARY+2) printf(" %s %s %s ", "s", "m", "x"); printf(" %4s %5s %4s %8s %8s %7s %3s %3s\n", "rs", "md", "rx", "spesf", "nsesf", "cutoff", "fp", "fn"); } cnt = 0; beg = time(NULL); for (rsi = 0; rsi < rsval->cnt; rsi++) { robs = rsval->data[rsi]; for (mdi = 0; mdi < mdval->cnt; mdi++) { min_dev = mdval->data[mdi]; for (rxi = 0; rxi < rxval->cnt; rxi++) { robx = rxval->data[rxi]; for (spi = 0; spi < spexp->cnt; spi++) { spex = spexp->data[spi]; sp_esf = ESF_SEL(sp_esf, pow(0.75, spex)); for (nsi = 0; nsi < nsexp->cnt; nsi++) { uint fp, fn; nsex = nsexp->data[nsi]; ns_esf = ESF_SEL(ns_esf, pow(0.75, nsex)); /* save parms */ r = &results[cnt++]; r->idx = cnt; r->rsi = rsi; r->rs = robs; r->rxi = rxi; r->rx = robx; r->mdi = mdi; r->md = min_dev; r->spi = spi; r->sp_exp = spex; r->nsi = nsi; r->ns_exp = nsex; if (verbose >= SUMMARY) { if (verbose >= SUMMARY+1) printf("%3u ", cnt); if (verbose >= SUMMARY+2) printf(" %u %u %u %u %u ", rsi, mdi, rxi, spi, nsi); printf("%6.4f %5.3f %5.3f %8.6f %8.6f", robs, min_dev, robx, sp_esf, ns_esf); fflush(stdout); } spam_cutoff = 0.01; score_ns(ns_scores); /* scores in descending order */ /* Determine spam_cutoff and false_pos */ for (fp = target; fp < ns_cnt; fp += 1) { spam_cutoff = ns_scores[fp-1]; if (spam_cutoff < 0.999999) break; if (coerced_target != 0) break; } if (ns_cnt < fp) fprintf(stderr, "Too few false positives to determine a valid cutoff\n"); score_sp(sp_scores); /* scores in ascending order */ fn = get_fn_count(sp_cnt, sp_scores); /* save results */ r->co = spam_cutoff; r->fp = fp; r->fn = fn; if (verbose < SUMMARY) progress(cnt, r_count); else { printf(" %8.6f %2u %3u\n", spam_cutoff, fp, fn); fflush(stdout); } #ifdef TEST if (test && spam_cutoff < 0.501) { printf("co: %0.16f\n", spam_cutoff); print_ns_scores(0, fp, 2); print_sp_scores(fn-10, fn, 10); } #endif if (fMakeCheck && cnt >= cMakeCheck) break; } if (fMakeCheck && cnt >= cMakeCheck) break; } if (fMakeCheck && cnt >= cMakeCheck) break; } if (fMakeCheck && cnt >= cMakeCheck) break; } fflush(stdout); if (fMakeCheck && cnt >= cMakeCheck) break; } if (verbose >= TIME) { end = time(NULL); show_elapsed_time(beg, end, cnt, (double)(end-beg)/cnt, "iterations", "secs"); } printf("\n"); /* Scan complete, now find minima */ sorted = results_sort(r_count, results); top_ten(sorted, r_count); best = count_outliers(r_count, sorted, results); robs = rsval->data[best->rsi]; robx = rxval->data[best->rxi]; min_dev = mdval->data[best->mdi]; spex = spexp->data[best->spi]; sp_esf = ESF_SEL(sp_esf, pow(0.75, spex)); nsex = nsexp->data[best->nsi]; ns_esf = ESF_SEL(ns_esf, pow(0.75, nsex)); printf( "Minimum found at s %6.4f, md %5.3f, x %5.3f, spesf %8.6f, nsesf %8.6f\n", robs, min_dev, robx, sp_esf, ns_esf); printf(" fp %u (%6.4f%%), fn %u (%6.4f%%)\n", best->fp, best->fp*100.0/ns_cnt, best->fn, best->fn*100.0/sp_cnt); printf("\n"); data_free(rsval); data_free(rxval); data_free(mdval); data_free(spexp); data_free(nsexp); xfree(results); xfree(sorted); } /* ** 9. Suggest possible spam and non-spam cutoff values ** With the final x, md and s values, score the spams and non-spams and ** sort the non-spam scores decreasing and the spam scores increasing; ** then, traverse the non-spam list until the 0.2% point; report cutoffs ** that give 0.05%, 0.1% and 0.2% fp. */ final_recommendations(skip); return status; }
int main(int argc, char *argv[]){ int i, j, k, sz, sz01, sz23, sz_fin, ri, name_len; elem_t *e; result_t sol[16]; u64 s, name_hash; char serial[32+1]; if(argc<2){ printf("Keygen for keygenme3 by Dcoder\nUsage: %s <name>\n", argv[0]); return 1; } name_len = strlen(argv[1]); hash(KEY_NAME, argv[1], name_len, &name_hash); memset(lists, 0, (LISTS+3)*PER_LIST*sizeof(elem_t*)); memset(buckets, 0, (LISTS+3)*PER_LIST*sizeof(node_t*)); fill_seeds(seeds); srand(0); fill_lists(lists); sub(lists[3], name_hash); //x1+..+(xn-c)=0 -> x1+..+xn=c //l0,-l1 -- l2,-l3 inv(lists[1]); inv(lists[3]); for(i=0;i<LISTS;i++){ distribute(lists[i], PER_LIST, buckets[i]); } sz01 = merge(buckets[0], buckets[1], lists[4]); sz23 = merge(buckets[2], buckets[3], lists[5]); //l01,-l23 inv(lists[5]); shr(lists[4], sz01, L); shr(lists[5], sz23, L); distribute(lists[4], sz01, buckets[4]); distribute(lists[5], sz23, buckets[5]); sz_fin = merge(buckets[4], buckets[5], lists[6]); for(i=0;i<sz_fin;i++){ e = lists[6][i]; // ">>" is arithmetic shift for u64, so we can check for 0 // instead of a certain power of 2 if(e->x==0){ //printf("i=%d, x=%llx\n", i, e->x); sz = walk(e, sol); assert(sz == 16); s = 0L; for(j=0;j<sz;j++){ s += sol[j].seed; ri = sol[j].ri; k = sol[j].k; assert(ri == j); //printf("j=%d, ri=%d, k=%02x, s=%llx\n", j, ri, k, s); sprintf(&serial[j*2], "%02x", k); } assert(s == name_hash); serial[32]=0; printf("%s\n", serial); } } return 0; }
void InferenceEngineBP::computeBeliefs(Beliefs &beliefs, FeatureGenerator *fGen, DataSequence *X, Model *m, int bComputePartition, int seqLabel, bool bUseStatePerNodes) { // Variable definition int xi, xj, nbNodes, seqLength; std::map<int,BPNode*> nodes; // tree graph std::map<int,BPNode*>::iterator itm; std::list<BPNode*>::iterator itl; BPNode* root; iMatrix adjMat; iVector nbStates; dVector* phi_i = 0; // singleton potentials dMatrix** phi_ij = 0; // pairwise potentials dVector** msg = 0; // messages if( m->isMultiViewMode() ) m->getAdjacencyMatrixMV(adjMat, X); else { uMatrix uAdjMat; m->getAdjacencyMatrix(uAdjMat, X); adjMat.resize(uAdjMat.getWidth(),uAdjMat.getHeight()); for(xi=0; xi<uAdjMat.getHeight(); xi++) for(xj=0; xj<uAdjMat.getWidth(); xj++) adjMat(xi,xj) = uAdjMat(xi,xj); } nbNodes = adjMat.getHeight(); seqLength = X->length(); // Create a vector that contains nbStates nbStates.create(nbNodes); for(xi=0; xi<nbNodes; xi++) nbStates[xi] = (m->isMultiViewMode()) ? m->getNumberOfStatesMV(xi/seqLength) : m->getNumberOfStates(); // Create BPGraph from adjMat for(xi=0; xi<nbNodes; xi++) { BPNode* v = new BPNode(xi, nbStates[xi]); nodes.insert( std::pair<int,BPNode*>(xi,v) ); } for(xi=0; xi<nbNodes; xi++) { for(xj=xi+1; xj<nbNodes; xj++) { if( !adjMat(xi,xj) ) continue; nodes[xi]->addNeighbor(nodes[xj]); nodes[xj]->addNeighbor(nodes[xi]); } } // Initialize initMessages(msg, X, m, adjMat, nbStates); initBeliefs(beliefs, X, m, adjMat, nbStates); initPotentials(phi_i, phi_ij, fGen, X, m, adjMat, nbStates, seqLabel); // Message update root = nodes[0]; // any node can be the root node { for(itl=root->neighbors.begin(); itl!=root->neighbors.end(); itl++) collect(root, *itl, phi_i, phi_ij, msg); for(itl=root->neighbors.begin(); itl!=root->neighbors.end(); itl++) distribute(root, *itl, phi_i, phi_ij, msg); } updateBeliefs(beliefs, phi_i, phi_ij, msg, X, m, adjMat); // Clean up for(xi=0; xi<nbNodes; xi++) { delete[] msg[xi]; msg[xi] = 0; delete[] phi_ij[xi]; phi_ij[xi] = 0; } delete[] msg; msg=0; delete[] phi_i; phi_i = 0; delete[] phi_ij; phi_ij = 0; for(itm=nodes.begin(); itm!=nodes.end(); itm++) delete (*itm).second; nodes.clear(); }
void FFTDataDistributor::process() { while (!input->empty()) { if (!isAnyOutputEmpty()) { return; } DemodulatorThreadIQData *inp; input->pop(inp); if (inp) { if (inputBuffer.sampleRate != inp->sampleRate || inputBuffer.frequency != inp->frequency) { bufferMax = inp->sampleRate / 4; // std::cout << "Buffer Max: " << bufferMax << std::endl; bufferOffset = 0; inputBuffer.sampleRate = inp->sampleRate; inputBuffer.frequency = inp->frequency; inputBuffer.data.resize(bufferMax); } if ((bufferOffset + bufferedItems + inp->data.size()) > bufferMax) { memmove(&inputBuffer.data[0], &inputBuffer.data[bufferOffset], bufferedItems*sizeof(liquid_float_complex)); bufferOffset = 0; } else { memcpy(&inputBuffer.data[bufferOffset+bufferedItems],&inp->data[0],inp->data.size()*sizeof(liquid_float_complex)); bufferedItems += inp->data.size(); } inp->decRefCount(); } else { continue; } // number of seconds contained in input double inputTime = (double)bufferedItems / (double)inputBuffer.sampleRate; // number of lines in input double inputLines = (double)bufferedItems / (double)fftSize; // ratio required to achieve the desired rate double lineRateStep = ((double)linesPerSecond * inputTime)/(double)inputLines; if (bufferedItems >= fftSize) { int numProcessed = 0; if (lineRateAccum + (lineRateStep * ((double)bufferedItems/(double)fftSize)) < 1.0) { // move along, nothing to see here.. lineRateAccum += (lineRateStep * ((double)bufferedItems/(double)fftSize)); numProcessed = bufferedItems; } else { for (int i = 0, iMax = bufferedItems; i < iMax; i += fftSize) { if ((i + fftSize) > iMax) { break; } lineRateAccum += lineRateStep; if (lineRateAccum >= 1.0) { DemodulatorThreadIQData *outp = outputBuffers.getBuffer(); outp->frequency = inputBuffer.frequency; outp->sampleRate = inputBuffer.sampleRate; outp->data.assign(inputBuffer.data.begin()+bufferOffset+i,inputBuffer.data.begin()+bufferOffset+i+fftSize); distribute(outp); while (lineRateAccum >= 1.0) { lineRateAccum -= 1.0; } } numProcessed += fftSize; } } if (numProcessed) { bufferedItems -= numProcessed; bufferOffset += numProcessed; } if (bufferedItems <= 0) { bufferedItems = 0; bufferOffset = 0; } } } }