void patchExpressionFunctionObject::writeTheData(const word &pName,PatchValueExpressionDriver &driver) { Field<T> result(driver.getResult<T>()); AccumulationCalculation<T> calculator( result, driver.result().isPoint(), driver ); Field<T> results(accumulations_.size()); forAll(accumulations_,i) { const NumericAccumulationNamedEnum::accuSpecification accu= accumulations_[i]; T val=calculator(accu); results[i]=val; if(verbose()) { Info << " " << accu << "=" << val; } } if (Pstream::master()) { writeTime(pName,time().value()); writeData(pName,results); endData(pName); } }
//--------------------------------------------------------------------------------------------------- // MAIN. //--------------------------------------------------------------------------------------------------- int main(void) { //--------------------------------------------------------------------------------------------------- // SETTING INPUT/OUTPUT CHARACTERISTICS FOR THE PINS. //--------------------------------------------------------------------------------------------------- myPortDDR |= (1 << p_clear); // clear is an output. myPortDDR |= (1 << p_1); // 1 is an output. myPortDDR |= (1 << p_3); // 3 is an output. myPortDDR |= (1 << p_8); // 8 is an output. myPortDDR &= ~(1 << p_sig_in); // the input audio signal is and INPUT (obviously :P). //--------------------------------------------------------------------------------------------------- // MAIN CODE LOOP. //--------------------------------------------------------------------------------------------------- int testDelay = 250; while(1) { calculator(p_clear); _delay_ms(testDelay); calculator(p_1); _delay_ms(testDelay); calculator(p_3); _delay_ms(testDelay); calculator(p_8); _delay_ms(testDelay); } }
int main() { int ret; int a, b; char c; scanf("%c\n%d %d", &c, &a, &b); switch (c) { case '+': ret = calculator(a, b, add); break; case '-': ret = calculator(a, b, sub); break; case '*': ret = calculator(a, b, mul); break; case '/': ret = calculator(a, b, dev); break; } if (ret == -1) return 0; printf("%d\n", ret); return 0; }
void MainWindow::spi_recvOver120003(Msg* pMsg) { qDebug()<<"0x50:"<<QDateTime::currentDateTime().toString("hh:mm:ss"); customPlot->legend->setVisible(true); calculator(); modeCombo->setEnabled(true); }
int main (void) { char c; for (;;) { c = getch (); if (strchr ("zq.", c) != NULL) break; switch (c) { case '+' : c = add ; break; case '-' : c = substract ; break; case '*' : c = multiply ; break; case '/' : c = divide ; break; case '(' : c = parentheses ; break; case ')' : c = parentheses ; break; default : c = c - '0' ; break; } printf ("%s", calculator (c)); } return 0; }
int main(void) { int menuChoice; int subMenu; printf("\tMenu\n"); printf("1. Calculator\n"); printf("2. Scheduler\n"); printf("3. End\n"); scanf("%d", &menuChoice); switch(menuChoice) { case 1: // 계산기 calculator(); break; case 2: while (1) { // 스케쥴러 subMenu = schedulerMenu(); switch(subMenu) { case 1: insertSchedule(mScheduleCount); break; } } break; case 3: // 종료 printf("종료됩니다.\n"); break; } return 0; }
// see also TestPapillaryFibreCalculatorLong() for bigger test of the main method on a cylinder. void TestGetFibreOrientationsOnSimpleCube(void) throw(Exception) { TrianglesMeshReader<3,3> mesh_reader("mesh/test/data/simple_cube"); TetrahedralMesh<3,3> mesh; mesh.ConstructFromMeshReader(mesh_reader); PapillaryFibreCalculator calculator(mesh); std::vector<c_vector<double,3> > fibre_orientations = calculator.CalculateFibreOrientations(); // Not very well defined for a cube (since it's so well structured that there are zero // eigenvectors in the smoothed tensors) but necessary to test coverage. // Nightly test TestPapillaryFibreCalculatorLong.hpp is a better one if you want to understand it! ///\todo There may still be a sign issue between flapack and MKL ///\todo THIS TEST IS KNOWN TO STALL IN LAPACK (dgeev_) // ON THIS CONFIGURATION : // * 32-bit virtual machine on Ubuntu 8.04 LTS // * build=GccOpt // * PETSc: petsc-2.3.2-p10 with f2cblaslapack TS_ASSERT_DELTA(fabs(fibre_orientations[0](0)), 0.7056, 1e-4); TS_ASSERT_DELTA(fabs(fibre_orientations[0](1)), 0.0641, 1e-4); TS_ASSERT_DELTA(fabs(fibre_orientations[0](2)), 0.7056, 1e-4); TS_ASSERT_DELTA(fabs(fibre_orientations[4](0)), 0.0455, 1e-4); TS_ASSERT_DELTA(fabs(fibre_orientations[4](1)), 0.5005, 1e-4); TS_ASSERT_DELTA(fabs(fibre_orientations[4](2)), 0.8645, 1e-4); TS_ASSERT_DELTA(fabs(fibre_orientations[5](0)), 0.6704, 1e-4); TS_ASSERT_DELTA(fabs(fibre_orientations[5](1)), 0.3176, 1e-4); TS_ASSERT_DELTA(fabs(fibre_orientations[5](2)), 0.6704, 1e-4); }
void TestAllCases() { TrianglesMeshReader<2,2> mesh_reader("mesh/test/data/square_2_elements"); MutableMesh<2,2> mesh; mesh.ConstructFromMeshReader(mesh_reader); TS_ASSERT_DELTA(mesh.GetAngleBetweenNodes(2,0), -0.75*M_PI, 1e-12); TS_ASSERT_DELTA(mesh.GetAngleBetweenNodes(2,1), -0.5*M_PI, 1e-12); CellsGenerator<FixedG1GenerationalCellCycleModel, 2> cells_generator; std::vector<CellPtr> cells; cells_generator.GenerateBasic(cells, mesh.GetNumNodes()); MeshBasedCellPopulation<2> cell_population(mesh, cells); MAKE_PTR(GeneralisedLinearSpringForce<2>, p_force); std::vector<boost::shared_ptr<AbstractTwoBodyInteractionForce<2> > > force_collection; force_collection.push_back(p_force); DiscreteSystemForceCalculator calculator(cell_population, force_collection); double epsilon = 0.5*M_PI; calculator.SetEpsilon(epsilon); TS_ASSERT_THROWS_NOTHING(calculator.GetSamplingAngles(2)); }
void addSiteDialog::doSubnetUpdate() { IpCalculator calculator(ui->lineEdit_2->text()+'/'+ui->lineEdit_3->text()); ui->label_15->setText(calculator.getBroadcast()); broadcastIp=calculator.getBroadcast(); ui->label_16->setText(calculator.getHostsPerNetwork()); ui->label_17->setText(calculator.getMaxHost()); ui->label_14->setText(calculator.getMinHost()); ui->label_13->setText(calculator.getSubnetMask()); ui->label_12->setText(calculator.getNetwork()); networkIp=calculator.getNetwork(); /*QString networkClass = calculator.getNetworkClass(); if (networkClass == IpCalculator::classUndefined) { ui->labelInformation->setText(QString("Undefined Class")); } else { QString classInformation = QString("Class %1 Network") .arg(calculator.getNetworkClass()); ui->labelInformation->setText(classInformation); }*/ }
//========================================================================================= ProjectivePoint::ProjectivePoint( BindType bindType ) : GAVisToolGeometry( bindType ) { VectorMath::Zero( center ); weight = 1.0; CalcLib::Calculator calculator( "geoalg" ); char decompositionCode[ 512 ]; sprintf_s( decompositionCode, sizeof( decompositionCode ), "do(" "w = pt . e0," "pt = pt / w," "x = scalar_part( pt, e1 )," "y = scalar_part( pt, e2 )," "z = scalar_part( pt, e3 )," ")" ); decompositionEvaluator = calculator.CompileEvaluator( decompositionCode ); wxASSERT( decompositionEvaluator != 0 ); char compositionCode[ 512 ]; sprintf_s( compositionCode, sizeof( compositionCode ), "do(" "c = x*e1 + y*e2 + z*e3," "pt = w*(c + e0)," ")" ); compositionEvaluator = calculator.CompileEvaluator( compositionCode ); wxASSERT( compositionEvaluator != 0 ); }
int main(int argc, const char* argv[]){ char chk; printf("\t<<<<<<<<<< Welcome to Postfix to Result Program >>>>>>>>>>\n"); do{ printf("\n\tPostfix\t: "); input(); printf("\t----------------------------------------------------------"); printf("\n\tResult\t: "); output(); printf("\n\t----------------------------------------------------------\n\n"); printf("\tPlease input value each variable\n"); calculator(); printf("\n\tTotal: %.2f", total); printf("\n\t----------------------------------------------------------"); destroy(); printf("\n\n"); do{ printf("\tDo you want to change Postfix to Result (y/n)? : "); fflush(stdin); scanf("%c", &chk); }while(!(tolower(chk) == 'y' || tolower(chk) == 'n')); }while(tolower(chk) != 'n'); printf("\n\n\t<<<<<<<<<<<<<<<<<<<<<<<< Good Bye >>>>>>>>>>>>>>>>>>>>>>>>\n\n"); getch(); return 0; }
QString addressRangeValidAvailable(QString networkIp,QString broadcastIp, QString vpnAddressRange, unsigned int vpnId) { unsigned int rangeStart=qstringAddressToUint(networkIp); unsigned int rangeEnd=qstringAddressToUint(broadcastIp); //bool valid=false; bool available=true; IpCalculator calculator(vpnAddressRange); unsigned int bufferRangeStart=qstringAddressToUint(calculator.getNetwork()); unsigned int bufferRangeEnd=qstringAddressToUint(calculator.getBroadcast()); if ((rangeStart>=bufferRangeStart)&&(rangeEnd<=bufferRangeEnd)){} else{return "Range outside current VPN";} QSqlQuery getSitesinVpn; getSitesinVpn.exec(QString("select siteAddressRange,siteName from sites where vpnId=%1").arg(vpnId)); QString siteAddress; QString interferingSites=""; while(getSitesinVpn.next()) { siteAddress=getSitesinVpn.value(0).toString(); IpCalculator calculator(siteAddress); bufferRangeStart=qstringAddressToUint(calculator.getNetwork()); bufferRangeEnd=qstringAddressToUint(calculator.getBroadcast()); if ((rangeStart<=bufferRangeEnd)&&(rangeEnd>=bufferRangeStart)) { available=false; interferingSites=interferingSites+" "+getSitesinVpn.value(1).toString(); } } if(!available){return("Range already used in sites:"+interferingSites+".");} return("ok"); }
void MainWindow::on_but_res_clicked() { if (!is_a||!is_b) { ui->op_show->setText("="); ui->output->display(temp); } if (is_a&&is_b&&is_op) { calculator(); } }
static void measureTextRenderer(RenderSVGInlineText* text, MeasureTextData* data, bool processRenderer) { ASSERT(text); SVGTextLayoutAttributes* attributes = text->layoutAttributes(); Vector<SVGTextMetrics>* textMetricsValues = &attributes->textMetricsValues(); if (processRenderer) { if (data->allCharactersMap) attributes->clear(); else textMetricsValues->clear(); } SVGTextMetricsCalculator calculator(text); bool preserveWhiteSpace = text->style()->whiteSpace() == PRE; unsigned surrogatePairCharacters = 0; unsigned skippedCharacters = 0; unsigned textPosition = 0; unsigned textLength = calculator.textLength(); SVGTextMetrics currentMetrics; for (; textPosition < textLength; textPosition += currentMetrics.length()) { currentMetrics = calculator.computeMetricsForCharacter(textPosition); if (!currentMetrics.length()) break; bool characterIsWhiteSpace = calculator.characterIsWhiteSpace(textPosition); if (characterIsWhiteSpace && !preserveWhiteSpace && data->lastCharacterWasWhiteSpace) { if (processRenderer) textMetricsValues->append(SVGTextMetrics(SVGTextMetrics::SkippedSpaceMetrics)); if (data->allCharactersMap) skippedCharacters += currentMetrics.length(); continue; } if (processRenderer) { if (data->allCharactersMap) { const SVGCharacterDataMap::const_iterator it = data->allCharactersMap->find(data->valueListPosition + textPosition - skippedCharacters - surrogatePairCharacters + 1); if (it != data->allCharactersMap->end()) attributes->characterDataMap().set(textPosition + 1, it->value); } textMetricsValues->append(currentMetrics); } if (data->allCharactersMap && calculator.characterStartsSurrogatePair(textPosition)) surrogatePairCharacters++; data->lastCharacterWasWhiteSpace = characterIsWhiteSpace; } if (!data->allCharactersMap) return; data->valueListPosition += textPosition - skippedCharacters; }
void search() { char tmp[610]; int p=ncount+1; while(fgets(tmp,610,input)) { latree[p].clean (); int c=0; while(tmp[c])c++; if(!isen(tmp[c-1])) tmp[c-1]=0; c=0; double ansmax=0.00000; latree[p].l=tmp[1]-48; //LEVEL<10 latree[p].makeakey(tmp+4); // printf("%d\n",latree[21].v); while(latree[c].howlong) { //printf(" [%d %d]\n",c,latree[c].l); if(latree[c].l<=latree[p].l) { if(calculator(c,p)>=ansmax&&calculator(c,p)!=0) { ansmax= calculator(c,p); anssheet(calculator(c,p),c); } } c++; } output(tmp); anssheet(); for(int a=0;a<610;a++) { tmp[a]=0; } } }
int main(int argc, char* argv[]) { Options options(argc, argv); if (options.parse()) { Calculator calculator(options.width(), options.height(), options.probability(), options.type(), options.gravity()); std::cout << (options.is_simulation() ? calculator.simulate() : calculator.calculate(options.steps())) << std::endl; } return 0; }
forAll(fractionBiggerThan,i) { scalar value=fractionBiggerThan[i]; NumericAccumulationNamedEnum::accuSpecification bigger( NumericAccumulationNamedEnum::numBigger, value ); NumericAccumulationNamedEnum::accuSpecification wbigger( NumericAccumulationNamedEnum::numWeightedBigger, value ); OStringStream annotation; annotation << "x > " << value << " | weighted"; writeData( Info,calculator(bigger), annotation.str(),NumericAccumulationNamedEnum::toString(bigger)); Info << " | "; writeData( Info,calculator(wbigger), "",NumericAccumulationNamedEnum::toString(wbigger),true); }
int findmymom(int now) { int tmp=0; double max=0; for(int i=0;i<now;i++) { if(max<calculator(now,i)) { max=calculator(now,i); // printf("%f",max) ; tmp=i; } //printf(" %d %d",i,now) ; //system("pause") ; } return tmp; }
MyPluralFormsCalculator* MyPluralFormsCalculator::make(const char* s) { MyPluralFormsCalculatorPtr calculator(new MyPluralFormsCalculator); if (s != NULL) { MyPluralFormsScanner scanner(s); MyPluralFormsParser p(scanner); if (!p.parse(*calculator)) { return NULL; } } return calculator.release(); }
/********************************* /function name: signal_handler() /function: execute the calculation every seconds *********************************/ void signal_handler() { clock_t start, finish; start = clock(); do{ calculator(); finish = clock(); }while(((finish - start) / CLOCKS_PER_SEC) <= 1); printf("%d seconds ", ++count); printf("%ld instructions\n", amount); }
int main(int argc, char* argv[]) { int sum = 0; if(argc != 2) { fprintf(stderr,"usage:%s expression.\n",argv[0]); return -1; } //printf("next operator:%c\n",__next_op_parenthesis("(((123+123)*3))-3",NULL)); calculator(argv[1],&sum); printf("expression:%s,value:%d\n",argv[1],sum); return 0; }
void interfaceViewer::on_pushButton_6_clicked() ///addDetail button { IpCalculator calculator(interfaceAddressRange); addDetail.setRangeStart(calculator.getMinHost()); addDetail.setRangeEnd(calculator.getMaxHost()); addDetail.setInterfaceId(interfaceId); addDetail.setInterfaceName(interfaceName); addDetail.setVpnId(vpnId); addDetail.setVpnName(vpnName); addDetail.show(); }
///gets the settings, interfaceId etc... void interfaceViewer::set(unsigned int inputInterfaceId, QString inputInterfaceName, QString inputInterfaceAddressRange) { interfaceId=inputInterfaceId; interfaceName=inputInterfaceName; interfaceAddressRange=inputInterfaceAddressRange; ui->label_7->setText("Platform name "+interfaceName); ui->label_8->setText("Address range "+interfaceAddressRange); QString detailQry=QString("SELECT detailId,detailAddress,localPort,comment FROM details where interfaceId=%1").arg(interfaceId); detailsModel->setQuery(detailQry); IpCalculator calculator(interfaceAddressRange); ui->label_2->setText(calculator.getHostsPerNetwork()); ui->label->setText(tr("%1").arg(countUsedDetails(interfaceId))); }
int main(int argc, char **argv) { /* * Check number of command line arguments */ if(argc <= 1){ return wrongArgs(); } /* * make copy of input string for rpn calculation */ char *rpn_input = calloc(strlen(argv[1]),255); strcpy(rpn_input, argv[1]); /* * Creating and execute RPN Validator * Push Down Automaton */ Pda *val_pda = pda_create(); validator(val_pda); pda_execute(val_pda, argv[1], false); /* * creating and executing RPN Calculator * Push Down Automaton */ if(val_pda->succeed) { Pda *calc_pda = pda_create(); calculator(calc_pda); pda_execute(calc_pda, rpn_input, false); pda_free(calc_pda); } /* * Clean up */ free(rpn_input); pda_free(val_pda); return 0; }
void ZLQtApplicationWindow::refresh() { if (((MyMenuBar*)myToolBar)->myIndex == -1) { ((MyMenuBar*)myToolBar)->myIndex = 1; ZLApplicationWindow::refresh(); ((MyMenuBar*)myToolBar)->myIndex = -1; } MenuMaskCalculator calculator(*this); calculator.processMenu(application()); if (calculator.shouldBeUpdated()) { myMenu->clear(); MenuUpdater(*this).processMenu(application()); } else { for (std::map<std::string,ZLQtMenuAction*>::iterator it = myMenuMap.begin(); it != myMenuMap.end(); ++it) { it->second->setEnabled(application().isActionEnabled(it->first)); } } }
int main(int argc, const char * argv[]) { //struct linearEq formula_1 = {1, -2, 0}; struct linearEq formula = {-3, 1 , 4}; struct xyPoint results; int x = 1; results = calculator(formula, x); printf(" solution of Eq1 %f * x + %f * y = %f is ( %f , %f) when x = %f \n",formula.A, formula.B, formula.C, results.x, results.y, results.x); // insert code here... printf("Hello, World!\n"); return 0; }
void TestCalculateWriteResultsToFile() { std::string output_directory = "TestDiscreteSystemForceCalculator"; // Set up a cell population HoneycombMeshGenerator mesh_generator(7, 5, 0, 2.0); MutableMesh<2,2>* p_mesh = mesh_generator.GetMesh(); CellsGenerator<FixedG1GenerationalCellCycleModel, 2> cells_generator; std::vector<CellPtr> cells; cells_generator.GenerateBasic(cells, p_mesh->GetNumNodes()); MeshBasedCellPopulation<2> cell_population(*p_mesh, cells); // Create the force law and pass in to a std::list MAKE_PTR(GeneralisedLinearSpringForce<2>, p_force); std::vector<boost::shared_ptr<AbstractTwoBodyInteractionForce<2> > > force_collection; force_collection.push_back(p_force); // Create a force calculator DiscreteSystemForceCalculator calculator(cell_population, force_collection); // Test WriteResultsToFile calculator.WriteResultsToFile(output_directory); // Compare output with saved files of what they should look like OutputFileHandler handler(output_directory, false); std::string results_file = handler.GetOutputDirectoryFullPath() + "results_from_time_0/results.vizstress"; NumericFileComparison node_velocities(results_file, "cell_based/test/data/TestDiscreteSystemForceCalculator/results.vizstress"); TS_ASSERT(node_velocities.CompareFiles(1e-4)); // Run a simulation to generate some results.viz<other things> files // so the visualizer can display the results.vizstress file. // (These lines are not actually necessary for generating results.vizstress) OffLatticeSimulation<2> simulator(cell_population); simulator.AddForce(p_force); simulator.SetEndTime(0.05); simulator.SetOutputDirectory(output_directory+"_rerun"); simulator.Solve(); }
//========================================================================================= ConformalQuarticGeometry::ConformalQuarticGeometry( BindType bindType ) : SurfaceGeometry( bindType, &conformalQuartic ) { CalcLib::Calculator calculator( "geoalg" ); char decompositionCode[ 2*1024 ]; strcpy_s( decompositionCode, sizeof( decompositionCode ), "do(" "c0 = scalar_part( quartic, no^nob )," "c1 = scalar_part( quartic, no^e1b )," "c2 = scalar_part( quartic, no^e2b )," "c3 = scalar_part( quartic, no^e3b )," "c4 = scalar_part( quartic, no^nib )," "c5 = scalar_part( quartic, e1^nob )," "c6 = scalar_part( quartic, e1^e1b )," "c7 = scalar_part( quartic, e1^e2b )," "c8 = scalar_part( quartic, e1^e3b )," "c9 = scalar_part( quartic, e1^nib )," "c10 = scalar_part( quartic, e2^nob )," "c11 = scalar_part( quartic, e2^e1b )," "c12 = scalar_part( quartic, e2^e2b )," "c13 = scalar_part( quartic, e2^e3b )," "c14 = scalar_part( quartic, e2^nib )," "c15 = scalar_part( quartic, e3^nob )," "c16 = scalar_part( quartic, e3^e1b )," "c17 = scalar_part( quartic, e3^e2b )," "c18 = scalar_part( quartic, e3^e3b )," "c19 = scalar_part( quartic, e3^nib )," "c20 = scalar_part( quartic, ni^nob )," "c21 = scalar_part( quartic, ni^e1b )," "c22 = scalar_part( quartic, ni^e2b )," "c23 = scalar_part( quartic, ni^e3b )," "c24 = scalar_part( quartic, ni^nib )," ")" ); decompositionEvaluator = calculator.CompileEvaluator( decompositionCode ); wxASSERT( decompositionEvaluator != 0 ); }
int main() { int i; printf("Insert a postfix notation :: "); gets(post); for(i=0;i<strlen(post);i++) { if(post[i]>='0' && post[i]<='9') { pushstack(i); } if(post[i]=='+' || post[i]=='-' || post[i]=='*' || post[i]=='/' || post[i]=='^') { calculator(post[i]); } } printf("\n\nResult :: %d",stack[top]); }
void TestGetSingleRadiusVector(void) throw(Exception) { TrianglesMeshReader<3,3> mesh_reader("mesh/test/data/simple_cube"); TetrahedralMesh<3,3> mesh; mesh.ConstructFromMeshReader(mesh_reader); TS_ASSERT_EQUALS(mesh.GetNumElements(),12u); PapillaryFibreCalculator calculator(mesh); // Call GetRadiusVectors on an element unsigned element_index = 0; c_vector<double, 3> radius_vector = calculator.GetRadiusVectorForOneElement(element_index); // Check they are right TS_ASSERT_DELTA(radius_vector[0], -0.275, 1e-9); TS_ASSERT_DELTA(radius_vector[1], -0.025, 1e-9); TS_ASSERT_DELTA(radius_vector[2], -0.275, 1e-9); }