源代码 数字和字符的比较

最新推荐文章于 2022-09-11 14:22:56 发布
最新推荐文章于 2022-09-11 14:22:56 发布
阅读量1.3k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 源代码 文章标签： 源代码 类 cstring iterator 对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/biggbang/article/details/24310129

Compare.h

GEOMETRIC_BEGIN

/*! \fn
* 函数功能：判断字符串是否一个合法的数字(包括科学记数法形式) \n 
* 输入参数：const CString &numStr, int* pStatus = NULL \n
* 输出参数：int* pStatu  \n
* 返 回 值：int型变量 0，表示是一个数字；非0 为出错位置 ；\n 
*/
GEOMETRIC_EXT int IsNotLegalNum(const CString &numStr, int* pStatus = NULL);
/*! \fn
* 函数功能：不区分大小写比较2字符串
* 输入参数：lhs,rhs-需比较的字符串
* 输出参数：void
* 返 回 值：2字符完全相同，返回0；如果lhs中有字符在rhs的前面，则返回-1，否则返回1 
*/
GEOMETRIC_EXT inline int Cmp_NoCase(const CString& lhs,const CString& rhs);

/*! \fn
* 函数功能：判断矢量是否在-pi与pi之间 \n
* 输入参数：double x, double y, double startAng, double endAng (要求startAng, endAng在(-PI, PI]之间) \n
* 输出参数：无 \n
* 返 回 值：TRUE or FALSE \n
*/
GEOMETRIC_EXT bool IsVectorBetweenRadAngs(double x, double y, double startAng, double endAng);

/*! \fn
* 函数功能：判断角度是否落在一个扇形区域内 \n
* 输入参数：angle:需判断的角度, startAng:扇区起始角度,
*              sweepAng:扫过的角度(-2PI~2PI,正时为逆时针， 为负时表示顺时针)\n
*             要求angle,startAng在[-PI,PI]之间
* 输出参数：无 \n
* 返 回 值：TRUE or FASLE \n
*/
GEOMETRIC_EXT bool IsAngleInSector(double angle, double startAng, double sweepAng);
/*!<把角度规范化到[0,2PI)之间*/ 
GEOMETRIC_EXT double NormalizeAngle(double angle);
/*!< 和自己比较取小值*/ 
template<class _Ty> inline void MinSelf(_Ty &self,const _Ty &comp) { self = min(self,comp); }
/*!<和自己比较取大值*/ 
template<class _Ty> inline void MaxSelf(_Ty &self,const _Ty &comp) { self = max(self,comp); }


//////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////// 浮点数比较 /////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
template<typename Real> inline bool Compare(const Real val1, const Real val2) { return fabs(val2-val1) < FLT_MIN_VALUE; }
// a==b
 GEOMETRIC_EXT inline bool Equal2Dbl(double val1,double val2=0) { return fabs(val2-val1) < MIN_VALUE; }
// a==b with precision
 GEOMETRIC_EXT inline bool Equal2DblEx(double val1,double val2,double dEps=MIN_VALUE) {	return fabs(val2-val1) < dEps; }
// a!=b
 GEOMETRIC_EXT inline bool DblNotEqual(double a,double b,double dEps=MIN_VALUE) { return !Equal2DblEx(a, b, dEps); }
// a<b
 GEOMETRIC_EXT inline bool DblLT(double a,double b,double dEps=MIN_VALUE) { return DblNotEqual(a, b,dEps) && (a<b);}
// a<=b
 GEOMETRIC_EXT inline bool DblLE(double a,double b,double dEps=MIN_VALUE) { return Equal2DblEx(a, b,dEps)||DblLT(a, b);}
// a>b
 GEOMETRIC_EXT inline bool DblGT(double a,double b,double dEps=MIN_VALUE) { return DblNotEqual(a, b,dEps) && (a>b);}
