void UNVIO::write (const std::string& file_name) { if (file_name.rfind(".gz") < file_name.size()) { #ifdef LIBMESH_HAVE_GZSTREAM ogzstream out_stream(file_name.c_str()); this->write_implementation (out_stream); #else libMesh::err << "ERROR: You must have the zlib.h header " << "files and libraries to read and write " << "compressed streams." << std::endl; libmesh_error(); #endif return; } else { std::ofstream out_stream (file_name.c_str()); this->write_implementation (out_stream); return; } }
void PrmNodeScoreModel::write_prm_normalizer_values() const { if (! indNormzlizersInitialized_) { cout << "Did not write PRM normalizers, models weren't initialized!" << endl; return; } string file_path = config_->get_resource_dir() + "/" + config_->get_model_name() + "_prm_norm.txt"; ofstream out_stream(file_path.c_str()); if (! out_stream.good()) { cout << "Error: couldn't open prm_norm file for writing: " << file_path << endl; exit(1); } out_stream << setprecision(3); int c; for (c=1; c<regional_prm_normalizers.size(); c++) { if (regional_prm_normalizers[c].size()==0) continue; int s; for (s=0; s<regional_prm_normalizers[c].size(); s++) { out_stream << c << " " << s << " " << regional_prm_normalizers[c][s].size(); int r; for (r=0; r<regional_prm_normalizers[c][s].size(); r++) out_stream << " " << regional_prm_normalizers[c][s][r]; out_stream << endl; } } out_stream.close(); }
void AdvancedScoreModel::write_prm_normalizer_values() const { string file_path = config.get_resource_dir() + "/" + this->model_name + "_prm_norm.txt"; ofstream out_stream(file_path.c_str()); if (! out_stream.good()) { cout << "Error: couldn't open prm_norm file for writing: " << file_path << endl; exit(1); } out_stream << setprecision(3); int c; for (c=1; c<regional_prm_normalizers.size(); c++) { if (regional_prm_normalizers[c].size()==0) continue; int s; for (s=0; s<regional_prm_normalizers[c].size(); s++) { out_stream << c << " " << s << " " << regional_prm_normalizers[c][s].size(); int r; for (r=0; r<regional_prm_normalizers[c][s].size(); r++) out_stream << " " << regional_prm_normalizers[c][s][r]; out_stream << endl; } } out_stream.close(); }
void svcbyz_recycle(SVCXPRT *xpt, char* in, int in_size, char *out, int out_size) { assert(xpt != 0); xdrmem_create(in_stream(xpt), in, in_size, XDR_DECODE); xdrmem_create(out_stream(xpt), out, out_size, XDR_ENCODE); }
void* SearchThread::Entry() { const wxString searchescaped = ConvToIRI(m_search_query); // std::cout << "Escaped search query: " << m_search_query.ToAscii().data() << std::endl; wxHTTP get; get.SetTimeout(10); get.Connect(_("api.springfiles.com")); const wxString query = wxFormat(_("/json.php?nosensitive=on&logical=or&springname=%s&tag=%s")) % searchescaped % searchescaped; wxInputStream * httpStream = get.GetInputStream(query); wxString res; if ( get.GetError() == wxPROTO_NOERR ) { wxStringOutputStream out_stream(&res); httpStream->Read(out_stream); } wxDELETE(httpStream); wxCommandEvent notify(SEARCH_FINISHED,ContentDownloadDialog::ID_SEARCH_FINISHED); notify.SetInt(0); notify.SetString(res); wxPostEvent(m_content_dialog,notify); // std::cout << "Search finished" << std::endl; return NULL; }
SVCXPRT * svcbyz_create(char* in, int in_size, char *out, int out_size) { register SVCXPRT *xprt; struct xp_ops* xops; xprt = (SVCXPRT *)malloc(sizeof(SVCXPRT)); if (xprt == NULL) { (void)fprintf(stderr, "svcbyz_create: out of memory\n"); return (NULL); } xprt->xp_sock = -1; xprt->xp_port = -1; xops = (struct xp_ops*) malloc(sizeof(struct xp_ops)); xops->xp_recv = byz_recv; xops->xp_stat = byz_stat; xops->xp_getargs = byz_getargs; xops->xp_reply = byz_reply; xops->xp_freeargs = byz_freeargs; xops->xp_destroy = byz_destroy; xprt->xp_ops = xops; xprt->xp_p1 = malloc(sizeof(XDR)); /* in XDR */ xprt->xp_p2 = malloc(sizeof(XDR)); /* out XDR */ xprt->xp_verf.oa_flavor = AUTH_NULL; xprt->xp_verf.oa_length = 0; xdrmem_create(in_stream(xprt), in, in_size, XDR_DECODE); xdrmem_create(out_stream(xprt), out, out_size, XDR_ENCODE); return xprt; }
std::string Falcon::PutURL(const std::string& url, const std::string& request, bool logresult) { static log4cpp::Category &logger_base = log4cpp::Category::getInstance(std::string("log_base")); wxString res; _http.SetMethod("POST"); _http.SetPostText("application/x-www-form-urlencoded", request); wxInputStream *httpStream = _http.GetInputStream(wxString(url)); logger_base.debug("Making request to falcon '%s'.", (const char *)url.c_str()); logger_base.debug(" With data '%s'.", (const char *)request.c_str()); if (_http.GetError() == wxPROTO_NOERR) { wxStringOutputStream out_stream(&res); httpStream->Read(out_stream); if (logresult) { logger_base.debug("Response from falcon '%s'.", (const char *)res.c_str()); } } else { logger_base.error("Unable to connect to falcon '%s'.", (const char *)url.c_str()); wxMessageBox(_T("Unable to connect!")); } _http.SetPostText("", ""); wxDELETE(httpStream); return res.ToStdString(); }
bool Transcribe::saveText() { if (!m_text_file) { // This shouldn't happen because of the GUI. We silently ignore it return false; } QSaveFile file(m_text_file->fileName()); if (file.open(QIODevice::WriteOnly | QIODevice::Text)) { #ifdef Q_OS_ANDROID // The on-screen keyboard doesn't actully add the word to the text area // until it is committed, normally by a space or period etc. To include it // in our saved file, we need to manually commit it. qApp->inputMethod()->commit(); #endif QTextStream out_stream(&file); out_stream << QQmlProperty::read(m_text_area, "text").toString(); if (file.commit()) { setTextDirty(false); return true; } } // Notify that the file could not be saved QString general_msg = tr("There was an error saving the text file.\n"); general_msg += tr("The latest changes are not saved!"); errorDetected(general_msg); return false; }
inline void write_file(const std::string& file_name, char* buffer, const std::size_t& buffer_size) { std::ofstream out_stream(file_name.c_str(),std::ios::binary); if (!out_stream) return; out_stream.write(buffer,static_cast<std::streamsize>(buffer_size)); out_stream.close(); }
bool CModelBaseExportor::exportUVChannelToStreamAsXML(std::wstring mesh_dir , xcomdoc& doc , xMeshData& meshData, int compress_rate) { int nVert = (int)meshData.m_VertexData.m_Positons.size(); for(int iUVCh = 0 ; iUVCh < meshData.m_VertexData.m_nUVChannes ; ++iUVCh ) { xXmlDocument xml; xXmlNode* rootNode = xml.insertNode(L"MeshUV"); rootNode->setValue(L"nVertex",nVert); rootNode->setValue(L"nMapChanel",iUVCh); for(int i = 0 ; i < nVert ; ++i ) { sUVCoord_t & uv = meshData.m_VertexData.m_UVChannels[iUVCh][i]; wchar_t index[32]={0};swprintf(index , L"idx-%d",i); xXmlNode* pUVNode = rootNode->insertNode( index ); pUVNode->setValue(L"u" , uv.u); pUVNode->setValue(L"v" , uv.v); } wchar_t buf[32]; swprintf(buf,L"/uv_%d.xml",iUVCh); wstring file_name = mesh_dir + buf; xcomdocstream* pUVStream = doc.create_stream(file_name.c_str(),xcddt_common,compress_rate); pUVStream->stream_seekw(xcdsd_beg,0); xcdstream out_stream(pUVStream); xml.setXMLStyle(true); xml.save(out_stream); out_stream.close(); doc.close_stream(pUVStream); } return true; }
bool CModelBaseExportor::exportDiffuseToStreamAsXML(std::wstring mesh_dir , xcomdoc& doc , xMeshData& meshData, int compress_rate) { int nVert = (int)meshData.m_VertexData.m_Positons.size(); xXmlDocument xml; xXmlNode* rootNode = xml.insertNode(L"MeshColor"); rootNode->setValue(L"nVertex",nVert); for(int i = 0 ; i < nVert ; ++i ) { sColor_t & cl = meshData.m_VertexData.m_Diffuses[i]; wchar_t index[32]={0};swprintf(index , L"idx-%d",i); xXmlNode* pVecNode = rootNode->insertNode( index ); pVecNode->setValue(L"r" , cl.r); pVecNode->setValue(L"g" , cl.g); pVecNode->setValue(L"b" , cl.b); pVecNode->setValue(L"a" , cl.a); } //写入Diffuse wstring mesh_diffuse_file = mesh_dir + L"/diffuse.xml"; xcomdocstream* pdiffuseStream = doc.create_stream(mesh_diffuse_file.c_str(),xcddt_common,compress_rate); pdiffuseStream->stream_seekw(xcdsd_beg,0); xcdstream out_stream(pdiffuseStream); xml.setXMLStyle(true); xml.save(out_stream); out_stream.close(); doc.close_stream(pdiffuseStream); return true; }
bool CModelBaseExportor::_export_svectorsAsXML(sVectors_t& vec , xcomdoc& doc , std::wstring mesh_dir , std::wstring stream_name , std::wstring rootNode_name , int compress_rate) { int nVert = (int)vec.size(); xXmlDocument xml; xXmlNode* rootNode = xml.insertNode(rootNode_name.c_str()); rootNode->setValue(L"nVertex",nVert); for(int i = 0 ; i < nVert ; ++i ) { sVector_t& v = vec[i]; wchar_t index[32]={0};swprintf(index , L"idx-%d",i); xXmlNode* pVecNode = rootNode->insertNode(index); pVecNode->setValue(L"x" , v.x); pVecNode->setValue(L"y" , v.y); pVecNode->setValue(L"z" , v.z); } //写入Normal wstring mesh_vec_file = mesh_dir + L"/" + stream_name + L".xml"; xcomdocstream* pVecDataStream = doc.create_stream(mesh_vec_file.c_str(),xcddt_common,compress_rate); pVecDataStream->stream_seekw(xcdsd_beg,0); xcdstream out_stream(pVecDataStream); xml.setXMLStyle(true); xml.save(out_stream); out_stream.close(); doc.close_stream(pVecDataStream); return true; }
void CSConnectionAcquirer::ServerStateInquire(const Request &request) { QHash<QByteArray, QUrl> id_to_addr; const Id &my_id = GetConnectionManager()->GetId(); const ConnectionTable &ct = GetConnectionManager()->GetConnectionTable(); foreach(const PublicIdentity &gc, _group.GetSubgroup()) { const Id &gc_id = gc.GetId(); if(gc_id == my_id) { continue; } QSharedPointer<Connection> con = ct.GetConnection(gc_id); if(!con) { continue; } id_to_addr[gc_id.GetByteArray()] = con->GetEdge()->GetRemotePersistentAddress().GetUrl(); } QByteArray slm; QDataStream out_stream(&slm, QIODevice::WriteOnly); out_stream << id_to_addr; QVariantHash msg; msg["connections"] = ct.GetConnections().size(); msg["list"] = slm; request.Respond(msg); }
void UCDIO::write_nodal_data(const std::string & fname, const std::vector<Number> & soln, const std::vector<std::string> & names) { const MeshBase & mesh = MeshOutput<MeshBase>::mesh(); const dof_id_type n_elem = mesh.n_elem(); // Only processor 0 does the writing if (mesh.processor_id()) return; std::ofstream out_stream(fname.c_str()); // UCD doesn't work in 1D libmesh_assert (mesh.mesh_dimension() != 1); // Write header this->write_header(out_stream,mesh,n_elem, cast_int<unsigned int>(names.size())); // Write the node coordinates this->write_nodes(out_stream, mesh); // Write the elements this->write_interior_elems(out_stream, mesh); // Write the solution this->write_soln(out_stream, mesh, names, soln); }
std::string Falcon::GetURL(const std::string& url, bool logresult) { static log4cpp::Category &logger_base = log4cpp::Category::getInstance(std::string("log_base")); wxString res; _http.SetMethod("GET"); wxInputStream *httpStream = _http.GetInputStream(wxString(url)); logger_base.debug("Making request to falcon '%s'.", (const char *)url.c_str()); if (_http.GetError() == wxPROTO_NOERR) { wxStringOutputStream out_stream(&res); httpStream->Read(out_stream); if (logresult) { logger_base.debug("Response from falcon '%s'.", (const char *)res.c_str()); } } else { logger_base.error("Unable to connect to falcon '%s'.", (const char *)url.c_str()); wxMessageBox(_T("Unable to connect!")); } wxDELETE(httpStream); return res.ToStdString(); }
int main(){ string buffer("buffer.txt"); string solution("solution.txt"); //for (unsigned int test_number = 0; test_number <= 100000000; test_number) { #ifdef READ T w, h; ifstream in_stream(buffer); in_stream >> w >> h; matrix<T> source(w, h); for (auto& i : source) { in_stream >> i; } in_stream.close(); #else const T w = 1000, h = 1000; matrix<T> source = gen_sourse_data(w, h, 5); #endif #ifdef WRITE ofstream out_stream(buffer); out_stream << w << ' ' << h; T j = 0; for (const auto& i : source) { if ((j++ % w) == 0) out_stream << '\n'; out_stream << i << ' '; } out_stream.close(); #endif #ifdef SOLVE cout << "w = " << w << "; h = " << h << ";" << endl; auto start_time = clock(); matrix<T> source_copy(source);//эта матрица будет преобразована в такую, что в каждом квадрате 3х3 будет не больше 3 текстур matrix< array<pair<T, bool>, 3> > res = get_textures_arrangement(source_copy); double time = (clock() - start_time) / double(1000); auto source_from_res = res_to_source(res); auto diff1 = difference(source, source_from_res); auto diff2 = difference(source, source_copy); cout << "time is " << time << " second" << endl; cout << "full difference is " << diff1 << " = " << (diff1 / (float)(w * h)) * 100 << "%" << endl; cout << "difference between source and 3x3 condition source is " << diff2 << " = " << (diff2 / (float)(w * h)) * 100 << "%" << endl << endl; #ifdef PRINT_SOLUTION ofstream solution_stream(solution); cout.rdbuf(solution_stream.rdbuf()); cout << "w = " << w << "; h = " << h << ";" << endl; cout << "time is " << time << " second" << endl; cout << "full difference is " << diff1 << " = " << (diff1 / (float)(w * h)) * 100 << "%" << endl; cout << "difference between source and 3x3 condition source is " << diff2 << " = " << (diff2 / (float)(w * h)) * 100 << "%" << endl << endl; print(source, res); solution_stream.close(); #endif #endif //} system("pause"); }
/*------------------------------------------------------------------------- * Function: out_init * * Purpose: Initialize output. * * Return: void * * Programmer: Robb Matzke * [email protected] * Dec 11 1996 * * Modifications: * Robb Matzke, 2000-05-23 * The column in which the equal sign appears is 25 percent * of the way across the screen. * * Robb Matzke, 2000-06-01 * The window size is obtained by ioctl() when possible. * * Robb Matzke, 2000-06-28 * Signal handlers are registered with sigaction() since its * behavior is more consistent. *------------------------------------------------------------------------- */ void out_init (void) { struct sigaction action; /* Keep track of terminal size changes */ out_init_size(); /* Open standard streams */ OUT_STDOUT = out_stream (stdout); OUT_STDERR = out_stream (stderr); /* Arrange to handle broken pipes and interrupts */ action.sa_handler = handle_signals; sigemptyset(&action.sa_mask); action.sa_flags = SA_RESTART; sigaction(SIGPIPE, &action, NULL); sigaction(SIGINT, &action, NULL); }
void test_iostream_iterator() { vector<string> text; istream_iterator<string> stream_start(cin); istream_iterator<string> eof; copy(stream_start, eof, back_inserter(text)); sort(text.begin(), text.end()); ostream_iterator<string> out_stream(cout, " "); copy(text.begin(), text.end(), out_stream); }
void test_load_stream() { remove_temp_file(); { std::ifstream in_stream(existing_file, std::ios::binary); xlnt::zip_file f(in_stream); std::ofstream out_stream(temp_file.GetFilename(), std::ios::binary); f.save(out_stream); } TS_ASSERT(files_equal(existing_file, temp_file.GetFilename())); remove_temp_file(); }
vector<string> StreamSorter<Message>::streaming_merge(const vector<string>& temp_files_in, unordered_map<string, size_t>* messages_per_file) { // What are the names of the merged files we create? vector<string> temp_files_out; // We don't do this loop in parallel because the point of looping is to limit the total currently open files. for (size_t start_file = 0; start_file < temp_files_in.size(); start_file += max_fan_in) { // For each range of sufficiently few files, starting at start_file and running for file_count size_t file_count = min(max_fan_in, temp_files_in.size() - start_file); // Open up cursors into all the files. list<ifstream> temp_ifstreams; list<cursor_t> temp_cursors; open_all(vector<string>(&temp_files_out[start_file], &temp_files_out[start_file + file_count]), temp_ifstreams, temp_cursors); // Work out how many messages to expect size_t expected_messages = 0; if (messages_per_file != nullptr) { for (size_t i = start_file; i < start_file + file_count; i++) { expected_messages += messages_per_file->at(temp_files_in.at(i)); } } // Open an output file string out_file_name = temp_file::create(); ofstream out_stream(out_file_name); temp_files_out.push_back(out_file_name); // Make an output emitter emitter_t emitter(out_stream); // Merge the cursors into the emitter streaming_merge(temp_cursors, emitter, expected_messages); // The output file will be flushed and finished automatically when the emitter goes away. // Clean up the input files we used temp_cursors.clear(); temp_ifstreams.clear(); for (size_t i = start_file; i < file_count; i++) { temp_file::remove(temp_files_in.at(i)); } if (messages_per_file != nullptr) { // Save the total messages that should be in the created file, in case we need to do another pass (*messages_per_file)[out_file_name] = expected_messages; } } return temp_files_out; }
TestFWParser::TestFWParser(): QObject() { test_cases_.append( "this is an exam ple of 256 cases being tested -3.14 times\n"); test_cases_.append( " \n"); test_cases_.append("this is an ex\n\n"); QString file_name("TestFW.txt"); file_name = KStandardDirs::locateLocal("appdata", file_name); if (!file_name.isNull()) { test_file_.setFileName(file_name); if (!test_file_.open(QIODevice::WriteOnly)) { kWarning() << QString("Couldn't open(%1)").arg(file_name); } } QTextStream out_stream(&test_file_); foreach(const QString &test_case, test_cases_) out_stream << test_case; test_file_.close(); //Building the sequence to be used. Includes all available types. sequence_.clear(); sequence_.append(qMakePair(QString("field1"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field2"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field3"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field4"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field5"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field6"), KSParser::D_INT)); sequence_.append(qMakePair(QString("field7"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field8"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field9"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field10"), KSParser::D_FLOAT)); sequence_.append(qMakePair(QString("field11"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field12"), KSParser::D_QSTRING)); widths_.append(5); widths_.append(3); widths_.append(3); widths_.append(9); widths_.append(3); widths_.append(4); widths_.append(6); widths_.append(6); widths_.append(7); widths_.append(6); widths_.append(6); //'repeatedly' doesn't need a width QString fname = KStandardDirs::locate( "appdata", file_name ); test_parser_ = new KSParser(fname, '#', sequence_, widths_); }
void onReturn(const std::string& path) { BracExtenssionProviderAPI * api_ptr = brac_extenssion_provider_api; if (!api_ptr) { return; } if (path.empty()) { api_ptr->log("No brac file selected, the path is empty "); return; } else { api_ptr->log("brac file selected: " + path); } std::string root_dir = api_ptr->getExtensionPath(); #if defined _WIN32 std::string command = "cd /d \"" + root_dir + "\" & bin\\7za.exe e -y \"" + path + "\" brac.xml"; #elif defined __APPLE__ std::string escaped_root_dir = escape_path(root_dir); api_ptr->log("brac extension root dir (escaped): " + escaped_root_dir); std::string escaped_path = escape_path(path); api_ptr->log("selected brac dir (escaped): " + escaped_path); std::string command = "cd " + escaped_root_dir + "; bin/7za e -y " + escaped_path + " brac.xml"; #endif api_ptr->systemCall(command); std::string content; std::string brac_path = root_dir + "/brac.xml"; pugi::xml_document brac_xml; std::stringstream out_stream(std::stringstream::out); pugi::xml_parse_result res = brac_xml.load_file(brac_path.c_str()); if (!res) { api_ptr->log("Couldn't load the brac.xml at " + brac_path + ": " + res.description()); return; } brac_xml.save(out_stream); content = out_stream.str(); #if defined _WIN32 command = "del /F /Q \"" + root_dir + "\\brac.xml\""; #elif defined __APPLE__ command = "rm -f " + escaped_root_dir + "/brac.xml"; #endif api_ptr->systemCall(command); brac_extenssion_provider_api->fire_bracfileselect(path, content); return; }
void PMCSQS_Scorer::write_sqs_models(const char *path) const { ofstream out_stream(path,ios::out); if (! out_stream.good()) { cout << "Error: couldn't open pmc model for writing: " << path << endl; exit(1); } int i; out_stream << sqs_models.size() << endl; out_stream << this->sqsMassThresholds_.size() << setprecision(2) << fixed; for (i=0; i<sqsMassThresholds_.size(); i++) out_stream << " " << sqsMassThresholds_[i]; out_stream << endl; const int numSizes = sqsMassThresholds_.size(); for (i=0; i<sqs_models.size(); i++) { out_stream << this->sqs_correction_factors[i].size() << setprecision(4); int j; for (j=0; j<sqs_correction_factors[i].size(); j++) out_stream << " " << sqs_correction_factors[i][j] << " " << sqs_mult_factors[i][j]; out_stream << endl; } // write ME models for (i=0; i<sqs_models.size(); i++) { int j; for (j=0; j<sqs_models[i].size(); j++) { int k; for (k=0; k<sqs_models[i][j].size(); k++) { if (sqs_models[i][j][k]) { out_stream << i << " " << j << " " << k << endl; sqs_models[i][j][k]->write_regression_model(out_stream); } } } } out_stream.close(); }
bool WriteMidiFile(const MIDIMultiTrack &src, const char *file, bool use_running_status) { MIDIFileWriteStreamFileName out_stream( file ); if ( !out_stream.IsValid() ) return false; MIDIFileWriteMultiTrack writer( &src, &out_stream ); // write midifile with or without running status usage writer.UseRunningStatus( use_running_status ); int tracks_number = src.GetNumTracksWithEvents(); return writer.Write( tracks_number ); }
void finalize_compile(CompilerType& compiler, std::string& output, size_t partition_size = 0) { if (partition_size == 0) { std::ofstream out_stream(output, std::ios::binary); compiler.Compile(callback); compiler.Write(out_stream); out_stream.close(); } else { std::string output_part_zero = output + ".0"; int partition_number = 1; std::ofstream out_stream(output_part_zero, std::ios::binary); while (compiler.CompileNext(partition_size, out_stream, 2, callback)) { std::cout << "Finalize partition " << partition_number << std::endl; out_stream.close(); out_stream.open(output + "." + std::to_string(partition_number), std::ios::binary); ++partition_number; } out_stream.close(); } }
int main(int argc, char* argv[]) { google::InitGoogleLogging(argv[0]); std::string corpus_filepath("/data/Corpus/wikipedia_dump/de_wiki_sen_tokenized_lower_per_line.txt"); int wordvec_dim = 100; int window_size = 11; float learning_rate = 0.025; int skipgram = 1; int hs = 1; int negative = 10; float sample = 1e-5; int num_iters = 10; int num_threads = 4; int verbose = 1; Corpus &corpus = Corpus::getCorpus(corpus_filepath); try{ /* corpus.build_vocab(); corpus.save_vocab(std::string("cbow_vocab.txt")); */ corpus.load_vocab(std::string("cbow_vocab.txt")); corpus.create_huffman_tree(); } catch (std::exception& e) { LOG(FATAL) << e.what(); } Word2Vec model(corpus, wordvec_dim, window_size, learning_rate, skipgram, hs, negative, sample, num_iters, num_threads, verbose); model.start_train(); LOG(INFO) << "Training done!"; { const char* name = "word2vec_sg_trained_model.bin"; std::ofstream out_stream(name); boost::archive::binary_oarchive oar(out_stream); oar << model; out_stream.close(); } model.export_vectors(std::string("cbow_word_vectors_save.bin")); return 0; }
virtual void VerifyInnerCiphertext() { Random &rand = Random::GetInstance(); if((rand.GetInt(0, 1024) / 1024.0) > N) { ShuffleRound::VerifyInnerCiphertext(); return; } SetTriggered(); QByteArray msg; QDataStream out_stream(&msg, QIODevice::WriteOnly); out_stream << GO_MESSAGE << GetRoundId() << false; VerifiableBroadcast(msg); _state_machine.StateComplete(); }
virtual bool createDiff(CourgetteBufferI* oldBuffer, CourgetteBufferI* newBuffer, CourgetteCallbackI* callback) { if (!callback || !oldBuffer || !newBuffer) return false; courgette::SourceStream old_stream; courgette::SourceStream new_stream; old_stream.Init(oldBuffer->getBuffer(), oldBuffer->getSize()); new_stream.Init(newBuffer->getBuffer(), newBuffer->getSize()); SinkStream out_stream(callback); courgette::Status status = courgette::GenerateEnsemblePatch(&old_stream, &new_stream, &out_stream); return (status == courgette::C_OK); }
void TestFWParser::initTestCase() { test_cases_.append( "this is an exam ple of 256 cases being tested -3.14 times\n"); test_cases_.append( " \n"); test_cases_.append("this is an ex\n\n"); KTemporaryFile temp_file; temp_file.setPrefix(QDir::tempPath() + "/"); temp_file.setSuffix(".txt"); temp_file.setAutoRemove(false); QVERIFY(temp_file.open()); test_file_name_ = temp_file.fileName(); QTextStream out_stream(&temp_file); foreach(const QString &test_case, test_cases_) out_stream << test_case; temp_file.close(); //Building the sequence to be used. Includes all available types. sequence_.clear(); sequence_.append(qMakePair(QString("field1"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field2"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field3"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field4"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field5"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field6"), KSParser::D_INT)); sequence_.append(qMakePair(QString("field7"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field8"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field9"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field10"), KSParser::D_FLOAT)); sequence_.append(qMakePair(QString("field11"), KSParser::D_QSTRING)); sequence_.append(qMakePair(QString("field12"), KSParser::D_QSTRING)); widths_.append(5); widths_.append(3); widths_.append(3); widths_.append(9); widths_.append(3); widths_.append(4); widths_.append(6); widths_.append(6); widths_.append(7); widths_.append(6); widths_.append(6); //'repeatedly' doesn't need a width test_parser_ = new KSParser(test_file_name_, '#', sequence_, widths_); }
void ShuffleRound::Shuffle() { qDebug() << _group.GetIndex(_local_id) << ": shuffling"; _state = Shuffling; for(int idx = 0; idx < _shuffle_data.count(); idx++) { for(int jdx = 0; jdx < _shuffle_data.count(); jdx++) { if(idx == jdx) { continue; } if(_shuffle_data[idx] != _shuffle_data[jdx]) { continue; } qWarning() << "Found duplicate cipher texts... blaming"; // blame ? return; } } QVector<QByteArray> out_data; int blame = OnionEncryptor::GetInstance().Decrypt(_outer_key, _shuffle_data, out_data); if (blame != -1) { qWarning() << _group.GetIndex(_local_id) << _local_id.ToString() << ": failed to decrypt layer due to block at index" << blame; // blame ? return; } const Id &next = _group.Next(_local_id); MessageType mtype = (next == Id::Zero) ? EncryptedData : ShuffleData; QByteArray msg; QDataStream out_stream(&msg, QIODevice::WriteOnly); out_stream << mtype << GetId().GetByteArray() << out_data; _state = ShuffleDone; if(mtype == EncryptedData) { Broadcast(msg); _encrypted_data = out_data; Verify(); } else { Send(msg, next); } }