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

int main (void){  struct MyTime first_time = { 10, 501};  struct MyTime second_time = { 2, 500};  struct MyTime min_time = { 99999, 999999};  struct MyTime max_time = { 0, 0};  struct MyTime diff_time = { 0, 0};    print_time ("First:", first_time);  print_time ("Second:", second_time);  print_time ("Min:", Min(first_time,second_time));  print_time ("Max:", Max(first_time,second_time));  print_time ("Diff:", Diff(second_time, first_time));    getCurrentMyTime(& first_time);  sleep (10);  getCurrentMyTime(& second_time);    print_time ("Average:", Avg(Diff(second_time,first_time), 10));     diff_time.SEC = first_time.SEC-second_time.SEC;   diff_time.FRAC_SEC = first_time.FRAC_SEC-second_time.FRAC_SEC;      /* If the substraction results in negative answer */   if(diff_time.FRAC_SEC < 0)    {        diff_time.FRAC_SEC = SCALE + diff_time.FRAC_SEC;            if(diff_time.SEC > 0 )               diff_time.SEC = diff_time.SEC-1;            else               diff_time.FRAC_SEC*=-1;    }   if(diff_time.FRAC_SEC < min_time.FRAC_SEC)    min_time.FRAC_SEC = diff_time.FRAC_SEC;     if(diff_time.FRAC_SEC > max_time.FRAC_SEC)    max_time.FRAC_SEC = diff_time.FRAC_SEC;   if(diff_time.SEC < min_time.SEC)    min_time.SEC = diff_time.SEC;     if(diff_time.SEC > max_time.SEC)    max_time.SEC = diff_time.SEC;   print_time("Old Min:", min_time);   print_time("Old Max:", max_time);  return 0;}