// a>=b
 GEOMETRIC_EXT inline bool DblGE(double a,double b,double dEps=MIN_VALUE) { return Equal2DblEx(a, b,dEps) || DblGT(a, b);}

 GEOMETRIC_EXT inline bool EqualToPairDbl(const pair<double,double> &pairobj1,const pair<double,double> &pairobj2)
{
	return (Equal2Dbl(pairobj1.first,pairobj2.first) && Equal2Dbl(pairobj1.second,pairobj2.second));
}
 GEOMETRIC_EXT inline bool EqualToPairCStr(const pair<CString,CString> &pairobj1,const pair<CString,CString> &pairobj2)
{
	return (pairobj1.first == pairobj2.first) && (pairobj1.second == pairobj2.second);
}
 GEOMETRIC_EXT inline bool EqualToPairDword(const pair<DWORD,DWORD> &pairobj1,const pair<DWORD,DWORD> &pairobj2)
{
	return (pairobj1.first == pairobj2.first) && (pairobj1.second == pairobj2.second);
}
 GEOMETRIC_EXT inline bool EqualToPairIntDbl(const pair<int,double> &pairobj1,const pair<int,double> &pairobj2)
{
	return (pairobj1.first != pairobj2.first && Equal2Dbl(pairobj1.second,pairobj2.second));
}
 GEOMETRIC_EXT inline bool Equal2vctDbl(const vctDbl& val1,const vctDbl& val2)
{
	if(val1.size()!=val2.size()) return false;

	bool bRst=equal(val1.begin(),val1.end(),val2.begin(),Equal2Dbl);
	return bRst;
}
 GEOMETRIC_EXT inline bool EqualToVectorPairDbl(const std::vector<pair<double,double>>& vctobj1,const vector<pair<double,double>>& vctobj2)
{
	std::vector<pair<double,double>>::const_iterator vit1 = vctobj1.begin();
	std::vector<pair<double,double>>::const_iterator vit2 = vctobj2.begin();

	while(vit1 != vctobj1.end() && vit2 != vctobj2.end())
	{
		if(!EqualToPairDbl(*(vit1),*(vit2)))
			break;
		++vit1;
		++vit2;
	}

	return (vit1==vctobj1.end() && vit2==vctobj2.end());
}
 GEOMETRIC_EXT inline bool EqualToVectorPairCStr(const std::vector<pair<CString,CString>>& vctobj1,const vector<pair<CString,CString>>& vctobj2)
{
	std::vector<pair<CString,CString>>::const_iterator vit1 = vctobj1.begin();
	std::vector<pair<CString,CString>>::const_iterator vit2 = vctobj2.begin();

	while(vit1 != vctobj1.end() && vit2 != vctobj2.end())
	{
		if(!EqualToPairCStr(*(vit1),*(vit2)))
			break;
		++vit1;
		++vit2;
	}

	return (vit1==vctobj1.end() && vit2==vctobj2.end());
}
 GEOMETRIC_EXT inline bool EqualToVectorIntDbl(const std::vector<pair<int,double>>& vctobj1,const vector<pair<int,double>>& vctobj2)
{
	std::vector<pair<int,double>>::const_iterator vit1 = vctobj1.begin();
	std::vector<pair<int,double>>::const_iterator vit2 = vctobj2.begin();

	while(vit1 != vctobj1.end() && vit2 != vctobj2.end())
	{
		if(!EqualToPairIntDbl(*(vit1),*(vit2)))
			break;
		++vit1;
		++vit2;
	}

	return (vit1==vctobj1.end() && vit2==vctobj2.end());
}
 GEOMETRIC_EXT inline bool EqualToMapPairDbl(const map<UINT,pair<double,double>>& mapobj1,const map<UINT,pair<double,double>>& mapobj2)
{
	std::map<UINT,pair<double,double>>::const_iterator mit1 = mapobj1.begin();
	std::map<UINT,pair<double,double>>::const_iterator mit2 = mapobj2.begin();

	while(mit1 != mapobj1.end() && mit2 != mapobj2.end())
	{
		if(!(mit1->first == mit2->first))
			break;
		if(!EqualToPairDbl(mit1->second,mit2->second))
			break;
		++mit1;
		++mit2;
	}

	return (mit1==mapobj1.end() && mit2==mapobj2.end());
}
 GEOMETRIC_EXT inline bool EqualToMapPairCStr(const map<CString,pair<CString,CString>>& mapobj1,const map<CString,pair<CString,CString>>& mapobj2)
{
	std::map<CString,pair<CString,CString>>::const_iterator mit1 = mapobj1.begin();
	std::map<CString,pair<CString,CString>>::const_iterator mit2 = mapobj2.begin();

	while(mit1 != mapobj1.end() && mit2 != mapobj2.end())
	{
		if(!(mit1->first == mit2->first))
			break;
		if(!EqualToPairCStr(mit1->second,mit2->second))
			break;
		++mit1;
		++mit2;
	}

	return (mit1==mapobj1.end() && mit2==mapobj2.end());
}
 GEOMETRIC_EXT inline bool EqualToMapPairDword(const map<UINT,std::pair<DWORD,DWORD>>& mapobj1,const map<UINT,std::pair<DWORD,DWORD>>& mapobj2)
{
	std::map<UINT,std::pair<DWORD,DWORD>>::const_iterator mit1 = mapobj1.begin();
	std::map<UINT,std::pair<DWORD,DWORD>>::const_iterator mit2 = mapobj2.begin();

	while(mit1 != mapobj1.end() && mit2 != mapobj2.end())
	{
		if(!(mit1->first == mit2->first))
			break;
		if(!(EqualToPairDword(mit1->second,mit2->second)))
			break;
		++mit1;
		++mit2;
	}

	return (mit1==mapobj1.end() && mit2==mapobj2.end());
}
 GEOMETRIC_EXT inline bool EqualToMapVectorPairDbl(const map<int,vector<pair<double,double>>>& mapobj1,const map<int,vector<pair<double,double>>>& mapobj2)
{
	std::map<int,vector<pair<double,double>>>::const_iterator mit1 = mapobj1.begin();
	std::map<int,vector<pair<double,double>>>::const_iterator mit2 = mapobj2.begin();

	while(mit1 != mapobj1.end() && mit2 != mapobj2.end())
	{
		if(!(mit1->first == mit2->first))
			break;
		if(!EqualToVectorPairDbl(mit1->second,mit2->second))
			break;
		++mit1;
		++mit2;
	}

	return (mit1==mapobj1.end() && mit2==mapobj2.end());
}

