bool TestDataReaders::TestCSVDataReader(SourceReader* sourceReader, vector<CSVDataType*> results) { bool ok = true; DataReader* dataReader = new CSVDataReader(sourceReader); for (int i = 0; i < results.size(); ++i) { CSVDataType* csvDataType = (CSVDataType*) dataReader->GetNextData(); if (csvDataType == NULL || results[i] == NULL) { if (csvDataType != NULL || results[i] != NULL) ok = false; } else { if (csvDataType->GetColNames() != results[i]->GetColNames()) ok = false; else { int size = csvDataType->GetColNames().size(); for (int j = 0; j < size; ++j) { if (csvDataType->GetValue(j) != results[i]->GetValue(j)) { ok = false; } } } delete csvDataType; } } delete dataReader; return ok; }
void SamplingProvider::read(DataReader &reader) { reader.read(this->m_sampling_radius); reader.read(this->m_curvatures); reader.read(this->m_barycentric_areas); reader.read(this->m_geodesics); reader.read(this->m_samples); }
int main(void) { DataReader reader; std::vector<fv_t> data; std::vector<fv_t> test_data; std::vector<label_t> labels; std::vector<label_t> test_labels; category_index_t category_index; NearestCentroidClassifier centroid_classifier; TFIDFTransformer tfidf; long t = tick(); long t_all = tick(); Evaluation evaluation; if (!reader.open(TRAIN_DATA)) { fprintf(stderr, "cant read file\n"); return -1; } reader.read(data, labels); printf("read %ld, %ld, %ldms\n", data.size(), labels.size(), tick() - t); reader.close(); t = tick(); srand(VT_SEED); build_category_index(category_index, data, labels); split_data(test_data, test_labels, data, labels, category_index, 0.05f); build_category_index(category_index, data, labels); printf("split train:%ld, test:%ld\n", data.size(), test_data.size()); t = tick(); tfidf.train(data); tfidf.transform(data); tfidf.transform(test_data); centroid_classifier.train(category_index, data); printf("build index %ldms\n", tick() -t ); t = tick(); #ifdef _OPENMP #pragma omp parallel for schedule(dynamic, 1) #endif for (int i = 0; i < (int)test_data.size(); ++i) { std::vector<int> topn_labels; centroid_classifier.predict(topn_labels, K, test_data[i]); #ifdef _OPENMP #pragma omp critical #endif { evaluation.update(topn_labels, test_labels[i]); if (i % 1000 == 0) { print_evaluation(evaluation, i, t); t = tick(); } } } printf("----\n"); print_evaluation(evaluation, test_data.size(), t_all); return 0; }
void SAMReader::readHeader( const char* fileName, ReaderContext& context) { DataReader* data = DataSupplier::Default[false]->getDataReader(maxLineLen); if (! data->init(fileName)) { fprintf(stderr, "Unable to read file %s\n", fileName); soft_exit(1); } // todo: allow for larger headers _int64 headerSize = 1024 * 1024; // 1M header max char* buffer = data->readHeader(&headerSize); if (!parseHeader(fileName, buffer, buffer + headerSize, context.genome, &headerSize, &context.headerMatchesIndex)) { fprintf(stderr,"SAMReader: failed to parse header on '%s'\n",fileName); soft_exit(1); } _ASSERT(context.header == NULL); char* p = new char[headerSize + 1]; memcpy(p, buffer, headerSize); p[headerSize] = 0; context.header = p; context.headerBytes = context.headerLength = headerSize; delete data; }
std::unique_ptr<float []> readVolumeData(const std::string& dtype, const std::string& fpath, size_t volx, size_t voly, size_t volz) { bd::DataType t = bd::to_dataType(dtype); float* rawdata = nullptr; switch (t) { case bd::DataType::Float: { bd::DataReader<float, float> reader; reader.loadRaw3d(fpath, volx, voly, volz, false); rawdata = reader.takeOwnership(); break; } case bd::DataType::UnsignedCharacter: { bd::DataReader<unsigned char, float> reader; reader.loadRaw3d(fpath, volx, voly, volz, false); rawdata = reader.takeOwnership(); break; } case bd::DataType::UnsignedShort: { DataReader<unsigned short, float> reader; reader.loadRaw3d(fpath, volx, voly, volz, false); rawdata = reader.takeOwnership(); break; } default: break; } return std::unique_ptr<float[]>(rawdata); }
void Listener::pushDataPacket(DataReader& reader) { if (!_pDataWriter && !init()) return; if(publication.publisher()) { if(ICE::ProcessSDPPacket(reader,(Peer&)*publication.publisher(),publication.publisher()->writer(),(Peer&)client,*_pDataWriter)) return; } if(_pDataTypeName == typeid(reader).name()) { if(!_pDataWriter->writeMedia(Writer::DATA,0,reader.packet,*this)) init(); return; } shared_ptr<DataWriter> pWriter; _pDataWriter->createWriter(pWriter); if (!pWriter) { if(!_pDataWriter->writeMedia(Writer::DATA,0,reader.packet,*this)) init(); return; } UInt32 offset = pWriter->packet.size(); reader.read(*pWriter); reader.reset(); PacketReader packet(pWriter->packet.data(),pWriter->packet.size()); packet.next(offset); if(!_pDataWriter->writeMedia(Writer::DATA,0,packet,*this)) init(); }
void GeodesicProvider::read(DataReader &reader) { reader.read(this->m_source_vertices); reader.read(this->m_target_vertices); reader.read(this->m_algorithm_option); reader.read(this->m_subdivision_level); reader.read(this->m_geodesics); }
bool Solver::read_results() { try { DataReader dr; dr.readAll(gyro::RESULT_FILE, *result_data); load(*result_data); msg = "Successfully finished!"; } catch (ios_base::failure& ) { msg += "failed to read the output of the solver!"; return FAILED; } catch (exception& e) { msg += "unexpected error "; msg += e.what(); return FAILED; } return SUCCESS; }
void ClientSocket::readName(DataReader r){ int id = r.readInt(); char buf[33]; r.read(buf,32); if(g.names.size()<=id)g.names.resize(id+20); g.names[id] = buf; std::cout<<id<<" is "<<buf<<"\n"; }
int VertexLoaderX64::RunVertices(DataReader src, DataReader dst, int count) { m_numLoadedVertices += count; return ((int (*)(u8*, u8*, int, const void*))region)( src.GetPointer(), dst.GetPointer(), count, memory_base_ptr); }
void TextAssetExtractor::Extract(FileWriter& writer, DataReader& reader, size_t length) { uint32_t len = reader.ReadNumber<uint32_t>(); reader.Skip(len); reader.Align(4); len = reader.ReadNumber<uint32_t>(); reader.WriteFile(writer, reader.Tell(), len); }
int Wav::loadMem(unsigned char *aMem, int aLength) { if (aMem == NULL || aLength <= 0) return INVALID_PARAMETER; DataReader dr; dr.open(aMem, aLength); return testAndLoadFile(&dr); }
int Wav::load(const char *aFilename) { DataReader dr; if (!dr.open(aFilename)) { return FILE_NOT_FOUND; } return testAndLoadFile(&dr); }
void ClientSocket::readItems(DataReader r) { int n=r.readInt(); Item it; for(int i=0; i<n; ++i) { r.read(&it, sizeof(it)); g.items_map.insert(it); } }
void Nikita() { DataReader<int, string> reader; FibonacciTable<int, string> table; reader.getData( table ); system( "pause" ); }
void ClientSocket::readDead(DataReader r){ int n = r.readInt(); for(int i=0;i<n;i++) { Unit u; r.read(&u,sizeof(Unit)); u.shootTime = timef(); g.deadUnits.push_back(u); } }
void Observer::init(DataReader& reader) { static const Card defaultCard(SUIT_LAST, RANK_LAST); reader.read(mGameCards, defaultCard); reader.read(mGameCardsCount); reader.read(mTrumpSuit); unsigned int playerAmount; reader.read(playerAmount); while (playerAmount--) { unsigned int playerIndex; reader.read(playerIndex); unsigned int cardsAmount; reader.read(cardsAmount); mPlayersCards[mPlayers[playerIndex]] = cardsAmount; } unsigned int rounds; reader.read(rounds); while (rounds--) { RoundData* roundData = new RoundData(); loadRoundData(reader, *roundData); mRoundsData.push_back(roundData); } reader.read(mCurrentRoundIndex); mRestored = true; bool currentRoundDataExist; reader.read(currentRoundDataExist); if (currentRoundDataExist) { mCurrentRoundData = new RoundData(); loadRoundData(reader, *mCurrentRoundData); } }
void Observer::loadRoundData(DataReader& reader, RoundData& roundData){ unsigned int players; reader.read(players); while (players--) { unsigned int playerIndex; reader.read(playerIndex); roundData.mPlayers.push_back(mPlayers[playerIndex]); } loadMap(reader, roundData.mDroppedCards); loadMap(reader, roundData.mPickedUpCards); }
int AssetbundleEntryInfo::Read(DataReader& reader) { int startOffset = reader.Tell(); reader.SetByteOrder(ByteOrder_BigEndian); name = reader.ReadString(); offset = reader.ReadNumber<uint32_t>(); size = reader.ReadNumber<uint32_t>(); int endOffset = reader.Tell(); return endOffset - startOffset; }
void Observer::loadMap(DataReader& reader, std::map<const PlayerId*, CardSet>& map) { static const Card defaultCard(SUIT_LAST, RANK_LAST); unsigned int mapSize; reader.read(mapSize); while (mapSize--) { unsigned int playerIndex; reader.read(playerIndex); CardSet cards; reader.read(cards, defaultCard); map[mPlayers[playerIndex]] = cards; } }
void Engine::readData() { DataReader dr; dr.readFile(m_programSettings->getEngineSettings().datafile); if(!dr.good()) { throw Engine::Exception("File " + m_programSettings->getEngineSettings().datafile + " has not been read or has no a header"); } if(dr.columnExist("[intensity]")) { dr.getColumn(m_exp_intens_vals, "[intensity]"); } else { throw Engine::Exception("Column \"[intensity]\" has not been found in " + m_programSettings->getEngineSettings().datafile); } if (dr.columnExist("[qx]")) { //get points without any transformation dr.getColumn(m_qx_vals, "[qx]"); } else { throw Engine::Exception("Column \"[qx]\" has not been found in "+ m_programSettings->getEngineSettings().datafile); } if (dr.columnExist("[qz]")) { //get points without any transformation dr.getColumn(m_qz_vals, "[qz]"); } else { throw Engine::Exception("Column \"[qz]\" has not been found in "+ m_programSettings->getEngineSettings().datafile); } /*allocate arguments and residuals*/ for(size_t i = 0; i < m_exp_intens_vals.size(); ++i) { m_DataPoints.push_back( NonlinearFit::DataPoint(new ANACalculatorCoplanarTripleArgument(m_qx_vals[i], m_qz_vals[i]), m_exp_intens_vals[i])); } m_ini_intens_vals.resize(m_exp_intens_vals.size(), 0.0); m_fin_intens_vals.resize(m_exp_intens_vals.size(), 0.0); std::cout << "Nb data residuals:\t" << m_DataPoints.size() << std::endl; }
int XfemManager :: instanciateYourself(DataReader &dr) { IRResultType result; // Required by IR_GIVE_FIELD macro std :: string name; enrichmentItemList.resize(numberOfEnrichmentItems); for ( int i = 1; i <= numberOfEnrichmentItems; i++ ) { InputRecord *mir = dr.giveInputRecord(DataReader :: IR_enrichItemRec, i); result = mir->giveRecordKeywordField(name); if ( result != IRRT_OK ) { mir->report_error(this->giveClassName(), __func__, "", result, __FILE__, __LINE__); } std :: unique_ptr< EnrichmentItem >ei( classFactory.createEnrichmentItem( name.c_str(), i, this, this->giveDomain() ) ); if ( ei.get() == NULL ) { OOFEM_ERROR( "unknown enrichment item (%s)", name.c_str() ); } ei->initializeFrom(mir); ei->instanciateYourself(dr); this->enrichmentItemList [ i - 1 ] = std :: move(ei); } mNucleationCriteria.resize(numberOfNucleationCriteria); for ( int i = 1; i <= numberOfNucleationCriteria; i++ ) { InputRecord *mir = dr.giveInputRecord(DataReader :: IR_crackNucleationRec, i); result = mir->giveRecordKeywordField(name); if ( result != IRRT_OK ) { mir->report_error(this->giveClassName(), __func__, "", result, __FILE__, __LINE__); } std :: unique_ptr< NucleationCriterion >nc( classFactory.createNucleationCriterion( name.c_str(), this->giveDomain() ) ); if ( nc.get() == NULL ) { OOFEM_ERROR( "Unknown nucleation criterion: (%s)", name.c_str() ); } nc->initializeFrom(mir); nc->instanciateYourself(dr); this->mNucleationCriteria [ i - 1 ] = std :: move(nc); } updateNodeEnrichmentItemMap(); return 1; }
void FlashStream::dataHandler(DataReader& data, double lostRate) { if(!_pPublication) { ERROR("a data packet has been received on a no publishing stream ",id,", certainly a publication currently closing"); return; } // necessary AMF0 here! if (*data.packet.current() == AMF_STRING && *(data.packet.current() + 3) == '@') { if (*(data.packet.current() + 1) == 0) { if (*(data.packet.current() + 2) == 13 && memcmp(data.packet.current() + 3, EXPAND("@setDataFrame"))==0) { // @setDataFrame data.next(); _pPublication->writeProperties(data); return; } else if (*(data.packet.current() + 2) == 15 && memcmp(data.packet.current() + 3, EXPAND("@clearDataFrame"))==0) { // @clearDataFrame _pPublication->clearProperties(); return; } } } _pPublication->pushData(data,peer.ping(),lostRate); }
bool TestDataReaders::TestLineDataReader(SourceReader* sourceReader, vector<StringDataType> results) { bool ok = true; DataReader* dataReader = new LineDataReader(sourceReader); for (int i = 0; i < results.size(); ++i) { StringDataType* stringDataType = (StringDataType*) dataReader->GetNextData(); if (stringDataType->GetString() != results[i].GetString()) ok = false; delete stringDataType; } delete dataReader; return ok; }
void ClientSocket::readBullet(DataReader r) { Bullet b; r.read(&b,sizeof(Bullet)); double vol = distvol(length(g.player->loc-b.origin));; if (b.type==ROCKET) { }else if (b.type==SHOTGUN) { sounds.push_back(Sound(SHOTGUNSOUND, vol)); }else if(b.type==BOUNCEGUN) { sounds.push_back(Sound(MACHINEGUNSOUND,vol)); }else if(b.type==MACHINEGUN)//MACHINEGUN == FLAMEGUN { //if(-lastFlame+timef()>0.4){ sounds.push_back(Sound(FLAMESOUND,vol)); //lastFlame=timef(); //} } else if (b.type==RAILGUN) { sounds.push_back(Sound(RAILSOUND,vol)); } g.bullets_map.insert(b); //g.bullets.push_back(*(Bullet*)r.cur); //g.bulletIndex[g.bullets.back().id] = g.bullets.size()-1; }
// open file and read space separated values and insert into data store void ReadInputFile(const std::string& datafile) { std::ifstream file(datafile); DataReader row; DataStore& dataStore = DataStore::GetInstance(); while (file >> row) { try { dataStore.Insert(row.at(0), row.at(1), row.at(2)); } catch(...) { // do nothing on exception but allow rest of data to ingested } } }
void Material_Dielectric::ReadData(DataReader& reader) { Material::ReadData(reader); MaterialValueGraph graph; reader.ReadDataStructure(graph, "IndexOfRefraction"); IndexOfRefraction = graph.GetRootVals()[0]; }
void Material_Medium::ReadData(DataReader& reader) { Material::ReadData(reader); MaterialValueGraph graph; reader.ReadDataStructure(graph, "Albedo"); Albedo = graph.GetRootVals()[0]; }
void ClientSocket::readLightning(DataReader r) { int cnt = r.readInt(); vector<int> ids((int*)r.cur, ((int*)r.cur)+cnt); g.lightnings.push_back(make_pair(0.0, ids)); double l = length(g.units[g.unitIndex[ids[0]]].loc - g.player->loc); sounds.push_back(Sound(ELECTROSOUND, distvol(l))); // cout<<"adding lightning "<<cnt<<'\n'; }
void Sim2d::Simulation::stateCellLoad(DataReader& reader) { if(m_stop) { reader.dataRead(buffers[0].rowGet(0),stateCellSizeGet()); buffers[1]=buffers[0]; if(m_view!=nullptr) {pixelsUpload();} } }