Esempio n. 1
0
void PrettyPrintImp::print(ostream& os, Pair* jv, int level) const{
    int width = level * _sep;
    os << setw(width) << "" << jv->getKey() << ": ";
    jv->getValue()->print(os, level+1);
}
Esempio n. 2
0
void print(int32 P[], int i)
{
	for(int j=0;j<i;j++)
		cout<<hex<<setw(8)<<setfill('0')<<P[j]<<" ";
}
Esempio n. 3
0
void main()
{
	clrscr();
	cout<<"\n\tHashing Technique used Snefru";
	cout<<"\n\tHash File Test.txt ";
	int32 ip[16],op[16],bitLength[2] = {0,0}, counter=0;
	char str[48],ch;
	int i;

	fstream fin("test.txt",ios::in|ios::binary);
	FILE *hash = fopen("hash.txt","wt");

	while(!fin.eof())
	{

		for(i=0; i<4; i++)
			op[i] = 0;
		fin>>str;
		bitLength[1] = bitLength[0] = 0;
		increment(bitLength,8*strlen(str));

		for(i=0;i<4;i++)
			ip[i] = op[i];

		for(counter=0; (counter+48) <= (bitLength[1]/8); counter+=48)
		{
			convert(str,counter,ip);
			//print(ip,16);
			hash512(op,ip,8);

			for(i=0;i<4;i++)
				ip[i] = op[i];
		}

		if(counter*8 < bitLength[1])
		{
			counter += (bitLength[1]/8);
			while(counter%48!=0)
				str[counter++] = 0;
			convert(str,(counter-48),ip);
			//print(ip,16);
			hash512(op,ip,8);

			for(i=0;i<4;i++)
				ip[i] = op[i];
		}
		//print(ip,16);
		ip[14] = bitLength[0];
		ip[15] = bitLength[1];
		//print(ip,16);
		hash512(op,ip,8);

		cout<<endl<<setw(10)<<setfill(' ')<<str<<" ";
		print(op,4);

		fprintf(hash,"%10s ",str);
		for(int j=0;j<4;j++)
			fprintf(hash,"%08lx ",op[j]);
		fprintf(hash,"\n");
	}
	getch();
}
Esempio n. 4
0
void cMiniBench::OutputSeconds(double adoubleResult, string aOutputMessage )
{
//   string lstrResult;
//   lstrResult. setNum( adoubleResult / 1000, 'g', 4 );
   cout << aOutputMessage << " (s): " <<  setw( 6 ) << setiosflags(ios::fixed) << setprecision(3)  << adoubleResult << endl;
}
Esempio n. 5
0
string Particle::toString() const {
	stringstream out;
	out << "Particle information" << "\n";
	out << setw(30) << "energy" << setw(30) << "px" << setw(30) << "py" << setw(30) << "pz" << "\n";
	out << setw(30) << energy() << setw(30) << px() << setw(30) << py() << setw(30) << pz() << "\n";
	out << setw(30) << "phi" << setw(30) << "eta" << setw(30) << "theta" << setw(30) << "  " << "\n";
	out << setw(30) << phi() << setw(30) << eta()  << setw(30) << theta() << setw(30) << " " << "\n";
	out << setw(30) << "momentum" << setw(30) << "E_T" << setw(30) << "p_T" << setw(30) << "  " << "\n";
	out << setw(30) << momentum() << setw(30) << et() << setw(30) << pt() << setw(30) << "  " << "\n";
	out << setw(30) << "m_dyn" << setw(30) << "m_fix" << setw(30) << "charge" << setw(30) << "  " << "\n";
	out << setw(30) << massFromEnergyAndMomentum() << setw(30) <<  mass() << setw(30) << charge() << setw(30) << "  " << "\n";
	out << setw(30) << "d0 =" << setw(30) << "d0_bs" << setw(30) << "  " << setw(30) << "  " << "\n";
	out << setw(30) << d0() << setw(30) << d0_wrtBeamSpot() << setw(30) << "  " << setw(30) << "  " << "\n";
	return out.str();
}
Esempio n. 6
0
void StackPrintElem(SElemType *e)
{cout<<"姓名   学号  年龄 成绩\n";
 cout<<e->name<<setw(8)<<e->stuno;
 cout<<setw(4)<<e->age;
 cout<<setw(5)<<e->score<<endl;
}
Esempio n. 7
0
File: log.cpp Progetto: 2php/mp4v2
/**
 * Log a buffer as ascii-hex
 *
 * @param indent the number of spaces to indent the buffer
 *
 * @param verbosity the level of detail the message contains
 *
 * @param pBytes the buffer to log
 *
 * @param numBytes the number of bytes to log
 *
 * @param format the format string to use to process the
 * remaining arguments, where the format + remaining args
 * describe @p pBytes.  The resulting string should not
 * contain a newline.  Only the first 255 characters of the
 * resulting string (not including the NUL terminator) make
 * it to the log callback or stdout.
 */