/*!<比较两个vector类对象指针形式存在时是否相等*/ 
template<class T> inline bool EqualToVectorEX(const std::vector<T>& vctobj1,const std::vector<T>& vctobj2)
{
	vector<T>::const_iterator vit1 = vctobj1.begin();
	vector<T>::const_iterator vit2 = vctobj2.begin();

	while(vit1 != vctobj1.end() && vit2 != vctobj2.end())
	{
		if(!(*(*vit1) == *(*vit2)))
			break;
		++vit1;
		++vit2;
	}

	return (vit1==vctobj1.end() && vit2==vctobj2.end());
}

inline bool EqualToVectorDbl(const std::vector<double>& vctobj1,const std::vector<double>& vctobj2)
{
	vector<double>::const_iterator vit1 = vctobj1.begin();
	vector<double>::const_iterator vit2 = vctobj2.begin();

	while(vit1 != vctobj1.end() && vit2 != vctobj2.end())
	{
		if(!Equal2Dbl(*(vit1),*(vit2)))
			break;
		++vit1;
		++vit2;
	}

	return (vit1==vctobj1.end() && vit2==vctobj2.end());
}

/*!<比较两个list类对象指针形式存在时是否相等*/ 
template<class T> inline bool EqualToListEX(const std::list<T>& lstobj1,const std::list<T>& lstobj2)
{
	list<T>::const_iterator lit1 = lstobj1.begin();
	list<T>::const_iterator lit2 = lstobj2.begin();

	while(lit1 != lstobj1.end() && lit2 != lstobj2.end())
	{
		if(!(*(*lit1) == *(*lit2)))
			break;
		++lit1;
		++lit2;
	}

	return (lit1==lstobj1.end() && lit2==lstobj2.end());
}
//!map<UINT,Class T> 类型判断相等
template<typename _Ty,class T> inline bool EqualToMapEX(const std::map<_Ty,T>& mapobj1,const std::map<_Ty,T>& mapobj2)
{
	std::map<_Ty,T>::const_iterator vit1 = mapobj1.begin();
	std::map<_Ty,T>::const_iterator vit2 = mapobj2.begin();

	while(vit1 != mapobj1.end() && vit2 != mapobj2.end())
	{
		if(!(vit1->first == vit2->first))
			break;
		if(!(*(vit1->second) == *(vit2->second)))
			break;
		++vit1;
		++vit2;
	}

	return (vit1==mapobj1.end() && vit2==mapobj2.end());
}
template<typename _Tx,class _Ty> inline bool EqualToMap(const std::map<_Tx,_Ty>& mapobj1,const std::map<_Tx,_Ty>& mapobj2)
{
	std::map<_Tx,_Ty>::const_iterator vit1 = mapobj1.begin();
	std::map<_Tx,_Ty>::const_iterator vit2 = mapobj2.begin();

	while(vit1 != mapobj1.end() && vit2 != mapobj2.end())
	{
		if(!(vit1->first == vit2->first))
			break;
		if(!(vit1->second == vit2->second))
			break;
		++vit1;
		++vit2;
	}

	return (vit1==mapobj1.end() && vit2==mapobj2.end());
}
template<class _Ty> inline bool EqualToVector(const std::vector<_Ty>& vctobj1,const std::vector<_Ty>& vctobj2)
{
	if(vctobj1.size()!=vctobj2.size())
		return false;

  std::vector<_Ty>::const_iterator vit1 = vctobj1.begin();
  std::vector<_Ty>::const_iterator vit2 = vctobj2.begin();

  while(vit1 != vctobj1.end() && vit2 != vctobj2.end())
  {
    if(!(*vit1 == *vit2))
      break;
    ++vit1;
    ++vit2;
  }

  return (vit1==vctobj1.end() && vit2==vctobj2.end());
}
template<typename _Kty,typename _Ty> inline bool EqualToMapVetorEx(const std::map<_Kty, std::vector<_Ty*> >& mapTs1,const std::map<_Kty, std::vector<_Ty*> >& mapTs2)
{
	std::map<_Kty, std::vector<_Ty*> >::const_iterator vit1 = mapTs1.begin();
	std::map<_Kty, std::vector<_Ty*> >::const_iterator vit2 = mapTs2.begin();

	while(vit1 != mapTs1.end() && vit2 != mapTs2.end())
	{
		if(!(vit1->first == vit2->first))
			break;

		if(!EqualToVectorEX(vit1->second,vit2->second))
			break;
		++vit1;
		++vit2;
	}

	return (vit1==mapTs1.end() && vit2==mapTs2.end());
}
template<typename _Kty,typename _Ty> inline bool EqualToMapVetorEx(const std::map<_Kty, std::vector<_Ty> >& mapTs1,const std::map<_Kty, std::vector<_Ty> >& mapTs2)
{
  std::map<_Kty, std::vector<_Ty> >::const_iterator vit1 = mapTs1.begin();
  std::map<_Kty, std::vector<_Ty> >::const_iterator vit2 = mapTs2.begin();

  while(vit1 != mapTs1.end() && vit2 != mapTs2.end())
  {
    if(!(vit1->first == vit2->first))
      break;

    if(!EqualToVector(vit1->second,vit2->second))
      break;
    ++vit1;
    ++vit2;
  }

  return (vit1==mapTs1.end() && vit2==mapTs2.end());
}
/*! \fn
* 函数功能：判断两个点是否相同 \n 
* 输入参数：const McGePoint2d& val1,const McGePoint2d& val2 \n
* 输出参数：bool型变量 \n 
* 返 回 值：TRUEorFALSE \n 
*/
 GEOMETRIC_EXT inline bool Equal2Point(const McGePoint2d& val1,const McGePoint2d& val2)
{
	return val1==val2;
}

 GEOMETRIC_EXT bool  Equal2vctPoints(const vctMcGePoint2ds& points1, const vctMcGePoint2ds& points2);