Diffs Node::getDiffs (const RobotState& last, const RobotState& current){  Diffs diffs;  const ros::Time now = ros::Time::now();;    // Use the fact that JointState is empty iff this is the first time around  if (last.isEmpty() || now >= last_keyframe_+keyframe_interval_)  {    last_keyframe_ = now;    if (last.isEmpty())      cerr << "Last is empty, so using all diffs" << endl;    else      cerr << "Keyframe interval elapsed, so saving entire joint state" << endl;    diffs.is_keyframe = true;    for (size_t i=0; i<current.joint_state->position.size(); i++)    {      diffs.new_joint_states.push_back(Diff(i, current.joint_state->position[i]));    }    diffs.pose_diff = true;    diffs.new_pose = current.pose;  }  else  {    for (size_t i=0; i<current.joint_state->position.size(); i++)    {      if (fabs(current.joint_state->position[i]-               last.joint_state->position[i])>distance_threshold_ &&          !joint_ignored_[i])      {        cerr << "Joint " << current.joint_state->name[i] << " value " <<          current.joint_state->position[i] << " differs from " <<          last.joint_state->position[i] << endl;        diffs.new_joint_states.push_back(Diff(i, current.joint_state->position[i]));      }    }    if ((current.pose.get() && !last.pose.get()) ||        (!current.pose.get() && last.pose.get()) ||        ((current.pose.get() && last.pose.get() &&          poseDistance(*current.pose, *last.pose)>distance_threshold_)))    {      cerr << "Current pose: " << (bool)current.pose.get() << "; last pose: "           << (bool)last.pose.get() << endl;      diffs.pose_diff = true;      diffs.new_pose = current.pose;    }  }  return diffs;}

EXPORT_C TAny* RDbRow::SetColumnWidthL(TDbColNo aColNo,TInt aWidth)// set the width for column aCol to Width// add extra NULL columns to buffer as required// return pointer to data for that column	{	__ASSERT(aColNo>0);	TDbCell* pC=Column(--aColNo);	if (pC==0)		{		// add extra NULL columns to buffer		if (aWidth==0)			return 0;	// setting to NULL, don't bother padding		TInt cFill=(aColNo-iColumn)*sizeof(TInt);		ExtendL(cFill+TDbCell::Size(aWidth));		pC=iCell;		Mem::FillZ(pC,cFill);		pC=PtrAdd(pC,cFill);		// set cache		SetCache(pC,aColNo);		}	else		{		TInt adjust=TDbCell::Size(aWidth)-pC->Size();	// how much to add		if (adjust!=0)			{			ExtendL(adjust);			pC=iCell;		// may have moved in extension			TDbCell* pNext=pC->Next();			TDbCell* pAdjust=PtrAdd(pNext,adjust);			Mem::Move(pAdjust,pNext,Diff(pAdjust,iLast));			}		}	pC->SetLength(aWidth);	return pC->Data();	}

void Camera::rotate( float x, float y ){    Vector po = getVSpherePos((float) m_LastMouseX, m_LastMouseY);    Vector pn = getVSpherePos(x, y);        if((po-pn).lengthSquared() < 0.0001f )        return;        float cosangle = po.dot(pn);    if(cosangle>1.0f) cosangle=1.0f;    if(cosangle<-1.0f) cosangle=-1.0f;        const float angle = acos(cosangle);    Vector RotAxis = pn.cross(po);    RotAxis.normalize();            //Vector Diff = m_Position-m_Target;    Vector Diff(0,0,(m_Position-m_Target).length());        Vector RotDiff = rotateAxisAngle(Diff, RotAxis, angle);        Vector cdir = m_Target-m_Position;    cdir.normalize();    Vector cup = m_Up;    Vector cright = cdir.cross(cup);    cright.normalize();    cup = cright.cross(cdir);    Vector RotDiffW;    RotDiffW.X = cright.X * RotDiff.X + cup.X * RotDiff.Y +  -cdir.X * RotDiff.Z;    RotDiffW.Y = cright.Y * RotDiff.X + cup.Y * RotDiff.Y +  -cdir.Y * RotDiff.Z;    RotDiffW.Z = cright.Z * RotDiff.X + cup.Z * RotDiff.Y +  -cdir.Z * RotDiff.Z;    m_Rotation = RotDiffW - (m_Position-m_Target);}

 Diff diff_to_index(Repository const & repo, Tree & t, git_diff_options const & opts) {     git_diff * diff;     auto op_res = git_diff_tree_to_index(&diff, repo.ptr(), t.ptr(), nullptr, &opts);     assert(op_res == 0);     return Diff(diff); }

bool DiffWrapperBase<T, TDiff>::GetElementDiffs(    google::protobuf::RepeatedPtrField<ElementDiff> *dst,    const google::protobuf::RepeatedPtrField<Element> &old_elements,    const google::protobuf::RepeatedPtrField<Element> &new_elements) {  bool differs = false;  assert(dst != nullptr);  int i = 0;  int j = 0;  while (i < old_elements.size() && j < new_elements.size()) {    const Element &old_element = old_elements.Get(i);    const Element &new_element = new_elements.Get(i);    if (Diff(old_element, new_element)) {      ElementDiff *diff = dst->Add();      Element *old_elementp = nullptr;      Element *new_elementp = nullptr;      if (!diff || !(old_elementp = diff->mutable_old()) ||          !(new_elementp = diff->mutable_new_())) {        llvm::errs() << "Failed to add diff element/n";        ::exit(1);      }      *old_elementp = old_element;      *new_elementp = new_element;      diff->set_index(i);      differs = true;    }    i++;    j++;  }  if (old_elements.size() != new_elements.size()) {    GetExtraElementDiffs(dst, i, j, old_elements, new_elements);    differs = true;  }  return differs;}

 Diff diff_index_to_workdir(Repository const & repo, git_diff_options const & opts) {     git_diff * diff;     auto op_res = git_diff_index_to_workdir(&diff, repo.ptr(), nullptr, &opts);     assert(op_res == 0);     return Diff(diff); }

 Matrix<double,ndim,1> Edge::jacobian(const double & t) const {   GeoPoint & a = *M_points[0];   GeoPoint & b = *M_points[1];   GeoPoint Diff(b-a);   return Matrix<double,ndim,1>(Diff[0],Diff[1]); }

// B here is the "reduced" matrix.  Square matrices w/ Row=Domain=Range only.double test_with_matvec_reduced_maps(const Epetra_CrsMatrix &A, const Epetra_CrsMatrix &B, const Epetra_Map & Bfullmap){  const Epetra_Map & Amap  = A.DomainMap();  Epetra_Vector Xa(Amap), Ya(Amap), Diff(Amap);  const Epetra_Map *Bmap  = Bfullmap.NumMyElements() > 0 ? &B.DomainMap() : 0;  Epetra_Vector *Xb = Bmap ? new Epetra_Vector(*Bmap) : 0;  Epetra_Vector *Yb = Bmap ? new Epetra_Vector(*Bmap) : 0;  Epetra_Vector Xb_alias(View,Bfullmap, Bmap ? Xb->Values(): 0);  Epetra_Vector Yb_alias(View,Bfullmap, Bmap ? Yb->Values(): 0);  Epetra_Import Ximport(Bfullmap,Amap);  // Set the input vector  Xa.SetSeed(24601);  Xa.Random();  Xb_alias.Import(Xa,Ximport,Insert);  // Do the multiplies  A.Apply(Xa,Ya);  if(Bmap) B.Apply(*Xb,*Yb);  // Check solution  Epetra_Import Yimport(Amap,Bfullmap);  Diff.Import(Yb_alias,Yimport,Insert);  Diff.Update(-1.0,Ya,1.0);  double norm;  Diff.Norm2(&norm);  delete Xb; delete Yb;  return norm;}

 Diff diff(Repository const & repo, Tree & a, Tree & b, git_diff_options const & opts) {     git_diff * diff;     auto op_res = git_diff_tree_to_tree(&diff, repo.ptr(), a.ptr(), b.ptr(), &opts);     assert(op_res == 0);     return Diff(diff); }

void DiffSideBySidePanel::OnVertical(wxRibbonButtonBarEvent& event){    m_splitter->Unsplit();    m_splitter->SplitVertically(m_splitterPageLeft, m_splitterPageRight);    m_config.SetViewMode(DiffConfig::kViewVerticalSplit);    Diff();}

void DiffSideBySidePanel::OnHorizontal(wxCommandEvent& event){    m_splitter->Unsplit();    m_splitter->SplitHorizontally(m_splitterPageLeft, m_splitterPageRight);    m_config.SetViewMode(DiffConfig::kViewHorizontalSplit);    Diff();}

int main(){    int len = 3000;    gsl_vector *v = gsl_vector_alloc(len);    for (double i=0; i< len; i++) gsl_vector_set(v, i, 1./(i+1));    double square;    gsl_blas_ddot(v, v, &square);    printf("1 + (1/2)^2 + (1/3)^2 + ...= %g/n", square);    double pi_over_six = gsl_pow_2(M_PI)/6.;    Diff(square, pi_over_six);    /* Now using apop_dot, in a few forms.       First, vector-as-data dot itself.       If one of the inputs is a vector,       apop_dot puts the output in a vector-as-data:*/    apop_data *v_as_data = &(apop_data){.vector=v};    apop_data *vdotv = apop_dot(v_as_data, v_as_data);    Diff(gsl_vector_get(vdotv->vector, 0), pi_over_six);    /* Wrap matrix in an apop_data set. */    gsl_matrix *v_as_matrix = apop_vector_to_matrix(v);    apop_data dm = (apop_data){.matrix=v_as_matrix};    // (1 X len) vector dot (len X 1) matrix --- produce a scalar (one item vector).    apop_data *mdotv = apop_dot(v_as_data, &dm);    double scalarval = apop_data_get(mdotv);    Diff(scalarval, pi_over_six);    //(len X 1) dot (len X 1) --- bad dimensions.    apop_opts.verbose=-1; //don't print an error.    apop_data *mdotv2 = apop_dot(&dm, v_as_data);    apop_opts.verbose=0; //back to safety.    assert(mdotv2->error);    // If we want (len X 1) dot (1 X len) --> (len X len),    // use apop_vector_to_matrix.    apop_data dmr = (apop_data){.matrix=apop_vector_to_matrix(v, .row_col='r')};    apop_data *product_matrix = apop_dot(&dm, &dmr);    //The trace is the sum of squares:    gsl_vector_view trace = gsl_matrix_diagonal(product_matrix->matrix);    double tracesum = apop_sum(&trace.vector);    Diff(tracesum, pi_over_six);    apop_data_free(product_matrix);    gsl_matrix_free(dmr.matrix);}

// Find the SnapPoint nearest to time tint SnapManager::Find(double t){   int len = (int)mSnapPoints->GetCount();   int index = Find(t, 0, len);   // At this point, either index is the closest, or the next one   // to the right is.  Keep moving to the right until we get a   // different value   int next = index + 1;   while(next+1 < len && Get(next) == Get(index))      next++;   // Now return whichever one is closer to time t   if (next < len && Diff(t, next) < Diff(t, index))      return next;   else      return index;}

int main(int argc, char *argv[]){  Value I(1), m(4);  for(int a = 0; a < 1000; a++)    m = Diff (I, m);  if (!(m / 4 == I))    abort ();  return 0;}

void DiffSideBySidePanel::OnRefreshDiff(wxCommandEvent& event){    if(m_stcLeft->IsModified() || m_stcRight->IsModified()) {        wxStandardID res = ::PromptForYesNoDialogWithCheckbox(            _("Refreshing the view will lose all your changes/nDo you want to continue?"), "DiffRefreshViewDlg");        if(res != wxID_YES) {            return;        }    }    Diff();}

//return 1 if _cost can be paid with current data, 0 otherwiseint ManaCost::canAfford(ManaCost * _cost){    ManaCost * diff = Diff(_cost);    int positive = diff->isPositive();    delete diff;    if (positive)    {        return 1;    }    return 0;}

double BinaryImage::SSD(const BinaryImage& T){	Matrix Diff(32, 32, 1);	double sum = 0;	for (int i = 0; i < 32; i++)	{		for (int j = 0; j < 32; j++)		{			Diff.Set(i, j, (Get(i, j) - T.Get(i, j)));			sum += Diff.Get(i, j)*Diff.Get(i, j);		}	}	return sum;}

int main(void){	int a = 7;	int b = 6;	printf("a = %d,b = %d",a,b);	a = a^b;	b = a^b;	a = a^b;	printf("a = %d,b = %d",a,b);	int d = Number(11);	int c = Diff(9,6);	printf("c = %d",c);	return 0;}

HRESULT STDMETHODCALLTYPE CPopupMenu::InvokeCommand( __in CMINVOKECOMMANDINFO *pici){	if(HIWORD(((CMINVOKECOMMANDINFOEX *)pici)->lpVerbW)){		return S_OK;	}	else	{		if(1 == LOWORD(pici->lpVerb)){			SetEnv();		}		else if(2 == LOWORD(pici->lpVerb)){			Update();		}		else if(3 == LOWORD(pici->lpVerb)){			Checkout();		}		else if(4 == LOWORD(pici->lpVerb)){			Commit();		}		else if(5 == LOWORD(pici->lpVerb)){			Checkin();		}		else if(6 == LOWORD(pici->lpVerb)){			Cancel();		}		else if(7 == LOWORD(pici->lpVerb)){			Add();		}		else if(8 == LOWORD(pici->lpVerb)){			Revert();		}		else if(9 == LOWORD(pici->lpVerb)){			Merge();		}		else if(10 == LOWORD(pici->lpVerb)){			ShowLog();		}		else if(11 == LOWORD(pici->lpVerb)){			Diff();		}		else if(12 == LOWORD(pici->lpVerb)){			Compare();		}		else if(13 == LOWORD(pici->lpVerb)){			UpdateRelyFiles();		}	}	return S_OK;}

 void OnConnect() {   gettime(&m_connect, NULL);   m_b_active = true;   {     double tconnect = Diff(m_create, m_connect);     //     g_min_time = tconnect < g_min_time ? tconnect : g_min_time;     g_max_time = tconnect > g_max_time ? tconnect : g_max_time;     g_tot_time += tconnect;     g_ant += 1;   }   SendBlock();   m_b_client = true; }

int ManaCost::pay(ManaCost * _cost){    int result = MANA_PAID;    ManaCost * toPay = NEW ManaCost();    toPay->copy(_cost);    ManaCost * diff = Diff(toPay);    for (int i = 0; i < Constants::NB_Colors; i++)    {        cost[i] = diff->getCost(i);    }    delete diff;    delete toPay;    return result;    //TODO return 0 if can't afford the cost!}

int main(){#ifndef _WIN32	Mutex mutex;	Semaphore sema(1);	struct timeval start;	struct timeval tt;	double d;	Utility::GetTime(&start);	for (int i = 0; i < 100000; i++)		lock(mutex, i);	Utility::GetTime(&tt);	d = Diff(start, tt);	printf("%.4f sec/n", d);	Utility::GetTime(&start);	for (int i = 0; i < 100000; i++)		lock(sema, i);	Utility::GetTime(&tt);	d = Diff(start, tt);	printf("%.4f sec/n", d);#endif}

  void OnContent() {//    std::cout << GetContentLength() << std::endl;    gettime(&m_reply, NULL);    {      double treply = Diff(m_send, m_reply);      //      g_min_time2 = treply < g_min_time2 ? treply : g_min_time2;      g_max_time2 = treply > g_max_time2 ? treply : g_max_time2;      g_tot_time2 += treply;      g_ant2 += 1;    }    gBytesIn += GetBytesReceived(true);    gBytesOut += GetBytesSent(true);    CreateNew();  }

void SRKIICalc(double AL, double AConst, double K,double Rx,iol_formula* SRKIIValues){  double i;  double Emmetropia, Emmetropia_Rounded,Emmetropia_New,CR,REFR1;  double Diff_In_Emmetropia, Diff_Add;  double REFR;  int Loop;  printf("/r/nSRK II/n");  if (AL < 20.0)   AConst = AConst + 3;  else if ((AL >= 20.0) & (AL < 21.0))   AConst = AConst + 2;  else if ((AL >= 21.0) & (AL < 22.0))   AConst = AConst + 1;  else if ((AL >= 22) & (AL < 24.5))   AConst = AConst;  else if (AL >= 24.5)   AConst = AConst - 0.5;  Emmetropia = AConst - (0.9 * K) - (2.5 * AL);  SRKIIValues->PEMM = Emmetropia;  Emmetropia_Rounded = floor(Emmetropia);  Diff_In_Emmetropia = Emmetropia - Emmetropia_Rounded;  if (Emmetropia < 14.0)   CR = 1.0;  else if (Emmetropia >= 14.0)   CR = 1.25;  Diff_Add = Diff(Diff_In_Emmetropia);  Emmetropia_New = Emmetropia_Rounded + Diff_Add;  Diff_In_Emmetropia = Emmetropia - Emmetropia_New;  REFR1 = Diff_In_Emmetropia / CR;  Loop=0;  for (i = Emmetropia_New - 1.0; i <= Emmetropia_New + 1.0; i = i + 0.5)   {    REFR = (REFR1 + (Emmetropia_New - i) / CR);	SRKIIValues->PORx[Loop] = REFR;    SRKIIValues->IOLPower[Loop] = i;//	printf("/r/n%5.2f,%5.2f",SRKIIValues->IOLPower[Loop],SRKIIValues->PORx[Loop]);	Loop++; } //printf("/r/n");}

void Life::tick(){    if( running && has_focus )    {        if( sec_scope.nextScope_skip() )        {            speed=Diff(step_number,map.getStepNumber());        }        if( divider.tick() )        {            map.step();            redraw();        }    }}