自学教程：C++ Calculate函数代码示例

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;}

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_TEMPLATEvector<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	}}

// Main Functionint 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();    }}