void THTMLPedestal::createTableOfCuts() { stringstream sectionContent; sectionContent<<"<h2>Seed and Hit Values in Units of Sigma</h2>\n"; std::vector<std::vector< std::string > > tablecontent; std::vector<std::vector< std::string > > tablecontent2; tablecontent.resize(3); tablecontent.at(0).push_back("Detector"); tablecontent.at(1).push_back("Seed"); tablecontent.at(2).push_back("Hit"); tablecontent2.resize(3); tablecontent2.at(0).push_back("Detector"); tablecontent2.at(1).push_back("Seed"); tablecontent2.at(2).push_back("Hit"); for(UInt_t det =0;det <TPlaneProperties::getNDetectors();det+=2){ tablecontent.at(0).push_back(TPlaneProperties::getStringForDetector(det)); tablecontent.at(1).push_back(floatToString(settings->getClusterSeedFactor(det,0))); tablecontent.at(2).push_back(floatToString(settings->getClusterHitFactor(det,0))); } for(UInt_t det =1;det <TPlaneProperties::getNDetectors();det+=2){ tablecontent2.at(0).push_back(TPlaneProperties::getStringForDetector(det)); tablecontent2.at(1).push_back(floatToString(settings->getClusterSeedFactor(det,0))); tablecontent2.at(2).push_back(floatToString(settings->getClusterHitFactor(det,0))); } sectionContent<<"<br><h4> X Coordinates</h4><br>"<<this->createTable(tablecontent)<<"<br><br>"; sectionContent<<"<br><h4> Y Coordinates</h4><br>"<<this->createTable(tablecontent2)<<"<br><br>"; sectionContent<<"<h3>Seed-Cuts</h3>\n"; sectionContent<<putImagesOfAllDetectors(path,"hPulseHeight_BiggestSignalInSigma"); // for(UInt_t det = 0; det< TPlaneProperties::getNSiliconDetectors();det+=2){ // stringstream name; // name<<"hPulseHeight_BiggestHitChannelInSigma"<<TADCEventReader::getStringForDetector(det); // sectionContent<<putImage(path,name.str()); // } // for(UInt_t det = 1; det< TPlaneProperties::getNSiliconDetectors();det+=2){ // stringstream name; // name<<"hPulseHeight_BiggestHitChannelInSigma"<<TADCEventReader::getStringForDetector(det); // sectionContent<<putImage(path,name.str()); // } // stringstream name; // name<<"hPulseHeight_BiggestHitChannelInSigma"<<TADCEventReader::getStringForDetector(TPlaneProperties::getDetDiamond()); // sectionContent<<putImage(path,name.str()); sectionContent<<"<h3>Hit-Cuts</h3>\n"; sectionContent<<putImagesOfAllDetectors(path,"hPulseHeight_BiggestAdjacentInSigma_"); // for(UInt_t det = 0; det< TPlaneProperties::getNSiliconDetectors();det+=2){ // stringstream name; // name<<"hPulseHeight_SecondBiggestHitChannelInSigma_"<<TADCEventReader::getStringForDetector(det); // sectionContent<<putImage(path,name.str()); // } // sectionContent<<"<br"; // for(UInt_t det = 1; det< TPlaneProperties::getNSiliconDetectors();det+=2){ // stringstream name; // name<<"hPulseHeight_SecondBiggestHitChannelInSigma_"<<TADCEventReader::getStringForDetector(det); // sectionContent<<putImage(path,name.str()); // } // name.str("");name.clear();name.str(""); // name<<"hPulseHeight_SecondBiggestHitChannelInSigma_"<<TADCEventReader::getStringForDetector(TPlaneProperties::getDetDiamond()); // sectionContent<<putImage(path,name.str()); this->addSection("Cluster Cuts",sectionContent.str()); }
std::string SDT::toString() { std::string result; result += "Class SDT contents:\n"; result += "\tdate: "; result += m_date.toString(); result += "\n\topeningPrice: "; result += floatToString(m_openingPrice); result += "\n\tclosingPrice: "; result += floatToString(m_closingPrice); result += "\n\ttoPrice: "; result += floatToString(m_topPrice); result += "\n\tfloorPrice: "; result += floatToString(m_floorPrice); result += "\n\tvolume: "; result += floatToString(m_volume); result +="\n\t20MaxPrice: "; result += floatToString(m_20Max); result += "\n\t20MinPrice: "; result += floatToString(m_20Min); result += "\n\t20AveragePrice: "; result += floatToString(m_20Average); result +="\n"; return result; }
void SelectBestCandidates::ntupleLoopCore(const int& entry_id) { TString event_candidate_id = floatToString(stm_no) + floatToString(exp_no) + floatToString(run_no) + floatToString(evt_no); EventCandidate event_candidate; event_candidate.entry = entry_id; event_candidate.momentum = l0_pcm + l1_pcm; unique_events_[event_candidate_id].push_back(event_candidate); }
/** * Creates the output HTML file. **/ void writeOutput(const std::list<Event>& list, std::list<TimedBlock*>& blockResults, std::list<TimedBlock*>& functionResults) { msg("Generating the output file...\n"); std::string pluginDir = ::idadir("plugins"); std::string hotchDir = pluginDir + "/hotch"; char filename[40] = {0}; sprintf(filename, "results.html"); // sprintf(filename, "results-%d.html", currentTime); std::string templateString; if (!readTextFile(hotchDir + "/template.htm", templateString)) { msg("Could not read template file\n"); return; } IdaFile file; unsigned int functions = file.getNumberOfFunctions(); unsigned int hitFunctions = countHitBlocks(functionResults); unsigned int unhitFunctions = functions - hitFunctions; unsigned int blocks = file.getDebugger().getNumberOfBreakpoints(); unsigned int hitBlocks = countHitBlocks(blockResults); unsigned int unhitBlocks = blocks - hitBlocks; replaceString(templateString, "%FILENAME%", file.getInputfilePath()); replaceString(templateString, "%NUMBER_OF_FUNCTIONS%", toString(functions)); replaceString(templateString, "%NUMBER_OF_HIT_FUNCTIONS%", toString(hitFunctions)); replaceString(templateString, "%NUMBER_OF_HIT_FUNCTIONS_PERCENTAGE%", floatToString(100.0 * hitFunctions / functions)); replaceString(templateString, "%NUMBER_OF_NOT_HIT_FUNCTIONS%", toString(unhitFunctions)); replaceString(templateString, "%NUMBER_OF_NOT_HIT_FUNCTIONS_PERCENTAGE%", floatToString(100.0 * unhitFunctions / functions)); replaceString(templateString, "%NUMBER_OF_BLOCKS%", toString(blocks)); replaceString(templateString, "%NUMBER_OF_HIT_BLOCKS%", toString(hitBlocks)); replaceString(templateString, "%NUMBER_OF_HIT_BLOCKS_PERCENTAGE%", floatToString(100.0 * hitBlocks / blocks)); replaceString(templateString, "%NUMBER_OF_NOT_HIT_BLOCKS%", toString(unhitBlocks)); replaceString(templateString, "%NUMBER_OF_NOT_HIT_BLOCKS_PERCENTAGE%", floatToString(100.0 * unhitBlocks / blocks)); replaceString(templateString, "%FUNCTIONS_BY_HITS%", generateFunctionTable(functionResults, sortByHits)); replaceString(templateString, "%FUNCTIONS_BY_TIME%", generateFunctionTable(functionResults, sortByTime)); replaceString(templateString, "%FUNCTIONS_BY_AVERAGE_TIME%", generateFunctionTable(functionResults, sortByAverageTime)); replaceString(templateString, "%BLOCKS_BY_HITS%", generateBlocksTable(blockResults, sortByHits)); replaceString(templateString, "%BLOCKS_BY_TIME%", generateBlocksTable(blockResults, sortByTime)); replaceString(templateString, "%ALL_EVENTS%", generateEventsTable(list)); writeOutput(hotchDir + "/" + filename, templateString); }
void ofxGuiSlider::draw() { glPushMatrix(); glTranslatef(mObjX, mObjY, 0.0); if(mParamName != "") drawParamString(0.0, 0.0, mParamName + ": " + floatToString(mValue, mDisplay), false); float x = (mCtrWidth * valueToFraction(mValue)); ofFill(); // background glColor4f(mGlobals->mCoverColor.r, mGlobals->mCoverColor.g, mGlobals->mCoverColor.b, mGlobals->mCoverColor.a); ofRect(mCtrX, mCtrY, mCtrWidth, mCtrHeight); // action glColor4f(mGlobals->mSliderColor.r, mGlobals->mSliderColor.g, mGlobals->mSliderColor.b, mGlobals->mSliderColor.a); ofRect(mCtrX, mCtrY, x, mCtrHeight); // handle glColor4f(mGlobals->mHandleColor.r, mGlobals->mHandleColor.g, mGlobals->mHandleColor.b, mGlobals->mHandleColor.a); ofRect(x, mCtrY, 1.0, mCtrHeight); ofNoFill(); // frame glColor4f(mGlobals->mFrameColor.r, mGlobals->mFrameColor.g, mGlobals->mFrameColor.b, mGlobals->mFrameColor.a); ofRect(mCtrX, mCtrY, mCtrWidth, mCtrHeight); glPopMatrix(); }
//Broadcasts readings void broadcastReadings(float* rawReadings, char** units) { logMsg("Broadcasting readings. . .", "INFO"); //Requires an array of readings and an array of units int readingsLength = sizeof(*rawReadings)/sizeof(rawReadings[0]); int unitsLength = sizeof(*units)/sizeof(units[0]); if(readingsLength == unitsLength){ char** formattedReadings; for(int j = 0; j < readingsLength ; ++j){ strcpy(formattedReadings[j], floatToString(rawReadings[j])); } char* messageToBroadcast; for(int i = 0; i < readingsLength && i < unitsLength; ++i){ //Put reading/unit pairs into message char* toAdd[] = {formattedReadings[i], MESSAGE_DELIMITER, units[i], MESSAGE_DELIMITER}; messageToBroadcast = concatStrings(toAdd); } // sendMessage(messageToBroadcast, READING_IDENTIFIER); } else{ logMsg("Readings and units vectors different lengths; they need to be the same size.", "ERROR"); } }
//Updates readings float* updateValues() { logMsg("Updating sensor values . . .", "DEBUG"); float* sensorReadings[MY_NUM_SENSORS]; float sensorRatios[MY_NUM_SENSORS]; float resistances[MY_NUM_SENSORS]; float readings[MY_NUM_SENSORS]; // Step through available sensors and record a top and bottom value for each for(int i = 0; i < 2*MY_NUM_SENSORS; i += 2){ //Steps through numSensors times float topReading = (float)analogRead(i); float bottomReading = (float)analogRead(i+1); float topBottom[] = { topReading, bottomReading }; sensorReadings[i/2] = topBottom; sensorRatios[i/2] = sensorReadings[i][0]/sensorReadings[i][1]; resistances[i/2] = (sensorRatios[i/2] - 1)*RBOTTOM; readings[i/2] = resistanceToTemp(resistances[i/2]); Serial.println(floatToString(readings[i/2])); } logMsg("Sensor values updated.", "DEBUG"); return readings; }
void Functions::toString(Aurora::NWScript::FunctionContext &ctx) { ctx.getReturn() = ""; switch (ctx.getParams()[0].getType()) { case Aurora::NWScript::kTypeInt: intToString(ctx); break; case Aurora::NWScript::kTypeFloat: floatToString(ctx); break; case Aurora::NWScript::kTypeString: ctx.getReturn() = ctx.getParams()[0]; break; case Aurora::NWScript::kTypeObject: objectToString(ctx); break; case Aurora::NWScript::kTypeVector: vectorToString(ctx); break; default: break; } }
std::string Time::toString() const { std::string result; switch(kind) { case GE: result = ">=" + floatToString(t1); break; case LE: result = "<=" + floatToString(t2); break; case INTERVAL: result = "["+floatToString(t1)+","+floatToString(t2) + "]"; break; case UNBOUNDED: result = "[0,infty]"; break; default: break; } return result; }
void PnlGlobal::refresh(GRender& render) { std::string time = getTimeFormatted(getUptimeMS()); render.print(26, 0, time.c_str()); render.print(1, 0, "packets:"); render.print(12, 0, intToString(sum.receivedPackets)); render.print(1, 1, "bytes:"); render.print(12, 1, intToString(sum.receivedBytes)); render.print(12, 3, "Total"); render.print(25, 3, "PerPacket"); uint32_t payload = sum.receivedBytes - sum.receivedProtocolOverheadBytes; uint32_t payloadPerPacket = payload / (sum.receivedPackets + 0.00001); render.print(1, 4, "payload:"); render.print(12, 4, intToString(payload).c_str()); render.print(25, 4, intToString(payloadPerPacket).c_str()); uint32_t protoOverhead = (sum.receivedProtocolOverheadBytes) / (float) (payload + 0.00001) * 100; uint32_t overheadPerPacket = sum.receivedProtocolOverheadBytes / (sum.receivedPackets + 0.00001); std::string overhead = "(" + floatToString(protoOverhead, 1) + "%)"; render.print(1, 5, "overhead:"); render.print(12, 5, intToString(sum.receivedProtocolOverheadBytes).c_str()); render.print(25, 5, intToString(overheadPerPacket).c_str()); render.print(29, 5, overhead.c_str()); }
void Nimbits::recordValue(double value, String pointId) { EthernetClient client; String json; json = "{\"d\":\""; json += floatToString(value, 4); json += "\"}"; String content; content += "&json="; content += json; content += "&id="; content += pointId; if (client.connect(_hostname.c_str(), _port)) { doPost(client, VALUE_API, content); String response = getFullResponse(client); client.stop(); } else { client.stop(); } }
//#define DEBUG blobtype best_blob(double alpha_0, double alpha_F, double inc_alpha, double a_0, double a_F, double inc_a, double w, double *target_att, int target_length) { blobtype retval; retval.order = 2; int alpha_size = FLOOR((alpha_F - alpha_0) / inc_alpha + 1); int a_size = FLOOR((a_F - a_0) / inc_a + 1); Image<double> att, ops; att().resize(alpha_size, a_size); ops().resize(alpha_size, a_size); int i, j; double a, alpha, best_a = -1, best_alpha = -1; double best_ops = 1e10, best_att = 0; for (i = 0, alpha = alpha_0; i < alpha_size; alpha += inc_alpha, i++) for (j = 0, a = a_0; j < a_size; a += inc_a, j++) { retval.radius = a; retval.alpha = alpha; A2D_ELEM(att(), i, j) = blob_att(w, retval); A2D_ELEM(ops(), i, j) = blob_ops(w, retval); if (j > 0) for (int n = target_length - 1; n >= 0; n--) if (A2D_ELEM(att(), i, j - 1) > target_att[n] && A2D_ELEM(att(), i, j) < target_att[n]) { A2D_ELEM(att(), i, j) = 0; if (A2D_ELEM(ops(), i, j - 1) < best_ops && A2D_ELEM(att(), i, j - 1) >= best_att) { best_alpha = alpha; best_a = a - inc_a; best_ops = A2D_ELEM(ops(), i, j - 1); best_att = target_att[n]; } } } #ifdef DEBUG att.write((std::string)"att" + floatToString(w) + ".xmp"); ops.write((std::string)"ops" + floatToString(w) + ".xmp"); #endif retval.radius = best_a; retval.alpha = best_alpha; return retval; }
/*--------------------------------------------------------------------*//*! * \brief Write key-value-pair into log * \param log qpTestLog instance * \param name Unique identifier for entry * \param description Human readable description * \param tag Optional tag * \param value Value of the key-value-pair * \return true if ok, false otherwise *//*--------------------------------------------------------------------*/ deBool qpTestLog_writeFloat (qpTestLog* log, const char* name, const char* description, const char* unit, qpKeyValueTag tag, float value) { char tmpString[64]; floatToString(value, tmpString, sizeof(tmpString)); /* <Number Name="name" Description="description" Tag="Performance">15</Number> */ return qpTestLog_writeKeyValuePair(log, "Number", name, description, unit, tag, tmpString); }
void GMLWriter::addPoint( float x, float y, float z, float time ) { char fp[5]; String s; s += "<pt><x>"; floatToString(&fp[0], x, 5); s += fp; s += "</x><y>"; floatToString(&fp[0], y, 5); s += fp; s += "</y><z>"; floatToString(&fp[0], z, 5); s += fp; s += "</z>"; s += "<t>"; floatToString(&fp[0], time, 5); s += fp; s += "</t></pt>"; file.write(s.c_str()); }
/*EDU US*/ void rgb_lcd::newWrite(double nbr){ //--- On convertit en String DEBUG2("Le nbr recu est : ", nbr); //- Enregistrement String nbrToStr; nbrToStr = floatToString(nbr); DEBUG2("Le nbr converti en chaine est : ", nbrToStr); effectiveNewWrite(nbrToStr); }
void ComputerView::setPingDelay(double delay) { Wt::WString text; if (delay < 0) text = "Timeout"; else text = Wt::WString("{1} ms").arg(floatToString(delay, 2)); _ping_txt->setText(text); app->triggerUpdate(); }
bool circleEmitter::updateParticle(particle *p){ if(p != NULL && p->life > 0){ p->prevPos.x = p->pos.x; p->prevPos.y = p->pos.y; p->prevPos.z = p->pos.z; p->dir = p->dir*(fmax((p->life),e->life/1.1)/(float)e->life); p->pos.x += p->dir.x; p->pos.y += p->dir.y; p->pos.z += p->dir.z; p->dir.x += e->force.x*cosf(p->pos.y)*p->side; p->dir.y += e->force.y*cosf(p->pos.y)*p->side; p->dir.z += e->force.z*cosf(p->pos.y)*p->side; p->life--; if(recording){ *emitterInfo << floatToString(p->pos.x) << endl; *emitterInfo << floatToString(p->pos.y) << endl; *emitterInfo << floatToString(p->pos.z) << endl; } return true; }else if(p != NULL && p->life == 0){ if(p->prev != NULL){ p->prev->next = p->next; }else{ e->particleList = p->next; } if(p->next != NULL){ p->next->prev = p->prev; } p->next = *managerParticleList; p->prev = NULL; *managerParticleList = p; e->particleCount--; } return false; }
// Create deformed PDB ===================================================== FileName ProgNmaAlignment::createDeformedPDB(int pyramidLevel) const { String program; String arguments; FileName fnRandom; fnRandom.initUniqueName(nameTemplate,fnOutDir); const char * randStr = fnRandom.c_str(); program = "xmipp_pdb_nma_deform"; arguments = formatString( "--pdb %s -o %s_deformedPDB.pdb --nma %s --deformations ", fnPDB.c_str(), randStr, fnModeList.c_str()); for (size_t i = 0; i < VEC_XSIZE(trial) - 5; ++i) arguments += floatToString(trial(i)) + " "; runSystem(program, arguments, false); program = "xmipp_volume_from_pdb"; arguments = formatString( "-i %s_deformedPDB.pdb --size %i --sampling %f -v 0", randStr, imgSize, sampling_rate); if (do_centerPDB) arguments.append(" --centerPDB "); if (useFixedGaussian) { arguments.append(" --intensityColumn Bfactor --fixed_Gaussian "); if (sigmaGaussian >= 0) arguments += formatString("%f",sigmaGaussian); } //else //arguments +=" --poor_Gaussian"; // Otherwise, a detailed conversion of the atoms takes too long in this context progVolumeFromPDB->read(arguments); progVolumeFromPDB->tryRun(); if (do_FilterPDBVol) { program = "xmipp_transform_filter"; arguments = formatString( "-i %s_deformedPDB.vol --sampling %f --fourier low_pass %f -v 0", randStr, sampling_rate, cutoff_LPfilter); runSystem(program, arguments, false); } if (pyramidLevel != 0) { Image<double> I; FileName fnDeformed = formatString("%s_deformedPDB.vol",randStr); I.read(fnDeformed); selfPyramidReduce(BSPLINE3, I(), pyramidLevel); I.write(fnDeformed); } return fnRandom; }
//Broadcasts readings void broadcastReadings(float* rawReadings, char** units) { logMsg("Broadcasting readings. . .", "INFO"); //Requires an array of readings and an array of units int readingsLength = sizeof(*rawReadings)/sizeof(rawReadings[0]); int unitsLength = sizeof(*units)/sizeof(units[0]); char* messageToBroadcast; if(readingsLength == unitsLength){ for(int i = 0; i < readingsLength && i < unitsLength; ++i){ //Put reading/unit pairs into message char* temp = floatToString(rawReadings[i]); char* toAdd[] = {floatToString(rawReadings[i]), MESSAGE_DELIMITER, units[i]}; char* newMsg[] = {messageToBroadcast, concatStrings(toAdd, sizeof(toAdd)/sizeof(toAdd[0]))}; messageToBroadcast = concatStrings(newMsg, sizeof(newMsg)/sizeof(newMsg[0])); } // Serial.println(messageToBroadcast); sendMessage(messageToBroadcast, READING_IDENTIFIER); } else{ logMsg("Readings and units vectors different lengths; they need to be the same size.", "ERROR"); } }
void GMLWriter::addPoint( float x, float y, float time ) { String s; char fp[10]; s += "<pt><x>"; //sprintf(&fp[0], "%f", x); floatToString(&fp[0], x, 5); Serial.print(fp); //itoa(x, fp, 10); s += fp; s += "</x><y>"; //sprintf(&fp[0], 5, "%f", y); floatToString(&fp[0], y, 5); Serial.print(fp); s += fp; s += "</y><t>"; //snprintf(&fp[0], 5, "%f", z); floatToString(&fp[0], time, 5); Serial.print(fp); s += fp; s += "</t></pt>"; file.write(s.c_str()); }
void NumberInputWidget::setValue(float value) { if (!getText().empty()) { m_oldValue = getValue(); } value = constraintValue(value); std::string text = floatToString(value, m_precision); if (getText() != text) { replaceText(text); valueChanged(this, text); } }
std::string sdOSCMessage::getAllArgumentsAsString(void){ int numArguments = typetags.size() -1; std::string str; for(int i = 0; i < numArguments; i++){ switch(typetags[i+1]){ // we need to skip ',' case 'i': str += intToString(getArgumentAsInt(i)); break; case 'f': str += floatToString(getArgumentAsFloat(i)); break; case 's': str += getArgumentAsString(i); break; } str += " "; } return str; }
std::map<std::string, std::string> Component::getAttributes() const { std::map<std::string, std::string> attributes; attributes["id"] = mId; attributes["name"] = mName; if (mSampleRate != 0.0f) { attributes["sampleRate"] = floatToString(mSampleRate); } if (!mUuid.empty()) { attributes["uuid"] = mUuid; } return attributes; }
//------------------------------------------------------------------------------- void GameApp::renderDebugHUD() { if( m_renderDebugHUD ) { m_renderer->pushCamera( m_debugCamera ); m_mainFontParams.set( "text", std::string( "FPS: " ) + floatToString( m_currentFPS, 0 ) ); mat4f modelMatrix( mat4f::IDENTITY ); modelMatrix.translate( vec3f( (float)m_screenWidth, (float) m_screenHeight - 30.0f, 0.0f ) ); m_mainFontParams.set( "modelMatrix", modelMatrix ); m_mainFontParams.set( "posRel", std::string( "TOPRIGHT" ) ); fireEvent( "renderText", m_mainFontParams ); //m_mainFontParams.set( "posRel", std::string( "TOPLEFT" ) ); //modelMatrix.loadIdentity(); //modelMatrix.translate( vec3f( 0.0f, (float)m_screenHeight ) ); //m_mainFontParams.set( "modelMatrix", modelMatrix ); ProfileSystem::getInstance()->renderData( vec3f( 50.0f, (float)m_screenHeight - 30.0f, 0.0f ), m_debugCamera ); m_renderer->popCamera(); } }
int main(void) { GPIO_InitTypeDef GPIO_InitStructure; //RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE); //enable gpioB peripherial clock RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE); //enable gpioA peripherial clock GPIO_InitStructure.GPIO_Pin = SCE|RES|DC|SCLK|SDIN; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_SetBits(GPIOA, SCE|RES|DC|SCLK|SDIN); LCDinit(); //initialize LCD parameters while(count--) { LCDString("Hello worlds! "); } setXY(0,5); //while(count2--){ //writeCharInv('C'); // } newString("0.123457",0,2); floatToString(value-count2); newFont('V',55,5); /*To Do: */ return 0; }
int main(int argc, char *argv[]) { { // test toStringWithComma int x[] = {INT_MIN, -1234567890, -123456, -12345, -1000, -999, -1, 0, 1, 999, 1000, 12345, 123456, 1234567890, INT_MAX}; int n = sizeof(x)/ sizeof(x[0]); for (int i = 0; i < n; ++i) { printf("%-15d : %s\n", x[i], toStringWithComma(x[i]).c_str()); } } { // test toString std::vector<double> a; a.push_back(1.1); a.push_back(2.0); std::string s = floatToString(a); printf("%s\n", s.c_str()); } return 0; }
void Emitter::recordEmission(string outputFile){ emitterInfo = new ofstream (outputFile.c_str()); if (emitterInfo->is_open()) { *emitterInfo << floatToString(e->pos.x) << endl; *emitterInfo << floatToString(e->pos.y) << endl; *emitterInfo << floatToString(e->pos.z) << endl; *emitterInfo << floatToString(e->dir.x) << endl; *emitterInfo << floatToString(e->dir.y) << endl; *emitterInfo << floatToString(e->dir.z) << endl; *emitterInfo << floatToString(e->dirVar.x) << endl; *emitterInfo << floatToString(e->dirVar.y) << endl; *emitterInfo << floatToString(e->dirVar.z) << endl; *emitterInfo << floatToString(e->speed) << endl; *emitterInfo << floatToString(e->speedVar) << endl; *emitterInfo << intToString(e->totalParticles) << endl; *emitterInfo << intToString(e->emitsPerFrame) << endl; *emitterInfo << intToString(e->emitVar) << endl; *emitterInfo << intToString(e->life) << endl; *emitterInfo << intToString(e->lifeVar) << endl; *emitterInfo << floatToString(e->force.x) << endl; *emitterInfo << floatToString(e->force.y) << endl; *emitterInfo << floatToString(e->force.z) << endl; recording = true; } else cout << "Unable to open file"; }
void command_handler(uint8_t command){ uint16_t wbuf; uint8_t bufh, bufl; float fbuf; char sbuf[10]; switch(command){ /* read temperature in human readable form */ case READ_TEMP: sendByte(command); fbuf = getTemperature( ADC_read() ); floatToString(fbuf, sbuf); sendString(sbuf); sendString(EOM); break; /* read temperature in raw ADC counts */ case READ_TEMP_RAW: sendByte(command); wbuf = ADC_read(); HexToAscii(sbuf, 4, wbuf); sendString(sbuf); sendString(EOM); break; /* set operational voltage @25°C */ case SET_UBIAS_A: // echo the command sendByte(command); // waiting for a 4 character string receiveString(sbuf, 4); sendString(EOM); // set ADC register to given value wbuf = AsciiToHex(sbuf, 4); // max 0x7FF ADC_REG = 0x7FF & wbuf; break; /* set the temperature progression coefficient */ case SET_COEFF: // echo... sendByte(command); // waiting for a 2 character string receiveString(sbuf, 2); sendString(EOM); // Vcoef = AsciiToHex(sbuf, 2); // max value = 0x7F // Vcoef &= 0x7F; break; /* read the calculated adjusted operational voltage */ case READ_UADJ_A: sendByte(command); // get temperature fbuf = getTemperature( ADC_read() ); // calculate temperature adjusted voltage wbuf = calcAdjustedBiasVoltage(fbuf); // create string HexToAscii(sbuf, 5, wbuf); sendString(sbuf); sendString(EOM); break; /* read temperature coefficient */ case READ_COEFF: sendByte(command); sendString(EOM); break; /* print help */ case PRINT_HELP: sendByte(command); sendString("HW Version x.x SW Version 2.0"); sendString(EOM); break; /* print sipm info of module */ case SIPM_INFO: sendByte(command); sendString(EOM); break; case DAC_CAL: sendByte(command); sendString(EOM); break; default: MPPC_status = ADDRESSED; } }
void GuiEditor::updateDisplay() { if(opened == true) { int bufsize = -1; switch(myProg.iBufferSize){ case 512: bufsize = 0; break; case 1024: bufsize = 1; break; case 2048: bufsize = 2; break; case 4096: bufsize = 3; break; case 8192: bufsize = 4; break; } bufferMenu->setCurrent(bufsize); float val = myProg.fGain; gainFader->setValue(val/(float)maxGain); gainDisplay->setText(floatToString(val).c_str()); mySpectrumView->gain = val; val = myProg.fResponse; responseFader->setValue(val); responseDisplay->setText(floatToString(val).c_str()); val = myProg.fXScale; xScaleFader->setValue(val/(float)maxXScale); xScaleDisplay->setText(floatToString(val).c_str()); val = myProg.fYScale; yScaleFader->setValue(val/(float)maxYScale); yScaleDisplay->setText(floatToString(val).c_str()); int nBands = myProg.iNBands; bandsFader->setValue(nBands/(float)maxBands); bandsDisplay->setText(intToString(nBands).c_str()); mySpectrumView->nBands = nBands; ampScaleMenu->setCurrent(myProg.iAmpScale); freqScaleMenu->setCurrent(myProg.iFreqScale); displayMenu->setCurrent(myProg.iDisplay); mySpectrumView->display = myProg.iDisplay; typeMenu->setCurrent(myProg.iType); mySpectrumView->displayType = myProg.iType; resamplingMenu->setCurrent(myProg.iResampling); std::string address = myProg.sAddress; //const char * c = address.c_str(); addressDisplay->setText(address.c_str()); //addressDisplay->setText(c); std::string host = myProg.sHost; //const char * d = host.c_str(); hostDisplay->setText(host.c_str()); int port = myProg.iPort; portDisplay->setText(intToString(port).c_str()); sender.setup(myProg.sHost, myProg.iPort); } }
//----------------------------------------------------------------------------- void GuiEditor::valueChanged (CControl* control) { //effect->setParameterAutomated (control->getTag (), control->getValue ()); float value; int ival; const char* text; std::string result; char* tempt; switch (control->getTag()) { case kBufferSize: ((COptionMenu*)(control))->getCurrent(tempt); ival = ((COptionMenu*)(control))->getIndex(tempt); updateBufferSize(ival); break; case kGain: value = control->getValue(); result = floatToString(value*maxGain); gainDisplay->setText(result.c_str()); updateGain(value*maxGain); break; case kGainText: text = ((CTextEdit*)(control))->getText(); value = charToFloat(text); gainFader->setValue(value/(float)maxGain); updateGain(value); break; case kXScale: value = control->getValue(); result = floatToString(value*maxXScale); xScaleDisplay->setText(result.c_str()); updateXScale(value*maxXScale); break; case kXScaleText: text = ((CTextEdit*)(control))->getText(); value = charToFloat(text); xScaleFader->setValue(value/(float)maxXScale); updateXScale(value); break; case kYScale: value = control->getValue(); result = floatToString(value*maxYScale); yScaleDisplay->setText(result.c_str()); updateYScale(value*maxYScale); break; case kYScaleText: text = ((CTextEdit*)(control))->getText(); value = charToFloat(text); yScaleFader->setValue(value/(float)maxYScale); updateYScale(value); break; case kResponse: value = control->getValue(); result = floatToString(value); responseDisplay->setText(result.c_str()); updateResponse(value); break; case kResponseText: text = ((CTextEdit*)(control))->getText(); value = charToFloat(text); responseFader->setValue(value); updateResponse(value); break; case kBands: ival = (int)(control->getValue()*maxBands); result = intToString(ival); bandsDisplay->setText(result.c_str()); bandsFader->setValue(((float)ival)/(float)maxBands); updateBands(ival); break; case kBandsText: text = ((CTextEdit*)(control))->getText(); ival = charToInt(text); bandsFader->setValue((float)value/(float)maxBands); updateBands(ival); break; case kAmpScale: ((COptionMenu*)(control))->getCurrent(tempt); ival = ((COptionMenu*)(control))->getIndex(tempt); updateAmpScale(ival); break; case kType: ((COptionMenu*)(control))->getCurrent(tempt); ival = ((COptionMenu*)(control))->getIndex(tempt); updateType(ival); break; case kDisplay: ((COptionMenu*)(control))->getCurrent(tempt); ival = ((COptionMenu*)(control))->getIndex(tempt); updateDisplayt(ival); break; case kResampling: ((COptionMenu*)(control))->getCurrent(tempt); ival = ((COptionMenu*)(control))->getIndex(tempt); updateResampling(ival); break; case kFreqScale: ((COptionMenu*)(control))->getCurrent(tempt); ival = ((COptionMenu*)(control))->getIndex(tempt); updateFreqScale(ival); break; case kAddress: text = ((CTextEdit*)(control))->getText(); updateAddress(text); break; case kPort: text = ((CTextEdit*)(control))->getText(); ival = charToInt(text); updatePort(ival); break; case kHost: text = ((CTextEdit*)(control))->getText(); updateHost(text); break; } }