Operators on Point and Extent

The Point and Extent classes support many mathematical operators, but the set of available operators (and their expected behavior) isn’t quite as obvious as one might think. The table below lists all supported operators, with notes below on special cases. For the rationale behind these operations, see RFC-41.

LHS	RHS	Operator	Result	Notes
PointD	PointD	+, +=	Not supported	[1]
PointD	PointD	-	ExtentD
PointD	PointD	-=	Not supported	[2]
PointD	PointI	-	ExtentD
PointD	PointI	-=	Not supported	[2]
PointD	ExtentD	+, +=, -, -=	PointD
PointD	ExtentI	+, +=, -, -=	PointD
PointI	PointD	+, +=	Not supported	[1]
PointI	PointI	+, +=	Not supported	[1]
PointI	ExtentD	+	PointD
PointI	ExtentD	+=	Not supported	[2]
PointI	ExtentI	+, +=	PointI
PointI	PointD	-	ExtentD
PointI	PointD	-=	Not supported	[2]
PointI	PointI	-	ExtentI
PointI	PointI	-=	Not supported	[2]
PointI	ExtentD	-	PointD
PointI	ExtentD	-=	Not supported	[2]
PointI	ExtentI	-, -=	PointI
ExtentD	PointD	+	PointD
ExtentD	PointD	+=	Not supported	[2]
ExtentD	PointD	-, -=	Not supported	[1]
ExtentD	PointI	+	PointD
ExtentD	PointI	+=	Not supported	[2]
ExtentD	PointI	-, -=	Not supported	[1]
ExtentD	ExtentD	+, +=, -, -=	ExtentD
ExtentD	ExtentI	+, +=, -, -=	ExtentD
ExtentI	PointD	+	PointD
ExtentI	PointD	+=	Not supported	[2]
ExtentI	PointD	-, -=	Not supported	[1]
ExtentI	PointI	+	PointI
ExtentI	PointI	+=	Not supported	[2]
ExtentI	PointI	-, -=	Not supported	[1]
ExtentI	ExtentD	+, -	ExtentD
ExtentI	ExtentD	+=, -=	Not supported	[2]
ExtentI	ExtentI	+, -, +=, -=	ExtentI
ExtentD	double	*, *=, /, /=	ExtentD
ExtentD	double	//, //=	Not supported	[4]
ExtentD	int	*, *=, /, /=	ExtentD	[3]
ExtentD	int	//, //=	Not supported	[4]
ExtentI	double	*	ExtentD
ExtentI	double	*=	Not supported	[2]
ExtentI	double	/	ExtentD
ExtentI	double	/=	Not supported	[2]
ExtentI	double	//, //=	Not supported	[4]
ExtentI	int	*, *=	ExtentI
ExtentI	int	/	ExtentD
ExtentI	int	/=	Not supported (Python), ExtentI (C++)	[2]
ExtentI	int	//, //=	ExtentI	[5]
double	ExtentD	*	ExtentD
double	ExtentI	*	ExtentD
int	ExtentD	*	ExtentD	[3]
int	ExtentI	*	ExtentI

[1] (1,2,3,4,5,6,7)

Operation is not geometrically meaningful.

[2] (1,2,3,4,5,6,7,8,9,10,11,12,13,14)

This is an in-place operator that would require the LHS type to change. That would actually be possible to implement in Python, but its behavior would be confusing.

[3] (1,2)

This operator is not implemented directly in either C++ or Python, but is largely supported by the fact that an overload that takes double will also accept int (but may yield different answers for extremely large integers that cannot be represented exactly as doubles).

[4] (1,2,3)

The // operator applies only to integer types.

[5]

This Python-only operation does not always produce the same result as regular division of integers in C++, because Python specifies that a//b is equivalent to floor(a/b), while C++ specifies that it should be equivalent to int(a/b). Note that floor rounds negative numbers down and int rounds them up.