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