/*! \fn
* 函数功能：判断两个点是否相同 可以设置精度 \n 
* 输入参数：const McGePoint2d& val1,const McGePoint2d& val2 \n
* 输出参数：bool型变量 \n 
* 返 回 值：TRUEorFALSE \n 
*/
 GEOMETRIC_EXT inline bool Equal2PointEx(const McGePoint2d& val1,const McGePoint2d& val2,double dEps=MIN_VALUE)
{
	if (!Equal2DblEx(val1.GetX(), val2.GetX(), dEps))
		return false;
	if (!Equal2DblEx(val1.GetY(), val2.GetY(), dEps))
		return false;

	return true;
}

/*! \fn
* 函数功能：判断两个点组是否相同 \n 
* 输入参数：const vctMcGePoint2ds& val1,const vctMcGePoint2ds& val2 \n
* 输出参数：bool型变量 \n
* 返 回 值：TRUEorFALSE \n 
*/
 GEOMETRIC_EXT inline bool Equal2vctPoint(const vctMcGePoint2ds& val1,const vctMcGePoint2ds& val2)
{
	if(val1.size()!=val2.size())
		return false;

	bool bRst=equal(val1.begin(),val1.end(),val2.begin(),Equal2Point);
	return bRst;
}

 GEOMETRIC_EXT inline bool Equal2Polyline(const McGePolyline2d& val1,const McGePolyline2d& val2)
{
	return val1==val2;
}

 GEOMETRIC_EXT inline bool Equal2vctPolyline(const vector<McGePolyline2d>& val1,const vector<McGePolyline2d>& val2)
{
	if(val1.size()!=val2.size())
		return false;

	bool bRst=equal(val1.begin(),val1.end(),val2.begin(),Equal2Polyline);
	return bRst;
}

/*! \class: McGePoint2d_LessX
* 功能说明：用于排序点，按X坐标从小到大\n
* 编 制 者：echo     完 成  日 期： 2007-7-17 16:44:04 \n
* 修 改 者：echo     最后修改日期： -  - \n
* 历史记录：V 00.00.00 (每次修改升级最后一个数字)  \n
*/

class  GEOMETRIC_EXT McGePoint2d_LessX //用于排序点，按X坐标从小到大
:public binary_function<McGePoint2d,McGePoint2d,bool>
{
public:
	bool operator ()(const McGePoint2d& pt1,const McGePoint2d& pt2) const
	{			
		if(Equal2Dbl(pt1.x,pt2.x))
		{
			if(pt1.y<pt2.y)
				return true;
			else
				return false;
		}
		else
		{
			if(pt1.x < pt2.x)
				return pt1.x < pt2.x;
			else
				return false;	
		}
				
	}

	~McGePoint2d_LessX(void){};
	McGePoint2d_LessX(void){};
};

