예제 #1
0
int main()
{
    {
        testbuf<char> sb1;
        testbuf<char> sb2;
        test_ostream<char> os1(&sb1);
        test_ostream<char> os2(&sb2);
        os1.swap(os2);
        assert(os1.rdbuf() == &sb1);
        assert(os1.tie() == 0);
        assert(os1.fill() == ' ');
        assert(os1.rdstate() == os1.goodbit);
        assert(os1.exceptions() == os1.goodbit);
        assert(os1.flags() == (os1.skipws | os1.dec));
        assert(os1.precision() == 6);
        assert(os1.getloc().name() == "C");
        assert(os2.rdbuf() == &sb2);
        assert(os2.tie() == 0);
        assert(os2.fill() == ' ');
        assert(os2.rdstate() == os2.goodbit);
        assert(os2.exceptions() == os2.goodbit);
        assert(os2.flags() == (os2.skipws | os2.dec));
        assert(os2.precision() == 6);
        assert(os2.getloc().name() == "C");
    }
    {
        testbuf<wchar_t> sb1;
        testbuf<wchar_t> sb2;
        test_ostream<wchar_t> os1(&sb1);
        test_ostream<wchar_t> os2(&sb2);
        os1.swap(os2);
        assert(os1.rdbuf() == &sb1);
        assert(os1.tie() == 0);
        assert(os1.fill() == ' ');
        assert(os1.rdstate() == os1.goodbit);
        assert(os1.exceptions() == os1.goodbit);
        assert(os1.flags() == (os1.skipws | os1.dec));
        assert(os1.precision() == 6);
        assert(os1.getloc().name() == "C");
        assert(os2.rdbuf() == &sb2);
        assert(os2.tie() == 0);
        assert(os2.fill() == ' ');
        assert(os2.rdstate() == os2.goodbit);
        assert(os2.exceptions() == os2.goodbit);
        assert(os2.flags() == (os2.skipws | os2.dec));
        assert(os2.precision() == 6);
        assert(os2.getloc().name() == "C");
    }
}
예제 #2
0
std::string MobV2SAO::getClientInitializationData()
{
	//infostream<<__FUNCTION_NAME<<std::endl;

	updateProperties();

	std::ostringstream os(std::ios::binary);

	// version
	writeU8(os, 0);
	
	Settings client_properties;
	
	/*client_properties.set("version", "0");
	client_properties.updateValue(*m_properties, "pos");
	client_properties.updateValue(*m_properties, "yaw");
	client_properties.updateValue(*m_properties, "hp");*/

	// Just send everything for simplicity
	client_properties.update(*m_properties);

	std::ostringstream os2(std::ios::binary);
	client_properties.writeLines(os2);
	compressZlib(os2.str(), os);

	return os.str();
}
예제 #3
0
파일: nodedef.cpp 프로젝트: EXio4/minetest
void CNodeDefManager::serialize(std::ostream &os, u16 protocol_version) const
{
	writeU8(os, 1); // version
	u16 count = 0;
	std::ostringstream os2(std::ios::binary);
	for (u32 i = 0; i < m_content_features.size(); i++) {
		if (i == CONTENT_IGNORE || i == CONTENT_AIR
				|| i == CONTENT_UNKNOWN)
			continue;
		const ContentFeatures *f = &m_content_features[i];
		if (f->name.empty())
			continue;
		writeU16(os2, i);
		// Wrap it in a string to allow different lengths without
		// strict version incompatibilities
		std::ostringstream wrapper_os(std::ios::binary);
		f->serialize(wrapper_os, protocol_version);
		os2<<serializeString(wrapper_os.str());

		// must not overflow
		u16 next = count + 1;
		FATAL_ERROR_IF(next < count, "Overflow");
		count++;
	}
	writeU16(os, count);
	os << serializeLongString(os2.str());
}
예제 #4
0
	void serialize(std::ostream &os, u16 protocol_version)
	{
		writeU8(os, 1); // version
		u16 count = 0;
		std::ostringstream os2(std::ios::binary);
		for(u32 i=0; i<m_content_features.size(); i++)
		{
			if(i == CONTENT_IGNORE || i == CONTENT_AIR
					|| i == CONTENT_UNKNOWN)
				continue;
			ContentFeatures *f = &m_content_features[i];
			if(f->name == "")
				continue;
			writeU16(os2, i);
			// Wrap it in a string to allow different lengths without
			// strict version incompatibilities
			std::ostringstream wrapper_os(std::ios::binary);
			f->serialize(wrapper_os, protocol_version);
			os2<<serializeString(wrapper_os.str());

			assert(count + 1 > count); // must not overflow
			count++;
		}
		writeU16(os, count);
		os<<serializeLongString(os2.str());
	}
