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`	`PointI`	+, +=	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	(5)
`ExtentD`	`int`	, =, /, /=	`ExtentD`	(3)
`ExtentD`	`int`	//, //=	Not supported	(5)
`ExtentI`	`double`	*	`ExtentD`
`ExtentI`	`double`	*=	Not supported	(2)
`ExtentI`	`double`	/	`ExtentD`	(4)
`ExtentI`	`double`	/=	Not supported	(2), (4)
`ExtentI`	`double`	//, //=	Not supported	(5)
`ExtentI`	`int`	, =	`ExtentI`
`ExtentI`	`int`	/	`ExtentD`	(4)
`ExtentI`	`int`	/=	Not supported (Python), `ExtentI` (C++)	(2), (4)
`ExtentI`	`int`	//, //=	`ExtentI`	(6)
`double`	`ExtentD`	*	`ExtentD`
`double`	`ExtentI`	*	`ExtentD`
`int`	`ExtentD`	*	`ExtentD`	(3)
`int`	`ExtentI`	*	`ExtentI`

Operation is not geometrically meaningful.
This is an in-place operator that would require the LHS type to change. That would actually be possible to implement in Python, but it's behavior would be confusing.
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).
All "/" and "/=" operations here assume from __future__ import division. If this is not enabled, the behavior of the "/" operator will be that of "//", and likewise for "/=" and "//=", for all operations with ExtentI on the LHS.
The // operator applies only to integer types.
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.