class  GEOMETRIC_EXT McGePoint2d_LessXGreatY //用于排序点，按X坐标从小到大,Y从大到小
	:public binary_function<McGePoint2d,McGePoint2d,bool>
{
public:
	bool operator ()(const McGePoint2d& pt1,const McGePoint2d& pt2) const
	{			
		if(Equal2Dbl(pt1.x,pt2.x))
		{
			if(DblGT(pt1.y,pt2.y))
				return true;
			else
				return false;
		}
		else
		{
			if(DblLT(pt1.x,pt2.x))
				return true;
			else
				return false;
		}
	}

	~McGePoint2d_LessXGreatY(void){};
	McGePoint2d_LessXGreatY(void){};
};

/*! \class: McGePoint2d_LessY
* 功能说明：用于排序点，按Y坐标从小到大 \n
* 编 制 者：echo     完 成  日 期： 2007-7-17 16:44:41 \n
* 修 改 者：echo     最后修改日期： -  - \n
* 历史记录：V 00.00.00 (每次修改升级最后一个数字)  \n
*/
class  GEOMETRIC_EXT McGePoint2d_LessY //用于排序点，按Y坐标从小到大
:public binary_function<McGePoint2d,McGePoint2d,bool>
{
public:
	bool operator ()(const McGePoint2d& pt1,const McGePoint2d& pt2) const
	{	
		if(Equal2Dbl(pt1.y,pt2.y)) //相等
		{
			if(pt1.x<pt2.x)
				return true;
			else
				return false;	
		}		
		else
		{
			if(pt1.y < pt2.y)
				return true;
			else
				return false;
		}	
	}
	~McGePoint2d_LessY(void){};
	McGePoint2d_LessY(void){};
};
class /* GEOMETRIC_EXT*/ McGePoint2d_GreaterX //用于排序点，按X坐标从大到小
{
public:
	bool operator ()(const McGePoint2d& pt1,const McGePoint2d& pt2) const
	{			
		if(Equal2Dbl(pt1.x,pt2.x))
		{
			return pt1.y > pt2.y;
		}
		else
		{
			return pt1.x > pt2.x;
		}
	}

	~McGePoint2d_GreaterX(void){};
	McGePoint2d_GreaterX(void){};
};

/*! \class: McGePoint2d_LessY()
* 功能说明：用于排序点，按Y坐标从大到小 \n
* 编 制 者：echo     完 成  日 期： 2007-7-17 16:44:41 \n
* 修 改 者：echo     最后修改日期： -  - \n
* 历史记录：V 00.00.00 (每次修改升级最后一个数字)  \n
*/
class /* GEOMETRIC_EXT*/ McGePoint2d_GreaterVertexY //用于排序点，按Y坐标从大到小
{
public:
	bool operator ()(const CVertex2d& pt1,const CVertex2d& pt2) const
	{	
		if(Equal2Dbl(pt1.m_pt.y,pt2.m_pt.y)) //相等
		{
			return (pt1.m_pt.x > pt2.m_pt.x);
		}		
		else
		{
			return(pt1.m_pt.y > pt2.m_pt.y);
		}	
	}
	~McGePoint2d_GreaterVertexY(void){};
	McGePoint2d_GreaterVertexY(void){};
};

/*! \class: McGePoint2d_LessY()
* 功能说明：用于排序点，按Y坐标从大到小 \n
* 编 制 者：hbq     完 成  日 期： 2014年3月10日11:36:28 \n
* 修 改 者：hbq     最后修改日期： -  - \n
* 历史记录：V 00.00.00 (每次修改升级最后一个数字)  \n
*/
class /* GEOMETRIC_EXT*/ McGePoint2d_GreaterY //用于排序点，按Y坐标从大到小
{
public:
	bool operator ()(const McGePoint2d& pt1,const McGePoint2d& pt2) const
	{	
		if(Equal2Dbl(pt1.y,pt2.y)) //相等
		{
			return (pt1.x > pt2.x);
		}		
		else
		{
			return(pt1.y > pt2.y);
		}	
	}
	~McGePoint2d_GreaterY(void){};
	McGePoint2d_GreaterY(void){};
};