예제 #5
0
int main()
{
    {
        std::ostream os((std::streambuf*)0);
        std::ostream::sentry s(os);
        assert(!bool(s));
    }
    {
        testbuf1<char> sb;
        std::ostream os(&sb);
        std::ostream::sentry s(os);
        assert(bool(s));
    }
    {
        testbuf1<char> sb;
        std::ostream os(&sb);
        testbuf1<char> sb2;
        std::ostream os2(&sb2);
        os.tie(&os2);
        assert(sync_called == 0);
        std::ostream::sentry s(os);
        assert(bool(s));
        assert(sync_called == 1);
    }
}
예제 #6
0
파일: hash.cpp 프로젝트: Zoxc/mirb
	value_t Hash::to_s(Hash *self)
	{
		RecursionDetector<RecursionType::Hash_to_s, false> rd(self);

		if(rd.recursion())
			return String::get("{...}");

		CharArray result = "{";

		OnStack<1> os1(self);
		OnStackString<1> os2(result);

		HashAccess::each_pair(self, [&](value_t key, value_t value) -> bool {

			OnStack<1> os(value);
			
			result += inspect(key);
			result += "=>";
			result += inspect(value);
			result += ", ";

			return true;
		});

		if(result.size() > 1)
			result.shrink(result.size() - 2);

		result += "}";

		return result.to_string();
	}