void
Log::hexDump( uint8_t           indent,
              MP4LogLevel       verbosity_,
              const uint8_t*    pBytes,
              uint32_t          numBytes,
              const char*       format,
              ... )
{
    va_list     ap;

    ASSERT(pBytes || (numBytes == 0));
    ASSERT(format);

    if (verbosity_ > this->_verbosity)
    {
        // We're not set verbose enough to log this
        return;
    }

    // Build the description by processing format and the
    // remaining args.  Since we don't have asprintf, pick
    // an arbitrary length for the string and use snprintf.
    // To save a memory allocation, only do this if there's
    // a non-empty format string or non-zero indent
    char *desc = NULL;
    if (format[0] || indent)
    {
        desc = (char *)MP4Calloc(256 + indent);
        sprintf(desc,"%*c",indent,' ');
        va_start(ap,format);
        vsnprintf(desc + indent,255,format,ap);
        va_end(ap);
    }

    // From here we can use the C++ standard lib classes and
    // build a string for each line
    for (uint32_t i = 0;(i < numBytes);i += 16)
    {
        // ios_base::ate means at end.  With out this desc
        // gets overwritten with each << operation
        ostringstream oneLine(desc ? desc : "",ios_base::ate);

        // Append the byte offset this line starts with as
        // an 8 character, leading 0, hex number.  Leave the
        // fill character set to 0 for the remaining
        // operations
        oneLine << ':' << hex << setw(8) << setfill('0') <<
            std::right << i << setw(0) << setfill(' ') << ": ";

        uint32_t curlen = min((uint32_t)16,numBytes - i);
        const uint8_t *b = pBytes + i;
        uint32_t j;

        for (j = 0;(j < curlen);j++)
        {
            oneLine << hex << setw(2) << setfill('0') << right << static_cast<uint32_t>(b[j]);
            oneLine << setw(0) << setfill(' ') << ' ';
        }

        for (; j < 16; j++)
        {
            oneLine << "   ";
        }

        b = pBytes + i;
        for (j = 0;(j < curlen);j++)
        {
            if (isprint(static_cast<int>(b[j])))
            {
                oneLine << static_cast<char>(b[j]);
            }
            else
            {
                oneLine << '.';
            }
        }

        // We can either call the callback directly or use
        // the Log::printf function.  To call the callback
        // directly, we need a va_list.  (I think) we need
        // and extra function call to build that, so we may
        // as well call Log::printf.  It's going to
        // double-check the verbosity and the callback
        // function pointer, but that seems OK (13-feb-09,
        // dbyron)
        this->printf(verbosity_,"%s",oneLine.str().c_str());
    }

    if (desc)
    {
        MP4Free(desc);
        desc = NULL;
    }
}
Esempio n. 8
0
void sum_and_output4(vector<aa_rou> proteins2, vector<aa_rou> proteins1, vector<aa_rou> proteins)
{
            int i,j,k; 

            char  *temp;

            string residue1[19];
            string temp1;
  
           
            //double angle_total_value,angle_average_value;
            double  angle_total_num,angle_total_num1,angle_total_num2;

            //angle_total_value=0;
            angle_total_num=0;
            angle_total_num1=0;
            angle_total_num2=0;
   
            residue1[0]="ALA";
            residue1[1]="VAL";
            residue1[2]="PHE";
            residue1[3]="PRO";
            residue1[4]="MET";
            residue1[5]="ILE";
            residue1[6]="LEU";
            residue1[7]="ASP";
            residue1[8]="GLU";
            residue1[9]="LYS";
            residue1[10]="ARG";
            residue1[11]="SER";
            residue1[12]="THR";
            residue1[13]="TYR";
            residue1[14]="HIS";
            residue1[15]="CYS";
            residue1[16]="ASN";
            residue1[17]="GLN";
            residue1[18]="TRP";

            temp=new char[20];
                
            double  num_of_aa[19], num_of_aa1[19],num_of_aa2[19];
            double angle_total_value[19],angle_total_value1[19],angle_total_value2[19];
            double angle_average_value[19],angle_average_value1[19],angle_average_value2[19];

  
       //for patch_0_1 
       for(k=0;k<19;k++)
       {  
          angle_total_value[k]=0; 
          num_of_aa[k]=0;
          angle_average_value[k]=0;

          temp1=residue1[k]+".patch_0_1";
          strcpy(temp,temp1.c_str()); 
          cout<<temp1<<endl;
	  ofstream file(temp,ios::out|ios::app);
	  file<<setiosflags(ios::left)<<setw(10)<<"angle"<<"\t"<<"type"<<endl;

	  for(i=0;i<proteins.size();i++)
	  {
	    if(strncmp(proteins[i].res_id,temp,3)==0)
            {
               angle_total_value[k]=angle_total_value[k]+proteins[i].angle;
               angle_total_num=angle_total_num+1;
               num_of_aa[k]=num_of_aa[k]+1;
               file<<setiosflags(ios::left)<<setw(10)<<proteins[i].angle<<"\t"<<proteins[i].res_id<<endl;  
            }//end if
          } //end for

           angle_average_value[k]=angle_total_value[k]/num_of_aa[k];

        file.close();
      } // end of for k=0

        //for patch_1_10  
       for(k=0;k<19;k++)
       {  

          angle_total_value1[k]=0; 
          num_of_aa1[k]=0;
          angle_average_value1[k]=0;
 
          temp1=residue1[k]+".patch_1_10";
          strcpy(temp,temp1.c_str()); 
          cout<<temp1<<endl;
	  ofstream file(temp,ios::out|ios::app);
	  file<<setiosflags(ios::left)<<setw(10)<<"angle"<<"\t"<<"type"<<endl;
	  for(i=0;i<proteins1.size();i++)
	  {
	    if(strncmp(proteins1[i].res_id,temp,3)==0)
            {
               angle_total_value1[k]=angle_total_value1[k]+proteins1[i].angle;
               angle_total_num1=angle_total_num1+1;
               num_of_aa1[k]=num_of_aa1[k]+1;
 
               file<<setiosflags(ios::left)<<setw(10)<<proteins1[i].angle<<"\t"<<proteins1[i].res_id<<endl;  
            }//end if
          }//end for

           angle_average_value1[k]=angle_total_value1[k]/num_of_aa1[k];

        file.close();
      } // end of for k=0

       //for patch_>_10
       for(k=0;k<19;k++)
       {  
          angle_total_value2[k]=0; 
          num_of_aa2[k]=0;
          angle_average_value2[k]=0;
           
          temp1=residue1[k]+".patch_>_10";
          strcpy(temp,temp1.c_str()); 
          cout<<temp1<<endl;
	  ofstream file(temp,ios::out|ios::app);
	  file<<setiosflags(ios::left)<<setw(10)<<"angle"<<"\t"<<"type"<<endl;
	  for(i=0;i<proteins2.size();i++)
	  {
	    if(strncmp(proteins2[i].res_id,temp,3)==0)
            {
               angle_total_value2[k]=angle_total_value2[k]+proteins2[i].angle;
               angle_total_num2=angle_total_num2+1;
               num_of_aa2[k]=num_of_aa2[k]+1;
 
               file<<setiosflags(ios::left)<<setw(10)<<proteins2[i].angle<<"\t"<<proteins2[i].res_id<<endl;  
            }
          }

           angle_average_value2[k]=angle_total_value2[k]/num_of_aa2[k];

        file.close();
      } // end of for k=0

          double pro_aa[19],pro_aa1[19],pro_aa2[19];
          double t;
             
              t=0;

           for(i=0;i<19;i++)
           { 
            pro_aa[i]=0;
            pro_aa1[i]=0;
            pro_aa2[i]=0;
  
            t=num_of_aa[i]/angle_total_num*100;
            pro_aa[i]=t;

            t=num_of_aa1[i]/angle_total_num1*100;
            pro_aa1[i]=t;

            t=num_of_aa2[i]/angle_total_num2*100;
            pro_aa2[i]=t;

           }

          ofstream file1("aa.txt",ios::out|ios::app);
          file1<<"0_1_patch "<<"\t"<<angle_total_num<<"\t"
               <<"1_10_patch"<<"\t"<<angle_total_num1<<"\t"
               <<"10_patch  "<<"\t"<<angle_total_num2<<endl;
          
          
         for(i=0;i<19;i++)
          { 
	  file1<<setiosflags(ios::left)<<setw(10)<<residue1[i]<<setiosflags(ios::fixed)
               <<setiosflags(ios::left)<<setprecision(2)<<setw(5)<<pro_aa[i]
               <<setiosflags(ios::left)<<setprecision(2)<<setw(5)<<pro_aa1[i]
               <<setiosflags(ios::left)<<setprecision(2)<<setw(5)<<pro_aa2[i]
               <<endl;
          }

          ofstream file2("omega.txt",ios::out|ios::app);
          file2<<"0_1_patch "<<"\t"<<angle_total_num<<"\t"
               <<"1_10_patch"<<"\t"<<angle_total_num1<<"\t"
               <<"10_patch  "<<"\t"<<angle_total_num2<<endl;
          
          
         for(i=0;i<19;i++)
          { 
	  file2<<setiosflags(ios::left)<<setw(10)<<residue1[i]<<setiosflags(ios::fixed)
               <<setiosflags(ios::left)<<setprecision(2)<<setw(10)<<angle_average_value[i]
               <<setiosflags(ios::left)<<setprecision(2)<<setw(10)<<angle_average_value1[i]
               <<setiosflags(ios::left)<<setprecision(2)<<setw(10)<<angle_average_value2[i]
               <<endl;
          }

          file1.close(); 

          file2.close(); 
        
}// end of function sum_and_output4