/*! \class: McGePoint2d_EQ
* 功能说明：用于比较点是否相等                            \n
* 编 制 者：echo     完 成  日 期： 2007-7-17 16:45:00 \n
* 修 改 者：echo     最后修改日期： -  - \n
* 历史记录：V 00.00.00 (每次修改升级最后一个数字)  \n
*/
class  GEOMETRIC_EXT McGePoint2d_EQ //用于比较点是否相等
{
public:	
	explicit McGePoint2d_EQ(const McGePoint2d& pt1,double dPrecision=MIN_VALUE):m_pt(pt1),m_dPrecision(dPrecision){}
	bool operator()(const McGePoint2d& pt2)
	{
		double dDist=(pt2.x-m_pt.x)*(pt2.x-m_pt.x)+(pt2.y-m_pt.y)*(pt2.y-m_pt.y);
		if(dDist<=m_dPrecision*m_dPrecision)
			return true;
		else 
			return false;
	}
	~McGePoint2d_EQ(void){};
private:
	McGePoint2d_EQ(void){};
	McGePoint2d m_pt;
	double m_dPrecision;
};

class  GEOMETRIC_EXT McGePoint2d_EQ_X //用于比较点X坐标是否相等
{
public:	
	explicit McGePoint2d_EQ_X(const McGePoint2d& pt1,double dPrecision=MIN_VALUE):m_pt(pt1),m_dPrecision(dPrecision){}
	bool operator()(const McGePoint2d& pt2)
	{
		return Equal2DblEx(m_pt.x, pt2.x, m_dPrecision);	
	}
	~McGePoint2d_EQ_X(void){};
private:
	McGePoint2d_EQ_X(void){};
	McGePoint2d m_pt;
	double m_dPrecision;
};

/*! \class: McGePoint2d_LessX
* 功能说明：用于排序点，按X坐标从小到大\n
* 编 制 者：echo     完 成  日 期： 2007-7-17 16:44:04 \n
* 修 改 者：echo     最后修改日期： -  - \n
* 历史记录：V 00.00.00 (每次修改升级最后一个数字)  \n
*/

class  GEOMETRIC_EXT McGePoint2d_UNIQUE_EQ_X //用于排序点，按X坐标从小到大
	:public binary_function<McGePoint2d,McGePoint2d,bool>
{
public:
	bool operator ()(const McGePoint2d& pt1,const McGePoint2d& pt2) const
	{			
		if(Equal2Dbl(pt1.x,pt2.x))
		{
			return true;
		}
		else
		{
			return false;	
		}

	}

	~McGePoint2d_UNIQUE_EQ_X(void){};
	McGePoint2d_UNIQUE_EQ_X(void){};
};

class  GEOMETRIC_EXT McGePoint2d_EQ_Y //用于比较点Y坐标是否相等
{
public:	
	explicit McGePoint2d_EQ_Y(const McGePoint2d& pt1,double dPrecision=MIN_VALUE):m_pt(pt1),m_dPrecision(dPrecision){}
	bool operator()(const McGePoint2d& pt2)
	{
		return Equal2DblEx(m_pt.y, pt2.y, m_dPrecision);	
	}
	~McGePoint2d_EQ_Y(void){};
private:
	McGePoint2d_EQ_Y(void){};
	McGePoint2d m_pt;
	double m_dPrecision;
};

/*! \class: McGePoint2d_assignX
* 功能说明：改变点的X坐标                            \n
* 编 制 者：echo     完 成  日 期： 2007-7-17 16:45:15 \n
* 修 改 者：echo     最后修改日期： -  - \n
* 历史记录：V 00.00.00 (每次修改升级最后一个数字)  \n
*/
class  GEOMETRIC_EXT McGePoint2d_assignX //! 改变点的X坐标
{
public:
	explicit McGePoint2d_assignX(double x) : m_x(x){}
	McGePoint2d operator() (const McGePoint2d &pt)
	{
		return McGePoint2d(m_x,pt.y);
	}
private:
	double m_x;
};

/*! \class: McGePoint2d_assignY
* 功能说明：改变点的Y坐标                            \n
* 编 制 者：echo     完 成  日 期： 2007-7-17 16:45:36 \n
* 修 改 者：echo     最后修改日期： -  - \n
* 历史记录：V 00.00.00 (每次修改升级最后一个数字)  \n
*/
class  GEOMETRIC_EXT McGePoint2d_assignY //! 改变点的Y坐标
{
public:
	explicit McGePoint2d_assignY(double y) : m_y(y){}
	McGePoint2d operator() (const McGePoint2d &pt)
	{
		return McGePoint2d(pt.x,m_y);
	}
private:
	double m_y;
};

class  GEOMETRIC_EXT CDouble_EQ //用于比较点是否相等
{
public:	
	explicit CDouble_EQ(double dSrc,double dPrecision=MIN_VALUE):m_dSrc(dSrc),m_dPrecision(dPrecision){}
	bool operator()(double dDect)
	{
		return Equal2Dbl(dDect,m_dSrc);	
	}
	~CDouble_EQ(void){};
private:
	CDouble_EQ(void){};
	double m_dSrc;
	double m_dPrecision;
};