예제 #7
0
파일: mesh.cpp 프로젝트: jdesai927/skulptor
void Mesh::objFileStructure2(const char* mtlfilename){
	cout<<mtlfilename<<endl;
	ifstream mtl(mtlfilename,ios::in);
	if(!mtl){
			cerr<<"File could not be found."<<endl;
			exit(1);
	}
	string materialLine="";
	string materialToken="";
	while(!mtl.eof()){
	
		if(materialToken!="newmtl"){
			getline(mtl, materialLine);
			std::stringstream os1(materialLine);
			os1>>materialToken;
		}
		
		if(materialToken =="newmtl"){
			std::stringstream os2(materialLine);
			os2>>materialToken;//new mtl
			
			os2>>materialToken;//material
			
			string thematerial = materialToken;
			float red = 0.0776f;
			float green = 0.2571f;
			float blue = 0.2041f;
			do{
				if(mtl.eof()){
					break;
				}
				if(!mtl.eof()){
					getline(mtl, materialLine);
				//	cout<<"lines before newmtl ..."<<materialLine<<endl;
					std::stringstream os3(materialLine);
					os3>>materialToken;
					
				if(materialToken=="Kd"){
					
						os3>>materialToken;
						//cout<<"red "<<materialToken<<endl;
						 red = atof(materialToken.c_str());
						
						os3>>materialToken;
						//cout<<"green "<<materialToken<<endl;
						 green = atof(materialToken.c_str());
						
						os3>>materialToken;
					//	cout<<"blue "<<materialToken<<endl;
						 blue = atof(materialToken.c_str());
						

				}
				
				}
예제 #8
0
  /**
   * Runs rbx from the filesystem. Searches for the Rubinius runtime files
   * according to the algorithm in find_runtime().
   */
  void Environment::run_from_filesystem() {
    int i = 0;
    state->vm()->set_root_stack(reinterpret_cast<uintptr_t>(&i),
                                VM::cStackDepthMax);

    std::string runtime = system_prefix() + RBX_RUNTIME_PATH;

    load_platform_conf(runtime);
    boot_vm();
    start_finalizer();

    load_argv(argc_, argv_);

    start_signals();
    state->vm()->initialize_config();

    load_tool();

    G(rubinius)->set_const(state, "Signature", Integer::from(state, signature_));

    if(LANGUAGE_20_ENABLED(state)) {
      runtime += "/20";
    } else if(LANGUAGE_19_ENABLED(state)) {
      runtime += "/19";
    } else {
      runtime += "/18";
    }
    G(rubinius)->set_const(state, "RUNTIME_PATH", String::create(state,
                           runtime.c_str(), runtime.size()));

    load_kernel(runtime);
    shared->finalizer_handler()->start_thread(state);

    run_file(runtime + "/loader.rbc");

    state->vm()->thread_state()->clear();

    Object* loader = G(rubinius)->get_const(state, state->symbol("Loader"));
    if(loader->nil_p()) {
      rubinius::bug("Unable to find loader");
    }

    OnStack<1> os(state, loader);

    Object* inst = loader->send(state, 0, state->symbol("new"));
    if(inst) {
      OnStack<1> os2(state, inst);

      inst->send(state, 0, state->symbol("main"));
    } else {
      rubinius::bug("Unable to instantiate loader");
    }
  }
예제 #9
0
파일: help.cpp 프로젝트: nitehawk/koalamud
/** Save help entry to database */
void HelpOLC::save(void)
{
    QString query;
    QTextOStream qos(&query);
    QSqlQuery q;

    if (_entry == 0)
    {
        qos << "insert into helptext (title, keywords, body) values " << endl
            << "('" << _topic << "', '" << _keywords << "', '" << _body << "');";
    }
    else
    {
        qos << "update helptext " << endl
            << "set title='" << _topic << "', " << endl
            << "keywords='" << _keywords << "', " << endl
            << "body='" << Logger::escapeString(_body) << "'" << endl
            << "where helpid = " << _entry << ";";
    }
    if (q.exec(query))
    {
        if (_entry == 0)
        {
            /* Doesn't look like we can get the last insert ID, so we'll query for a
             * specific match to our title and keywords */
            QString q2;
            QTextOStream os2(&q2);
            os2 << "select helpid from helptext where " << endl
                << "title = '" << _topic << "' and keywords = '" << _keywords
                << "';";
            if (q.exec(q2) && q.next())
            {
                _entry = q.value(0).toUInt();
            }
        }
    } else {
        QString out;
        QTextOStream os(&out);
        os << "Failed save query in help editor: " << query;
        Logger::msg(out, Logger::LOG_ERROR);
    }
}
예제 #10
0
int main()
{
    {
        std::ostream os((std::streambuf*)0);
        const void* n = 0;
        os << n;
        assert(os.bad());
        assert(os.fail());
    }
    {
        testbuf<char> sb1;
        std::ostream os1(&sb1);
        int n1;
        os1 << &n1;
        assert(os1.good());
        std::string s1(sb1.str());

        testbuf<char> sb2;
        std::ostream os2(&sb2);
        int n2;
        os2 << &n2;
        assert(os2.good());
        std::string s2(sb2.str());

        // %p is implementation defined. Instead of validating the
        // output, at least ensure that it does not generate an empty
        // string. Also make sure that given two distinct addresses, the
        // output of %p is different.
        assert(!s1.empty());
        assert(!s2.empty());
        assert(s1 != s2);
    }
    {
        testbuf<char> sb;
        std::ostream os(&sb);
        const void* n = &sb;
        os << n;
        assert(os.good());
    }
}
예제 #11
0
	void serialize(std::ostream &os)
	{
		writeU8(os, 1); // version
		u16 count = 0;
		std::ostringstream os2(std::ios::binary);
		for(u16 i=0; i<=MAX_CONTENT; i++)
		{
			if(i == CONTENT_IGNORE || i == CONTENT_AIR)
				continue;
			ContentFeatures *f = &m_content_features[i];
			if(f->name == "")
				continue;
			writeU16(os2, i);
			// Wrap it in a string to allow different lengths without
			// strict version incompatibilities
			std::ostringstream wrapper_os(std::ios::binary);
			f->serialize(wrapper_os);
			os2<<serializeString(wrapper_os.str());
			count++;
		}
		writeU16(os, count);
		os<<serializeLongString(os2.str());
	}
예제 #12
0
QuadcopterPlanner::QuadcopterPlanner():
  ph_("~"){
    
    pose_pub_ = nh_.advertise<geometry_msgs::PoseStamped>("/app/quadcmdpose",1);
    status_pub_ = nh_.advertise<actionlib_msgs::GoalStatus>("/app/plannersts",1);
      
    bool prmAvail = false;
    std::string param;
    if(ph_.getParam("wayPtThreshold",param)){
      std::stringstream os1(param.c_str());
      os1 >> wayPtThreshold_.x>> wayPtThreshold_.y>> wayPtThreshold_.z;
      if(ph_.getParam("minThreshold",param)){
	std::stringstream os2(param.c_str());
	os2 >> min_threshold.x>> min_threshold.y>> min_threshold.z;
	if(ph_.getParam("step",param)){
	  std::stringstream os3(param.c_str());
	  os3 >> step_.x>> step_.y>> step_.z;
	  if(ph_.getParam("proximityThreshold",proxityData_.threshold)){
	    if(ph_.getParam("avoidStep",collisionData_.avoidStep)){
	      std::cout << "Parameter read from launch file!" << std::endl;
	      prmAvail=true;
            }
          }
        }
예제 #13
0
	void Run()
	{
		{ // ver 0

		SharedBuffer<u8> fromdata(4);
		fromdata[0]=1;
		fromdata[1]=5;
		fromdata[2]=5;
		fromdata[3]=1;
		
		std::ostringstream os(std::ios_base::binary);
		compress(fromdata, os, 0);

		std::string str_out = os.str();
		
		infostream<<"str_out.size()="<<str_out.size()<<std::endl;
		infostream<<"TestCompress: 1,5,5,1 -> ";
		for(u32 i=0; i<str_out.size(); i++)
		{
			infostream<<(u32)str_out[i]<<",";
		}
		infostream<<std::endl;

		assert(str_out.size() == 10);

		assert(str_out[0] == 0);
		assert(str_out[1] == 0);
		assert(str_out[2] == 0);
		assert(str_out[3] == 4);
		assert(str_out[4] == 0);
		assert(str_out[5] == 1);
		assert(str_out[6] == 1);
		assert(str_out[7] == 5);
		assert(str_out[8] == 0);
		assert(str_out[9] == 1);

		std::istringstream is(str_out, std::ios_base::binary);
		std::ostringstream os2(std::ios_base::binary);

		decompress(is, os2, 0);
		std::string str_out2 = os2.str();

		infostream<<"decompress: ";
		for(u32 i=0; i<str_out2.size(); i++)
		{
			infostream<<(u32)str_out2[i]<<",";
		}
		infostream<<std::endl;

		assert(str_out2.size() == fromdata.getSize());

		for(u32 i=0; i<str_out2.size(); i++)
		{
			assert(str_out2[i] == fromdata[i]);
		}

		}

		{ // ver HIGHEST

		SharedBuffer<u8> fromdata(4);
		fromdata[0]=1;
		fromdata[1]=5;
		fromdata[2]=5;
		fromdata[3]=1;
		
		std::ostringstream os(std::ios_base::binary);
		compress(fromdata, os, SER_FMT_VER_HIGHEST);

		std::string str_out = os.str();
		
		infostream<<"str_out.size()="<<str_out.size()<<std::endl;
		infostream<<"TestCompress: 1,5,5,1 -> ";
		for(u32 i=0; i<str_out.size(); i++)
		{
			infostream<<(u32)str_out[i]<<",";
		}
		infostream<<std::endl;

		/*assert(str_out.size() == 10);

		assert(str_out[0] == 0);
		assert(str_out[1] == 0);
		assert(str_out[2] == 0);
		assert(str_out[3] == 4);
		assert(str_out[4] == 0);
		assert(str_out[5] == 1);
		assert(str_out[6] == 1);
		assert(str_out[7] == 5);
		assert(str_out[8] == 0);
		assert(str_out[9] == 1);*/

		std::istringstream is(str_out, std::ios_base::binary);
		std::ostringstream os2(std::ios_base::binary);

		decompress(is, os2, SER_FMT_VER_HIGHEST);
		std::string str_out2 = os2.str();

		infostream<<"decompress: ";
		for(u32 i=0; i<str_out2.size(); i++)
		{
			infostream<<(u32)str_out2[i]<<",";
		}
		infostream<<std::endl;

		assert(str_out2.size() == fromdata.getSize());

		for(u32 i=0; i<str_out2.size(); i++)
		{
			assert(str_out2[i] == fromdata[i]);
		}

		}
	}
예제 #14
0
int main(int argc, char *argv[]) {
	ParamProgram *par = new ParamProgram();
	char fileName[300];

	if(argc != 2){
		cout << "ERRORR !! " << endl;
		cout << "buildDL_LZ's usage requires the Properties File as parameter !! " << endl;
		cout << "Example for the file 'config.txt' in the same directory: ./buildDL_LZ config.txt" << endl;
		exit(1);
	}
	par->configFile = string(argv[1]);
	cout << "Congif file: " << par->configFile << endl;
	ConfigFile cf(par->configFile);

	TRACE = cf.Value("GLOBALS","TRACE");
	TEST = cf.Value("GLOBALS","TEST");
	N_REP = cf.Value("GLOBALS","N_REP");

	strcpy(par->inputFile, ((string)(cf.Value("DL","inputFile"))).c_str());
	par->filesInList = cf.Value("DL","filesInList");
	par->boundSymbol = cf.Value("DL","boundSymbol");
	par->cutDoc = cf.Value("DL","cutDoc");
	par->lowercase = cf.Value("DL","lowercase");
	par->levRMQ_range = cf.Value("DL","levRMQ");
	strcpy(par->dirStore, ((string)(cf.Value("DL","dirStore"))).c_str());

	cout << "buildDL_LZ config parameters..." << endl;
	cout << "Input File            : " << par->inputFile << endl;
	cout << "File in list          : " << par->filesInList << endl;
	cout << "Boundary Symbol(code) : " << (int)par->boundSymbol << endl;
	cout << "Cut Doc. Symbol(code) : " << (int)par->cutDoc << endl;
	cout << "Lowercase             : " << par->lowercase << endl;
	cout << "Range levels with RMQ : " << par->levRMQ_range << endl;
	cout << "Store Folder          : " << par->dirStore << endl;

	LZDocList64::TRACE = TRACE;
	LZDocList64::TEST = TEST;
	par->index = new LZDocList64(par->levRMQ_range, par->inputFile, par->filesInList, par->cutDoc, par->lowercase, par->dirStore, par->boundSymbol, false);
	par->n = par->index->n;
	par->EndDocs = par->index->EndDocs;
	cout << "____________________________________________________" << endl;
	cout << "***  Index size " << par->index->sizeDS << " bytes = " << (float)par->index->sizeDS*8.0/(float)par->n << " bpc" << endl;
	cout << "***  SizeUpRange = " << par->index->sizeUpRange << " bytes = " << (float)par->index->sizeUpRange*8.0/(float)par->n << " bpc" << endl;
	cout << "====================================================" << endl;

	par->index->saveDS(true);

	{
		// create the FMI to execute test...
		cout << "____________________________________________________" << endl;
		cout << " Make the FMI ..." << endl;
		strcpy(fileName, "");
		strcpy(fileName, par->inputFile);
		cout << " Reading... " << fileName << endl;
		strcat(fileName, "_copy.txt");
		construct(par->index->fmi, fileName, 1); // generate index
		cout << " **  FMI size " << size_in_bytes(par->index->fmi) << " bytes = " << (float)size_in_bytes(par->index->fmi)/(float)par->n << "|T|" << endl;
		cout << " **  FMI length " << par->index->fmi.size() << endl;
		if (par->index->fmi.size() != par->n){
			cout << "ERROR. FMI length != n = " << par->n << endl;
			exit(1);
		}
		strcpy(fileName, "");
		strcpy(fileName, par->dirStore);
		strcat(fileName, "fmi.test");
		store_to_file(par->index->fmi, fileName);
	}

	if (TEST){
		strcpy(fileName, "");
		strcpy(fileName, par->dirStore);
		strcat(fileName, "EndDocs.test");
		ofstream os2 (fileName, ios::binary);
		os2.write((const char*)par->EndDocs, par->index->nDocs*sizeof(ulong));					// save LbRev[]
		if(TRACE) cout << " .- EndDocs[] " << par->index->nDocs*sizeof(ulong) << " Bytes" << endl;
		os2.close();

		par->index->sep_rrr = rrr_vector<127>(par->index->sepPhrase_b);
		par->index->sep_rank = rrr_vector<127>::rank_1_type(&par->index->sep_rrr);
		std::cout << " sep_rrr uses " << size_in_bytes(par->index->sep_rrr) << " Bytes" << endl;

		strcpy(fileName, "");
		strcpy(fileName, par->dirStore);
		strcat(fileName, "sep_rrr.test");
		store_to_file(par->index->sep_rrr, fileName);

		strcpy(fileName, "");
		strcpy(fileName, par->dirStore);
		strcat(fileName, "sep_rank.test");
		store_to_file(par->index->sep_rank, fileName);

		strcpy(fileName, "");
		strcpy(fileName, par->dirStore);
		strcat(fileName, "EndDocs.test");
		ofstream os3 (fileName, ios::binary);
		os3.write((const char*)par->EndDocs, par->index->nDocs*sizeof(ulong));					// save LbRev[]
		if(TRACE) cout << " .- EndDocs[] " << par->index->nDocs*sizeof(ulong) << " Bytes" << endl;
		os3.close();

		// load Sequence...
		strcpy(fileName, "");
		strcpy(fileName, par->dirStore);
		strcat(fileName, "sequence.test");
		ifstream is(fileName, ios::binary);
		par->seq = new uchar[par->n];
		is.read((char*)par->seq, par->n*sizeof(uchar));
		is.close();

		cout << "Running test searchPattern.." << endl;
		testSearchPatt_DL_CSA_LZ(par);
		cout << "Test searchPattern OK !!" << endl;
	}

	par->index->~LZDocList64();

	cout << "$$$$$$$$$$$$$$$$$$$$$" << endl;
	return 0;
}
예제 #15
0
int main(int argc, char *argv[])
{
    // We need all parameters, otherwise the mesh cannot be created correctly
    if (argc != 14)
    {
        std::cout << "usage: " << argv[0] << " type nx ny min_x min_y max_x max_y bcids factor loading ul_lr dead-axis filename\n";
        std::cout << "type: Q|q for Quad-4, T|t for Tri-3\n"
                  << "nx: no. elements on primary axis\n"
                  << "ny: no. elements on secondary axis\n"
                  << "min_x: minimum position on the primary axis\n"
                  << "min_y: minimum position on the secondary axis\n"
                  << "max_x: maximum position on the primary axis\n"
                  << "max_y: maximum position on the secondary axis\n"
                  << "bcids: comma-separated list of boundary condition IDs in the ordering top,bottom,left,right border (e.g. 2,0,20,21). If border has no BC, type -1\n"
                  << "factor: global factor multiplied on all force entries in the force file\n"
                  << "loading: 0 for no loading at all, 1 for concentrated load on central node, 2 for uniform load on entire mesh\n"
                  << "ul_lr: 1 if triangle hypotenuse should face the lower right corner of the divided square, 0 for 90° rotated orientation. If type is Quad-4, the value doesn't matter.\n"
                  << "dead-axis: 'x','y' or 'z' to specify which axis should be considered dead. The resulting mesh will lie in the 'yz','xz' or 'xy'-plane, respectively.\n"
                  << "filename: the name of the mesh file to create\n";
        return -1;
    }

    char type = argv[1][0];

    // edit here, for more types in the future:
    if (type != 'Q' && type != 'q' &&
        type != 'T' && type != 't')
    {
        std::cout << "Invalid element type specified: \"" << type << "\". "
                  << "Only 'Q'|'q' and 'T'|'t' are allowed.\n";
        return -1;
    }
    // bring the type into lower case for better management
    // in the rest of the program:
    if (type == 'Q')
        type = 'q';
    else if (type == 'T')
        type = 't';

    int nx = atoi(argv[2]);
    if (nx <= 0)
    {
        std::cout << "Invalid number of elements on primary axis! Only positive integer values allowed.\n";
        return -1;
    }

    int ny = atoi(argv[3]);
    if (ny <= 0)
    {
        std::cout << "Invalid number of elements on secondary axis! Only positive integer values allowed.\n";
        return -1;
    }

    double min_x = atof(argv[4]);
    double min_y = atof(argv[5]);
    double max_x = atof(argv[6]);
    double max_y = atof(argv[7]);

    // get comma-separated list of boundary condition IDs
    // expected format: int,int,int,int
    std::string bcids = argv[8];
    std::size_t first = bcids.find_first_of(",");
    int curPos = 0;
    int t_bcid = -1;
    if (first != std::string::npos)
    {
        std::string str = bcids.substr(0, first);
        t_bcid = std::stoi(str);
    }
    curPos = first+1;
    first = bcids.find_first_of(",", first+1);
    int b_bcid = -1;
    if (first != std::string::npos)
    {
        std::string str = bcids.substr(curPos, first-curPos);
        b_bcid = std::stoi(str);
    }
    curPos = first+1;
    first = bcids.find_first_of(",", first+1);
    int l_bcid = -1;
    if (first != std::string::npos)
    {
        std::string str = bcids.substr(curPos, first-curPos);
        l_bcid = std::stoi(str);
    }
    curPos = first+1;
    std::string str = bcids.substr(curPos, bcids.size());
    int r_bcid = std::stoi(str);

    double factor = atof(argv[9]);

    int loading = atoi(argv[10]);

    bool ul_lr = atoi(argv[11])==1? true : false; // upper left to lower right diagonal, or ur_ll?

    char deadAxis = argv[12][0];

    char* fname = argv[13];

    bool bleft = false;
    if (l_bcid >= 0)
        bleft = true;
    bool bright = false;
    if (r_bcid >= 0)
        bright = true;
    bool btop = false;
    if (t_bcid >= 0)
        btop = true;
    bool bbottom = false;
    if (b_bcid >= 0)
        bbottom = true;

    if (deadAxis != 'x' && deadAxis != 'y' && deadAxis != 'z')
    {
        std::cout << "Invalid parameter for dead axis: \"" << deadAxis << "\". Only 'x','y' and 'z' are allowed.\n";
        return -1;
    }

    int n_elem = nx*ny;
    if (type == 't') // we split every rectangle into two triangles
        n_elem *= 2;
    int n_nodes = (nx+1)*(ny+1);

    std::vector<std::vector<double> > nodes;
    std::vector<std::vector<int> > elem;

    double fracx = (max_x-min_x)/(double)nx;
    double fracy = (max_y-min_y)/(double)ny;
    // creates nodes
    for (int y = 0; y <= ny; y++)
    {
        std::vector<double> node(3, 0.0);
        if (deadAxis == 'z') // secondary axis is y
            node[1] = min_y + y*fracy;
        else // deadAxis = y|x -> secondary axis is z
            node[2] = min_y + y*fracy;
        for (int x = 0; x <= nx; x++)
        {
            if (deadAxis == 'x') // primary axis is y
                node[1] = (min_x + x*fracx);
            else // deadAxis = y|z -> primary axis is x
                node[0] = (min_x + x*fracx);

            nodes.push_back(node);
        }
    }

    // create elements
    for (int y = 0; y < ny; y++)
    {
        if (type == 'q')
        {
            std::vector<int> quad(4);
            for (int x = 0; x < nx; x++)
            {
                /* 3-----2
                   |     |
                   |     |
                   0-----1 */
                int n_id = x + y*(nx+1);
                quad[0] = n_id;
                quad[1] = n_id + 1;
                quad[2] = n_id + (nx+1) + 1;
                quad[3] = n_id + (nx+1);

                elem.push_back(quad);
            }
        }
        else if (type == 't')
        {
            std::vector<int> tri1(3);
            std::vector<int> tri2(3);
            for (int x = 0; x < nx; x++)
            {
                int n_id = x + y*(nx+1);
                if (ul_lr)
                {
                    /* 2|2---1
                       |\\   |
                       | \\  |
                       |  \\ |
                       0---1|0 */
                    tri1[0] = n_id;
                    tri1[1] = n_id + 1;
                    tri1[2] = n_id + (nx+1);

                    tri2[0] = n_id + 1;
                    tri2[1] = n_id + (nx+1) + 1;
                    tri2[2] = n_id + (nx+1);
                }
                else
                {
                    /* 2---0|1
                       |   //|
                       |  // |
                       | //  |
                       1|0---2 */
                    tri1[0] = n_id;
                    tri1[1] = n_id + (nx+1) + 1;
                    tri1[2] = n_id + 1;

                    tri2[0] = n_id + (nx+1) + 1;
                    tri2[1] = n_id;
                    tri2[2] = n_id + (nx+1);
                }
                elem.push_back(tri1);
                elem.push_back(tri2);
            }
        }
    }

    std::string meshname = fname;
    meshname += ".xda";
    std::filebuf fb;
    fb.open (meshname.c_str(), std::ios::out);
    std::ostream os(&fb);

    // The header of the XDA mesh file:
    os << "libMesh-0.7.0+\n";
    os << n_elem  << "      # number of elements\n";
    os << n_nodes << "      # number of nodes\n";
    os << ".        # boundary condition specification file\n";
    os << "n/a      # subdomain id specification file\n";
    os << "n/a      # processor id specification file\n";
    os << "n/a      # p-level specification file\n";
    os << n_elem << "      # n_elem at level 0, [ type (n0 ... nN-1) ]\n";

    // write the elements:
    char elType = 't';
    if (type == 't')
        elType = '3';
    else if (type == 'q')
        elType = '5';
    for (unsigned int i = 0; i < elem.size(); i++)
    {
        std::vector<int> cur_elem = elem[i];
        os << elType;
        for (unsigned int k = 0; k < cur_elem.size(); k++)
            os << " " << cur_elem[k];
        os << "\n";
    }

    // write the node coordinates:
    for (unsigned int i = 0; i < nodes.size(); i++)
    {
        std::vector<double> cur_node = nodes[i];
        os << cur_node[0] << " " << cur_node[1] << " " << cur_node[2] << "\n";
    }

    // calculate the number of edges with boundary conditions:
    int noBC = 0;
    if (bleft)
        noBC += ny;
    if (bright)
        noBC += ny;
    if (btop)
        noBC += nx;
    if (bbottom)
        noBC += nx;
    os << noBC << "        # number of boundary conditions\n";
    // boundary condition format:
    // x y z
    // x: ID of element
    // y: number of edge of element.
    //    edge 0 from vertex 0 to 1,
    //    edge 1 from vertex 1 to 2, etc.
    // z: BC ID

    // top and bottom borders:
    for (int i = 0; i < nx; i++)
    {
        if (type == 't')
        {
            if (ul_lr)
            {
                if (bbottom)
                    os << 2*i << " 0 " << b_bcid << "\n"; // bottom border
                if (btop)
                    os << 2*nx*ny-2*i-1 << " 1 " << t_bcid << "\n"; // top border
            }
            else
            {
                if (bbottom)
                    os << 2*i << " 2 " << b_bcid << "\n"; // bottom border
                if (btop)
                    os << 2*nx*ny-2*i-1 << " 2 " << t_bcid << "\n"; // top border
            }
        }
        else if (type == 'q')
        {
            if (bbottom)
                os << i << " 0 " << b_bcid << "\n"; // bottom border
            if (btop)
                os << nx*ny-1-i << " 2 " << t_bcid << "\n"; // top border
        }
    }
    // left and right borders:
    for (int i = 0; i < ny; i++)
    {
        if (type == 't')
        {
            if (ul_lr)
            {
                if (bleft)
                    os << 2*nx*i << " 2 " << l_bcid << "\n"; // left border
                if (bright)
                    os << 2*nx*(i+1)-1 << " 0 " << r_bcid << "\n"; // right border
            }
            else
            {
                if (bleft)
                    os << 2*nx*i+1 << " 1 " << l_bcid << "\n"; // left border
                if (bright)
                    os << 2*nx*(i+1)-2 << " 1 " << r_bcid << "\n"; // right border
            }
        }
        else if (type == 'q')
        {
            if (bleft)
                os << nx*i << " 3 " << l_bcid << "\n"; // left border
            if (bright)
                os << nx*(i+1)-1 << " 1 " << r_bcid << "\n"; // right border
        }
    }
    fb.close();

    if (loading <= 0) // if no loading is desired, we are done.
        return 0;
    std::string forcename = fname;
    forcename += "_f"; // convention: force file is named like mesh file with "_f" at the end
    fb.open (forcename.c_str(), std::ios::out);
    std::ostream os2(&fb);

    os2 << n_nodes << "\n";
    if (loading == 1) // concentrated loading at central node
    {
        os2 << factor << "\n";
        for (unsigned int i = 0; i < nodes.size()-1; i++)
        {
            // force is applied perpendicular to mesh plane (for plate testing)
            // direction of force could be also command-line argument (for the future)
            if (i == (unsigned)n_nodes/2)
                if (deadAxis == 'x')
                    os2 << "1 0 0 0 0 0\n";
                else if (deadAxis == 'y')
                    os2 << "0 1 0 0 0 0\n";
                else
                    os2 << "0 0 1 0 0 0\n";
            else
                os2 << "0 0 0 0 0 0\n";
        }
    }
    else if (loading == 2) // uniformly distributed loading
    {
        // convert area force to nodal force:
        // factor * elem_x_len * elem_y_len / #nodes_of_elem * #neighboring_elements_sharing_this_node
        // for quad's: f*xlen*ylen / 4 * 4 -> f*xlen*ylen
        // for tri's: f*xlen*ylen/2 / 3 * 6 -> f*xlen*ylen
        os2 << (factor*((max_x-min_x)/(double)nx)*((max_y-min_y)/(double)ny)) << "\n";
        // force is applied perpendicular to mesh plane (for plate testing)
        // direction of force could be also command-line argument (for the future)
        if (deadAxis == 'x')
            for (unsigned int i = 0; i < nodes.size()-1; i++)
                os2 << "1 0 0 0 0 0\n";
        else if (deadAxis == 'y')
            for (unsigned int i = 0; i < nodes.size()-1; i++)
                os2 << "0 1 0 0 0 0\n";
        else
            for (unsigned int i = 0; i < nodes.size()-1; i++)
                os2 << "0 0 1 0 0 0\n";

    }
    fb.close();

    return 0;
}
예제 #16
0
int main()
{
    double data[][5] = {
        { 0.1, 0.2, 0.3, 0.4, 0.5 },
        { 1.1, 1.2, 1.3, 1.4, 1.5 },
        { 2.1, 2.2, 2.3, 2.4, 2.5 },
    };

    std::wstring fileName = L"data.dat";

    std::ofstream os(ws2s(fileName));
    if (os.is_open())
    {
        for (size_t j = 0; j < ARRAYSIZE(data[0]); ++j)
        {
            for (size_t i = 0; i < ARRAYSIZE(data); ++i)
                os.write(reinterpret_cast<const char *>(&data[i][j]), sizeof data[i][j]);
        }

        os.close();
    }

    SharedFileDataSourcePtr dataSource = std::make_shared<SimpleFileDataSource<double>>(3, 1);
    Verify(dataSource->ReadFile(fileName));
    for (int i = 0; i < dataSource->GetChannelCount(); ++i)
    {
        for (int j = 0; j < dataSource->GetLength(); ++j)
            std::cout << dataSource->Read(i, j, 1)[0] << "\t";

        std::cout << std::endl;
    }

    DIVIDING_LINE_2('-', 79);

    short data2[][5] = {
        { short(0.1 * 1000), short(0.2 * 1000), short(0.3 * 1000), short(0.4 * 1000), short(0.5 * 1000) },
        { short(1.1 * 1000), short(1.2 * 1000), short(1.3 * 1000), short(1.4 * 1000), short(1.5 * 1000) },
        { short(2.1 * 1000), short(2.2 * 1000), short(2.3 * 1000), short(2.4 * 1000), short(2.5 * 1000) },
    };

    std::ofstream os2(ws2s(fileName));
    if (os2.is_open())
    {
        for (size_t j = 0; j < ARRAYSIZE(data2[0]); ++j)
        {
            for (size_t i = 0; i < ARRAYSIZE(data2); ++i)
                os2.write(reinterpret_cast<const char *>(&data2[i][j]), sizeof data2[i][j]);
        }

        os2.close();
    }

    dataSource = std::make_shared<SimpleFileDataSource<short>>(3, 1);
    Verify(dataSource->ReadFile(fileName));
    for (int i = 0; i < dataSource->GetChannelCount(); ++i)
    {
        for (int j = 0; j < dataSource->GetLength(); ++j)
            std::cout << dataSource->Read(i, j, 1)[0] << "\t";

        std::cout << std::endl;
    }

    return 0;
}
예제 #17
0
void MetaDataTable::readStarLoop(std::ifstream& in, std::vector<EMDLabel> *desiredLabels)
{
	setIsList(false);

	//Read column labels
    int labelPosition = 0;
    EMDLabel label;
    std::string line, token, value;

    // First read all the column labels
    while (getline(in, line, '\n'))
    {
    	line = simplify(line);
    	// TODO: handle comments...
    	if (line[0] == '#' || line[0] == '\0' || line[0] == ';')
    		continue;

    	if (line[0] == '_') // label definition line
    	{
    		//Only take string from "_" until "#"
    		token = line.substr(line.find("_") + 1, line.find("#") - 2);
    		label = EMDL::str2Label(token);
    		//std::cerr << " label= XX" << label << "XX token= XX" << token<<"XX" << std::endl;
    		if (desiredLabels != NULL && !vectorContainsLabel(*desiredLabels, label))
    			label = EMDL_UNDEFINED; //ignore if not present in desiredLabels

    		if (label == EMDL_UNDEFINED)
    		{
    			//std::cerr << "Warning: ignoring the following (undefined) label:" <<token << std::endl;
    			REPORT_ERROR("ERROR: Unrecognised metadata label: " + token);
    			ignoreLabels.push_back(labelPosition);
    		}
    		else
    			activeLabels.push_back(label);

    		labelPosition++;
    	}
    	else // found first data line
    	{
    		break;
    	}
    }

    // Then fill the table (dont read another line until the one from above has been handled)
    bool is_first= true;
    while (is_first || getline(in, line, '\n'))
    {
    	is_first=false;
    	line = simplify(line);
    	// Stop at empty line
    	if (line[0] == '\0')
    		break;

    	// Add a new line to the table
    	addObject();

    	// Parse data values
    	std::stringstream os2(line);
    	std::string value;
		labelPosition = 0;
		int counterIgnored = 0;
		while (os2 >> value)
		{
			// TODO: handle comments here...
			if (std::find(ignoreLabels.begin(), ignoreLabels.end(), labelPosition) != ignoreLabels.end())
			{
				// Ignore this column
				counterIgnored++;
				labelPosition++;
				continue;
			}
			setValueFromString(activeLabels[labelPosition - counterIgnored], value);
			labelPosition++;
		}

    }

}
예제 #18
0
파일: pop_data.C 프로젝트: steabert/libwfa
void pop_data::print(std::ostream &out, const std::vector<std::string> &l,
        size_t cw, size_t prec, size_t off) const {

    if (m_sets.size() == 0) return;

    // Check if all data sets have the correct size
    for (iterator i = m_sets.begin(); i != m_sets.end(); i++) {
        if (l.size() != i->data.size()) {
            throw libwfa_exception("pop_data", "print(...) const",
                    __FILE__, __LINE__, "Length of population data.");
        }
    }

    // Compute max width of an index number
    size_t nw1 = 0, nl = l.size();
    while (nl != 0) { nl /= 10; nw1++; }

    // Compute max width of a label
    size_t nw2 = 0;
    for (std::vector<std::string>::const_iterator i = l.begin();
            i != l.end(); i++) {
        nw2 = std::max(nw2, i->size());
    }

    // Compute width of initial columns
    size_t nw = nw1 + nw2 + 1;
    nw = std::max(nw, (size_t) 4);

    std::string os1(off, ' '), os2(nw - (nw1 + nw2 + 1) + off, ' ');

    // Reduce column width, if total width is wider than 80 characters
    size_t maxwidth = 80;
    size_t mincolwidth = prec + 4;
    size_t width = off + nw + cw * m_sets.size();
    while (width > maxwidth && cw > mincolwidth) {
        width -= m_sets.size();
        cw--;
    }

    // Print header
    out << std::right << std::fixed << std::setprecision(prec);
    out << os1 << std::setw(nw) << "Atom";
    for (pop_data::iterator i = m_sets.begin(); i != m_sets.end(); i++) {
        out << std::setw(cw) << i->name;
    }
    out << std::endl;

    out << os1 << std::string(width - off, '-') << std::endl;
        
    arma::vec total(m_sets.size(), arma::fill::zeros);
    for (size_t i = 0, j = 1; i != l.size(); i++, j++) {

        out << os2 << std::setw(nw1) << j;
        out << " " << std::setw(nw2) << l[i];

        size_t k = 0;
        for (iterator kk = m_sets.begin(); kk != m_sets.end(); k++, kk++) {

            total(k) += kk->data(i);

            out << std::setw(cw) << kk->data(i);
        }
        out << std::endl;
    }

    // sum
    out << os1 << std::string(width - off, '-') << std::endl;

    out << std::right;
    out << os1 << std::setw(nw) << "Sum:";
    for (size_t i = 0; i < total.size(); i++) 
        out << std::setw(cw) << total(i);
    out << std::endl;
}