void main(){ int count = 0; double Numbers[30],Answer; char symbols[30]; count = Input(Numbers,symbols); Print(Numbers, symbols, count); Answer = Calculate(Numbers, symbols, &count); printf(" = %.1f\n", Answer); }
void LinearRegression::addXY(const double& x, const double& y) { n++; sumX += x; sumY += y; sumXsquared += x * x; sumYsquared += y * y; sumXY += x * y; Calculate(); }
//--------------------------------------------------------------------------- bool mmImages::mmCalcMethod::Execute(void) { SendLogMessage(mmLog::debug,mmString(L"Start Execute")); bool v_bResult = Calculate(); SendLogMessage(mmLog::debug,mmString(L"End Execute")); return v_bResult; }
void main(int argc, char **argv) { setlocale(0, "Russian"); double s1 = Calculate(mt1, len(mt1)); double s2 = Calculate(mt2, len(mt2)); double s3 = Calculate(mt3, len(mt3)); double max_value = max(max(s1, s2), s3); printf("Максимальное значение %0.1lf содержится в:\n", s1); if (max_value == s1) printf(" mt1", s1); if (max_value == s2) printf(" mt2", s1); if (max_value == s3) printf(" mt3", s1); printf("\n"); }
int FGTurboProp::InitRunning(void) { FDMExec->SuspendIntegration(); Cutoff=false; Running=true; N2=16.0; Calculate(); FDMExec->ResumeIntegration(); return phase==tpRun; }
void Decision::run() { while(ros::ok()) { Calculate(); ros::spinOnce(); loop_rate.sleep(); } }
bool FGAtmosphere::Run(bool Holding) { if (FGModel::Run(Holding)) return true; if (Holding) return false; Calculate(in.altitudeASL); Debug(2); return false; }
// *************************************************************************** // Function: CommandWhile // Description: Our '/while' command // Usage: /while (<conditions>) // *************************************************************************** VOID CommandWhile(PSPAWNINFO pChar, PCHAR szLine) { CHAR szCond[MAX_STRING] = {0}; if (!gMacroBlock) { MacroError("Can only use /while during a macro."); return; } bRunNextCommand = TRUE; if (szLine[0]!='(') { FatalError("Failed to parse /while command. Expected () around conditions."); SyntaxError("Usage: /while (<conditions>)"); return; } PCHAR pEnd=&szLine[1]; DWORD nParens=1; while(1) { if (*pEnd=='(') nParens++; else if (*pEnd==')') { nParens--; if (nParens==0) { pEnd++; if (*pEnd!=0) { FatalError("Failed to parse /while command. Parameters after conditions."); SyntaxError("Usage: /while (<conditions>)"); return; } break; } } else if (*pEnd==0) { FatalError("Failed to parse /while command. Could not find conditions to evaluate."); SyntaxError("Usage: /while (<conditions>)"); return; } ++pEnd; } // while strcpy(szCond,szLine); DOUBLE Result=0; if (!Calculate(szCond,Result)) { FatalError("Failed to parse /while condition '%s', non-numeric encountered",szCond); return; } if (Result==0) EndWhile(pChar, gMacroBlock); }
const TRotation& KVFlowTensor::GetAziReacPlaneRotation() { // Returns the azimuthal rotation around the beam axis required // to put the X-axis in the reaction plane defined by the beam axis // and the major axis (largest eignevalue) of the ellipsoid. // The azimuthal angle of the rotation is that of the major axis // in the forward direction. if (!fCalculated) Calculate(); return fAziReacPlane; }
const TRotation& KVFlowTensor::GetFlowReacPlaneRotation() { // Returns composition of two rotations: // - around Z-axis to put X-axis in reaction plane (see GetAziReacPlaneRotation) // - around Y-axis to align Z-axis with flow (major) axis // In this rotated frame, theta is polar angle with respect to flow axis // and phi is azimuthal angle around flow axis (phi=0,180 => in-plane) if (!fCalculated) Calculate(); return fFlowReacPlane; }
void main(int argc, char **argv) { setlocale(0, ""); int s1 = Calculate(mt1, len(mt1)); int s2 = Calculate(mt2, len(mt2)); int s3 = Calculate(mt3, len(mt3)); int u = max(max(s1,s2),s3); printf("Больше сумма элементов, не попадающих в заданный диапазон [%i; %i] содержится в:\n", TrgetNumber1, TrgetNumber2); if(u==s1) printf(" mt1"); if(u==s2) printf(" mt2"); if(u==s3) printf(" mt3"); printf("\n"); system("pause"); }
int main(void) { struct Points *Field; struct Cluster *Clusters; int Width, Height; int NumOfPoints; int NumOfClusters; Field = Init(&Height,&Width,&NumOfPoints); Clusters = Calculate(Field, Height, Width, &NumOfClusters, NumOfPoints); Output_Data(Clusters, Field, NumOfClusters); return 0; }
void BroadCollisionStrategy::Detect( int nLayer, Player * pPlayer, Stack * stack, list<Space *> * retVal) { Calculate( nLayer, pPlayer, stack, retVal); }
void LinearRegression::addXY(const double& x, const double& y, bool auto_calculate) { n++; sumX += x; sumY += y; sumXsquared += x * x; sumYsquared += y * y; sumXY += x * y; if(auto_calculate) Calculate(); }
int FGTurbine::InitRunning(void) { FDMExec->SuspendIntegration(); Cutoff=false; Running=true; N1_factor = MaxN1 - IdleN1; N2_factor = MaxN2 - IdleN2; N2 = IdleN2 + ThrottlePos * N2_factor; N1 = IdleN1 + ThrottlePos * N1_factor; Calculate(); FDMExec->ResumeIntegration(); return phase==tpRun; }
ROOT_FEATURE_CALCULATOR_TEMPLATE vector<typename ROOT_FEATURE_CALCULATOR_TEMPLATE1::StringBatch> ROOT_FEATURE_CALCULATOR_TEMPLATE1::Calculate( const SyntaxTree& tree) { const vector<SyntaxNode>& nodes = tree.GetNodes(); vector<StringBatch> features; for (size_t nodeIndex = 0; nodeIndex < nodes.size(); ++nodeIndex) { features.emplace_back(Calculate(nodes[nodeIndex], tree)); } return features; }
void CDrawDoc::NewStructure(int number) { StructureNumber = number; int i; for (i=1;i<=ct.numofbases;i++) { if (ct.basepr[number][i]) { Calculate(); nopair = false; return; } } nopair = true; }
// 得到趋势信号 int CTechnique::GetTrendIntensity(int nIndex, CSPDWordArray & adwDays, UINT itsLong, UINT itsShort, UINT * pnCode ) { if( pnCode ) *pnCode = ITSC_NOTHING; if( nIndex <= 0 ) return ITS_NOTHING; int nRet = ITS_NOTHING; for( int k=1; k<adwDays.GetSize(); k++ ) { double dMALast1, dMALast2, dMANow1, dMANow2; if( !Calculate( &dMALast1, nIndex-1, min(adwDays[k-1],adwDays[k]), FALSE ) || !Calculate( &dMALast2, nIndex-1, max(adwDays[k-1],adwDays[k]), FALSE ) || !Calculate( &dMANow1, nIndex, min(adwDays[k-1],adwDays[k]), FALSE ) || !Calculate( &dMANow2, nIndex, max(adwDays[k-1],adwDays[k]), FALSE ) ) return ITS_NOTHING; if( dMANow1 >= dMALast1 && dMANow2 >= dMALast2 && dMANow1 > dMANow2 && (dMANow1-dMANow2)>=(dMALast1-dMALast2) && (ITS_ISBUY(nRet) || 1==k) ) { if( pnCode ) *pnCode = ITSC_LONG; nRet = itsLong; } else if( dMANow1 <= dMALast1 && dMANow2 <= dMALast2 && dMANow1 < dMANow2 && (dMANow1-dMANow2)<=(dMALast1-dMALast2) && (ITS_ISSELL(nRet) || 1==k) ) { if( pnCode ) *pnCode = ITSC_SHORT; nRet = itsShort; } else { if( pnCode ) *pnCode = ITSC_NOTHING; return ITS_NOTHING; } } return nRet; }
//--------------------------------------------------------- bool CSG_Regression::Calculate(int nValues, double *x, double *y, TSG_Regression_Type Type) { bool bResult; Destroy(); m_nValues = nValues; m_x = x; m_y = y; bResult = Calculate(Type); return( bResult ); }
void SceneAnimator::Init(const aiScene* pScene){// this will build the skeleton based on the scene passed to it and CLEAR EVERYTHING if(!pScene->HasAnimations()) return; Release(); Skeleton = CreateBoneTree( pScene->mRootNode, NULL); ExtractAnimations(pScene); for (unsigned int i = 0; i < pScene->mNumMeshes;++i){ const aiMesh* mesh = pScene->mMeshes[i]; for (unsigned int n = 0; n < mesh->mNumBones;++n){ const aiBone* bone = mesh->mBones[n]; std::map<std::string, cBone*>::iterator found = BonesByName.find(bone->mName.data); if(found != BonesByName.end()){// FOUND IT!!! woohoo, make sure its not already in the bone list bool skip = false; for(size_t j(0); j< Bones.size(); j++){ std::string bname = bone->mName.data; if(Bones[j]->Name == bname) { skip = true;// already inserted, skip this so as not to insert the same bone multiple times break; } } if(!skip){// only insert the bone if it has not already been inserted std::string tes = found->second->Name; TransformMatrix(found->second->Offset, bone->mOffsetMatrix); found->second->Offset.Transpose();// transpoce their matrix to get in the correct format Bones.push_back(found->second); BonesToIndex[found->first] = (unsigned int)Bones.size()-1; } } } } Transforms.resize( Bones.size()); float timestep = 1.0f/30.0f;// 30 per second for(size_t i(0); i< Animations.size(); i++){// pre calculate the animations SetAnimIndex((unsigned int)i); float dt = 0; for(float ticks = 0; ticks < Animations[i].Duration; ticks += Animations[i].TicksPerSecond/30.0f){ dt +=timestep; Calculate(dt); Animations[i].Transforms.push_back(std::vector<mat4>()); std::vector<mat4>& trans = Animations[i].Transforms.back(); for( size_t a = 0; a < Transforms.size(); ++a){ mat4 rotationmat = Bones[a]->Offset * Bones[a]->GlobalTransform; trans.push_back(rotationmat); } } } OUTPUT_DEBUG_MSG("Finished loading animations with "<<Bones.size()<<" bones"); }
// 得到趋势信号 int CTechnique::GetTrendIntensity1( int nIndex, UINT itsLong, UINT itsShort, UINT *pnCode ) { if( pnCode ) *pnCode = ITSC_NOTHING; if( nIndex <= 0 ) return ITS_NOTHING; double dLast = 0, dNow = 0; if( !Calculate( &dLast, nIndex-1, FALSE ) || !Calculate( &dNow, nIndex, FALSE ) ) return ITS_NOTHING; if( dNow > dLast ) { if( pnCode ) *pnCode = ITSC_LONG; return itsLong; } if( dNow < dLast ) { if( pnCode ) *pnCode = ITSC_SHORT; return itsShort; } return ITS_NOTHING; }
void CMandelbrotCalculator::Run (unsigned nCore) { while (1) { #ifdef ARM_ALLOW_MULTI_CORE unsigned nHalfWidth = m_pScreen->GetWidth () / 2; unsigned nHalfHeight = (m_pScreen->GetHeight ()-LINES_LEFT_FREE) / 2; switch (nCore) { case 0: Calculate (-2.0, 1.0, -1.0, 1.0, MAX_ITERATION, 0, nHalfWidth, 0, nHalfHeight); break; case 1: Calculate (-1.5, 0.0, -0.75, 0.25, MAX_ITERATION, nHalfWidth, nHalfWidth, 0, nHalfHeight); break; case 2: Calculate (-1.125, -0.375, -0.5, 0.0, MAX_ITERATION, 0, nHalfWidth, nHalfHeight, nHalfHeight); break; case 3: Calculate (-0.9375, -0.5625, -0.375, -0.125, MAX_ITERATION, nHalfWidth, nHalfWidth, nHalfHeight, nHalfHeight); break; } #else Calculate (-2.0, 1.0, -1.0, 1.0, MAX_ITERATION, 0, m_pScreen->GetWidth (), 0, m_pScreen->GetHeight ()-LINES_LEFT_FREE); #endif } }
bool FGAtmosphere::InitModel(void) { Calculate(0.0); SLtemperature = Temperature = 518.67; SLpressure = Pressure = 2116.22; SLdensity = Density = Pressure/(Reng*Temperature); SLsoundspeed = Soundspeed = sqrt(SHRatio*Reng*(Temperature)); rSLtemperature = 1/SLtemperature ; rSLpressure = 1/SLpressure ; rSLdensity = 1/SLdensity ; rSLsoundspeed = 1/SLsoundspeed ; return true; }
// Main Function int main() { user = InitiatePoint(); dest = InitiatePoint(); pass = InitiatePoint(); MAP[user.x][user.y] = MAZE[user.x][user.y] = 'S'; MAP[dest.x][dest.y] = MAZE[dest.x][dest.y] = 'P'; MAP[pass.x][pass.y] = MAZE[pass.x][pass.y] = 'D'; ShowMap(); while (1) { printf("Count: %d\n", ++count); Search(); if (!Calculate()) { dest = pass; break; } Move(); if (count == 5) return 0; } count = 0; while (1) { printf("Count %d\n", ++count); Search(); if (!Calculate()) { return 0; } Move(); if (count == 3) { return 0; } } return 0; }
//_________________________________________________________________ Double_t KVCaloBase::getvalue_int(Int_t i) { // derived method // protected method // On retourne la ieme valeur du tableau // si i est superieur au nbre de variables definies dans ingredient_list // retourne la valeur par defaut (ie 0) // appel a la methode Calculate pour mettre a jour // les variables avant d effectuer le retour if (i < nvl_ing->GetNpar()) { Calculate(); return GetIngValue(i); } else return 0; }
int MeanValues::compute(const char *) { calctype = p_calctype->getValue(); coDistributedObject *p_output = Calculate(p_data->getCurrentObject(), p_mesh->getCurrentObject(), p_solution->getObjName()); if (p_output) { p_solution->setCurrentObject(p_output); } else { return FAIL; } // done return CONTINUE_PIPELINE; }
void FGStandardAtmosphere::PrintStandardAtmosphereTable() { std::cout << "Altitude (ft) Temp (F) Pressure (psf) Density (sl/ft3)" << std::endl; std::cout << "------------- -------- -------------- ----------------" << std::endl; for (int i=0; i<280000; i+=1000) { Calculate(i); std::cout << std::setw(12) << std::setprecision(2) << i << " " << std::setw(9) << std::setprecision(2) << Temperature - 459.67 << " " << std::setw(13) << std::setprecision(4) << Pressure << " " << std::setw(18) << std::setprecision(8) << Density << std::endl; } // Re-execute the Run() method to reset the calculated values Run(false); }
/***************************************************************************** * Function: Calculate * * Description: Returns the controller output for a given error. Derivative error is * calculated as a simple dx/dt. If a derivative error is already * calculated then use overloaded method. *****************************************************************************/ float PID::Calculate ( float error, // Difference between desired and actual measurement. float delta_time // Change in time since last measurement. (seconds) ) { float derivative_error = 0.f; if (delta_time != 0.0f) // Avoid division by zero. { derivative_error = (error - previous_error) / delta_time; } return Calculate(error, derivative_error, delta_time); } // PID::Calculate()
//----------------------------------------------------------// void CCalculator::Calculate(CCalculator::contract_vector& contracts) { if (!contracts.empty()) { InterlockedExchange(&m_nContractsProcessed, static_cast<long>(contracts.size())); CCalculator::contract_vector::iterator it = contracts.begin(); CCalculator::contract_vector::iterator it_end = contracts.end(); for (; it != it_end; it++) { CAbstractContract* pContract = *it; if (pContract != NULL) Calculate(pContract); }; //wait to complete ::WaitForSingleObject(m_hComplete, INFINITE); }; };
void Fibonacci::Calculate() { m_mutex.lock(); if (m_count) { u_int64_t tempValue; tempValue = m_prevValue + m_currentValue; m_prevValue = m_currentValue; m_currentValue = tempValue; m_mutex.unlock(); PrintValue(); std::chrono::milliseconds duration(250); std::this_thread::sleep_for(duration); Calculate(); } else { m_mutex.unlock(); } }