_ GEOMETRIC_END



Compare.cpp


double NormalizeAngle(double angle)
{
	if(angle > 2*M_PI) {
		angle -= 2*M_PI;
	} else if(angle < 0) {
		angle += 2*M_PI;
	}
	return angle;
}

// 把angle,startAng化到[0, 2*pi)之间
bool IsAngleInSector(double angle, double startAng, double sweepAng)
{
	startAng = NormalizeAngle(startAng);
	double endAng = NormalizeAngle(startAng + sweepAng);
	angle = NormalizeAngle(angle);
	bool bInSector = angle>startAng && angle<endAng ;
	//! 扫描角度为负时
	if(sweepAng < 0) bInSector = !bInSector;

	//! 当角度等于起始角度时
	if(Equal2Dbl(angle, startAng) || Equal2Dbl(angle, endAng))
		bInSector = true;
	return bInSector;
}

bool  Equal2vctPoints(const vctMcGePoint2ds& points1, const vctMcGePoint2ds& points2)
{
	if(points1.size()!=points2.size())
		return false;

	vector<McGePoint2d>::const_iterator pIter;
	for(vector<McGePoint2d>::const_iterator pIt=points1.begin();pIt!=points1.end();++pIt)
	{
		pIter=find_if(points2.begin(),points2.end(),McGePoint2d_EQ(*pIt));
		if(pIter==points2.end())
			return false;
	}

	for(vector<McGePoint2d>::const_iterator pIt=points2.begin();pIt!=points2.end();++pIt)
	{
		pIter=find_if(points1.begin(),points1.end(),McGePoint2d_EQ(*pIt));
		if(pIter==points1.end())
			return false;
	}

	return true;
}

////要求startAng, endAng在(-180, 180]之间
//bool IsVectorBetweenDegAngs(double x, double y, double startAng, double endAng)
//{
//	double angle = atan2(y, x);
//	angle *= 180. / M_PI;
//	if((angle >= startAng && angle <= endAng) ||
//		startAng > endAng && (angle >= startAng || angle <= endAng))
//		return TRUE;
//	return FALSE;
//}



GEOMETRIC_END


