diff --git a/source/simple/support/range.hpp b/source/simple/support/range.hpp
index d0f839ebbac040f0006c2bd5658a85cf7403ee4c..2c5c9c4e6d969f2d5e4a2541207ea5cb41296d79 100644
--- a/source/simple/support/range.hpp
+++ b/source/simple/support/range.hpp
@@ -47,9 +47,9 @@ namespace simple::support
 		constexpr const Type& upper() const noexcept { return bounds[1]; }
 
 		constexpr bool operator ==(const range& other) const
-		{
-			return bounds == other.bounds;
-		}
+		{ return bounds == other.bounds; }
+		constexpr bool operator !=(const range& other) const
+		{ return !(*this == other); }
 
 		template <typename It = Type,
 			std::enable_if_t<is_iterable<It>{}>...>
@@ -109,6 +109,12 @@ namespace simple::support
 			return range{*this}.fix();
 		}
 
+		[[nodiscard]]
+		constexpr range fixed() const
+		{
+			return range{*this}.fix();
+		}
+
 		[[nodiscard]]
 		constexpr auto reverse() const
 		{
@@ -144,13 +150,18 @@ namespace simple::support
 		{ return lower() <= other.upper() && upper() >= other.lower(); }
 		// { return intersection(other).valid(); } // why is the cool way always inefficient :/
 
-		constexpr range intersection(range other) const
+		constexpr range& intersect(const range& other)
 		{
 			using std::min;
 			using std::max;
-			other.lower() = max(other.lower(), lower());
-			other.upper() = min(other.upper(), upper());
-			return other;
+			lower() = max(lower(), other.lower());
+			upper() = min(upper(), other.upper());
+			return *this;
+		}
+
+		constexpr range intersection(range other) const
+		{
+			return other.intersect(*this);
 		}
 
 		template <typename Other, std::enable_if_t<
diff --git a/unit_tests/range.cpp b/unit_tests/range.cpp
index 796dc6fd6cd238f6615eedc4f8720443e5734897..31f6ccdbc08a94a75bb6cbe0950ef5442ee4b339 100644
--- a/unit_tests/range.cpp
+++ b/unit_tests/range.cpp
@@ -11,11 +11,18 @@ void Validity()
 	assert(valid_range.valid());
 	valid_range.fix();
 	assert(valid_range.valid());
+	assert(valid_range.fixed() == valid_range);
+	assert(valid_range.fixed().valid());
 
 	range invalid_range{valid_range.upper(), valid_range.lower()};
 	const range const_invalid_range = invalid_range;
 	assert(!invalid_range.valid());
 	assert(!const_invalid_range.valid());
+
+	assert(invalid_range.fixed().valid());
+	assert(invalid_range.fixed() == valid_range);
+	assert(!invalid_range.valid());
+
 	invalid_range.fix();
 	const range const_valid_range = const_invalid_range.fix();
 	assert(invalid_range.valid());
@@ -89,11 +96,21 @@ void SetLikePredicates()
 	assert(!intersects(r, {-67, -102}));
 
 	assert(( intersection(r, {12,56}) == range{12,31} ));
+	assert(( r != range{12,31} ));
 	assert(( intersection(r, {12,22}) == range{12,22} ));
+	assert(( r != range{12,22} ));
 	assert(( intersection(r, {-31,13}) == range{-13,13} ));
+	assert(( r != range{-13,13} ));
 	assert(( !intersection(r, {-31,-21}).valid() ));
 	assert(( !intersection(r, {32,52}).valid() ));
 
+	r.intersect({12,56});
+	assert(( r == range{12,31} ));
+	r.intersect({12,22});
+	assert(( r == range{12,22} ));
+	r.intersect({-31,13});
+	assert(( r == range{12,13} ));
+
 }
 
 void Clamping()