Python 编程1000例(4)：比较数字和字符串大小
棒棒编程修炼场
01-19 5247
文章目录一、比较数字大小二、比较字符串大小三、统计和筛选学生成绩 本系列文章通过 1000（一篇文章表示 1 个实例） 个实例 ，为读者提供较为详细的练习题目，以便读者举一反三，深度学习。本系列的文章涉及到 Python 知识点包括：Python 语言基础、运算符和表达式、语句和程序结构、列表和元组、字典和集合、字符串、正则表达式、函数、面向对象编程、模块和包、异常处理和程序调试、文件和目录操作、数据库编程、界面编程、网络编程、WEB 编程、进程和线程、网络爬虫、游戏编程等知识点，由易到难，由浅入深，一步步
类模板编程示例一
曾今沧海难为水，除却巫山不是云。
08-28 547
allege.h头文件 #ifndef _ALLEGE_H #define _ALLEGE_H #include #include #include inline void allege_error(int arg,const char* msg) { if (!arg) { fprintf(stderr,"error: %s\n",msg); #ifdef
Javascript 数字比较
点滴的积累，让自己成长
01-05 195
Javascript 数字比较 收藏 function compareNumber(data1, data2) { //假设data1 and data2 是text 对象 if(Number(data1.value))&gt;Number(data1.value))){ alert("data1对象的值大于data12对象的值") }el...
数字验证码源代码
Zhangyt__的博客
11-07 780
package com.neuedu.action;import java.awt.Color; import java.awt.Graphics; import java.awt.image.BufferedImage; import java.io.IOException; import java.io.OutputStream; import java.util.Random;imp
数字频率c语言程序源代码,用AT89C51制作八位数字频率计源程序
weixin_28040125的博客
05-25 691
ORG 00H ；指定下条指令的地址AJMP MAIN ；跳转至MAIN50MINC 23HRETIORG 001BH ；定时器T1中断入口，T1作定时，T0作计数PUSH A ；累加器A压入堆栈PUSH PSW...
源码、反码、补码（超详细解析）
热门推荐
weixin_45031801的博客
09-11 1万+
在现代的计算机中主要采用的数字集成电路完成，数字电路通过高低电平只能表示0和1，所以就出现了，计算机只会识别0和1。无论是存储还是计算，计算机均采用二进制体系完成。例如：十进制---------- 用二进制表示为。
【Python项目源代码】DIY字符画（附程序使用说明+配置文件）.zip
07-11
除了字符画程序，该压缩包中还可能包含了其他类型的Python项目，如管理系统和小游戏的源代码。管理系统可能涉及数据库操作、用户界面设计和业务逻辑处理，使用Python的Flask、Django等Web框架实现。这些项目的源代码...
判断输入数字、字符的实例，VB源代码.rar
07-09
Vb判断输入数字、字符的方法及例子，本文本框是只允许输入数字的，如果你输入了其它类型或是混杂有其它类型的字符，那么后面的文本框会适时给出提示，告诉你输入有误。虽然是简单的小例子，但却是挺实用的，特别是对...
易语言源代码_限制字符输入例程.zip
最新发布
10-18
这个“易语言源代码_限制字符输入例程.zip”压缩包文件包含了关于如何在易语言中实现字符输入限制的源代码示例。我们将深入探讨这个例程，了解其工作原理以及如何应用。 首先，易语言的核心概念是“表意编程”，它...
Visual Studio开发环境下C++文件读取，字符串复杂处理源代码
02-25
Visual Studio开发环境下C++字符串复杂处理源代码 基本功能：该程序可以从TXT文件中逐行读取文件名，然后逐个打开每个文件名，再从每个文件中逐行读取字符串，读取字符串中对字符串中的数字字母符合等进行自动删除后...
探索猜数字游戏：字符界面与GUI界面源代码解析
在这个例子中，源代码文件的名称为“GuessNumber”，它包含了实现猜数字游戏逻辑的所有指令和数据定义。理解源代码对于维护和修改程序至关重要。 6. 文件名“GuessNumber”： 该文件名表明游戏程序的主文件名是...
php中的数值型字符串相加 相比较(> < ==)
kbx8916的博客
10-13 4945
一。php中数值型字符串相加 1.若两个字符串开头没有有效数值或不是数值型字符串，这两个字符串相加时都看成0; eg: $a="abc"; $b="b01"; $a+$b是0 2.两个数值型字符串相加时，有效数字进行相加。 eg: $a="100"; $b="01a"; $a+$b=101; 3/如果字符串中带有‘.’,'e',
【Java】【基本数据类型】数字字符串和数值型数据有什么区别?
weixin_33860528的博客
11-20 7014
数据类型不同，使用起来自然也不同了，数值型数据可以进行加减乘除操作，字符串则不行，而字符串可以进行字符串连接操作，比如将“123”和“456”连接起来，就是“123456”了，数字字符串可以通过基本数据类型的包装类转换成数值型。 两种数据类型所占的内存空间也是不一样的，字符串占2个字节，而数值型则不一定，得看它是什么类型的了，byte 1字节，short...
#项目实现相关# | Linux、C++ | Ubuntu环境下用linux实现虚拟串口的收发通信、多线程下串口发送和接收数据
小太阳的博客
03-19 1451
参考：https://blog.youkuaiyun.com/haifengid/article/details/51996613 项目场景： 运行环境：Ubuntu18.04，linux系统，gcc编译器 实现描述： 需求：由于目前需要实现对于多个串口数据的收发，同时，或许可以利用多线程实现异步收发等； 问题：但是通过Windows平台的虚拟串口在一个Windows笔记本上没有实现和linux的通信；而且硬件设备来实现串口数据输入的话会存在接触不良而数据没有接受到等问题； 解决思路：所以对于linu...
数字字符串的各种比较问题
qq_37744648的博客
03-29 1282
var str1 = 'ext'; var str2 = 'drug'; alert(str1>str2);//比较首字母的ASCII； alert(122 > '30'); //数字和数字型字符串比较，将字符用parseInt（）方法转成数字，true alert(122 > 'abc'); //数字和字符串比较，将字符用pars...
字符、数字比较
初级程序员
04-14 1638
int choice;        scanf("%d",&amp;choice);char choice;     scanf("%c",&amp;choice);case '1'      字符case 1        整数switch(choice==1)switch(choice=='1')
针对字符串是数字和字母结合而进行的比较
Watson的码步
04-15 552
       针对字符串是数字和字母结合而进行的，如"a20"和"a9";比较而得出结果是"a20"&gt;"a9"。这种情况直接调用String的compareTo方法得出的结果是不是我们希望的。这个时候就需要写自己的类并且实现Comarable接口来进行比较。这个是来源一次的面试题目，但是当时只有个思路。     思路：     1.转换String为包含substring和Integer...
各数相加的思路、流程图、源代码及实现截图
weixin_30632883的博客
09-26 1299
1、大致思路：需要申请一个长度为n的动态数组，其中n为字符个数，然后循环输入，定义一个变量作为和，初始化为0，循环相加，最后输出。 2、流程图 3、源代码： //2015.9.26 chengchongjing 多数字相加 import java.util.Scanner; public class mathplus { public static voi...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

虚坏叔叔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值