diff --git a/src/headless/main.cpp b/src/headless/main.cpp
index 1c1114576..9511b9411 100644
--- a/src/headless/main.cpp
+++ b/src/headless/main.cpp
@@ -12,6 +12,8 @@
 #include <spdlog/logger.h>
 #include <spdlog/sinks/callback_sink.h>
 
+#include <openvic-simulation/core/memory/MemoryTracker.hpp>
+#include <openvic-simulation/core/memory/Vector.hpp>
 #include <openvic-simulation/GameManager.hpp>
 #include <openvic-simulation/country/CountryInstance.hpp>
 #include <openvic-simulation/dataloader/Dataloader.hpp>
@@ -20,9 +22,7 @@
 #include <openvic-simulation/economy/production/ResourceGatheringOperation.hpp>
 #include <openvic-simulation/pathfinding/AStarPathing.hpp>
 #include <openvic-simulation/testing/Testing.hpp>
-#include <openvic-simulation/utility/Containers.hpp>
 #include <openvic-simulation/utility/Logger.hpp>
-#include <openvic-simulation/utility/MemoryTracker.hpp>
 
 using namespace OpenVic;
 
@@ -37,7 +37,7 @@ inline static void print_memory_usage( //
 #else
 		spdlog::source_loc {},
 #endif
-		spdlog::level::info, "{} Memory Usage: {} Bytes", prefix, OpenVic::utility::MemoryTracker::get_memory_usage()
+		spdlog::level::info, "{} Memory Usage: {} Bytes", prefix, OpenVic::memory::MemoryTracker::get_memory_usage()
 	);
 #endif
 #endif
@@ -365,7 +365,7 @@ static bool run_headless(fs::path const& root, memory::vector<memory::string>& m
 	SPDLOG_INFO("===== Ending game session... =====");
 	ret &= game_manager.end_game_session();
 
-	SPDLOG_INFO("Max Memory Usage: {} Bytes", OpenVic::utility::MemoryTracker::get_max_memory_usage());
+	SPDLOG_INFO("Max Memory Usage: {} Bytes", OpenVic::memory::MemoryTracker::get_max_memory_usage());
 
 	return ret;
 }
diff --git a/src/openvic-simulation/GameManager.cpp b/src/openvic-simulation/GameManager.cpp
index a4d0594be..c94bb7db6 100644
--- a/src/openvic-simulation/GameManager.cpp
+++ b/src/openvic-simulation/GameManager.cpp
@@ -9,8 +9,9 @@
 
 #include <spdlog/spdlog.h>
 
+#include <openvic-simulation/core/memory/String.hpp>
+#include <openvic-simulation/core/memory/Vector.hpp>
 #include "openvic-simulation/dataloader/Dataloader.hpp"
-#include "openvic-simulation/types/OrderedContainers.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
 
 using namespace OpenVic;
diff --git a/src/openvic-simulation/GameManager.hpp b/src/openvic-simulation/GameManager.hpp
index 974db0bcd..2ee594f1c 100644
--- a/src/openvic-simulation/GameManager.hpp
+++ b/src/openvic-simulation/GameManager.hpp
@@ -3,13 +3,13 @@
 #include <optional>
 #include <string_view>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/DefinitionManager.hpp"
 #include "openvic-simulation/InstanceManager.hpp"
 #include "openvic-simulation/dataloader/ModManager.hpp"
 #include "openvic-simulation/dataloader/Dataloader.hpp"
 #include "openvic-simulation/misc/GameRulesManager.hpp"
 #include "openvic-simulation/gen/commit_info.gen.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 #include <function2/function2.hpp>
 
diff --git a/src/openvic-simulation/InstanceManager.hpp b/src/openvic-simulation/InstanceManager.hpp
index 311727432..79efa92a2 100644
--- a/src/openvic-simulation/InstanceManager.hpp
+++ b/src/openvic-simulation/InstanceManager.hpp
@@ -4,6 +4,7 @@
 
 #include <function2/function2.hpp>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/console/ConsoleInstance.hpp"
 #include "openvic-simulation/country/CountryInstanceManager.hpp"
 #include "openvic-simulation/country/CountryInstanceDeps.hpp"
@@ -23,7 +24,6 @@
 #include "openvic-simulation/types/Date.hpp"
 #include "openvic-simulation/types/FlagStrings.hpp"
 #include "openvic-simulation/utility/ThreadPool.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 
diff --git a/src/openvic-simulation/console/ConsoleInstance.cpp b/src/openvic-simulation/console/ConsoleInstance.cpp
index 6f0393770..b1fb634c0 100644
--- a/src/openvic-simulation/console/ConsoleInstance.cpp
+++ b/src/openvic-simulation/console/ConsoleInstance.cpp
@@ -9,6 +9,8 @@
 
 #include <fmt/format.h>
 
+#include <openvic-simulation/core/memory/String.hpp>
+#include <openvic-simulation/core/memory/Vector.hpp>
 #include "openvic-simulation/DefinitionManager.hpp"
 #include "openvic-simulation/InstanceManager.hpp"
 #include "openvic-simulation/core/error/ErrorMacros.hpp"
@@ -21,7 +23,6 @@
 #include "openvic-simulation/research/Technology.hpp"
 #include "openvic-simulation/types/Colour.hpp"
 #include "openvic-simulation/types/Date.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 using namespace OpenVic;
 using namespace std::string_view_literals;
diff --git a/src/openvic-simulation/console/ConsoleInstance.hpp b/src/openvic-simulation/console/ConsoleInstance.hpp
index a3ebcca37..f2791eb3b 100644
--- a/src/openvic-simulation/console/ConsoleInstance.hpp
+++ b/src/openvic-simulation/console/ConsoleInstance.hpp
@@ -7,10 +7,11 @@
 #include <fmt/color.h>
 #include <fmt/core.h>
 
+#include "openvic-simulation/core/memory/Formatting.hpp"
+#include "openvic-simulation/core/memory/String.hpp"
 #include "openvic-simulation/types/Colour.hpp"
 #include "openvic-simulation/types/Date.hpp"
 #include "openvic-simulation/types/OrderedContainers.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
 #include <function2/function2.hpp>
diff --git a/src/openvic-simulation/core/Math.hpp b/src/openvic-simulation/core/Math.hpp
index 8050714c0..a6a39e01f 100644
--- a/src/openvic-simulation/core/Math.hpp
+++ b/src/openvic-simulation/core/Math.hpp
@@ -6,14 +6,15 @@
 #include <type_traits>
 
 #include "openvic-simulation/core/Typedefs.hpp"
+#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 
 namespace OpenVic {
     template<typename T>
-    [[nodiscard]] OV_SPEED_INLINE constexpr T abs(T num);
+    [[nodiscard]] OV_SPEED_INLINE constexpr T abs(const T num);
 
 	template<typename T>
 	requires std::integral<T> || std::floating_point<T>
-	[[nodiscard]] OV_SPEED_INLINE constexpr T abs(T num) {
+	[[nodiscard]] OV_SPEED_INLINE constexpr T abs(const T num) {
 		if (std::is_constant_evaluated()) {
 			return num < 0 ? -num : num;
 		} else {
@@ -21,9 +22,14 @@ namespace OpenVic {
 		}
 	}
 
+    template<>
+	[[nodiscard]] OV_SPEED_INLINE constexpr fixed_point_t abs(const fixed_point_t  num) {
+		return num.abs();
+	}
+
     template<typename T>
-	requires (!(std::integral<T> || std::floating_point<T>))
-	[[nodiscard]] OV_SPEED_INLINE constexpr T abs(T num);
+	requires (!(std::integral<T> || std::floating_point<T> || std::is_same_v<T, fixed_point_t>))
+	[[nodiscard]] OV_SPEED_INLINE constexpr T abs(T const& num);
 
 	template<std::floating_point T>
 	OV_SPEED_INLINE constexpr int64_t round_to_int64(T num) {
@@ -58,32 +64,6 @@ namespace OpenVic {
 		return ret;
 	}
 
-	OV_SPEED_INLINE constexpr uint64_t sqrt(uint64_t n) {
-		uint64_t x = n;
-		uint64_t c = 0;
-		uint64_t d = 1ull << 62;
-
-		while (d > n) {
-			d >>= 2;
-		}
-
-		for (; d != 0; d >>= 2) {
-			if (x >= c + d) {
-				x -= c + d;
-				c = (c >> 1) + d;
-			} else {
-				c >>= 1;
-			}
-		}
-
-		// round up
-		if (x > 0) {
-			c += 1;
-		}
-
-		return c;
-	}
-
 	OV_SPEED_INLINE constexpr bool is_power_of_two(uint64_t n) {
 		return n > 0 && (n & (n - 1)) == 0;
 	}
diff --git a/src/openvic-simulation/core/MathSqrt.hpp b/src/openvic-simulation/core/MathSqrt.hpp
new file mode 100644
index 000000000..4c365bf75
--- /dev/null
+++ b/src/openvic-simulation/core/MathSqrt.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <cstdint>
+
+namespace OpenVic {
+	inline constexpr uint64_t sqrt(uint64_t n) {
+		uint64_t x = n;
+		uint64_t c = 0;
+		uint64_t d = 1ull << 62;
+
+		while (d > n) {
+			d >>= 2;
+		}
+
+		for (; d != 0; d >>= 2) {
+			if (x >= c + d) {
+				x -= c + d;
+				c = (c >> 1) + d;
+			} else {
+				c >>= 1;
+			}
+		}
+
+		// round up
+		if (x > 0) {
+			c += 1;
+		}
+
+		return c;
+	}
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/error/ErrorSet.hpp b/src/openvic-simulation/core/error/ErrorSet.hpp
index 33292328b..8fb2d66af 100644
--- a/src/openvic-simulation/core/error/ErrorSet.hpp
+++ b/src/openvic-simulation/core/error/ErrorSet.hpp
@@ -4,7 +4,7 @@
 #include <cstddef>
 
 #include "openvic-simulation/core/error/Error.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
+#include "openvic-simulation/core/memory/String.hpp"
 
 namespace OpenVic {
 	// Set of all reported errors, if empty operates as if set to Error::OK
diff --git a/src/openvic-simulation/core/io/BMP.cpp b/src/openvic-simulation/core/io/BMP.cpp
index 5e58f7329..54aa19c94 100644
--- a/src/openvic-simulation/core/io/BMP.cpp
+++ b/src/openvic-simulation/core/io/BMP.cpp
@@ -6,7 +6,6 @@
 #include <fmt/std.h>
 
 #include "openvic-simulation/types/OrderedContainers.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
 
 using namespace OpenVic;
diff --git a/src/openvic-simulation/core/io/BMP.hpp b/src/openvic-simulation/core/io/BMP.hpp
index 98b1a2f4b..c1ac71c4e 100644
--- a/src/openvic-simulation/core/io/BMP.hpp
+++ b/src/openvic-simulation/core/io/BMP.hpp
@@ -4,7 +4,7 @@
 #include <fstream>
 #include <span>
 
-#include "openvic-simulation/utility/Containers.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 
 namespace OpenVic {
 	namespace fs = std::filesystem;
diff --git a/src/openvic-simulation/core/memory/Colony.hpp b/src/openvic-simulation/core/memory/Colony.hpp
new file mode 100644
index 000000000..e4d51b7f2
--- /dev/null
+++ b/src/openvic-simulation/core/memory/Colony.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <plf_colony.h>
+
+#include <foonathan/memory/default_allocator.hpp>
+#include <foonathan/memory/std_allocator.hpp>
+
+#include "MemoryTracker.hpp"
+
+namespace OpenVic::memory {
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
+	using colony = plf::colony<T, foonathan::memory::std_allocator<T, tracker<RawAllocator>>>;
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/memory/CowPtr.hpp b/src/openvic-simulation/core/memory/CowPtr.hpp
new file mode 100644
index 000000000..15bcc8702
--- /dev/null
+++ b/src/openvic-simulation/core/memory/CowPtr.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <foonathan/memory/default_allocator.hpp>
+#include <foonathan/memory/std_allocator.hpp>
+
+#include "openvic-simulation/types/CowPtr.hpp"
+#include "MemoryTracker.hpp"
+
+namespace OpenVic::memory {
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
+	using cow_ptr = cow_ptr<T, foonathan::memory::std_allocator<T, tracker<RawAllocator>>>;
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/memory/CowVector.hpp b/src/openvic-simulation/core/memory/CowVector.hpp
new file mode 100644
index 000000000..3ab795bde
--- /dev/null
+++ b/src/openvic-simulation/core/memory/CowVector.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <foonathan/memory/default_allocator.hpp>
+#include <foonathan/memory/std_allocator.hpp>
+
+#include "openvic-simulation/types/CowVector.hpp"
+#include "MemoryTracker.hpp"
+
+namespace OpenVic::memory {
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
+	using cow_vector = cow_vector<T, foonathan::memory::std_allocator<T, tracker<RawAllocator>>>;
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/memory/Deque.hpp b/src/openvic-simulation/core/memory/Deque.hpp
new file mode 100644
index 000000000..e3c29932d
--- /dev/null
+++ b/src/openvic-simulation/core/memory/Deque.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <scoped_allocator>
+
+#include <foonathan/memory/config.hpp>
+#include <foonathan/memory/std_allocator.hpp>
+
+#include "openvic-simulation/core/portable/Deque.hpp"
+#include "MemoryTracker.hpp"
+
+namespace OpenVic::memory {
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
+	FOONATHAN_ALIAS_TEMPLATE(
+		deque,
+		OpenVic::utility::deque<
+			T,
+			foonathan::memory::std_allocator<T, tracker<RawAllocator>>
+		>
+	);
+
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
+	FOONATHAN_ALIAS_TEMPLATE(
+		deque_scoped_alloc,
+		OpenVic::utility::deque<
+			T,
+			std::scoped_allocator_adaptor<foonathan::memory::std_allocator<T, tracker<RawAllocator>>>
+		>
+	);
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/memory/Formatting.hpp b/src/openvic-simulation/core/memory/Formatting.hpp
new file mode 100644
index 000000000..24941bfbd
--- /dev/null
+++ b/src/openvic-simulation/core/memory/Formatting.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <fmt/base.h>
+#include <fmt/format.h>
+
+#include <foonathan/memory/default_allocator.hpp>
+
+#include "MemoryTracker.hpp"
+#include "String.hpp"
+
+namespace OpenVic::memory {
+	namespace fmt {
+		template<typename T, class RawAllocator = foonathan::memory::default_allocator>
+		using basic_memory_buffer = ::fmt::basic_memory_buffer<
+			T,
+			::fmt::inline_buffer_size,
+			foonathan::memory::std_allocator<
+				T,
+				OpenVic::memory::tracker<RawAllocator>
+			>
+		>;
+
+		inline static memory::string vformat(::fmt::string_view fmt, ::fmt::format_args args) {
+			memory::fmt::basic_memory_buffer<char> buf {};
+			::fmt::vformat_to(std::back_inserter(buf), fmt, args);
+			return memory::string(buf.data(), buf.size());
+		}
+
+		template<typename... Args>
+		memory::string format(::fmt::string_view fmt, const Args&... args) {
+			return memory::fmt::vformat(fmt, ::fmt::make_format_args(args...));
+		}
+	}
+}
diff --git a/src/openvic-simulation/utility/MemoryTracker.hpp b/src/openvic-simulation/core/memory/MemoryTracker.hpp
similarity index 93%
rename from src/openvic-simulation/utility/MemoryTracker.hpp
rename to src/openvic-simulation/core/memory/MemoryTracker.hpp
index 69e504245..b96942e75 100644
--- a/src/openvic-simulation/utility/MemoryTracker.hpp
+++ b/src/openvic-simulation/core/memory/MemoryTracker.hpp
@@ -5,7 +5,7 @@
 
 #include <foonathan/memory/tracking.hpp>
 
-namespace OpenVic::utility {
+namespace OpenVic::memory {
 	struct MemoryTracker {
 		void on_node_allocation(void* mem, std::size_t size, std::size_t) {
 			uint64_t new_mem_usage = _memory_usage.fetch_add(size, std::memory_order_acq_rel) + size;
@@ -53,7 +53,7 @@ namespace OpenVic::memory {
 	template<class RawAllocator>
 	using tracker =
 #ifdef DEBUG_ENABLED
-		foonathan::memory::tracked_allocator<OpenVic::utility::MemoryTracker, RawAllocator>
+		foonathan::memory::tracked_allocator<OpenVic::memory::MemoryTracker, RawAllocator>
 #else
 		RawAllocator
 #endif
diff --git a/src/openvic-simulation/core/memory/Queue.hpp b/src/openvic-simulation/core/memory/Queue.hpp
new file mode 100644
index 000000000..ad54a480e
--- /dev/null
+++ b/src/openvic-simulation/core/memory/Queue.hpp
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <queue>
+
+#include "Deque.hpp"
+
+namespace OpenVic::memory {
+	template<typename T, typename Container = memory::deque<T>>
+	using queue = std::queue<T, Container>;
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/memory/SmartPtr.hpp b/src/openvic-simulation/core/memory/SmartPtr.hpp
new file mode 100644
index 000000000..b94076398
--- /dev/null
+++ b/src/openvic-simulation/core/memory/SmartPtr.hpp
@@ -0,0 +1,127 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <foonathan/memory/default_allocator.hpp>
+#include <foonathan/memory/smart_ptr.hpp>
+
+#include "MemoryTracker.hpp"
+#include "make_tracked_allocator.hpp"
+#include "allocators/BaseAllocator.hpp" // IWYU pragma: keep for will_optimize_deleter_for
+
+namespace OpenVic::memory {
+#ifdef DEBUG_ENABLED
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
+	using unique_ptr = foonathan::memory::unique_ptr<T, tracker<RawAllocator>>;
+
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
+	using unique_base_ptr = foonathan::memory::unique_base_ptr<T, tracker<RawAllocator>>;
+
+	template<typename T, class RawAllocator, typename... Args>
+	requires(!std::is_array_v<T>)
+	unique_ptr<T, std::decay_t<RawAllocator>> allocate_unique(RawAllocator&& alloc, Args&&... args) {
+		return foonathan::memory::allocate_unique<T>(
+			OpenVic::memory::make_tracked_allocator(std::forward<RawAllocator>(alloc)), std::forward<Args>(args)...
+		);
+	}
+
+	template<typename T, class RawAllocator>
+	requires(std::is_array_v<T>)
+	unique_ptr<T, std::decay_t<RawAllocator>> allocate_unique(RawAllocator&& alloc, std::size_t size) {
+		return foonathan::memory::allocate_unique<T, tracker<RawAllocator>>(
+			OpenVic::memory::make_tracked_allocator(std::forward<RawAllocator>(alloc)), size
+		);
+	}
+#else
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
+	using unique_ptr = std::conditional_t<
+		will_optimize_deleter_for<RawAllocator>::value, std::unique_ptr<T>,
+		foonathan::memory::unique_ptr<T, tracker<RawAllocator>>>;
+
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
+	using unique_base_ptr = std::conditional_t<
+		will_optimize_deleter_for<RawAllocator>::value, std::unique_ptr<T>,
+		foonathan::memory::unique_base_ptr<T, tracker<RawAllocator>>>;
+
+	template<typename T, class RawAllocator, typename... Args>
+	requires(!std::is_array_v<T>)
+	unique_ptr<T, std::decay_t<RawAllocator>> allocate_unique(RawAllocator&& alloc, Args&&... args) {
+		if constexpr (will_optimize_deleter_for<RawAllocator>::value) {
+			return std::make_unique<T>(std::forward<Args>(args)...);
+		} else {
+			return foonathan::memory::allocate_unique<T>(
+				OpenVic::memory::make_tracked_allocator(std::forward<RawAllocator>(alloc)), std::forward<Args>(args)...
+			);
+		}
+	}
+
+	template<typename T, class RawAllocator>
+	requires(std::is_array_v<T>)
+	unique_ptr<T, std::decay_t<RawAllocator>> allocate_unique(RawAllocator&& alloc, std::size_t size) {
+		if constexpr (will_optimize_deleter_for<RawAllocator>::value) {
+			return std::make_unique<T>(size);
+		} else {
+			return foonathan::memory::allocate_unique<T, tracker<RawAllocator>>(
+				OpenVic::memory::make_tracked_allocator(std::forward<RawAllocator>(alloc)), size
+			);
+		}
+	}
+#endif
+
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator, typename... Args>
+	requires(!std::is_array_v<T>)
+	static inline unique_ptr<T, RawAllocator> make_unique(Args&&... args) {
+		return allocate_unique<T>(RawAllocator {}, std::forward<Args>(args)...);
+	}
+
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator, typename... Args>
+	requires(std::is_unbounded_array_v<T>)
+	static inline unique_ptr<T, RawAllocator> make_unique(size_t n) {
+		return allocate_unique<T>(
+			OpenVic::memory::make_tracked_allocator(RawAllocator {}),
+			n
+		);
+	}
+
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator, typename... Args>
+	requires(!std::is_array_v<T>)
+	static inline unique_ptr<T, RawAllocator> make_unique_for_overwrite() {
+		using raw_ptr = std::unique_ptr<T, foonathan::memory::allocator_deallocator<T, tracker<RawAllocator>>>;
+
+		tracker<RawAllocator> alloc = OpenVic::memory::make_tracked_allocator(RawAllocator {});
+		auto memory = alloc.allocate_node(sizeof(T), alignof(T));
+		// raw_ptr deallocates memory in case of constructor exception
+		raw_ptr result(static_cast<T*>(memory), { alloc });
+		// pass ownership to return value using a deleter that calls destructor
+		return { result.release(), { alloc } };
+	}
+
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator, typename... Args>
+	requires(std::is_unbounded_array_v<T>)
+	static inline unique_ptr<T, RawAllocator> make_unique_for_overwrite(size_t size) {
+		using raw_ptr = std::unique_ptr<T, foonathan::memory::allocator_deallocator<T, tracker<RawAllocator>>>;
+
+		tracker<RawAllocator> alloc = OpenVic::memory::make_tracked_allocator(RawAllocator {});
+		auto memory = alloc.allocate_array(size, sizeof(T), alignof(T));
+		// raw_ptr deallocates memory in case of constructor exception
+		raw_ptr result(static_cast<T*>(memory), { alloc, size });
+		// pass ownership to return value using a deleter that calls destructor
+		return { result.release(), { alloc, size } };
+	}
+
+	template<typename T, class RawAllocator, typename... Args>
+	std::shared_ptr<T> allocate_shared(RawAllocator&& alloc, Args&&... args) {
+		return foonathan::memory::allocate_shared<T>(
+			OpenVic::memory::make_tracked_allocator(
+				std::forward<RawAllocator>(alloc)
+			),
+			std::forward<Args>(args)...
+		);
+	}
+
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator, typename... Args>
+	static inline std::shared_ptr<T> make_shared(Args&&... args) {
+		return allocate_shared<T>(RawAllocator {}, std::forward<Args>(args)...);
+	}
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/memory/Stack.hpp b/src/openvic-simulation/core/memory/Stack.hpp
new file mode 100644
index 000000000..9c56ca1cb
--- /dev/null
+++ b/src/openvic-simulation/core/memory/Stack.hpp
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <stack>
+
+#include "Deque.hpp"
+
+namespace OpenVic::memory {
+	template<typename T, typename Container = memory::deque<T>>
+	using stack = std::stack<T, Container>;
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/memory/String.hpp b/src/openvic-simulation/core/memory/String.hpp
new file mode 100644
index 000000000..a16d77ebb
--- /dev/null
+++ b/src/openvic-simulation/core/memory/String.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <string>
+
+#include <foonathan/memory/default_allocator.hpp>
+#include <foonathan/memory/std_allocator.hpp>
+
+#include "MemoryTracker.hpp"
+
+namespace OpenVic::memory {
+	template<typename CharT, class RawAllocator = foonathan::memory::default_allocator>
+	using basic_string = std::basic_string<
+		CharT,
+		std::char_traits<CharT>,
+		foonathan::memory::std_allocator<CharT, tracker<RawAllocator>>
+	>;
+
+	template<class RawAllocator = foonathan::memory::default_allocator>
+	using string_alloc = basic_string<char, RawAllocator>;
+
+	using string = string_alloc<>;
+
+	template<class RawAllocator = foonathan::memory::default_allocator>
+	using wstring_alloc = basic_string<wchar_t, RawAllocator>;
+
+	using wstring = wstring_alloc<>;
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/memory/StringStream.hpp b/src/openvic-simulation/core/memory/StringStream.hpp
new file mode 100644
index 000000000..c23536ac7
--- /dev/null
+++ b/src/openvic-simulation/core/memory/StringStream.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <string>
+#include <sstream>
+
+#include <foonathan/memory/default_allocator.hpp>
+#include <foonathan/memory/std_allocator.hpp>
+
+#include "MemoryTracker.hpp"
+
+namespace OpenVic::memory {
+	template<typename CharT, typename CharTraits = std::char_traits<CharT>, class RawAllocator = foonathan::memory::default_allocator>
+	using basic_stringstream = std::basic_stringstream<
+		CharT,
+		CharTraits,
+		foonathan::memory::std_allocator<CharT, tracker<RawAllocator>>
+	>;
+
+	template<class RawAllocator = foonathan::memory::default_allocator>
+	using stringstream_alloc = basic_stringstream<char, std::char_traits<char>, RawAllocator>;
+	template<class RawAllocator = foonathan::memory::default_allocator>
+	using wstringstream_alloc = basic_stringstream<wchar_t, std::char_traits<wchar_t>, RawAllocator>;
+
+	using stringstream = stringstream_alloc<>;
+	using wstringstream = wstringstream_alloc<>;
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/memory/Vector.hpp b/src/openvic-simulation/core/memory/Vector.hpp
new file mode 100644
index 000000000..32e624064
--- /dev/null
+++ b/src/openvic-simulation/core/memory/Vector.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <foonathan/memory/container.hpp>
+#include <foonathan/memory/default_allocator.hpp>
+
+#include "MemoryTracker.hpp"
+
+namespace OpenVic::memory {
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
+	using vector = foonathan::memory::vector<T, tracker<RawAllocator>>;
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/memory/allocators/BaseAllocator.hpp b/src/openvic-simulation/core/memory/allocators/BaseAllocator.hpp
new file mode 100644
index 000000000..abed4b76f
--- /dev/null
+++ b/src/openvic-simulation/core/memory/allocators/BaseAllocator.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <type_traits>
+
+#include <foonathan/memory/allocator_storage.hpp>
+
+namespace OpenVic::memory {
+	template<class RawAllocator>
+	using allocator_reference = foonathan::memory::allocator_reference<RawAllocator>;
+
+	template<class RawAllocator>
+	struct will_optimize_deleter_for : std::false_type {};
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/memory/allocators/Deleter.hpp b/src/openvic-simulation/core/memory/allocators/Deleter.hpp
new file mode 100644
index 000000000..9914c6f46
--- /dev/null
+++ b/src/openvic-simulation/core/memory/allocators/Deleter.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <foonathan/memory/deleter.hpp>
+
+#include "BaseAllocator.hpp"
+#include "openvic-simulation/core/memory/make_tracked_allocator.hpp"
+
+namespace OpenVic::memory {
+	template<typename T, class RawAllocator>
+	using allocator_deleter = foonathan::memory::allocator_deleter<T, RawAllocator>;
+	
+	template<typename T, class RawAllocator>
+	requires(!std::is_array_v<T>)
+	static inline void dealloc_delete(RawAllocator&& alloc, T* ptr) {
+		ptr->~T();
+		allocator_reference<RawAllocator> alloc_ref = foonathan::memory::make_allocator_reference(alloc);
+		alloc_ref.deallocate(ptr, sizeof(T), alignof(T));
+	}
+
+	template<typename T, class RawAllocator>
+	requires(std::is_unbounded_array_v<T>)
+	static inline void dealloc_delete(RawAllocator&& alloc, T* ptr, size_t n) {
+		std::destroy_n(ptr, n);
+		allocator_reference<RawAllocator> alloc_ref = foonathan::memory::make_allocator_reference(alloc);
+		alloc_ref.deallocate(ptr, sizeof(T) * n, alignof(T));
+	}
+
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
+	requires(!std::is_array_v<T>)
+	static inline void delete_at(T* ptr) {
+		dealloc_delete(OpenVic::memory::make_tracked_allocator(RawAllocator {}), ptr);
+	}
+
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
+	requires(std::is_unbounded_array_v<T>)
+	static inline void delete_at(T* ptr, size_t n) {
+		dealloc_delete(OpenVic::memory::make_tracked_allocator(RawAllocator {}), ptr, n);
+	}
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/memory/allocators/HeapAllocator.hpp b/src/openvic-simulation/core/memory/allocators/HeapAllocator.hpp
new file mode 100644
index 000000000..4832911a0
--- /dev/null
+++ b/src/openvic-simulation/core/memory/allocators/HeapAllocator.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <type_traits>
+
+#include <foonathan/memory/heap_allocator.hpp>
+
+#include "BaseAllocator.hpp"
+
+namespace OpenVic::memory {
+	template<>
+	struct will_optimize_deleter_for<foonathan::memory::heap_allocator> : std::true_type {};
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/memory/allocators/MallocAllocator.hpp b/src/openvic-simulation/core/memory/allocators/MallocAllocator.hpp
new file mode 100644
index 000000000..88aae1c88
--- /dev/null
+++ b/src/openvic-simulation/core/memory/allocators/MallocAllocator.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <type_traits>
+
+#include <foonathan/memory/malloc_allocator.hpp>
+
+#include "BaseAllocator.hpp"
+
+namespace OpenVic::memory {
+	template<>
+	struct will_optimize_deleter_for<foonathan::memory::malloc_allocator> : std::true_type {};
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/memory/allocators/NewAllocator.hpp b/src/openvic-simulation/core/memory/allocators/NewAllocator.hpp
new file mode 100644
index 000000000..fa3c1f98c
--- /dev/null
+++ b/src/openvic-simulation/core/memory/allocators/NewAllocator.hpp
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <type_traits>
+
+#include <foonathan/memory/default_allocator.hpp>
+#include <foonathan/memory/new_allocator.hpp>
+
+#include "BaseAllocator.hpp"
+#include "openvic-simulation/core/memory/make_tracked_allocator.hpp"
+
+namespace OpenVic::memory {
+	template<>
+	struct will_optimize_deleter_for<foonathan::memory::new_allocator> : std::true_type {};
+
+	template<typename T, class RawAllocator, typename... Args>
+	requires(!std::is_array_v<T>)
+	static inline T* allocate_new(RawAllocator&& alloc, Args&&... args) {
+		allocator_reference<RawAllocator> alloc_ref = foonathan::memory::make_allocator_reference(alloc);
+		T* ptr = static_cast<T*>(alloc_ref.allocate_node(sizeof(T), alignof(T)));
+		::new (ptr) T(std::forward<Args>(args)...);
+		return ptr;
+	}
+
+	template<typename T, class RawAllocator, typename... Args>
+	requires(std::is_unbounded_array_v<T>)
+	static inline T* allocate_new(RawAllocator&& alloc, size_t n) {
+		allocator_reference<RawAllocator> alloc_ref = foonathan::memory::make_allocator_reference(alloc);
+		return static_cast<T*>(alloc_ref.allocate_node(sizeof(T) * n, alignof(T)));
+	}
+
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator, typename... Args>
+	requires(!std::is_array_v<T>)
+	static inline T* make_new(Args&&... args) {
+		return allocate_new<T>(OpenVic::memory::make_tracked_allocator(RawAllocator {}), std::forward<Args>(args)...);
+	}
+
+	template<typename T, class RawAllocator = foonathan::memory::default_allocator, typename... Args>
+	requires(std::is_unbounded_array_v<T>)
+	static inline T* make_new(size_t n) {
+		return allocate_new<T>(OpenVic::memory::make_tracked_allocator(RawAllocator {}), n);
+	}
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/memory/make_tracked_allocator.hpp b/src/openvic-simulation/core/memory/make_tracked_allocator.hpp
new file mode 100644
index 000000000..81093b13c
--- /dev/null
+++ b/src/openvic-simulation/core/memory/make_tracked_allocator.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <utility>
+
+#include "MemoryTracker.hpp"
+
+namespace OpenVic::memory {
+	template<class RawAllocator>
+	tracker<RawAllocator> make_tracked_allocator(
+		RawAllocator&& alloc
+	) {
+#ifdef DEBUG_ENABLED
+		return foonathan::memory::make_tracked_allocator(
+			typename tracker<RawAllocator>::tracker {},
+			std::forward<RawAllocator>(alloc)
+		);
+#else
+		return std::forward<RawAllocator>(alloc);
+#endif
+	}
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/core/string/Utility.hpp b/src/openvic-simulation/core/string/Utility.hpp
index 8dbe0cb92..1522fe1d9 100644
--- a/src/openvic-simulation/core/string/Utility.hpp
+++ b/src/openvic-simulation/core/string/Utility.hpp
@@ -11,7 +11,7 @@
 #include <range/v3/view/join.hpp>
 #include <range/v3/view/transform.hpp>
 
-#include "openvic-simulation/utility/Containers.hpp"
+#include "openvic-simulation/core/memory/String.hpp"
 
 namespace OpenVic {
 	inline constexpr bool ascii_equal_case_insensitive(std::string_view const& lhs, std::string_view const& rhs) {
diff --git a/src/openvic-simulation/core/template/Concepts.hpp b/src/openvic-simulation/core/template/Concepts.hpp
index dd4fba1e7..d21d92c12 100644
--- a/src/openvic-simulation/core/template/Concepts.hpp
+++ b/src/openvic-simulation/core/template/Concepts.hpp
@@ -144,9 +144,6 @@ namespace OpenVic {
 		{ typename Case::equal {}(identifier, identifier) } -> std::same_as<bool>;
 	};
 
-	template<typename T>
-	concept integral_max_size_4 = std::integral<T> && sizeof(T) <= 4;
-
 	template<typename T>
 	concept unary_negatable = requires(T const& a) {
 		{ -a } -> std::same_as<T>;
diff --git a/src/openvic-simulation/country/CountryInstance.cpp b/src/openvic-simulation/country/CountryInstance.cpp
index 341247069..e6ccd5f2d 100644
--- a/src/openvic-simulation/country/CountryInstance.cpp
+++ b/src/openvic-simulation/country/CountryInstance.cpp
@@ -45,11 +45,11 @@
 #include "openvic-simulation/types/ClampedValue.hpp"
 #include "openvic-simulation/types/Date.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
+#include "openvic-simulation/types/fixed_point/Math.hpp"
 #include "openvic-simulation/types/IndexedFlatMap.hpp"
 #include "openvic-simulation/population/PopSize.hpp"
 #include "openvic-simulation/population/PopSum.hpp"
 #include "openvic-simulation/types/UnitBranchType.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
 #include "openvic-simulation/core/Typedefs.hpp"
 
@@ -1331,7 +1331,7 @@ void CountryInstance::_update_production() {
 
 	for (auto const& [country, money_invested] : foreign_investments) {
 		if (country.get().exists()) {
-			const fixed_point_t investment_industrial_power = fixed_point_t::mul_div(
+			const fixed_point_t investment_industrial_power = fp::mul_div(
 				money_invested,
 				country_defines.get_country_investment_industrial_score_factor(),
 				100
@@ -1425,13 +1425,13 @@ void CountryInstance::_update_budget() {
 		administrative_efficiency_from_administrators.set(fixed_point_t::_1);
 		administrator_percentage.set(fixed_point_t::_0);
 	} else {		
-		administrator_percentage.set(fixed_point_t::from_fraction(administrators, total_non_colonial_population));
+		administrator_percentage.set(fp::from_fraction<pop_sum_t>(administrators, total_non_colonial_population));
 
-		const pop_sum_t desired_administrators = fixed_point_t::multiply_truncate(
+		const pop_sum_t desired_administrators = fp::multiply_truncate(
 			total_non_colonial_population,
 			desired_administrator_percentage.get_untracked()
 		);
-		const pop_sum_t effective_administrators = fixed_point_t::multiply_truncate(
+		const pop_sum_t effective_administrators = fp::multiply_truncate(
 			administrators,
 			fixed_point_t::_1 + get_modifier_effect_value(*modifier_effect_cache.get_administrative_efficiency())
 		);
@@ -1439,7 +1439,7 @@ void CountryInstance::_update_budget() {
 			desired_administrators == 0
 			? fixed_point_t::_1
 			: std::min(
-				fixed_point_t::from_fraction(effective_administrators, desired_administrators)
+				fp::from_fraction(effective_administrators, desired_administrators)
 					* (fixed_point_t::_1 + get_modifier_effect_value(*modifier_effect_cache.get_administrative_efficiency_modifier())),
 				fixed_point_t::_1
 			);
@@ -1564,14 +1564,14 @@ void CountryInstance::_update_population() {
 
 	for (auto const& [pop_type, pop_size] : get_population_by_type()) {
 		if (pop_type.research_leadership_optimum > 0 && pop_size > 0) {
-			const pop_sum_t optimum_size = fixed_point_t::multiply_truncate(
+			const pop_sum_t optimum_size = fp::multiply_truncate(
 				get_total_population(),
 				pop_type.research_leadership_optimum
 			);
 			const fixed_point_t factor = optimum_size == 0
 				? fixed_point_t::_1
 				: std::min(
-					fixed_point_t::from_fraction(
+					fp::from_fraction(
 						pop_size,
 						optimum_size
 					), fixed_point_t::_1
@@ -1638,7 +1638,7 @@ void CountryInstance::_update_military() {
 	}
 
 	military_power_from_land.set(
-		supply_consumption * fixed_point_t::mul_div(
+		supply_consumption * fp::mul_div(
 			sum_of_regiment_type_stats,
 			fixed_point_t::parse_raw(regular_army_size),
 			fixed_point_t::parse_raw(7 * (1 + unit_type_manager.get_regiment_type_count()))
@@ -1682,7 +1682,7 @@ void CountryInstance::_update_military() {
 	// TODO - use country_defines.get_min_mobilize_limit(); (wiki: "lowest maximum of brigades you can mobilize. (by default 3)")
 
 	mobilisation_max_regiment_count = regiment_count
-		+ fixed_point_t::multiply_truncate(regiment_count, mobilisation_impact);
+		+ fp::multiply_truncate(regiment_count, mobilisation_impact);
 
 	mobilisation_potential_regiment_count = 0; // TODO - calculate max regiments from poor citizens
 	if (mobilisation_potential_regiment_count > mobilisation_max_regiment_count) {
@@ -1709,7 +1709,7 @@ void CountryInstance::_update_military() {
 	naval_unit_start_experience += get_modifier_effect_value(*modifier_effect_cache.get_naval_unit_start_experience());
 
 	recruit_time = fixed_point_t::_1 + get_modifier_effect_value(*modifier_effect_cache.get_unit_recruitment_time());
-	combat_width = fixed_point_t::multiply_truncate(
+	combat_width = fp::multiply_truncate(
 		military_defines.get_base_combat_width(),
 		get_modifier_effect_value(*modifier_effect_cache.get_combat_width_additive())
 	);
@@ -2213,7 +2213,7 @@ void CountryInstance::manage_national_stockpile(
 				const fixed_point_t weight = weights[good_index];
 				const fixed_point_t max_costs = max_costs_per_good[good_index];
 				
-				fixed_point_t cash_available_for_good = fixed_point_t::mul_div(
+				fixed_point_t cash_available_for_good = fp::mul_div(
 					cash_left_to_spend_draft,
 					weight,
 					weights_sum
@@ -2470,7 +2470,7 @@ void CountryInstance::request_salaries_and_welfare_and_import_subsidies(Pop& pop
 	SharedPopTypeValues const& pop_type_values = shared_country_values.get_shared_pop_type_values(pop_type);
 
 	if (actual_administration_budget > 0) {
-		const fixed_point_t administration_salary = fixed_point_t::mul_div(
+		const fixed_point_t administration_salary = fp::mul_div(
 			pop_size * administration_salary_base_by_pop_type.at(pop_type).get_untracked(),
 			actual_administration_budget,
 			projected_administration_spending_unscaled_by_slider.get_untracked()
@@ -2482,7 +2482,7 @@ void CountryInstance::request_salaries_and_welfare_and_import_subsidies(Pop& pop
 	}
 
 	if (actual_education_budget > 0) {
-		const fixed_point_t education_salary = fixed_point_t::mul_div(
+		const fixed_point_t education_salary = fp::mul_div(
 			pop_size * education_salary_base_by_pop_type.at(pop_type).get_untracked(),
 			actual_education_budget,
 			projected_education_spending_unscaled_by_slider.get_untracked()
@@ -2494,7 +2494,7 @@ void CountryInstance::request_salaries_and_welfare_and_import_subsidies(Pop& pop
 	}
 
 	if (actual_military_budget > 0) {
-		const fixed_point_t military_salary = fixed_point_t::mul_div(
+		const fixed_point_t military_salary = fp::mul_div(
 			pop_size * military_salary_base_by_pop_type.at(pop_type).get_untracked(),
 			actual_military_budget,
 			projected_military_spending_unscaled_by_slider.get_untracked()
@@ -2506,7 +2506,7 @@ void CountryInstance::request_salaries_and_welfare_and_import_subsidies(Pop& pop
 	}
 
 	if (actual_social_budget > 0) {
-		const fixed_point_t pension_income = fixed_point_t::mul_div(
+		const fixed_point_t pension_income = fp::mul_div(
 			pop_size * calculate_pensions_base(pop_type),
 			actual_social_budget,
 			projected_social_spending_unscaled_by_slider.get_untracked()
@@ -2516,7 +2516,7 @@ void CountryInstance::request_salaries_and_welfare_and_import_subsidies(Pop& pop
 			actual_pensions_spending += pension_income;
 		}
 
-		const fixed_point_t unemployment_subsidies = fixed_point_t::mul_div(
+		const fixed_point_t unemployment_subsidies = fp::mul_div(
 			pop.get_unemployed() * calculate_unemployment_subsidies_base(pop_type),
 			actual_social_budget,
 			projected_social_spending_unscaled_by_slider.get_untracked()
@@ -2528,7 +2528,7 @@ void CountryInstance::request_salaries_and_welfare_and_import_subsidies(Pop& pop
 	}
 
 	if (actual_import_subsidies_budget > 0) {
-		const fixed_point_t import_subsidies = fixed_point_t::mul_div(
+		const fixed_point_t import_subsidies = fp::mul_div(
 			effective_tariff_rate.get_untracked() // < 0
 				* pop.get_yesterdays_import_value().get_copy_of_value(),
 			actual_import_subsidies_budget, // < 0
diff --git a/src/openvic-simulation/country/CountryInstance.hpp b/src/openvic-simulation/country/CountryInstance.hpp
index 655e73138..0854e6f45 100644
--- a/src/openvic-simulation/country/CountryInstance.hpp
+++ b/src/openvic-simulation/country/CountryInstance.hpp
@@ -1,10 +1,13 @@
 #pragma once
 
 #include <functional>
+#include <mutex>
 #include <utility>
 
 #include <fmt/base.h>
 
+#include "openvic-simulation/core/memory/SmartPtr.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/diplomacy/CountryRelation.hpp"
 #include "openvic-simulation/economy/BuildingLevel.hpp"
 #include "openvic-simulation/economy/BuildingRestrictionCategory.hpp"
@@ -27,7 +30,6 @@
 #include "openvic-simulation/types/UnitVariant.hpp"
 #include "openvic-simulation/types/ValueHistory.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/reactive/DerivedState.hpp"
 #include "openvic-simulation/utility/reactive/MutableState.hpp"
 
diff --git a/src/openvic-simulation/country/CountryInstanceManager.hpp b/src/openvic-simulation/country/CountryInstanceManager.hpp
index b43ed5e99..196aa679e 100644
--- a/src/openvic-simulation/country/CountryInstanceManager.hpp
+++ b/src/openvic-simulation/country/CountryInstanceManager.hpp
@@ -3,11 +3,11 @@
 #include <functional>
 #include <string_view>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/country/CountryInstance.hpp"
 #include "openvic-simulation/country/SharedCountryValues.hpp"
 #include "openvic-simulation/types/Date.hpp"
 #include "openvic-simulation/types/IndexedFlatMap.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {
diff --git a/src/openvic-simulation/dataloader/Dataloader.cpp b/src/openvic-simulation/dataloader/Dataloader.cpp
index 4d7fd6d39..06986c5ec 100644
--- a/src/openvic-simulation/dataloader/Dataloader.cpp
+++ b/src/openvic-simulation/dataloader/Dataloader.cpp
@@ -18,7 +18,6 @@
 #include "openvic-simulation/misc/SoundEffect.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
 #include "openvic-simulation/core/string/Utility.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/core/template/Concepts.hpp"
 
 using namespace OpenVic;
diff --git a/src/openvic-simulation/dataloader/Dataloader.hpp b/src/openvic-simulation/dataloader/Dataloader.hpp
index ef268f275..d5d5fc237 100644
--- a/src/openvic-simulation/dataloader/Dataloader.hpp
+++ b/src/openvic-simulation/dataloader/Dataloader.hpp
@@ -8,8 +8,8 @@
 
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 #include "openvic-simulation/dataloader/ModManager.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/core/template/Concepts.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 
 #include <function2/function2.hpp>
 
diff --git a/src/openvic-simulation/dataloader/NodeTools.hpp b/src/openvic-simulation/dataloader/NodeTools.hpp
index cd76905f4..b3582fafd 100644
--- a/src/openvic-simulation/dataloader/NodeTools.hpp
+++ b/src/openvic-simulation/dataloader/NodeTools.hpp
@@ -5,7 +5,6 @@
 #include <functional>
 #include <optional>
 #include <type_traits>
-#include <vector>
 
 #include <openvic-dataloader/detail/SymbolIntern.hpp>
 #include <openvic-dataloader/v2script/AbstractSyntaxTree.hpp>
@@ -24,9 +23,10 @@
 #include "openvic-simulation/types/Vector.hpp"
 #include "openvic-simulation/core/FormatValidate.hpp"
 #include "openvic-simulation/utility/TslHelper.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
-#include "openvic-simulation/core/template/Concepts.hpp"
+#include "openvic-simulation/core/memory/String.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/core/string/Utility.hpp"
+#include "openvic-simulation/core/template/Concepts.hpp"
 
 #include <function2/function2.hpp>
 
diff --git a/src/openvic-simulation/dataloader/Vic2PathSearch.cpp b/src/openvic-simulation/dataloader/Vic2PathSearch.cpp
index 11c079dc7..3b169d6ea 100644
--- a/src/openvic-simulation/dataloader/Vic2PathSearch.cpp
+++ b/src/openvic-simulation/dataloader/Vic2PathSearch.cpp
@@ -11,7 +11,6 @@
 
 #include "openvic-simulation/types/OrderedContainers.hpp"
 #include "openvic-simulation/utility/ConstexprIntToStr.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
 
 #include "Dataloader.hpp"
diff --git a/src/openvic-simulation/dataloader/Vic2PathSearch_Windows.hpp b/src/openvic-simulation/dataloader/Vic2PathSearch_Windows.hpp
index c1c456c59..f84d8002a 100644
--- a/src/openvic-simulation/dataloader/Vic2PathSearch_Windows.hpp
+++ b/src/openvic-simulation/dataloader/Vic2PathSearch_Windows.hpp
@@ -9,7 +9,7 @@
 
 #include <Windows.h>
 
-#include "openvic-simulation/utility/Containers.hpp"
+#include "openvic-simulation/core/memory/String.hpp"
 #include "openvic-simulation/core/template/Concepts.hpp"
 
 namespace OpenVic::Windows {
diff --git a/src/openvic-simulation/diplomacy/CountryRelation.hpp b/src/openvic-simulation/diplomacy/CountryRelation.hpp
index 915e89763..6780ae663 100644
--- a/src/openvic-simulation/diplomacy/CountryRelation.hpp
+++ b/src/openvic-simulation/diplomacy/CountryRelation.hpp
@@ -9,9 +9,10 @@
 #include <tuple>
 #include <type_traits>
 
+#include "openvic-simulation/core/Compare.hpp"
+#include "openvic-simulation/core/Hash.hpp"
 #include "openvic-simulation/types/Date.hpp"
 #include "openvic-simulation/types/OrderedContainers.hpp"
-#include "openvic-simulation/core/Hash.hpp"
 
 namespace OpenVic {
 	struct CountryInstance;
diff --git a/src/openvic-simulation/economy/BuildingType.hpp b/src/openvic-simulation/economy/BuildingType.hpp
index 9f2b5c828..4b9616aaa 100644
--- a/src/openvic-simulation/economy/BuildingType.hpp
+++ b/src/openvic-simulation/economy/BuildingType.hpp
@@ -3,6 +3,7 @@
 #include <functional>
 #include <optional>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/modifier/Modifier.hpp"
 #include "openvic-simulation/economy/BuildingLevel.hpp"
 #include "openvic-simulation/economy/BuildingRestrictionCategory.hpp"
@@ -11,7 +12,6 @@
 #include "openvic-simulation/types/IdentifierRegistry.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct BuildingTypeManager;
diff --git a/src/openvic-simulation/economy/GoodDefinition.hpp b/src/openvic-simulation/economy/GoodDefinition.hpp
index 64c45d291..44a19d2e5 100644
--- a/src/openvic-simulation/economy/GoodDefinition.hpp
+++ b/src/openvic-simulation/economy/GoodDefinition.hpp
@@ -2,11 +2,11 @@
 
 #include <functional>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/types/HasIdentifier.hpp"
 #include "openvic-simulation/types/HasIndex.hpp"
 #include "openvic-simulation/types/IdentifierRegistry.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct GoodDefinitionManager;
diff --git a/src/openvic-simulation/economy/production/ArtisanalProducer.cpp b/src/openvic-simulation/economy/production/ArtisanalProducer.cpp
index fef8535e2..18c4db0b8 100644
--- a/src/openvic-simulation/economy/production/ArtisanalProducer.cpp
+++ b/src/openvic-simulation/economy/production/ArtisanalProducer.cpp
@@ -21,6 +21,7 @@
 #include "openvic-simulation/population/Pop.hpp"
 #include "openvic-simulation/population/PopValuesFromProvince.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
+#include "openvic-simulation/types/fixed_point/Math.hpp"
 
 using namespace OpenVic;
 
@@ -231,7 +232,7 @@ void ArtisanalProducer::artisan_tick_handler::allocate_money_for_inputs(
 			}
 			const ptrdiff_t i = it - input_goods.begin();
 
-			const fixed_point_t optimal_quantity = fixed_point_t::mul_div(
+			const fixed_point_t optimal_quantity = fp::mul_div(
 				demand_per_input[i],
 				max_possible_satisfaction_numerator,
 				max_possible_satisfaction_denominator
@@ -259,7 +260,7 @@ void ArtisanalProducer::artisan_tick_handler::allocate_money_for_inputs(
 
 		const fixed_point_t max_quantity_to_buy = good_demand - stockpiled_quantity;
 		if (max_quantity_to_buy > 0) {
-			const fixed_point_t optimal_quantity = fixed_point_t::mul_div(
+			const fixed_point_t optimal_quantity = fp::mul_div(
 				good_demand,
 				max_possible_satisfaction_numerator,
 				max_possible_satisfaction_denominator
@@ -490,11 +491,15 @@ fixed_point_t ArtisanalProducer::calculate_production_type_score(
 	static_assert(0 <= k);
 	static_assert(k <= 1);
 
-	return (
-		k * fixed_point_t::mul_div(costs, costs, revenue)
-		-(1+k)*costs
-		+ revenue
-	).mul_div(Pop::size_denominator, workforce); //factor out pop size without making values too small
+	return fp::mul_div(
+		(
+			k * fp::mul_div(costs, costs, revenue)
+			-(1+k)*costs
+			+ revenue
+		),
+		Pop::size_denominator,
+		workforce
+	); //factor out pop size without making values too small
 }
 
 ProductionType const* ArtisanalProducer::pick_production_type(
diff --git a/src/openvic-simulation/economy/production/ArtisanalProducer.hpp b/src/openvic-simulation/economy/production/ArtisanalProducer.hpp
index fa06298f8..a6dc3987f 100644
--- a/src/openvic-simulation/economy/production/ArtisanalProducer.hpp
+++ b/src/openvic-simulation/economy/production/ArtisanalProducer.hpp
@@ -3,6 +3,7 @@
 #include <cstdint>
 #include <optional>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/types/IndexedFlatMap.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp"
diff --git a/src/openvic-simulation/economy/production/ProductionType.hpp b/src/openvic-simulation/economy/production/ProductionType.hpp
index 170f26f1f..b554c2f9e 100644
--- a/src/openvic-simulation/economy/production/ProductionType.hpp
+++ b/src/openvic-simulation/economy/production/ProductionType.hpp
@@ -2,13 +2,13 @@
 
 #include <openvic-dataloader/v2script/Parser.hpp>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/scripts/ConditionScript.hpp"
 #include "openvic-simulation/types/IdentifierRegistry.hpp"
 #include "openvic-simulation/types/IndexedFlatMap.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/population/PopSize.hpp"
 #include "openvic-simulation/types/PopSprite.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct PopType;
diff --git a/src/openvic-simulation/economy/production/ResourceGatheringOperation.cpp b/src/openvic-simulation/economy/production/ResourceGatheringOperation.cpp
index 2ac1e6dd3..4059db807 100644
--- a/src/openvic-simulation/economy/production/ResourceGatheringOperation.cpp
+++ b/src/openvic-simulation/economy/production/ResourceGatheringOperation.cpp
@@ -10,13 +10,13 @@
 #include "openvic-simulation/map/State.hpp"
 #include "openvic-simulation/modifier/ModifierEffectCache.hpp"
 #include "openvic-simulation/population/Pop.hpp"
-#include "openvic-simulation/population/PopType.hpp"
-#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/population/PopSize.hpp"
 #include "openvic-simulation/population/PopSum.hpp"
+#include "openvic-simulation/population/PopType.hpp"
+#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
+#include "openvic-simulation/types/fixed_point/Math.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 #include <type_safe/strong_typedef.hpp>
 
@@ -80,7 +80,7 @@ void ResourceGatheringOperation::initialise_rgo_size_multiplier() {
 	} else {
 		size_multiplier = (
 			(
-				fixed_point_t::from_fraction<pop_sum_t>(
+				fp::from_fraction<pop_sum_t>(
 					total_worker_count_in_province,
 					base_workforce_size
 				) / size_modifier
@@ -198,7 +198,7 @@ void ResourceGatheringOperation::hire() {
 		proportion_to_hire = 1;
 	} else {
 		//hire all pops proportionally
-		proportion_to_hire = fixed_point_t::from_fraction<pop_sum_t>(max_employee_count_cache, available_worker_count);
+		proportion_to_hire = fp::from_fraction<pop_sum_t>(max_employee_count_cache, available_worker_count);
 	}
 
 	std::span<const Job> jobs = production_type.get_jobs();
@@ -256,13 +256,15 @@ fixed_point_t ResourceGatheringOperation::produce() {
 		if (total_owner_count_in_state_cache > 0) {
 			switch (owner_job.effect_type) {
 				case Job::effect_t::OUTPUT:
-					output_multiplier += owner_job.effect_multiplier.mul_div(
+					output_multiplier += fp::mul_div(
+						owner_job.effect_multiplier,
 						total_owner_count_in_state_cache,
 						state_population
 					);
 					break;
 				case Job::effect_t::THROUGHPUT:
-					throughput_multiplier += owner_job.effect_multiplier.mul_div(
+					throughput_multiplier += fp::mul_div(
+						owner_job.effect_multiplier,
 						total_owner_count_in_state_cache,
 						state_population
 					);
@@ -323,9 +325,9 @@ fixed_point_t ResourceGatheringOperation::produce() {
 			const fixed_point_t effect_multiplier = job.effect_multiplier;
 			const fixed_point_t amount = job.amount;
 			const fixed_point_t effect = effect_multiplier != fixed_point_t::_1
-				&& fixed_point_t::from_fraction(employees_of_type, max_employee_count_cache) > amount
+				&& fp::from_fraction<pop_size_t>(employees_of_type, max_employee_count_cache) > amount
 				? effect_multiplier * amount //special Vic2 logic
-				: effect_multiplier.mul_div(employees_of_type, max_employee_count_cache);
+				: fp::mul_div(effect_multiplier, employees_of_type, max_employee_count_cache);
 
 			switch (job.effect_type) {
 				case Job::effect_t::OUTPUT:
@@ -377,7 +379,7 @@ void ResourceGatheringOperation::pay_employees(memory::vector<fixed_point_t>& re
 	if (revenue <= total_minimum_wage) {
 		for (Employee& employee : employees) {
 			const fixed_point_t income_for_this_pop = std::max(
-				fixed_point_t::mul_div(
+				fp::mul_div(
 					revenue,
 					employee.get_minimum_wage_cached(),
 					total_minimum_wage
@@ -396,13 +398,17 @@ void ResourceGatheringOperation::pay_employees(memory::vector<fixed_point_t>& re
 				fixed_point_t::_1 - total_minimum_wage / revenue_left
 			);
 			const fixed_point_t owner_share = std::min(
-				fixed_point_t::from_fraction(2 * total_owner_count_in_state_cache, total_worker_count_in_province_cache),
+				fp::from_fraction(2 * total_owner_count_in_state_cache, total_worker_count_in_province_cache),
 				upper_limit
 			);
 
 			for (Pop& owner_pop : *owner_pops_cache_nullable) {
 				const fixed_point_t income_for_this_pop = std::max(
-					revenue_left * owner_share.mul_div<pop_sum_t>(owner_pop.get_size(), total_owner_count_in_state_cache),
+					revenue_left * fp::mul_div<pop_sum_t>(
+						owner_share,
+						owner_pop.get_size(),
+						total_owner_count_in_state_cache
+					),
 					fixed_point_t::epsilon //revenue > 0 is already checked, so rounding up
 				);
 				owner_pop.add_rgo_owner_income(income_for_this_pop);
@@ -435,7 +441,11 @@ void ResourceGatheringOperation::pay_employees(memory::vector<fixed_point_t>& re
 
 				const pop_size_t employee_size = employee.get_size();
 				const fixed_point_t income_for_this_pop = std::max(
-					revenue_left.mul_div(employee_size, count_workers_to_be_paid),
+					fp::mul_div(
+						revenue_left,
+						employee_size,
+						count_workers_to_be_paid
+					),
 					fixed_point_t::epsilon //revenue > 0 is already checked, so rounding up
 				);
 
diff --git a/src/openvic-simulation/economy/production/ResourceGatheringOperation.hpp b/src/openvic-simulation/economy/production/ResourceGatheringOperation.hpp
index 29adf0b94..2667acfff 100644
--- a/src/openvic-simulation/economy/production/ResourceGatheringOperation.hpp
+++ b/src/openvic-simulation/economy/production/ResourceGatheringOperation.hpp
@@ -2,13 +2,13 @@
 
 #include <functional>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/economy/production/Employee.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/IndexedFlatMap.hpp"
 #include "openvic-simulation/population/PopSize.hpp"
 #include "openvic-simulation/population/PopSum.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct MarketInstance;
diff --git a/src/openvic-simulation/economy/trading/GoodMarket.cpp b/src/openvic-simulation/economy/trading/GoodMarket.cpp
index 8a735c169..1bb92a6ef 100644
--- a/src/openvic-simulation/economy/trading/GoodMarket.cpp
+++ b/src/openvic-simulation/economy/trading/GoodMarket.cpp
@@ -6,7 +6,7 @@
 #include "openvic-simulation/economy/trading/MarketSellOrder.hpp"
 #include "openvic-simulation/misc/GameRulesManager.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
+#include "openvic-simulation/types/fixed_point/Math.hpp"
 
 using namespace OpenVic;
 static constexpr size_t MONTHS_OF_PRICE_HISTORY = 36;
@@ -200,7 +200,7 @@ void GoodMarket::execute_orders(
 						actual_bought_per_country[country_index_optional.value()] -= distributed_supply;
 					}
 
-					distributed_supply = fixed_point_t::mul_div(
+					distributed_supply = fp::mul_div(
 						remaining_supply,
 						purchasing_power_per_order[i],
 						purchasing_power_sum
@@ -351,7 +351,7 @@ void GoodMarket::execute_orders(
 					const fixed_point_t total_domestic_supply = supply_per_country[country_index];
 					quantity_sold_domestically = total_bought_domestically >= total_domestic_supply
 						? quantity_offered
-						: fixed_point_t::mul_div(
+						: fp::mul_div(
 							quantity_offered,
 							total_bought_domestically,
 							total_domestic_supply //> 0 as we're selling
@@ -359,7 +359,7 @@ void GoodMarket::execute_orders(
 					quantity_offered_as_export = quantity_offered - quantity_sold_domestically;
 				}
 
-				const fixed_point_t fair_share_of_exports = fixed_point_t::mul_div(
+				const fixed_point_t fair_share_of_exports = fp::mul_div(
 					quantity_offered_as_export,
 					total_quantity_traded_as_export,
 					total_quantity_offered_as_export
@@ -438,7 +438,7 @@ void GoodMarket::execute_buy_orders(
 					//no imports
 					money_spent_on_imports = 0;
 				} else {
-					const fixed_point_t money_spent_domestically = fixed_point_t::mul_div(
+					const fixed_point_t money_spent_domestically = fp::mul_div(
 						money_spent_total,
 						supply_in_my_country,
 						actual_bought_in_my_country
diff --git a/src/openvic-simulation/economy/trading/GoodMarket.hpp b/src/openvic-simulation/economy/trading/GoodMarket.hpp
index 0abedcfd0..04f90b2b7 100644
--- a/src/openvic-simulation/economy/trading/GoodMarket.hpp
+++ b/src/openvic-simulation/economy/trading/GoodMarket.hpp
@@ -3,13 +3,13 @@
 #include <mutex>
 #include <span>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/economy/trading/BuyUpToOrder.hpp"
 #include "openvic-simulation/economy/trading/MarketSellOrder.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
 #include "openvic-simulation/types/TypedSpan.hpp"
 #include "openvic-simulation/types/ValueHistory.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {
diff --git a/src/openvic-simulation/economy/trading/MarketInstance.cpp b/src/openvic-simulation/economy/trading/MarketInstance.cpp
index 3dde889c2..a655efe29 100644
--- a/src/openvic-simulation/economy/trading/MarketInstance.cpp
+++ b/src/openvic-simulation/economy/trading/MarketInstance.cpp
@@ -6,7 +6,6 @@
 #include "openvic-simulation/economy/trading/BuyUpToOrder.hpp"
 #include "openvic-simulation/economy/trading/MarketSellOrder.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/ThreadPool.hpp"
 #include "openvic-simulation/core/Typedefs.hpp"
 
diff --git a/src/openvic-simulation/economy/trading/MarketInstance.hpp b/src/openvic-simulation/economy/trading/MarketInstance.hpp
index 57d4c527a..0750084f7 100644
--- a/src/openvic-simulation/economy/trading/MarketInstance.hpp
+++ b/src/openvic-simulation/economy/trading/MarketInstance.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct BuyUpToOrder;
diff --git a/src/openvic-simulation/economy/trading/MarketSellOrder.hpp b/src/openvic-simulation/economy/trading/MarketSellOrder.hpp
index 975c18aa7..7c059c42f 100644
--- a/src/openvic-simulation/economy/trading/MarketSellOrder.hpp
+++ b/src/openvic-simulation/economy/trading/MarketSellOrder.hpp
@@ -3,8 +3,8 @@
 #include <optional>
 
 #include "openvic-simulation/economy/trading/SellResult.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct GoodDefinition;
diff --git a/src/openvic-simulation/history/CountryHistory.hpp b/src/openvic-simulation/history/CountryHistory.hpp
index 72ac07278..1cdb25977 100644
--- a/src/openvic-simulation/history/CountryHistory.hpp
+++ b/src/openvic-simulation/history/CountryHistory.hpp
@@ -2,13 +2,13 @@
 
 #include <optional>
 
+#include "openvic-simulation/core/memory/SmartPtr.hpp"
 #include "openvic-simulation/history/HistoryMap.hpp"
 #include "openvic-simulation/types/Date.hpp"
 #include "openvic-simulation/types/IndexedFlatMap.hpp"
 #include "openvic-simulation/types/OrderedContainers.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp"
 #include "openvic-simulation/research/TechnologyUnlockLevel.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct CountryHistoryMap;
diff --git a/src/openvic-simulation/history/DiplomaticHistory.cpp b/src/openvic-simulation/history/DiplomaticHistory.cpp
index 916bf2e9f..1b4f20d86 100644
--- a/src/openvic-simulation/history/DiplomaticHistory.cpp
+++ b/src/openvic-simulation/history/DiplomaticHistory.cpp
@@ -1,7 +1,6 @@
 #include "DiplomaticHistory.hpp"
 
 #include "openvic-simulation/DefinitionManager.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/history/DiplomaticHistory.hpp"
 
 using namespace OpenVic;
diff --git a/src/openvic-simulation/history/DiplomaticHistory.hpp b/src/openvic-simulation/history/DiplomaticHistory.hpp
index 6acd8a14e..3fc829da7 100644
--- a/src/openvic-simulation/history/DiplomaticHistory.hpp
+++ b/src/openvic-simulation/history/DiplomaticHistory.hpp
@@ -2,13 +2,13 @@
 
 #include <functional>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 #include "openvic-simulation/history/diplomacy/AllianceHistory.hpp"
 #include "openvic-simulation/history/diplomacy/ReparationsHistory.hpp"
 #include "openvic-simulation/history/diplomacy/SubjectHistory.hpp"
 #include "openvic-simulation/history/diplomacy/WarHistory.hpp"
 #include "openvic-simulation/types/Date.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct CountryDefinitionManager;
diff --git a/src/openvic-simulation/history/HistoryMap.hpp b/src/openvic-simulation/history/HistoryMap.hpp
index 828a7032e..c106b0caa 100644
--- a/src/openvic-simulation/history/HistoryMap.hpp
+++ b/src/openvic-simulation/history/HistoryMap.hpp
@@ -3,10 +3,11 @@
 #include <algorithm>
 #include <system_error>
 
+#include "openvic-simulation/core/memory/SmartPtr.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 #include "openvic-simulation/types/Date.hpp"
 #include "openvic-simulation/types/OrderedContainers.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 
diff --git a/src/openvic-simulation/history/ProvinceHistory.cpp b/src/openvic-simulation/history/ProvinceHistory.cpp
index 099fc2e07..f9268bacf 100644
--- a/src/openvic-simulation/history/ProvinceHistory.cpp
+++ b/src/openvic-simulation/history/ProvinceHistory.cpp
@@ -9,7 +9,6 @@
 #include "openvic-simulation/economy/GoodDefinition.hpp"
 #include "openvic-simulation/map/ProvinceDefinition.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 using namespace OpenVic;
 using namespace OpenVic::NodeTools;
diff --git a/src/openvic-simulation/history/ProvinceHistory.hpp b/src/openvic-simulation/history/ProvinceHistory.hpp
index 37b7c27a8..12c37acbd 100644
--- a/src/openvic-simulation/history/ProvinceHistory.hpp
+++ b/src/openvic-simulation/history/ProvinceHistory.hpp
@@ -2,6 +2,7 @@
 
 #include <optional>
 
+#include "openvic-simulation/core/memory/SmartPtr.hpp"
 #include "openvic-simulation/economy/BuildingType.hpp"
 #include "openvic-simulation/history/HistoryMap.hpp"
 #include "openvic-simulation/population/Pop.hpp"
@@ -14,7 +15,6 @@
 #include "openvic-simulation/types/TypedSpan.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
 #include "openvic-simulation/map/LifeRating.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {
diff --git a/src/openvic-simulation/history/diplomacy/WarHistory.hpp b/src/openvic-simulation/history/diplomacy/WarHistory.hpp
index 30bc8939a..2a13ce3b3 100644
--- a/src/openvic-simulation/history/diplomacy/WarHistory.hpp
+++ b/src/openvic-simulation/history/diplomacy/WarHistory.hpp
@@ -3,9 +3,9 @@
 #include <optional>
 #include <type_traits>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/history/Period.hpp"
 #include "openvic-simulation/types/Date.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {
diff --git a/src/openvic-simulation/interface/GFXObject.hpp b/src/openvic-simulation/interface/GFXObject.hpp
index 03dcfd926..3f3aa0aba 100644
--- a/src/openvic-simulation/interface/GFXObject.hpp
+++ b/src/openvic-simulation/interface/GFXObject.hpp
@@ -2,10 +2,10 @@
 
 #include <cstdint>
 
-#include "openvic-simulation/interface/LoadBase.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/core/ui/TextFormat.hpp"
+#include "openvic-simulation/interface/LoadBase.hpp"
 #include "openvic-simulation/types/Vector.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic::GFX {
 
diff --git a/src/openvic-simulation/interface/GFXSprite.hpp b/src/openvic-simulation/interface/GFXSprite.hpp
index 58e0c5726..8c8e963e4 100644
--- a/src/openvic-simulation/interface/GFXSprite.hpp
+++ b/src/openvic-simulation/interface/GFXSprite.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "openvic-simulation/core/memory/SmartPtr.hpp"
+#include "openvic-simulation/core/memory/String.hpp"
 #include "openvic-simulation/interface/LoadBase.hpp"
 #include "openvic-simulation/types/HasIdentifier.hpp"
 
diff --git a/src/openvic-simulation/map/MapDefinition.cpp b/src/openvic-simulation/map/MapDefinition.cpp
index a50ae778b..cc3b4cd37 100644
--- a/src/openvic-simulation/map/MapDefinition.cpp
+++ b/src/openvic-simulation/map/MapDefinition.cpp
@@ -8,7 +8,6 @@
 #include <cstdint>
 #include <limits>
 #include <system_error>
-#include <vector>
 
 #include <fmt/std.h>
 
@@ -17,19 +16,20 @@
 
 #include <type_safe/strong_typedef.hpp>
 
+#include "openvic-simulation/core/FormatValidate.hpp"
 #include "openvic-simulation/core/io/BMP.hpp"
+#include "openvic-simulation/core/string/CharConv.hpp"
+#include "openvic-simulation/core/Typedefs.hpp"
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 #include "openvic-simulation/map/ProvinceDefinition.hpp"
 #include "openvic-simulation/modifier/ModifierManager.hpp"
 #include "openvic-simulation/types/Colour.hpp"
+#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
+#include "openvic-simulation/types/fixed_point/Math.hpp"
 #include "openvic-simulation/types/OrderedContainersMath.hpp"
 #include "openvic-simulation/types/TypedSpan.hpp"
 #include "openvic-simulation/types/Vector.hpp"
-#include "openvic-simulation/core/FormatValidate.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
-#include "openvic-simulation/core/string/CharConv.hpp"
-#include "openvic-simulation/core/Typedefs.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 using namespace OpenVic;
 using namespace OpenVic::NodeTools;
@@ -111,7 +111,9 @@ ProvinceDefinition::distance_t MapDefinition::calculate_distance_between(
 		)
 	);
 
-	return fvec2_t { min_x, to_pos.y - from_pos.y }.length_squared().sqrt();
+	return fp::sqrt(
+		fvec2_t { min_x, to_pos.y - from_pos.y }.length_squared()
+	);
 }
 
 using adjacency_t = ProvinceDefinition::adjacency_t;
diff --git a/src/openvic-simulation/map/MapDefinition.hpp b/src/openvic-simulation/map/MapDefinition.hpp
index c52099ac4..a2aa45f95 100644
--- a/src/openvic-simulation/map/MapDefinition.hpp
+++ b/src/openvic-simulation/map/MapDefinition.hpp
@@ -8,6 +8,7 @@
 #include <openvic-dataloader/csv/LineObject.hpp>
 
 #include "openvic-simulation/core/io/BMP.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/map/ProvinceDefinition.hpp"
 #include "openvic-simulation/map/Region.hpp"
 #include "openvic-simulation/map/TerrainType.hpp"
@@ -16,7 +17,6 @@
 #include "openvic-simulation/types/IdentifierRegistry.hpp"
 #include "openvic-simulation/types/OrderedContainers.hpp"
 #include "openvic-simulation/types/Vector.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct BuildingTypeManager;
diff --git a/src/openvic-simulation/map/ProvinceDefinition.cpp b/src/openvic-simulation/map/ProvinceDefinition.cpp
index 78f9b2751..ee0a49181 100644
--- a/src/openvic-simulation/map/ProvinceDefinition.cpp
+++ b/src/openvic-simulation/map/ProvinceDefinition.cpp
@@ -5,7 +5,7 @@
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 #include "openvic-simulation/economy/BuildingType.hpp"
 #include "openvic-simulation/map/MapDefinition.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
+#include "openvic-simulation/types/fixed_point/Math.hpp"
 
 using namespace OpenVic;
 using namespace OpenVic::NodeTools;
@@ -64,7 +64,10 @@ bool ProvinceDefinition::load_positions(
 			const fixed_point_t rotation = get_building_rotation(building_type_manager.get_port_building_type());
 
 			/* At 0 rotation the port faces west, as rotation increases the port rotates anti-clockwise. */
-			const fvec2_t port_dir { -rotation.cos(), rotation.sin() };
+			const fvec2_t port_dir {
+				-fp::cos(rotation),
+				fp::sin(rotation)
+			};
 			const ivec2_t port_facing_position = static_cast<ivec2_t>(*port_position + port_dir / 4);
 
 			ProvinceDefinition const* province_ptr = map_definition.get_province_definition_at(port_facing_position);
diff --git a/src/openvic-simulation/map/ProvinceDefinition.hpp b/src/openvic-simulation/map/ProvinceDefinition.hpp
index 2a644fee3..29c991c0b 100644
--- a/src/openvic-simulation/map/ProvinceDefinition.hpp
+++ b/src/openvic-simulation/map/ProvinceDefinition.hpp
@@ -5,6 +5,7 @@
 
 #include <type_safe/strong_typedef.hpp>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp"
@@ -13,7 +14,6 @@
 #include "openvic-simulation/types/OrderedContainers.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
 #include "openvic-simulation/types/Vector.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 
diff --git a/src/openvic-simulation/map/ProvinceInstance.hpp b/src/openvic-simulation/map/ProvinceInstance.hpp
index f280155c7..4e77066d7 100644
--- a/src/openvic-simulation/map/ProvinceInstance.hpp
+++ b/src/openvic-simulation/map/ProvinceInstance.hpp
@@ -2,8 +2,8 @@
 
 #include <functional>
 
-#include <plf_colony.h>
-
+#include "openvic-simulation/core/memory/Colony.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/core/portable/ForwardableSpan.hpp"
 #include "openvic-simulation/economy/BuildingInstance.hpp"
 #include "openvic-simulation/economy/production/ResourceGatheringOperation.hpp"
@@ -22,7 +22,6 @@
 #include "openvic-simulation/types/TypedIndices.hpp"
 #include "openvic-simulation/types/TypedSpan.hpp"
 #include "openvic-simulation/types/UnitBranchType.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct BaseIssue;
diff --git a/src/openvic-simulation/map/Region.hpp b/src/openvic-simulation/map/Region.hpp
index abed3a3e0..fffecd617 100644
--- a/src/openvic-simulation/map/Region.hpp
+++ b/src/openvic-simulation/map/Region.hpp
@@ -4,9 +4,9 @@
 #include <ranges>
 #include <string_view>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/modifier/Modifier.hpp"
 #include "openvic-simulation/types/HasIdentifier.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct ProvinceDefinition;
diff --git a/src/openvic-simulation/map/State.cpp b/src/openvic-simulation/map/State.cpp
index 6fa3b5847..c4992c84d 100644
--- a/src/openvic-simulation/map/State.cpp
+++ b/src/openvic-simulation/map/State.cpp
@@ -9,7 +9,6 @@
 #include "openvic-simulation/population/Pop.hpp"
 #include "openvic-simulation/population/PopType.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 using namespace OpenVic;
 
diff --git a/src/openvic-simulation/map/State.hpp b/src/openvic-simulation/map/State.hpp
index 038c11b04..a695f1235 100644
--- a/src/openvic-simulation/map/State.hpp
+++ b/src/openvic-simulation/map/State.hpp
@@ -3,12 +3,12 @@
 #include <functional>
 
 #include <fmt/base.h>
-#include <plf_colony.h>
 
+#include "openvic-simulation/core/memory/Colony.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/population/PopsAggregate.hpp"
 #include "openvic-simulation/types/ColonyStatus.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/core/portable/ForwardableSpan.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
diff --git a/src/openvic-simulation/map/TerrainType.cpp b/src/openvic-simulation/map/TerrainType.cpp
index 510c232a3..e7326cac8 100644
--- a/src/openvic-simulation/map/TerrainType.cpp
+++ b/src/openvic-simulation/map/TerrainType.cpp
@@ -6,7 +6,6 @@
 #include "openvic-simulation/types/Colour.hpp"
 #include "openvic-simulation/types/HasIdentifier.hpp"
 #include "openvic-simulation/core/FormatValidate.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 using namespace OpenVic;
 using namespace OpenVic::NodeTools;
diff --git a/src/openvic-simulation/map/TerrainType.hpp b/src/openvic-simulation/map/TerrainType.hpp
index 802eef402..8527b8f45 100644
--- a/src/openvic-simulation/map/TerrainType.hpp
+++ b/src/openvic-simulation/map/TerrainType.hpp
@@ -1,11 +1,11 @@
 #pragma once
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/modifier/Modifier.hpp"
 #include "openvic-simulation/types/HasIdentifier.hpp"
 #include "openvic-simulation/types/HasIndex.hpp"
 #include "openvic-simulation/types/OrderedContainers.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	// Using HasColour rather than HasIdentifierAndColour to avoid needing virtual inheritance
diff --git a/src/openvic-simulation/military/Deployment.cpp b/src/openvic-simulation/military/Deployment.cpp
index 6959d7b54..dfeba572d 100644
--- a/src/openvic-simulation/military/Deployment.cpp
+++ b/src/openvic-simulation/military/Deployment.cpp
@@ -6,7 +6,6 @@
 #include "openvic-simulation/military/Leader.hpp"
 #include "openvic-simulation/military/LeaderTrait.hpp"
 #include "openvic-simulation/military/UnitType.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 using namespace OpenVic;
 using namespace OpenVic::NodeTools;
diff --git a/src/openvic-simulation/military/Deployment.hpp b/src/openvic-simulation/military/Deployment.hpp
index c3c1a073b..c4c2574b7 100644
--- a/src/openvic-simulation/military/Deployment.hpp
+++ b/src/openvic-simulation/military/Deployment.hpp
@@ -4,12 +4,12 @@
 #include <optional>
 #include <string_view>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/military/Leader.hpp"
 #include "openvic-simulation/military/UnitBranchedGetterMacro.hpp"
 #include "openvic-simulation/types/HasIdentifier.hpp"
 #include "openvic-simulation/types/IdentifierRegistry.hpp"
 #include "openvic-simulation/types/UnitBranchType.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {
diff --git a/src/openvic-simulation/military/LeaderTrait.hpp b/src/openvic-simulation/military/LeaderTrait.hpp
index 8bc4c93e2..f43d90e25 100644
--- a/src/openvic-simulation/military/LeaderTrait.hpp
+++ b/src/openvic-simulation/military/LeaderTrait.hpp
@@ -2,10 +2,10 @@
 
 #include <string_view>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 #include "openvic-simulation/modifier/Modifier.hpp"
 #include "openvic-simulation/types/IdentifierRegistry.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct LeaderTrait : Modifier {
diff --git a/src/openvic-simulation/military/UnitInstanceGroup.cpp b/src/openvic-simulation/military/UnitInstanceGroup.cpp
index c649a633e..08e336d85 100644
--- a/src/openvic-simulation/military/UnitInstanceGroup.cpp
+++ b/src/openvic-simulation/military/UnitInstanceGroup.cpp
@@ -1,7 +1,5 @@
 #include "UnitInstanceGroup.hpp"
 
-#include <vector>
-
 #include <fmt/std.h>
 
 #include "openvic-simulation/country/CountryInstance.hpp"
@@ -13,7 +11,6 @@
 #include "openvic-simulation/population/Culture.hpp"
 #include "openvic-simulation/population/PopType.hpp"
 #include "openvic-simulation/types/OrderedContainersMath.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 using namespace OpenVic;
 
diff --git a/src/openvic-simulation/military/UnitInstanceGroup.hpp b/src/openvic-simulation/military/UnitInstanceGroup.hpp
index cbd94049d..ee2804ab7 100644
--- a/src/openvic-simulation/military/UnitInstanceGroup.hpp
+++ b/src/openvic-simulation/military/UnitInstanceGroup.hpp
@@ -3,15 +3,13 @@
 #include <functional>
 #include <string_view>
 
-#include <plf_colony.h>
-
+#include "openvic-simulation/core/memory/Colony.hpp"
 #include "openvic-simulation/military/Leader.hpp"
 #include "openvic-simulation/military/UnitInstance.hpp"
 #include "openvic-simulation/military/UnitType.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/UnitBranchType.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 #include "openvic-simulation/military/UnitBranchedGetterMacro.hpp" //below other imports that undef the macros
 
diff --git a/src/openvic-simulation/military/Wargoal.hpp b/src/openvic-simulation/military/Wargoal.hpp
index 4cb2fc775..daeb958a5 100644
--- a/src/openvic-simulation/military/Wargoal.hpp
+++ b/src/openvic-simulation/military/Wargoal.hpp
@@ -4,12 +4,12 @@
 
 #include <openvic-dataloader/v2script/Parser.hpp>
 
+#include "openvic-simulation/core/memory/String.hpp"
 #include "openvic-simulation/scripts/ConditionScript.hpp"
 #include "openvic-simulation/scripts/EffectScript.hpp"
 #include "openvic-simulation/core/template/EnumBitfield.hpp"
 #include "openvic-simulation/types/IdentifierRegistry.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct WargoalTypeManager;
diff --git a/src/openvic-simulation/misc/Event.cpp b/src/openvic-simulation/misc/Event.cpp
index 1ea77109f..d54f8b7aa 100644
--- a/src/openvic-simulation/misc/Event.cpp
+++ b/src/openvic-simulation/misc/Event.cpp
@@ -7,7 +7,6 @@
 
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 #include "openvic-simulation/politics/IssueManager.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 using namespace OpenVic;
 using namespace OpenVic::NodeTools;
diff --git a/src/openvic-simulation/misc/Event.hpp b/src/openvic-simulation/misc/Event.hpp
index f72f1b55b..c909f8e54 100644
--- a/src/openvic-simulation/misc/Event.hpp
+++ b/src/openvic-simulation/misc/Event.hpp
@@ -1,11 +1,12 @@
 #pragma once
 
+#include "openvic-simulation/core/memory/String.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/politics/IssueGroup.hpp"
 #include "openvic-simulation/scripts/ConditionalWeight.hpp"
 #include "openvic-simulation/scripts/EffectScript.hpp"
 #include "openvic-simulation/types/IdentifierRegistry.hpp"
 #include "openvic-simulation/types/OrderedContainers.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct EventManager;
diff --git a/src/openvic-simulation/misc/SimulationClock.hpp b/src/openvic-simulation/misc/SimulationClock.hpp
index c4c3af0a4..5d7d9b8c8 100644
--- a/src/openvic-simulation/misc/SimulationClock.hpp
+++ b/src/openvic-simulation/misc/SimulationClock.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
 #include <chrono>
-#include <vector>
 
 #include "openvic-simulation/utility/Getters.hpp"
 
diff --git a/src/openvic-simulation/modifier/ModifierSum.hpp b/src/openvic-simulation/modifier/ModifierSum.hpp
index 5e5c78810..72b2459c2 100644
--- a/src/openvic-simulation/modifier/ModifierSum.hpp
+++ b/src/openvic-simulation/modifier/ModifierSum.hpp
@@ -1,13 +1,12 @@
 #pragma once
 
-#include <concepts>
 #include <variant>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 #include "openvic-simulation/modifier/ModifierValue.hpp"
 #include "openvic-simulation/modifier/Modifier.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct CountryInstance;
diff --git a/src/openvic-simulation/pathfinding/AStarPathing.cpp b/src/openvic-simulation/pathfinding/AStarPathing.cpp
index a4d314b20..4667ee138 100644
--- a/src/openvic-simulation/pathfinding/AStarPathing.cpp
+++ b/src/openvic-simulation/pathfinding/AStarPathing.cpp
@@ -15,7 +15,6 @@
 #include "openvic-simulation/military/UnitInstanceGroup.hpp"
 #include "openvic-simulation/pathfinding/PointMap.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/core/Typedefs.hpp"
 
 using namespace OpenVic;
diff --git a/src/openvic-simulation/pathfinding/FringePathing.cpp b/src/openvic-simulation/pathfinding/FringePathing.cpp
index bdf67e635..2381163be 100644
--- a/src/openvic-simulation/pathfinding/FringePathing.cpp
+++ b/src/openvic-simulation/pathfinding/FringePathing.cpp
@@ -1,7 +1,5 @@
 #include "openvic-simulation/pathfinding/FringePathing.hpp"
 
-#include <vector>
-
 #include <tsl/ordered_map.h>
 #include <tsl/ordered_set.h>
 
@@ -13,7 +11,6 @@
 
 #include "openvic-simulation/pathfinding/PointMap.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 using namespace OpenVic;
 
diff --git a/src/openvic-simulation/pathfinding/PathingBase.hpp b/src/openvic-simulation/pathfinding/PathingBase.hpp
index 3ab4f0bf4..0ee32634a 100644
--- a/src/openvic-simulation/pathfinding/PathingBase.hpp
+++ b/src/openvic-simulation/pathfinding/PathingBase.hpp
@@ -5,10 +5,12 @@
 #include <fmt/core.h>
 
 #include "openvic-simulation/core/error/ErrorMacros.hpp"
+#include "openvic-simulation/core/memory/Formatting.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/pathfinding/PointMap.hpp"
 #include "openvic-simulation/types/Signal.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
+#include "openvic-simulation/types/fixed_point/Math.hpp"
 
 #include <foonathan/memory/default_allocator.hpp>
 #include <foonathan/memory/std_allocator.hpp>
@@ -64,11 +66,15 @@ namespace OpenVic {
 		}
 
 		virtual fixed_point_t _estimate_cost(search_const_iterator from_it, search_const_iterator end_it) {
-			return fixed_point_t { from_it.value().point->position.distance_squared(end_it.value().point->position) }.sqrt();
+			return fp::sqrt(
+				fixed_point_t { from_it.value().point->position.distance_squared(end_it.value().point->position) }
+			);
 		}
 
 		virtual fixed_point_t _compute_cost(search_const_iterator from_it, search_const_iterator end_it) {
-			return fixed_point_t { from_it.value().point->position.distance_squared(end_it.value().point->position) }.sqrt();
+			return fp::sqrt(
+				fixed_point_t { from_it.value().point->position.distance_squared(end_it.value().point->position) }
+			);
 		}
 
 		virtual bool _solve( //
diff --git a/src/openvic-simulation/pathfinding/PointMap.cpp b/src/openvic-simulation/pathfinding/PointMap.cpp
index d4a05d3cc..8489c32ac 100644
--- a/src/openvic-simulation/pathfinding/PointMap.cpp
+++ b/src/openvic-simulation/pathfinding/PointMap.cpp
@@ -4,7 +4,6 @@
 #include <cstdint>
 #include <span>
 #include <type_traits>
-#include <vector>
 
 #include <tsl/ordered_map.h>
 #include <tsl/ordered_set.h>
@@ -12,9 +11,10 @@
 #include <fmt/core.h>
 
 #include "openvic-simulation/core/error/ErrorMacros.hpp"
+#include "openvic-simulation/core/memory/Formatting.hpp"
+#include "openvic-simulation/core/Typedefs.hpp"
 #include "openvic-simulation/types/Vector.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/core/Typedefs.hpp"
 
 using namespace OpenVic;
 
diff --git a/src/openvic-simulation/pathfinding/PointMap.hpp b/src/openvic-simulation/pathfinding/PointMap.hpp
index cde85f497..c418f7f36 100644
--- a/src/openvic-simulation/pathfinding/PointMap.hpp
+++ b/src/openvic-simulation/pathfinding/PointMap.hpp
@@ -3,16 +3,15 @@
 #include <cstdint>
 #include <span>
 #include <utility>
-#include <vector>
 
 #include <tsl/ordered_map.h>
 #include <tsl/ordered_set.h>
 
+#include "openvic-simulation/core/Hash.hpp"
 #include "openvic-simulation/core/template/EnumBitfield.hpp"
+#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/Signal.hpp"
 #include "openvic-simulation/types/Vector.hpp"
-#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/core/Hash.hpp"
 
 namespace OpenVic {
 	struct PointMap {
diff --git a/src/openvic-simulation/player/PlayerManager.hpp b/src/openvic-simulation/player/PlayerManager.hpp
index b873eb6d0..a881756f4 100644
--- a/src/openvic-simulation/player/PlayerManager.hpp
+++ b/src/openvic-simulation/player/PlayerManager.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "openvic-simulation/utility/Containers.hpp"
+#include "openvic-simulation/core/memory/String.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {
diff --git a/src/openvic-simulation/politics/Government.hpp b/src/openvic-simulation/politics/Government.hpp
index 2ab8b7f9b..b41a09984 100644
--- a/src/openvic-simulation/politics/Government.hpp
+++ b/src/openvic-simulation/politics/Government.hpp
@@ -2,12 +2,13 @@
 
 #include <functional>
 
+#include "openvic-simulation/core/memory/String.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/types/Date.hpp"
 #include "openvic-simulation/types/HasIdentifier.hpp"
 #include "openvic-simulation/types/HasIndex.hpp"
 #include "openvic-simulation/types/IdentifierRegistry.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct Ideology;
diff --git a/src/openvic-simulation/population/Pop.cpp b/src/openvic-simulation/population/Pop.cpp
index a180c5d47..a099e60b3 100644
--- a/src/openvic-simulation/population/Pop.cpp
+++ b/src/openvic-simulation/population/Pop.cpp
@@ -37,10 +37,10 @@
 #include "openvic-simulation/population/Religion.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp"
+#include "openvic-simulation/types/fixed_point/Math.hpp"
 #include "openvic-simulation/types/IndexedFlatMap.hpp"
 #include "openvic-simulation/types/OrderedContainers.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
 
 
@@ -77,7 +77,7 @@ fixed_point_t Pop::get_unemployment_fraction() const {
 	if (!get_type().can_be_unemployed) {
 		return 0;
 	}
-	return fixed_point_t::from_fraction(get_unemployed(), size);
+	return fp::from_fraction(get_unemployed(), size);
 }
 
 void Pop::setup_pop_test_values(IssueManager const& issue_manager) {
@@ -422,7 +422,7 @@ void Pop::allocate_for_needs(
 			}
 
 			fixed_point_t weight = market_instance.get_good_instance(good_definition).get_price_inverse();
-			fixed_point_t cash_available_for_good = fixed_point_t::mul_div(
+			fixed_point_t cash_available_for_good = fp::mul_div(
 				cash_left_to_spend_draft,
 				weight,
 				weights_sum
@@ -676,7 +676,7 @@ void Pop::after_buy(void* actor, BuyResult const& buy_result) {
 
 		if (quantity_added_to_stockpile > 0) {
 			quantity_left_to_consume -= quantity_added_to_stockpile;
-			const fixed_point_t expense = fixed_point_t::mul_div(
+			const fixed_point_t expense = fp::mul_div(
 				money_spent,
 				quantity_added_to_stockpile,
 				quantity_bought
@@ -705,7 +705,7 @@ void Pop::after_buy(void* actor, BuyResult const& buy_result) {
 			if (get_country_to_report_economy_nullable != nullptr) { \
 				get_country_to_report_economy_nullable->report_pop_need_consumption(pop.type, good_definition, consumed_quantity); \
 			} \
-			const fixed_point_t expense = fixed_point_t::mul_div( \
+			const fixed_point_t expense = fp::mul_div( \
 				money_spent, \
 				consumed_quantity, \
 				quantity_bought \
diff --git a/src/openvic-simulation/population/Pop.hpp b/src/openvic-simulation/population/Pop.hpp
index efb10130c..87c974ff7 100644
--- a/src/openvic-simulation/population/Pop.hpp
+++ b/src/openvic-simulation/population/Pop.hpp
@@ -3,6 +3,7 @@
 #include <cstddef>
 #include <functional>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/core/portable/ForwardableSpan.hpp"
 #include "openvic-simulation/economy/production/ArtisanalProducer.hpp"
 #include "openvic-simulation/population/PopIdInProvince.hpp"
@@ -13,7 +14,6 @@
 #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp"
 #include "openvic-simulation/types/IndexedFlatMap.hpp"
 #include "openvic-simulation/types/UnitBranchType.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 #include <type_safe/strong_typedef.hpp>
 
diff --git a/src/openvic-simulation/population/PopType.hpp b/src/openvic-simulation/population/PopType.hpp
index 86ceb0a4f..f702c6d8e 100644
--- a/src/openvic-simulation/population/PopType.hpp
+++ b/src/openvic-simulation/population/PopType.hpp
@@ -2,6 +2,7 @@
 
 #include <functional>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/scripts/ConditionalWeight.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp"
@@ -11,7 +12,6 @@
 #include "openvic-simulation/population/PopSize.hpp"
 #include "openvic-simulation/types/PopSprite.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct BaseIssue;
diff --git a/src/openvic-simulation/research/Technology.hpp b/src/openvic-simulation/research/Technology.hpp
index 9ec16e2b6..25997a222 100644
--- a/src/openvic-simulation/research/Technology.hpp
+++ b/src/openvic-simulation/research/Technology.hpp
@@ -3,6 +3,7 @@
 #include <cstdint>
 #include <functional>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/modifier/Modifier.hpp"
 #include "openvic-simulation/scripts/ConditionalWeight.hpp"
 #include "openvic-simulation/types/Date.hpp"
@@ -11,7 +12,6 @@
 #include "openvic-simulation/types/OrderedContainers.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
 #include "openvic-simulation/types/UnitVariant.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct BuildingType;
diff --git a/src/openvic-simulation/scripts/Condition.cpp b/src/openvic-simulation/scripts/Condition.cpp
index 08cc1d384..eb8ef376c 100644
--- a/src/openvic-simulation/scripts/Condition.cpp
+++ b/src/openvic-simulation/scripts/Condition.cpp
@@ -4,7 +4,6 @@
 
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 #include "openvic-simulation/DefinitionManager.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 using namespace OpenVic;
 using namespace OpenVic::NodeTools;
diff --git a/src/openvic-simulation/scripts/Condition.hpp b/src/openvic-simulation/scripts/Condition.hpp
index 2e9633531..1411d05ca 100644
--- a/src/openvic-simulation/scripts/Condition.hpp
+++ b/src/openvic-simulation/scripts/Condition.hpp
@@ -5,10 +5,11 @@
 #include <string_view>
 #include <variant>
 
+#include "openvic-simulation/core/memory/String.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/core/template/EnumBitfield.hpp"
 #include "openvic-simulation/types/HasIdentifier.hpp"
 #include "openvic-simulation/types/IdentifierRegistry.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	struct ConditionManager;
diff --git a/src/openvic-simulation/scripts/ConditionalWeight.hpp b/src/openvic-simulation/scripts/ConditionalWeight.hpp
index f789ba2b0..fe45d7d0d 100644
--- a/src/openvic-simulation/scripts/ConditionalWeight.hpp
+++ b/src/openvic-simulation/scripts/ConditionalWeight.hpp
@@ -1,12 +1,11 @@
 #pragma once
 
 #include <variant>
-#include <vector>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 #include "openvic-simulation/scripts/ConditionScript.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 	enum class conditional_weight_type_t : uint8_t {
diff --git a/src/openvic-simulation/scripts/Script.hpp b/src/openvic-simulation/scripts/Script.hpp
index 4d83842ba..4178104d5 100644
--- a/src/openvic-simulation/scripts/Script.hpp
+++ b/src/openvic-simulation/scripts/Script.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <vector>
-
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 
 namespace OpenVic {
diff --git a/src/openvic-simulation/testing/TestScript.hpp b/src/openvic-simulation/testing/TestScript.hpp
index 2ae2fd73e..410a533ef 100644
--- a/src/openvic-simulation/testing/TestScript.hpp
+++ b/src/openvic-simulation/testing/TestScript.hpp
@@ -1,10 +1,8 @@
 #pragma once
-#include <memory>
-#include <vector>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/DefinitionManager.hpp"
 #include "openvic-simulation/testing/Requirement.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
 
diff --git a/src/openvic-simulation/testing/Testing.cpp b/src/openvic-simulation/testing/Testing.cpp
index 29400aeb1..8ea5353ce 100644
--- a/src/openvic-simulation/testing/Testing.cpp
+++ b/src/openvic-simulation/testing/Testing.cpp
@@ -3,7 +3,6 @@
 #include <memory>
 
 #include "openvic-simulation/testing/TestScript.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 using namespace OpenVic;
 
diff --git a/src/openvic-simulation/testing/Testing.hpp b/src/openvic-simulation/testing/Testing.hpp
index 27d57afcf..2099d1386 100644
--- a/src/openvic-simulation/testing/Testing.hpp
+++ b/src/openvic-simulation/testing/Testing.hpp
@@ -1,10 +1,11 @@
 #pragma once
 
 #include <memory>
-#include <vector>
 
 #include <spdlog/spdlog.h>
 
+#include "openvic-simulation/core/memory/SmartPtr.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/DefinitionManager.hpp"
 #include "openvic-simulation/testing/TestScript.hpp"
 #include "openvic-simulation/testing/test_scripts/A_001_file_tests.cpp"
diff --git a/src/openvic-simulation/testing/test_scripts/A_001_file_tests.cpp b/src/openvic-simulation/testing/test_scripts/A_001_file_tests.cpp
index dbf777f65..dcce879a2 100644
--- a/src/openvic-simulation/testing/test_scripts/A_001_file_tests.cpp
+++ b/src/openvic-simulation/testing/test_scripts/A_001_file_tests.cpp
@@ -1,8 +1,5 @@
-#include "openvic-simulation/DefinitionManager.hpp"
 #include "openvic-simulation/testing/TestScript.hpp"
 
-#include "utility/Containers.hpp"
-
 namespace OpenVic {
 	class A_001_file_tests : public TestScript {
 
diff --git a/src/openvic-simulation/types/CowVector.hpp b/src/openvic-simulation/types/CowVector.hpp
index 22b7abb3e..38b9a62fd 100644
--- a/src/openvic-simulation/types/CowVector.hpp
+++ b/src/openvic-simulation/types/CowVector.hpp
@@ -9,7 +9,6 @@
 #include <memory>
 #include <span>
 #include <type_traits>
-#include <vector>
 
 #include "openvic-simulation/core/Assert.hpp"
 #include "openvic-simulation/types/BasicIterator.hpp"
diff --git a/src/openvic-simulation/types/Date.hpp b/src/openvic-simulation/types/Date.hpp
index 90c45b410..7fb0fff13 100644
--- a/src/openvic-simulation/types/Date.hpp
+++ b/src/openvic-simulation/types/Date.hpp
@@ -9,13 +9,14 @@
 #include <limits>
 #include <numeric>
 #include <ostream>
-#include <string>
 #include <system_error>
 
 #include <fmt/format.h>
 
 #include <range/v3/algorithm/max_element.hpp>
 
+#include "openvic-simulation/core/memory/Formatting.hpp"
+#include "openvic-simulation/core/memory/String.hpp"
 #include "openvic-simulation/core/error/ErrorMacros.hpp"
 #include "openvic-simulation/types/StackString.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
diff --git a/src/openvic-simulation/types/FixedVector.hpp b/src/openvic-simulation/types/FixedVector.hpp
index ce6a97bb7..77f220792 100644
--- a/src/openvic-simulation/types/FixedVector.hpp
+++ b/src/openvic-simulation/types/FixedVector.hpp
@@ -203,7 +203,7 @@ namespace OpenVic::_detail {
 
 #include <foonathan/memory/std_allocator.hpp>
 
-#include "openvic-simulation/utility/MemoryTracker.hpp"
+#include "openvic-simulation/core/memory/MemoryTracker.hpp"
 
 namespace OpenVic::memory {
 	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
diff --git a/src/openvic-simulation/types/IdentifierRegistry.hpp b/src/openvic-simulation/types/IdentifierRegistry.hpp
index 577bd61ea..811fc6ecb 100644
--- a/src/openvic-simulation/types/IdentifierRegistry.hpp
+++ b/src/openvic-simulation/types/IdentifierRegistry.hpp
@@ -1,8 +1,8 @@
 #pragma once
 
 #include <concepts>
-#include <vector>
 
+#include "openvic-simulation/core/memory/SmartPtr.hpp"
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp"
 #include "openvic-simulation/core/template/Concepts.hpp"
diff --git a/src/openvic-simulation/types/IndexedFlatMap.hpp b/src/openvic-simulation/types/IndexedFlatMap.hpp
index 94dca9008..1b17503a0 100644
--- a/src/openvic-simulation/types/IndexedFlatMap.hpp
+++ b/src/openvic-simulation/types/IndexedFlatMap.hpp
@@ -11,6 +11,7 @@
 
 #include <function2/function2.hpp>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/types/FixedVector.hpp"
 #include "openvic-simulation/core/template/Concepts.hpp"
 #include "openvic-simulation/core/portable/ForwardableSpan.hpp"
diff --git a/src/openvic-simulation/types/OrderedContainers.hpp b/src/openvic-simulation/types/OrderedContainers.hpp
index f1c1d942f..bcd316f6e 100644
--- a/src/openvic-simulation/types/OrderedContainers.hpp
+++ b/src/openvic-simulation/types/OrderedContainers.hpp
@@ -8,10 +8,10 @@
 #include <tsl/ordered_map.h>
 #include <tsl/ordered_set.h>
 
-#include "openvic-simulation/core/template/Concepts.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
+#include "openvic-simulation/core/memory/String.hpp"
 #include "openvic-simulation/core/portable/Deque.hpp"
 #include "openvic-simulation/core/string/Utility.hpp"
+#include "openvic-simulation/core/template/Concepts.hpp"
 
 #include <foonathan/memory/default_allocator.hpp>
 #include <foonathan/memory/std_allocator.hpp>
diff --git a/src/openvic-simulation/types/RingBuffer.hpp b/src/openvic-simulation/types/RingBuffer.hpp
index 731395e88..dee68b6a0 100644
--- a/src/openvic-simulation/types/RingBuffer.hpp
+++ b/src/openvic-simulation/types/RingBuffer.hpp
@@ -10,7 +10,6 @@
 #include <memory>
 #include <span>
 #include <type_traits>
-#include <vector>
 
 #include <range/v3/algorithm/move.hpp>
 #include <range/v3/iterator/operations.hpp>
diff --git a/src/openvic-simulation/types/Signal.hpp b/src/openvic-simulation/types/Signal.hpp
index 882ed3d46..26bb0e09c 100644
--- a/src/openvic-simulation/types/Signal.hpp
+++ b/src/openvic-simulation/types/Signal.hpp
@@ -10,13 +10,17 @@
 #include <optional>
 #include <tuple>
 #include <type_traits>
-#include <vector>
 
-#include "openvic-simulation/types/CowPtr.hpp"
-#include "openvic-simulation/types/CowVector.hpp"
+#ifdef DEBUG_ENABLED
+	#include "openvic-simulation/core/memory/allocators/NewAllocator.hpp"
+#else
+	#include "openvic-simulation/core/memory/SmartPtr.hpp"
+#endif
+
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/core/thread/NullMutex.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/core/Typedefs.hpp"
+#include "openvic-simulation/types/CowVector.hpp"
 
 // Based heavily on https://github.com/palacaze/sigslot and https://github.com/mousebyte/sigslot20
 
diff --git a/src/openvic-simulation/types/StackString.hpp b/src/openvic-simulation/types/StackString.hpp
index d2c73aec3..15aca796f 100644
--- a/src/openvic-simulation/types/StackString.hpp
+++ b/src/openvic-simulation/types/StackString.hpp
@@ -6,7 +6,7 @@
 #include <string_view>
 
 #include "openvic-simulation/core/Assert.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
+#include "openvic-simulation/core/memory/String.hpp"
 
 namespace OpenVic {
 	template<size_t Size>
diff --git a/src/openvic-simulation/types/fixed_point/FixedPoint.cpp b/src/openvic-simulation/types/fixed_point/FixedPoint.cpp
index 80cf69b85..1ca61c324 100644
--- a/src/openvic-simulation/types/fixed_point/FixedPoint.cpp
+++ b/src/openvic-simulation/types/fixed_point/FixedPoint.cpp
@@ -1,11 +1,38 @@
 #include "FixedPoint.hpp"
+#include "FixedPointStackString.hpp"
+
+#include <concepts>
+#include <cstdint>
 
 #include <fmt/base.h>
 #include <fmt/format.h>
 
+#include "openvic-simulation/core/string/CharConv.hpp"
 #include "openvic-simulation/core/Typedefs.hpp"
+#include "openvic-simulation/utility/Logger.hpp"
+
+/* Base e exponential lookup table */
+#include "openvic-simulation/types/fixed_point/FixedPointLUT_2_16_EXP_e.hpp"
+
+/* Base 2001 exponential lookup table */
+#include "openvic-simulation/types/fixed_point/FixedPointLUT_2_16_EXP_2001.hpp"
 
 using namespace OpenVic;
+static_assert(_detail::LUT::_2_16_EXP_e_DIVISOR == 1 << fixed_point_t::PRECISION);
+static_assert(_detail::LUT::_2_16_EXP_2001_DIVISOR == 1 << fixed_point_t::PRECISION);
+
+OV_SPEED_INLINE void fixed_point_t::warn_if_truncated() const {
+	if (OV_unlikely(
+		value != 0
+		&& abs() < fixed_point_t::_1
+	)) {
+		spdlog::warn_s(
+			"0 < abs(Fixed point) < 1, truncation will result in zero, this may be a bug. raw_value: {} as float: {}",
+			get_raw_value(),
+			static_cast<float>(*this)
+		);
+	}
+}
 
 fmt::format_context::iterator fmt::formatter<fixed_point_t>::format(fixed_point_t fp, format_context& ctx) const {
 	format_specs specs { _specs };
@@ -14,7 +41,7 @@ fmt::format_context::iterator fmt::formatter<fixed_point_t>::format(fixed_point_
 		detail::handle_dynamic_spec(_specs.dynamic_width(), specs.width, _specs.width_ref, ctx);
 	}
 
-	fixed_point_t::stack_string result = fp.to_array(specs.precision);
+	fp_stack_string result = fp.to_array(specs.precision);
 	if (OV_unlikely(result.empty())) {
 		return ctx.out();
 	}
@@ -52,3 +79,274 @@ fmt::format_context::iterator fmt::formatter<fixed_point_t>::format(fixed_point_
 	view = { buffer.data(), buffer.size() };
 	return detail::write<char>(out, view, specs, ctx.locale());
 }
+
+std::to_chars_result fixed_point_t::to_chars(char* first, char* last, size_t decimal_places) const {
+	if (first == nullptr || first >= last) {
+		return { last, std::errc::value_too_large };
+	}
+
+	if (is_negative()) {
+		*first = '-';
+		++first;
+		if (last - first <= 1) {
+			return { last, std::errc::value_too_large };
+		}
+	}
+
+	std::to_chars_result result {};
+	if (decimal_places == static_cast<size_t>(-1)) {
+		result = OpenVic::to_chars(first, last, abs().unsafe_truncate<int64_t>());
+		if (OV_unlikely(result.ec != std::errc {})) {
+			return result;
+		}
+		if (OV_unlikely(last - result.ptr <= 1)) {
+			return result;
+		}
+
+		fixed_point_t frac = abs().get_frac();
+		if (frac != _0) {
+			*result.ptr = '.';
+			++result.ptr;
+			do {
+				if (OV_unlikely(last - result.ptr <= 1)) {
+					return { last, std::errc::value_too_large };
+				}
+				frac *= 10;
+				*result.ptr = static_cast<char>('0' + frac.unsafe_truncate<int64_t>());
+				++result.ptr;
+				frac = frac.get_frac();
+			} while (frac != _0);
+		}
+		return result;
+	}
+
+	// Add the specified number of decimal places, potentially 0 (so no decimal point)
+	fixed_point_t err = _0_50;
+	for (size_t i = decimal_places; i > 0; --i) {
+		err /= 10;
+	}
+	fixed_point_t val = this->abs() + err;
+
+
+	result = OpenVic::to_chars(first, last, val.unsafe_truncate<int64_t>());
+	if (OV_unlikely(result.ec != std::errc {})) {
+		return result;
+	}
+
+	if (decimal_places > 0) {
+		if (OV_unlikely(last - result.ptr <= 1)) {
+			return result;
+		}
+		val = val.get_frac();
+		*result.ptr = '.';
+		result.ptr++;
+		do {
+			if (OV_unlikely(last - result.ptr <= 1)) {
+				return result;
+			}
+			val *= 10;
+			*result.ptr = static_cast<char>('0' + val.unsafe_truncate<int64_t>());
+			++result.ptr;
+			val = val.get_frac();
+		} while (--decimal_places > 0);
+	}
+	return result;
+}
+
+fp_stack_string fixed_point_t::to_array(size_t decimal_places) const {
+	fp_stack_string str {};
+	std::to_chars_result result = to_chars(str._array.data(), str._array.data() + str._array.size(), decimal_places);
+	str._string_size = result.ptr - str.data();
+	return str;
+}
+
+namespace OpenVic {
+	std::ostream& operator<<(std::ostream& stream, fixed_point_t const& obj) {
+		fp_stack_string result = obj.to_array();
+		if (OV_unlikely(result.empty())) {
+			return stream;
+		}
+
+		return stream << static_cast<std::string_view>(result);
+	}
+}
+
+std::from_chars_result fixed_point_t::from_chars(char const* begin, char const* end) {
+	if (begin == nullptr || begin >= end) {
+		return { begin, std::errc::invalid_argument };
+	}
+
+	if (char const& c = *(end - 1); c == 'f' || c == 'F') {
+		--end;
+		if (begin == end) {
+			return { begin, std::errc::invalid_argument };
+		}
+	}
+
+	char const* dot_pointer = begin;
+	while (*dot_pointer != '.' && ++dot_pointer != end) {}
+	// "."
+	if (dot_pointer == begin && dot_pointer + 1 == end) {
+		return { begin, std::errc::invalid_argument };
+	}
+
+	fixed_point_t result = 0;
+	std::from_chars_result from_chars = {};
+	if (dot_pointer != begin) {
+		// Non-empty integer part, may be negative
+		from_chars = from_chars_integer(begin, dot_pointer, result);
+	}
+
+	if (from_chars.ec != std::errc{}) {
+		return from_chars;
+	}
+
+	if (dot_pointer + 1 < end) {
+		// Non-empty fractional part, cannot be negative
+		fixed_point_t adder;
+		from_chars = from_chars_fraction(dot_pointer + 1, end, adder);
+		result += result.is_negative() || (*begin == '-' && result == _0) ? -adder : adder;
+	}
+
+	if (from_chars.ec != std::errc{}) {
+		return { begin, from_chars.ec };
+	}
+
+	value = result.value;
+	return from_chars;
+}
+
+std::from_chars_result fixed_point_t::from_chars_with_plus(char const* begin, char const* end) {
+	if (begin && *begin == '+') {
+		begin++;
+		if (begin < end && *begin == '-') {
+			return std::from_chars_result { begin, std::errc::invalid_argument };
+		}
+	}
+
+	return from_chars(begin, end);
+}
+
+std::from_chars_result fixed_point_t::from_chars_integer(char const* str, char const* const end, fixed_point_t& value) {
+	int64_t parsed_value = 0;
+	std::from_chars_result result = string_to_int64(str, end, parsed_value);
+	if (result.ec == std::errc{}) {
+		if (parsed_value > std::numeric_limits<int32_t>::max()) {
+			result.ec = std::errc::value_too_large;
+		} else {
+			value = fixed_point_t(static_cast<int32_t>(parsed_value));
+		}
+	}
+	return result;
+}
+
+std::from_chars_result fixed_point_t::from_chars_fraction(char const* begin, char const* end, fixed_point_t& value) {
+	if (begin && *begin == '-') {
+		return { begin, std::errc::invalid_argument };
+	}
+
+	end = end - begin > PRECISION ? begin + PRECISION : end;
+	uint64_t parsed_value;
+	std::from_chars_result result = string_to_uint64(begin, end, parsed_value);
+	if (result.ec != std::errc{}) {
+		return result;
+	}
+
+	for (ptrdiff_t remaining_shift = PRECISION - (end - begin); remaining_shift > 0; remaining_shift--) {
+		parsed_value *= 10;
+	}
+	uint64_t decimal = pow(static_cast<uint64_t>(10), PRECISION);
+	int64_t ret = 0;
+	for (int i = PRECISION - 1; i >= 0; --i) {
+		decimal >>= 1;
+		if (parsed_value >= decimal) {
+			parsed_value -= decimal;
+			ret |= 1 << i;
+		}
+	}
+	value = parse_raw(ret);
+	return result;
+}
+
+fixed_point_t fixed_point_t::parse(char const* str, char const* end, bool* successful) {
+	fixed_point_t value = 0;
+	std::from_chars_result result = value.from_chars_with_plus(str, end);
+	if (successful) {
+		*successful = result.ec == std::errc {};
+	}
+	return value;
+}
+
+fixed_point_t fixed_point_t::parse(char const* str, size_t length, bool* successful) {
+	return parse(str, str + length, successful);
+}
+
+fixed_point_t fixed_point_t::parse(std::string_view str, bool* successful) {
+	return parse(str.data(), str.length(), successful);
+}
+
+fixed_point_t fixed_point_t::parse_unsafe(char const* value) {
+	char* endpointer;
+	double double_value = std::strtod(value, &endpointer);
+
+	if (*endpointer != '\0') {
+		spdlog::error_s("Unsafe fixed point parse failed to parse the end of a string: \"{}\"", endpointer);
+	}
+
+	value_type integer_value = static_cast<long>(double_value * ONE + 0.5 * (double_value < 0 ? -1 : 1));
+
+	return parse_raw(integer_value);
+}
+
+template<std::integral T>
+requires (sizeof(T) >= 4)
+static fixed_point_t parse_capped_generic(const T value) {
+	fixed_point_t result;
+	if (value > std::numeric_limits<int32_t>::max()) {
+		if (value >= fixed_point_t::max.truncate<T>()) {
+			spdlog::error_s("parse_capped value exceeded int32 max. Falling back to fixed_point_t::max");
+			result = fixed_point_t::max;
+		} else {
+			spdlog::warn_s("parse_capped value exceeded int32 max. It still fits but exceeds fixed_point_t::usable_max");
+			result = fixed_point_t::parse_raw(value << fixed_point_t::PRECISION);
+		}
+	} else {
+		result = fixed_point_t(static_cast<int32_t>(value));
+	}
+
+	return result;
+}
+
+fixed_point_t fixed_point_t::parse_capped(const int64_t value) { return parse_capped_generic(value); }
+fixed_point_t fixed_point_t::parse_capped(const uint64_t value) { return parse_capped_generic(value); }
+
+template<size_t N, std::array<int64_t, N> EXP_LUT>
+OV_SPEED_INLINE static constexpr fixed_point_t _exp_internal(fixed_point_t const& x) {
+	const bool negative = x.is_negative();
+	fixed_point_t::value_type bits = negative ? -x.get_raw_value() : x.get_raw_value();
+	fixed_point_t result = fixed_point_t::_1;
+
+	for (size_t index = 0; bits != 0 && index < EXP_LUT.size(); ++index, bits >>= 1) {
+		if (bits & 1LL) {
+			result *= fixed_point_t::parse_raw(EXP_LUT[index]);
+		}
+	}
+
+	if (bits != 0) {
+		spdlog::error_s("Fixed point exponential overflow!");
+	}
+
+	if (negative) {
+		return fixed_point_t::_1 / result;
+	} else {
+		return result;
+	}
+}
+
+fixed_point_t fixed_point_t::exp(fixed_point_t const& x) {
+	return _exp_internal<_detail::LUT::_2_16_EXP_e.size(), _detail::LUT::_2_16_EXP_e>(x);
+}
+
+fixed_point_t fixed_point_t::exp_2001(fixed_point_t const& x) {
+	return _exp_internal<_detail::LUT::_2_16_EXP_2001.size(), _detail::LUT::_2_16_EXP_2001>(x);
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/types/fixed_point/FixedPoint.hpp b/src/openvic-simulation/types/fixed_point/FixedPoint.hpp
index 764c7c4fb..30f6ec28e 100644
--- a/src/openvic-simulation/types/fixed_point/FixedPoint.hpp
+++ b/src/openvic-simulation/types/fixed_point/FixedPoint.hpp
@@ -5,37 +5,20 @@
 #include <concepts>
 #include <cstddef>
 #include <cstdint>
-#include <cstdlib>
 #include <limits>
-#include <string_view>
-#include <system_error>
-#include <type_traits>
 
 #include <fmt/base.h>
 #include <fmt/format.h>
 
-#include <type_safe/strong_typedef.hpp>
-
-#include "openvic-simulation/types/StackString.hpp"
-#include "openvic-simulation/utility/Getters.hpp"
-#include "openvic-simulation/utility/Logger.hpp"
-#include "openvic-simulation/core/string/CharConv.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/core/Typedefs.hpp"
-#include "openvic-simulation/core/Math.hpp"
-#include "openvic-simulation/core/template/Concepts.hpp"
-
-/* Sin lookup table */
-#include "openvic-simulation/types/fixed_point/FixedPointLUT_sin.hpp"
-
-/* Base e exponential lookup table */
-#include "openvic-simulation/types/fixed_point/FixedPointLUT_2_16_EXP_e.hpp"
-
-/* Base 2001 exponential lookup table */
-#include "openvic-simulation/types/fixed_point/FixedPointLUT_2_16_EXP_2001.hpp"
 
 namespace OpenVic {
+	struct fp_stack_string;
+
 	enum class midpoint_rounding { AWAY_ZERO, TO_ZERO };
+	
+	template<typename T>
+	concept integral_max_size_4 = std::integral<T> && sizeof(T) <= 4;
 
 	struct fixed_point_t {
 		/* PROPERTY generated getter functions will return fixed points by value, rather than const reference. */
@@ -59,12 +42,12 @@ namespace OpenVic {
 		 *   overflowing. For larger values this will not work and the result will be missing its most significant bits. */
 
 	private:
-		value_type PROPERTY_RW_CUSTOM_NAME(value, get_raw_value, set_raw_value);
-
-		static_assert(_detail::LUT::SIN_PRECISION == PRECISION);
-		static_assert(_detail::LUT::_2_16_EXP_e_DIVISOR == 1 << PRECISION);
-		static_assert(_detail::LUT::_2_16_EXP_2001_DIVISOR == 1 << PRECISION);
-
+		value_type value;
+	public:
+		[[nodiscard]] constexpr value_type const& get_raw_value() const {
+			return value;
+		}
+	private:
 		// Doesn't account for sign, so -n.abc -> 1 - 0.abc
 		OV_ALWAYS_INLINE constexpr fixed_point_t get_frac() const {
 			return parse_raw(value & FRAC_MASK);
@@ -147,29 +130,6 @@ namespace OpenVic {
 			return value <=> static_cast<value_type>(rhs) << PRECISION;
 		}
 
-		OV_SPEED_INLINE constexpr fixed_point_t sin() const {
-			using namespace _detail::LUT;
-
-			value_type num = (*this % pi2 * one_div_pi2).get_raw_value();
-
-			const bool negative = num < 0;
-			if (negative) {
-				num = -num;
-			}
-
-			const value_type index = num >> SIN_SHIFT;
-			const value_type a = SIN[index];
-			const value_type b = SIN[index + 1];
-
-			const value_type fraction = (num - (index << SIN_SHIFT)) << SIN_COUNT_LOG2;
-			const value_type result = a + (((b - a) * fraction) >> SIN_PRECISION);
-			return !negative ? parse_raw(result) : parse_raw(-result);
-		}
-
-		OV_SPEED_INLINE constexpr fixed_point_t cos() const {
-			return (*this + pi_half).sin();
-		}
-
 		OV_SPEED_INLINE constexpr bool is_negative() const {
 			return value < 0;
 		}
@@ -178,12 +138,6 @@ namespace OpenVic {
 			return !is_negative() ? parse_raw(value) : parse_raw(-value);
 		}
 
-		OV_SPEED_INLINE constexpr fixed_point_t sqrt() const {
-			return !is_negative()
-				? parse_raw(OpenVic::sqrt(static_cast<uint64_t>(value) << PRECISION))
-				: _0;
-		}
-
 		OV_SPEED_INLINE constexpr bool is_integer() const {
 			return get_frac() == 0;
 		}
@@ -196,19 +150,15 @@ namespace OpenVic {
 			return value >> PRECISION;
 		}
 
+		OV_SPEED_INLINE void warn_if_truncated() const;
+
 		template<std::integral T>
 		OV_SPEED_INLINE explicit constexpr operator T() const {
-#ifdef DEV_ENABLED
+			#ifdef DEV_ENABLED
 			if (!std::is_constant_evaluated()) {
-				if (OV_unlikely(value != 0 && abs() < fixed_point_t::_1)) {
-					spdlog::warn_s(
-						"0 < abs(Fixed point) < 1, truncation will result in zero, this may be a bug. raw_value: {} as float: {}",
-						get_raw_value(),
-						static_cast<float>(*this)
-					);
-				}
+				warn_if_truncated();
 			}
-#endif
+			#endif
 			return unsafe_truncate<T>();
 		}
 
@@ -220,21 +170,6 @@ namespace OpenVic {
 		OV_SPEED_INLINE constexpr T truncate() const {
 			return static_cast<T>(*this);
 		}
-		
-		template<is_strongly_typed StrongType>
-		OV_SPEED_INLINE static constexpr StrongType multiply_truncate(StrongType const& integer, fixed_point_t const& fp) {
-			return StrongType(multiply_truncate(
-				type_safe::get(integer),
-				fp
-			));
-		}
-
-		template<std::integral T>
-		OV_SPEED_INLINE static constexpr T multiply_truncate(T const& integer, fixed_point_t const& fp) {
-			return static_cast<T>(
-				(static_cast<value_type>(integer) * fp.get_raw_value()) >> PRECISION
-			);
-		}
 
 		template<std::floating_point T>
 		OV_SPEED_INLINE explicit constexpr operator T() const {
@@ -323,221 +258,40 @@ namespace OpenVic {
 			return static_cast<T>(round_to_int64<T>((value / static_cast<T>(ONE)) * T { 100000 })) / T { 100000 };
 		}
 
-		OV_SPEED_INLINE constexpr std::to_chars_result to_chars(char* first, char* last, size_t decimal_places = -1) const {
-			if (first == nullptr || first >= last) {
-				return { last, std::errc::value_too_large };
-			}
-
-			if (is_negative()) {
-				*first = '-';
-				++first;
-				if (last - first <= 1) {
-					return { last, std::errc::value_too_large };
-				}
-			}
-
-			std::to_chars_result result {};
-			if (decimal_places == static_cast<size_t>(-1)) {
-				result = OpenVic::to_chars(first, last, abs().unsafe_truncate<int64_t>());
-				if (OV_unlikely(result.ec != std::errc {})) {
-					return result;
-				}
-				if (OV_unlikely(last - result.ptr <= 1)) {
-					return result;
-				}
-
-				fixed_point_t frac = abs().get_frac();
-				if (frac != _0) {
-					*result.ptr = '.';
-					++result.ptr;
-					do {
-						if (OV_unlikely(last - result.ptr <= 1)) {
-							return { last, std::errc::value_too_large };
-						}
-						frac *= 10;
-						*result.ptr = static_cast<char>('0' + frac.unsafe_truncate<int64_t>());
-						++result.ptr;
-						frac = frac.get_frac();
-					} while (frac != _0);
-				}
-				return result;
-			}
-
-			// Add the specified number of decimal places, potentially 0 (so no decimal point)
-			fixed_point_t err = _0_50;
-			for (size_t i = decimal_places; i > 0; --i) {
-				err /= 10;
-			}
-			fixed_point_t val = this->abs() + err;
-
-
-			result = OpenVic::to_chars(first, last, val.unsafe_truncate<int64_t>());
-			if (OV_unlikely(result.ec != std::errc {})) {
-				return result;
-			}
-
-			if (decimal_places > 0) {
-				if (OV_unlikely(last - result.ptr <= 1)) {
-					return result;
-				}
-				val = val.get_frac();
-				*result.ptr = '.';
-				result.ptr++;
-				do {
-					if (OV_unlikely(last - result.ptr <= 1)) {
-						return result;
-					}
-					val *= 10;
-					*result.ptr = static_cast<char>('0' + val.unsafe_truncate<int64_t>());
-					++result.ptr;
-					val = val.get_frac();
-				} while (--decimal_places > 0);
-			}
-			return result;
-		}
-
-		struct stack_string;
-		OV_SPEED_INLINE  constexpr stack_string to_array(size_t decimal_places = -1) const;
-
-		struct stack_string final : StackString<25> {
-		protected:
-			using StackString::StackString;
-			friend OV_SPEED_INLINE constexpr stack_string fixed_point_t::to_array(size_t decimal_places) const;
-		};
-
-		OV_SPEED_INLINE memory::string to_string(size_t decimal_places = -1) const {
-			stack_string result = to_array(decimal_places);
-			if (OV_unlikely(result.empty())) {
-				return {};
-			}
+		std::to_chars_result to_chars(char* first, char* last, size_t decimal_places = -1) const;
 
-			return result;
-		}
+		fp_stack_string to_array(size_t decimal_places = -1) const;
 
 		// Deterministic
 		OV_ALWAYS_INLINE static constexpr fixed_point_t parse_raw(value_type value) {
 			return fixed_point_t { raw_value, value };
 		}
 
+		OV_SPEED_INLINE static constexpr fixed_point_t parse_capped(const int32_t value) { return fixed_point_t(value); }
+
 		template<std::integral T>
-		static constexpr fixed_point_t parse_capped(const T value) {
-			fixed_point_t result;
-			if (value > std::numeric_limits<int32_t>::max()) {
-				if (value >= fixed_point_t::max.truncate<T>()) {
-					if (std::is_constant_evaluated()) {
-						assert(value >= fixed_point_t::max.truncate<T>());
-					} else {
-						spdlog::error_s("parse_capped value exceeded int32 max. Falling back to fixed_point_t::max");
-					}
-					result = fixed_point_t::max;
-				} else {
-					if (!std::is_constant_evaluated()) {
-						spdlog::warn_s("parse_capped value exceeded int32 max. It still fits but exceeds fixed_point_t::usable_max");
-					}
-					result = fixed_point_t::parse_raw(value << PRECISION);
-				}
-			} else {
-				result = fixed_point_t(static_cast<int32_t>(value));
-			}
+		requires (sizeof(T) < 4)
+		OV_SPEED_INLINE static constexpr  fixed_point_t parse_capped(const T value) { return fixed_point_t(static_cast<int32_t>(value)); }
 
-			return result;
-		}
+		static fixed_point_t parse_capped(const int64_t value);
+		static fixed_point_t parse_capped(const uint64_t value);
 		
-		template<is_strongly_typed StrongType>
-		OV_SPEED_INLINE static constexpr fixed_point_t from_fraction(StrongType const& numerator, StrongType const& denominator) {
-			return from_fraction(type_safe::get(numerator), type_safe::get(denominator));
-		}
-
-		template<integral_max_size_4 TNumerator, integral_max_size_4 TDenominator>
-		OV_SPEED_INLINE static constexpr fixed_point_t from_fraction(const TNumerator numerator, const TDenominator denominator) {
-			return parse_raw((static_cast<value_type>(numerator) << PRECISION) / static_cast<value_type>(denominator));
-		}
-
-		static constexpr fixed_point_t from_fraction(const int64_t numerator, const int64_t denominator) {
-			assert(numerator < 140737488355328LL); //2^47
-			assert(numerator >= -140737488355328LL); //- 2^47
-			return parse_raw((numerator << PRECISION) / denominator);
-		}
-
-		static constexpr fixed_point_t from_fraction(const uint64_t numerator, const uint64_t denominator) {
-			assert(numerator < 281474976710656ULL); //2^48
-			return parse_raw((numerator << PRECISION) / denominator);
+		template<std::integral T>
+		requires (sizeof(T) >= 4)
+		static fixed_point_t parse_capped(const T value) {
+			return std::is_signed_v<T>
+				? parse_capped(static_cast<int64_t>(value))
+				: parse_capped(static_cast<uint64_t>(value));
 		}
 
 		// Deterministic
-		OV_SPEED_INLINE constexpr std::from_chars_result from_chars(char const* begin, char const* end) {
-			if (begin == nullptr || begin >= end) {
-				return { begin, std::errc::invalid_argument };
-			}
-
-			if (char const& c = *(end - 1); c == 'f' || c == 'F') {
-				--end;
-				if (begin == end) {
-					return { begin, std::errc::invalid_argument };
-				}
-			}
-
-			char const* dot_pointer = begin;
-			while (*dot_pointer != '.' && ++dot_pointer != end) {}
-			// "."
-			if (dot_pointer == begin && dot_pointer + 1 == end) {
-				return { begin, std::errc::invalid_argument };
-			}
-
-			fixed_point_t result = 0;
-			std::from_chars_result from_chars = {};
-			if (dot_pointer != begin) {
-				// Non-empty integer part, may be negative
-				from_chars = from_chars_integer(begin, dot_pointer, result);
-			}
-
-			if (from_chars.ec != std::errc{}) {
-				return from_chars;
-			}
-
-			if (dot_pointer + 1 < end) {
-				// Non-empty fractional part, cannot be negative
-				fixed_point_t adder;
-				from_chars = from_chars_fraction(dot_pointer + 1, end, adder);
-				result += result.is_negative() || (*begin == '-' && result == _0) ? -adder : adder;
-			}
-
-			if (from_chars.ec != std::errc{}) {
-				return { begin, from_chars.ec };
-			}
-
-			value = result.value;
-			return from_chars;
-		}
-
-		OV_SPEED_INLINE constexpr std::from_chars_result from_chars_with_plus(char const* begin, char const* end) {
-			if (begin && *begin == '+') {
-				begin++;
-				if (begin < end && *begin == '-') {
-					return std::from_chars_result { begin, std::errc::invalid_argument };
-				}
-			}
-
-			return from_chars(begin, end);
-		}
+		std::from_chars_result from_chars(char const* begin, char const* end);
+		std::from_chars_result from_chars_with_plus(char const* begin, char const* end);
 
 		// Deterministic
-		OV_SPEED_INLINE static constexpr fixed_point_t parse(char const* str, char const* end, bool* successful = nullptr) {
-			fixed_point_t value = 0;
-			std::from_chars_result result = value.from_chars_with_plus(str, end);
-			if (successful) {
-				*successful = result.ec == std::errc {};
-			}
-			return value;
-		}
-
-		OV_SPEED_INLINE static constexpr fixed_point_t parse(char const* str, size_t length, bool* successful = nullptr) {
-			return parse(str, str + length, successful);
-		}
-
-		OV_SPEED_INLINE static constexpr fixed_point_t parse(std::string_view str, bool* successful = nullptr) {
-			return parse(str.data(), str.length(), successful);
-		}
+		static fixed_point_t parse(char const* str, char const* end, bool* successful = nullptr);
+		static fixed_point_t parse(char const* str, size_t length, bool* successful = nullptr);
+		static fixed_point_t parse(std::string_view str, bool* successful = nullptr);
 
 		// Not Deterministic
 		OV_SPEED_INLINE static constexpr fixed_point_t parse_unsafe(float value) {
@@ -545,31 +299,9 @@ namespace OpenVic {
 		}
 
 		// Not Deterministic
-		OV_SPEED_INLINE static fixed_point_t parse_unsafe(char const* value) {
-			char* endpointer;
-			double double_value = std::strtod(value, &endpointer);
-
-			if (*endpointer != '\0') {
-				spdlog::error_s("Unsafe fixed point parse failed to parse the end of a string: \"{}\"", endpointer);
-			}
-
-			value_type integer_value = static_cast<long>(double_value * ONE + 0.5 * (double_value < 0 ? -1 : 1));
+		static fixed_point_t parse_unsafe(char const* value);
 
-			return parse_raw(integer_value);
-		}
-
-		OV_SPEED_INLINE explicit operator memory::string() const {
-			return to_string();
-		}
-
-		friend std::ostream& operator<<(std::ostream& stream, fixed_point_t const& obj) {
-			stack_string result = obj.to_array();
-			if (OV_unlikely(result.empty())) {
-				return stream;
-			}
-
-			return stream << static_cast<std::string_view>(result);
-		}
+		friend std::ostream& operator<<(std::ostream& stream, fixed_point_t const& obj);
 
 		OV_SPEED_INLINE constexpr friend fixed_point_t operator-(fixed_point_t const& obj) {
 			return parse_raw(-obj.value);
@@ -680,21 +412,6 @@ namespace OpenVic {
 			return *this;
 		}
 
-		template<is_strongly_typed StrongType>
-		OV_SPEED_INLINE constexpr fixed_point_t mul_div(StrongType const& numerator, StrongType const& denominator) const {
-			return mul_div(type_safe::get(numerator), type_safe::get(denominator));
-		}
-
-		template<std::integral T>
-		OV_SPEED_INLINE constexpr fixed_point_t mul_div(T const& numerator, T const& denominator) const {
-			return parse_raw(value * numerator / denominator);
-		}
-
-		//Preserves accuracy. Performing a normal multiplication of small values results in 0.
-		OV_SPEED_INLINE constexpr static fixed_point_t mul_div(fixed_point_t const& a, fixed_point_t const& b, fixed_point_t const& denominator) {
-			return a.mul_div(b.value, denominator.value);
-		}
-
 		OV_SPEED_INLINE constexpr friend fixed_point_t operator%(fixed_point_t const& lhs, fixed_point_t const& rhs) {
 			return parse_raw(lhs.value % rhs.value);
 		}
@@ -746,91 +463,19 @@ namespace OpenVic {
 	private:
 		// Deterministic
 		// Can produce negative values
-		OV_SPEED_INLINE static constexpr std::from_chars_result from_chars_integer(char const* str, char const* const end, fixed_point_t& value) {
-			int64_t parsed_value = 0;
-			std::from_chars_result result = string_to_int64(str, end, parsed_value);
-			if (result.ec == std::errc{}) {
-				if (parsed_value > std::numeric_limits<int32_t>::max()) {
-					result.ec = std::errc::value_too_large;
-				} else {
-					value = fixed_point_t(static_cast<int32_t>(parsed_value));
-				}
-			}
-			return result;
-		}
+		static std::from_chars_result from_chars_integer(char const* str, char const* const end, fixed_point_t& value);
 
 		// Deterministic
 		// Cannot produce negative values
-		OV_SPEED_INLINE static constexpr std::from_chars_result from_chars_fraction(char const* begin, char const* end, fixed_point_t& value) {
-			if (begin && *begin == '-') {
-				return { begin, std::errc::invalid_argument };
-			}
-
-			end = end - begin > PRECISION ? begin + PRECISION : end;
-			uint64_t parsed_value;
-			std::from_chars_result result = string_to_uint64(begin, end, parsed_value);
-			if (result.ec != std::errc{}) {
-				return result;
-			}
-
-			for (ptrdiff_t remaining_shift = PRECISION - (end - begin); remaining_shift > 0; remaining_shift--) {
-				parsed_value *= 10;
-			}
-			uint64_t decimal = pow(static_cast<uint64_t>(10), PRECISION);
-			int64_t ret = 0;
-			for (int i = PRECISION - 1; i >= 0; --i) {
-				decimal >>= 1;
-				if (parsed_value >= decimal) {
-					parsed_value -= decimal;
-					ret |= 1 << i;
-				}
-			}
-			value = parse_raw(ret);
-			return result;
-		}
-
-		template<size_t N, std::array<int64_t, N> EXP_LUT>
-		OV_SPEED_INLINE static constexpr fixed_point_t _exp_internal(fixed_point_t const& x) {
-			const bool negative = x.is_negative();
-			value_type bits = negative ? -x.value : x.value;
-			fixed_point_t result = _1;
-
-			for (size_t index = 0; bits != 0 && index < EXP_LUT.size(); ++index, bits >>= 1) {
-				if (bits & 1LL) {
-					result *= parse_raw(EXP_LUT[index]);
-				}
-			}
-
-			if (bits != 0) {
-				spdlog::error_s("Fixed point exponential overflow!");
-			}
-
-			if (negative) {
-				return _1 / result;
-			} else {
-				return result;
-			}
-		}
+		static std::from_chars_result from_chars_fraction(char const* begin, char const* end, fixed_point_t& value);
 
 	public:
-		OV_SPEED_INLINE static constexpr fixed_point_t exp(fixed_point_t const& x) {
-			return _exp_internal<_detail::LUT::_2_16_EXP_e.size(), _detail::LUT::_2_16_EXP_e>(x);
-		}
-
-		OV_SPEED_INLINE static constexpr fixed_point_t exp_2001(fixed_point_t const& x) {
-			return _exp_internal<_detail::LUT::_2_16_EXP_2001.size(), _detail::LUT::_2_16_EXP_2001>(x);
-		}
+		static fixed_point_t exp(fixed_point_t const& x);
+		static fixed_point_t exp_2001(fixed_point_t const& x);
 	};
 
 	static_assert(sizeof(fixed_point_t) == fixed_point_t::SIZE, "fixed_point_t is not 8 bytes");
 
-	OV_SPEED_INLINE constexpr fixed_point_t::stack_string fixed_point_t::to_array(size_t decimal_places) const {
-		stack_string str {};
-		std::to_chars_result result = to_chars(str._array.data(), str._array.data() + str._array.size(), decimal_places);
-		str._string_size = result.ptr - str.data();
-		return str;
-	}
-
 	inline constexpr fixed_point_t fixed_point_t::max = parse_raw(std::numeric_limits<value_type>::max());
 	inline constexpr fixed_point_t fixed_point_t::min = parse_raw(std::numeric_limits<value_type>::min());
 	inline constexpr fixed_point_t fixed_point_t::usable_max = parse_raw(2147483648LL);
@@ -857,11 +502,6 @@ namespace OpenVic {
 	inline constexpr fixed_point_t fixed_point_t::deg2rad = parse_raw(1143LL);
 	inline constexpr fixed_point_t fixed_point_t::rad2deg = parse_raw(3754936LL);
 	inline constexpr fixed_point_t fixed_point_t::e = parse_raw(178145LL);
-
-	template<>
-	[[nodiscard]] OV_SPEED_INLINE constexpr fixed_point_t abs(fixed_point_t num) {
-		return num.abs();
-	}
 }
 
 template<>
diff --git a/src/openvic-simulation/types/fixed_point/FixedPointStackString.hpp b/src/openvic-simulation/types/fixed_point/FixedPointStackString.hpp
new file mode 100644
index 000000000..692dbaa0d
--- /dev/null
+++ b/src/openvic-simulation/types/fixed_point/FixedPointStackString.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "openvic-simulation/types/StackString.hpp"
+
+namespace OpenVic {
+	struct fixed_point_t;
+
+	struct fp_stack_string final : StackString<25> {
+		friend fixed_point_t;
+	protected:
+		using StackString::StackString;
+	};
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/types/fixed_point/Fraction.hpp b/src/openvic-simulation/types/fixed_point/Fraction.hpp
index 205a18b08..613942f53 100644
--- a/src/openvic-simulation/types/fixed_point/Fraction.hpp
+++ b/src/openvic-simulation/types/fixed_point/Fraction.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
+#include "openvic-simulation/types/fixed_point/Math.hpp"
 #include "openvic-simulation/core/Typedefs.hpp"
 
 namespace OpenVic {
@@ -9,11 +10,11 @@ namespace OpenVic {
 		fixed_point_t denominator = fixed_point_t::_1;
 
 		OV_SPEED_INLINE constexpr friend fixed_point_t operator*(Fraction const& lhs, fixed_point_t const& rhs) {
-			return fixed_point_t::mul_div(rhs, lhs.numerator, lhs.denominator);
+			return fp::mul_div(rhs, lhs.numerator, lhs.denominator);
 		}
 
 		OV_SPEED_INLINE constexpr friend fixed_point_t operator*(fixed_point_t const& lhs, Fraction const& rhs) {
-			return fixed_point_t::mul_div(lhs, rhs.numerator, rhs.denominator);
+			return fp::mul_div(lhs, rhs.numerator, rhs.denominator);
 		}
 	};
 }
\ No newline at end of file
diff --git a/src/openvic-simulation/types/fixed_point/Math.hpp b/src/openvic-simulation/types/fixed_point/Math.hpp
new file mode 100644
index 000000000..a2f7854b3
--- /dev/null
+++ b/src/openvic-simulation/types/fixed_point/Math.hpp
@@ -0,0 +1,105 @@
+#pragma once
+
+#include "FixedPoint.hpp"
+
+#include <cassert>
+
+#include "openvic-simulation/core/MathSqrt.hpp"
+#include "openvic-simulation/core/template/Concepts.hpp"
+#include "openvic-simulation/core/Typedefs.hpp"
+
+/* Sin lookup table */
+#include "openvic-simulation/types/fixed_point/FixedPointLUT_sin.hpp"
+
+namespace OpenVic::fp {
+	static_assert(_detail::LUT::SIN_PRECISION == fixed_point_t::PRECISION);	
+
+	OV_SPEED_INLINE static constexpr fixed_point_t sin(fixed_point_t const& v) {
+		using namespace _detail::LUT;
+
+		fixed_point_t::value_type num = (v % fixed_point_t::pi2 * fixed_point_t::one_div_pi2).get_raw_value();
+
+		const bool negative = num < 0;
+		if (negative) {
+			num = -num;
+		}
+
+		const fixed_point_t::value_type index = num >> SIN_SHIFT;
+		const fixed_point_t::value_type a = SIN[index];
+		const fixed_point_t::value_type b = SIN[index + 1];
+
+		const fixed_point_t::value_type fraction = (num - (index << SIN_SHIFT)) << SIN_COUNT_LOG2;
+		const fixed_point_t::value_type result = a + (((b - a) * fraction) >> SIN_PRECISION);
+		return fixed_point_t::parse_raw(
+			!negative ? result : -result
+		);
+	}
+
+	OV_SPEED_INLINE static constexpr fixed_point_t cos(fixed_point_t const& v) {
+		return fp::sin(v + fixed_point_t::pi_half);
+	}
+
+	OV_SPEED_INLINE static constexpr fixed_point_t sqrt(fixed_point_t const& v) {
+		return !v.is_negative()
+			? fixed_point_t::parse_raw(
+				OpenVic::sqrt(
+					static_cast<uint64_t>(v.get_raw_value()) << fixed_point_t::PRECISION
+				)
+			)
+			: fixed_point_t::_0;
+	}
+
+	//Preserves accuracy. Performing a normal multiplication of small values results in 0.
+	template<std::integral T>
+	OV_SPEED_INLINE static constexpr fixed_point_t mul_div(fixed_point_t const& multiplier, T const& numerator, T const& denominator) {
+		return fixed_point_t::parse_raw(multiplier.get_raw_value() * numerator / denominator);
+	}
+
+	OV_SPEED_INLINE static constexpr fixed_point_t mul_div(fixed_point_t const& multiplier, fixed_point_t const& numerator, fixed_point_t const& denominator) {
+		return mul_div(multiplier, numerator.get_raw_value(), denominator.get_raw_value());
+	}
+
+	template<is_strongly_typed StrongType>
+	OV_SPEED_INLINE static constexpr fixed_point_t mul_div(fixed_point_t const& multiplier, StrongType const& numerator, StrongType const& denominator) {
+		return mul_div(multiplier, type_safe::get(numerator), type_safe::get(denominator));
+	}
+	
+	template<std::integral T>
+	OV_SPEED_INLINE static constexpr T multiply_truncate(T const& integer, fixed_point_t const& v) {
+		return static_cast<T>(
+			(static_cast<fixed_point_t::value_type>(integer) * v.get_raw_value()) >> fixed_point_t::PRECISION
+		);
+	}
+
+	template<is_strongly_typed StrongType>
+	OV_SPEED_INLINE static constexpr StrongType multiply_truncate(StrongType const& integer, fixed_point_t const& v) {
+		return StrongType(multiply_truncate(
+			type_safe::get(integer),
+			v
+		));
+	}
+
+	template<integral_max_size_4 TNumerator, integral_max_size_4 TDenominator>
+	OV_SPEED_INLINE static constexpr fixed_point_t from_fraction(const TNumerator numerator, const TDenominator denominator) {
+		return fixed_point_t::parse_raw(
+			(static_cast<fixed_point_t::value_type>(numerator) << fixed_point_t::PRECISION)
+			/ static_cast<fixed_point_t::value_type>(denominator)
+		);
+	}
+
+	OV_SPEED_INLINE static constexpr fixed_point_t from_fraction(const int64_t numerator, const int64_t denominator) {
+		assert(numerator < 140737488355328LL); //2^47
+		assert(numerator >= -140737488355328LL); //- 2^47
+		return fixed_point_t::parse_raw((numerator << fixed_point_t::PRECISION) / denominator);
+	}
+
+	OV_SPEED_INLINE static constexpr fixed_point_t from_fraction(const uint64_t numerator, const uint64_t denominator) {
+		assert(numerator < 281474976710656ULL); //2^48
+		return fixed_point_t::parse_raw((numerator << fixed_point_t::PRECISION) / denominator);
+	}
+
+	template<is_strongly_typed StrongType>
+	OV_SPEED_INLINE static constexpr fixed_point_t from_fraction(StrongType const& numerator, StrongType const& denominator) {
+		return from_fraction(type_safe::get(numerator), type_safe::get(denominator));
+	}
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/utility/Containers.hpp b/src/openvic-simulation/utility/Containers.hpp
deleted file mode 100644
index eb115a663..000000000
--- a/src/openvic-simulation/utility/Containers.hpp
+++ /dev/null
@@ -1,292 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <queue>
-#include <sstream>
-#include <stack>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-#include <plf_colony.h>
-
-#include <fmt/format.h>
-
-#include "openvic-simulation/types/CowPtr.hpp"
-#include "openvic-simulation/types/CowVector.hpp"
-#include "openvic-simulation/utility/DequeMemory.hpp"
-#include "openvic-simulation/utility/MemoryTracker.hpp"
-
-#include <foonathan/memory/allocator_storage.hpp>
-#include <foonathan/memory/container.hpp>
-#include <foonathan/memory/default_allocator.hpp>
-#include <foonathan/memory/heap_allocator.hpp>
-#include <foonathan/memory/new_allocator.hpp>
-#include <foonathan/memory/smart_ptr.hpp>
-#include <foonathan/memory/tracking.hpp>
-
-namespace OpenVic::memory {
-	template<class RawAllocator>
-	tracker<RawAllocator> make_tracked_allocator( //
-		RawAllocator&& alloc
-	) {
-#ifdef DEBUG_ENABLED
-		return foonathan::memory::make_tracked_allocator(
-			typename tracker<RawAllocator>::tracker {}, std::forward<RawAllocator>(alloc)
-		);
-#else
-		return std::forward<RawAllocator>(alloc);
-#endif
-	}
-
-	template<class RawAllocator>
-	using allocator_reference = foonathan::memory::allocator_reference<RawAllocator>;
-
-	template<class RawAllocator>
-	allocator_reference<RawAllocator> make_allocator_reference(RawAllocator&& alloc) {
-		return foonathan::memory::make_allocator_reference(alloc);
-	}
-
-	template<typename T, class RawAllocator>
-	using allocator_deleter = foonathan::memory::allocator_deleter<T, RawAllocator>;
-
-	template<class RawAllocator>
-	struct will_optimize_deleter_for : std::false_type {};
-
-	template<>
-	struct will_optimize_deleter_for<foonathan::memory::heap_allocator> : std::true_type {};
-
-	template<>
-	struct will_optimize_deleter_for<foonathan::memory::malloc_allocator> : std::true_type {};
-
-	template<>
-	struct will_optimize_deleter_for<foonathan::memory::new_allocator> : std::true_type {};
-
-#ifdef DEBUG_ENABLED
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
-	using unique_ptr = foonathan::memory::unique_ptr<T, tracker<RawAllocator>>;
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
-	using unique_base_ptr = foonathan::memory::unique_base_ptr<T, tracker<RawAllocator>>;
-
-	template<typename T, class RawAllocator, typename... Args>
-	requires(!std::is_array_v<T>)
-	unique_ptr<T, std::decay_t<RawAllocator>> allocate_unique(RawAllocator&& alloc, Args&&... args) {
-		return foonathan::memory::allocate_unique<T>(
-			make_tracked_allocator(std::forward<RawAllocator>(alloc)), std::forward<Args>(args)...
-		);
-	}
-
-	template<typename T, class RawAllocator>
-	requires(std::is_array_v<T>)
-	unique_ptr<T, std::decay_t<RawAllocator>> allocate_unique(RawAllocator&& alloc, std::size_t size) {
-		return foonathan::memory::allocate_unique<T, tracker<RawAllocator>>(
-			make_tracked_allocator(std::forward<RawAllocator>(alloc)), size
-		);
-	}
-#else
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
-	using unique_ptr = std::conditional_t<
-		will_optimize_deleter_for<RawAllocator>::value, std::unique_ptr<T>,
-		foonathan::memory::unique_ptr<T, tracker<RawAllocator>>>;
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
-	using unique_base_ptr = std::conditional_t<
-		will_optimize_deleter_for<RawAllocator>::value, std::unique_ptr<T>,
-		foonathan::memory::unique_base_ptr<T, tracker<RawAllocator>>>;
-
-	template<typename T, class RawAllocator, typename... Args>
-	requires(!std::is_array_v<T>)
-	unique_ptr<T, std::decay_t<RawAllocator>> allocate_unique(RawAllocator&& alloc, Args&&... args) {
-		if constexpr (will_optimize_deleter_for<RawAllocator>::value) {
-			return std::make_unique<T>(std::forward<Args>(args)...);
-		} else {
-			return foonathan::memory::allocate_unique<T>(
-				make_tracked_allocator(std::forward<RawAllocator>(alloc)), std::forward<Args>(args)...
-			);
-		}
-	}
-
-	template<typename T, class RawAllocator>
-	requires(std::is_array_v<T>)
-	unique_ptr<T, std::decay_t<RawAllocator>> allocate_unique(RawAllocator&& alloc, std::size_t size) {
-		if constexpr (will_optimize_deleter_for<RawAllocator>::value) {
-			return std::make_unique<T>(size);
-		} else {
-			return foonathan::memory::allocate_unique<T, tracker<RawAllocator>>(
-				make_tracked_allocator(std::forward<RawAllocator>(alloc)), size
-			);
-		}
-	}
-#endif
-
-	template<typename T, class RawAllocator, typename... Args>
-	requires(!std::is_array_v<T>)
-	static inline T* allocate_new(RawAllocator&& alloc, Args&&... args) {
-		allocator_reference<RawAllocator> alloc_ref = ::OpenVic::memory::make_allocator_reference(alloc);
-		T* ptr = static_cast<T*>(alloc_ref.allocate_node(sizeof(T), alignof(T)));
-		::new (ptr) T(std::forward<Args>(args)...);
-		return ptr;
-	}
-
-	template<typename T, class RawAllocator, typename... Args>
-	requires(std::is_unbounded_array_v<T>)
-	static inline T* allocate_new(RawAllocator&& alloc, size_t n) {
-		allocator_reference<RawAllocator> alloc_ref = ::OpenVic::memory::make_allocator_reference(alloc);
-		return static_cast<T*>(alloc_ref.allocate_node(sizeof(T) * n, alignof(T)));
-	}
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator, typename... Args>
-	requires(!std::is_array_v<T>)
-	static inline T* make_new(Args&&... args) {
-		return allocate_new<T>(make_tracked_allocator(RawAllocator {}), std::forward<Args>(args)...);
-	}
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator, typename... Args>
-	requires(std::is_unbounded_array_v<T>)
-	static inline T* make_new(size_t n) {
-		return allocate_new<T>(make_tracked_allocator(RawAllocator {}), n);
-	}
-
-	template<typename T, class RawAllocator>
-	requires(!std::is_array_v<T>)
-	static inline void dealloc_delete(RawAllocator&& alloc, T* ptr) {
-		ptr->~T();
-		allocator_reference<RawAllocator> alloc_ref = ::OpenVic::memory::make_allocator_reference(alloc);
-		alloc_ref.deallocate(ptr, sizeof(T), alignof(T));
-	}
-
-	template<typename T, class RawAllocator>
-	requires(std::is_unbounded_array_v<T>)
-	static inline void dealloc_delete(RawAllocator&& alloc, T* ptr, size_t n) {
-		std::destroy_n(ptr, n);
-		allocator_reference<RawAllocator> alloc_ref = ::OpenVic::memory::make_allocator_reference(alloc);
-		alloc_ref.deallocate(ptr, sizeof(T) * n, alignof(T));
-	}
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
-	requires(!std::is_array_v<T>)
-	static inline void delete_at(T* ptr) {
-		dealloc_delete(make_tracked_allocator(RawAllocator {}), ptr);
-	}
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
-	requires(std::is_unbounded_array_v<T>)
-	static inline void delete_at(T* ptr, size_t n) {
-		dealloc_delete(make_tracked_allocator(RawAllocator {}), ptr, n);
-	}
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator, typename... Args>
-	requires(!std::is_array_v<T>)
-	static inline unique_ptr<T, RawAllocator> make_unique(Args&&... args) {
-		return allocate_unique<T>(RawAllocator {}, std::forward<Args>(args)...);
-	}
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator, typename... Args>
-	requires(std::is_unbounded_array_v<T>)
-	static inline unique_ptr<T, RawAllocator> make_unique(size_t n) {
-		return allocate_unique<T>(make_tracked_allocator(RawAllocator {}), n);
-	}
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator, typename... Args>
-	requires(!std::is_array_v<T>)
-	static inline unique_ptr<T, RawAllocator> make_unique_for_overwrite() {
-		using raw_ptr = std::unique_ptr<T, foonathan::memory::allocator_deallocator<T, tracker<RawAllocator>>>;
-
-		tracker<RawAllocator> alloc = make_tracked_allocator(RawAllocator {});
-		auto memory = alloc.allocate_node(sizeof(T), alignof(T));
-		// raw_ptr deallocates memory in case of constructor exception
-		raw_ptr result(static_cast<T*>(memory), { alloc });
-		// pass ownership to return value using a deleter that calls destructor
-		return { result.release(), { alloc } };
-	}
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator, typename... Args>
-	requires(std::is_unbounded_array_v<T>)
-	static inline unique_ptr<T, RawAllocator> make_unique_for_overwrite(size_t size) {
-		using raw_ptr = std::unique_ptr<T, foonathan::memory::allocator_deallocator<T, tracker<RawAllocator>>>;
-
-		tracker<RawAllocator> alloc = make_tracked_allocator(RawAllocator {});
-		auto memory = alloc.allocate_array(size, sizeof(T), alignof(T));
-		// raw_ptr deallocates memory in case of constructor exception
-		raw_ptr result(static_cast<T*>(memory), { alloc, size });
-		// pass ownership to return value using a deleter that calls destructor
-		return { result.release(), { alloc, size } };
-	}
-
-	template<typename T, class RawAllocator, typename... Args>
-	std::shared_ptr<T> allocate_shared(RawAllocator&& alloc, Args&&... args) {
-		return foonathan::memory::allocate_shared<T>(
-			make_tracked_allocator(std::forward<RawAllocator>(alloc)), std::forward<Args>(args)...
-		);
-	}
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator, typename... Args>
-	static inline std::shared_ptr<T> make_shared(Args&&... args) {
-		return allocate_shared<T>(RawAllocator {}, std::forward<Args>(args)...);
-	}
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
-	using vector = foonathan::memory::vector<T, tracker<RawAllocator>>;
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
-	using deque = OpenVic::utility::memory::deque<T, tracker<RawAllocator>>;
-
-	template<typename CharT, class RawAllocator = foonathan::memory::default_allocator>
-	using basic_string =
-		std::basic_string<CharT, std::char_traits<CharT>, foonathan::memory::std_allocator<CharT, tracker<RawAllocator>>>;
-
-	template<class RawAllocator = foonathan::memory::default_allocator>
-	using string_alloc = basic_string<char, RawAllocator>;
-
-	using string = string_alloc<>;
-
-	template<class RawAllocator = foonathan::memory::default_allocator>
-	using wstring_alloc = basic_string<wchar_t, RawAllocator>;
-
-	using wstring = wstring_alloc<>;
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
-	using colony = plf::colony<T, foonathan::memory::std_allocator<T, tracker<RawAllocator>>>;
-
-	template<typename T, typename Container = memory::deque<T>>
-	using stack = std::stack<T, Container>;
-
-	template<typename T, typename Container = memory::deque<T>>
-	using queue = std::queue<T, Container>;
-
-	template<typename T, typename CharTraits = std::char_traits<T>, class RawAllocator = foonathan::memory::default_allocator>
-	using basic_stringstream =
-		std::basic_stringstream<T, CharTraits, foonathan::memory::std_allocator<T, tracker<RawAllocator>>>;
-
-	template<class RawAllocator = foonathan::memory::default_allocator>
-	using stringstream_alloc = basic_stringstream<char, std::char_traits<char>, RawAllocator>;
-	template<class RawAllocator = foonathan::memory::default_allocator>
-	using wstringstream_alloc = basic_stringstream<wchar_t, std::char_traits<wchar_t>, RawAllocator>;
-
-	using stringstream = stringstream_alloc<>;
-	using wstringstream = wstringstream_alloc<>;
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
-	using cow_ptr = cow_ptr<T, foonathan::memory::std_allocator<T, tracker<RawAllocator>>>;
-
-	template<typename T, class RawAllocator = foonathan::memory::default_allocator>
-	using cow_vector = cow_vector<T, foonathan::memory::std_allocator<T, tracker<RawAllocator>>>;
-
-	namespace fmt {
-		template<typename T, class RawAllocator = foonathan::memory::default_allocator>
-		using basic_memory_buffer = ::fmt::basic_memory_buffer<
-			T, ::fmt::inline_buffer_size, foonathan::memory::std_allocator<T, tracker<RawAllocator>>>;
-
-		inline static memory::string vformat(::fmt::string_view fmt, ::fmt::format_args args) {
-			memory::fmt::basic_memory_buffer<char> buf {};
-			::fmt::vformat_to(std::back_inserter(buf), fmt, args);
-			return memory::string(buf.data(), buf.size());
-		}
-
-		template<typename... Args>
-		memory::string format(::fmt::string_view fmt, const Args&... args) {
-			return memory::fmt::vformat(fmt, ::fmt::make_format_args(args...));
-		}
-	}
-}
diff --git a/src/openvic-simulation/utility/DequeMemory.hpp b/src/openvic-simulation/utility/DequeMemory.hpp
deleted file mode 100644
index 91466539b..000000000
--- a/src/openvic-simulation/utility/DequeMemory.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-#include <scoped_allocator>
-
-#include "openvic-simulation/core/portable/Deque.hpp"
-
-#include <foonathan/memory/config.hpp>
-#include <foonathan/memory/std_allocator.hpp>
-
-namespace OpenVic::utility::memory {
-	template<typename T, class RawAllocator>
-	FOONATHAN_ALIAS_TEMPLATE(deque, OpenVic::utility::deque<T, foonathan::memory::std_allocator<T, RawAllocator>>);
-
-	template<typename T, class RawAllocator>
-	FOONATHAN_ALIAS_TEMPLATE(deque_scoped_alloc, OpenVic::utility::deque<T, std::scoped_allocator_adaptor<foonathan::memory::std_allocator<T, RawAllocator>>>);
-}
diff --git a/src/openvic-simulation/utility/Getters.hpp b/src/openvic-simulation/utility/Getters.hpp
index 33a660caf..147ce68d8 100644
--- a/src/openvic-simulation/utility/Getters.hpp
+++ b/src/openvic-simulation/utility/Getters.hpp
@@ -3,13 +3,12 @@
 #include <concepts>
 #include <functional>
 #include <optional>
-#include <string>
 #include <string_view>
 #include <type_traits>
 
+#include "openvic-simulation/core/memory/String.hpp"
 #include "openvic-simulation/core/portable/ForwardableSpan.hpp" // IWYU pragma: keep for SPAN_PROPERTY
 #include "openvic-simulation/core/Typedefs.hpp" // IWYU pragma: keep
-#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/core/template/Concepts.hpp"
 
 namespace OpenVic::utility {
diff --git a/src/openvic-simulation/utility/Logger.hpp b/src/openvic-simulation/utility/Logger.hpp
index 11bac05cb..d54d11fec 100644
--- a/src/openvic-simulation/utility/Logger.hpp
+++ b/src/openvic-simulation/utility/Logger.hpp
@@ -9,7 +9,8 @@
 #include <spdlog/logger.h>
 #include <spdlog/spdlog.h>
 
-#include "openvic-simulation/utility/Containers.hpp"
+#include "openvic-simulation/core/memory/Stack.hpp"
+#include "openvic-simulation/core/memory/String.hpp"
 
 namespace spdlog {
 	template<typename... Args>
diff --git a/src/openvic-simulation/utility/ThreadPool.cpp b/src/openvic-simulation/utility/ThreadPool.cpp
index 2fc169548..13f22df4c 100644
--- a/src/openvic-simulation/utility/ThreadPool.cpp
+++ b/src/openvic-simulation/utility/ThreadPool.cpp
@@ -8,7 +8,6 @@
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
 #include "openvic-simulation/types/TypedSpan.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 using namespace OpenVic;
 
diff --git a/src/openvic-simulation/utility/ThreadPool.hpp b/src/openvic-simulation/utility/ThreadPool.hpp
index 5b37f0c96..a0043e54c 100644
--- a/src/openvic-simulation/utility/ThreadPool.hpp
+++ b/src/openvic-simulation/utility/ThreadPool.hpp
@@ -7,7 +7,7 @@
 
 #include "openvic-simulation/population/PopValuesFromProvince.hpp"
 #include "openvic-simulation/types/Date.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/core/portable/ForwardableSpan.hpp"
 #include "openvic-simulation/core/random/RandomGenerator.hpp"
 
diff --git a/tests/src/pathfinding/AStarPathing.cpp b/tests/src/pathfinding/AStarPathing.cpp
index d73d68978..0873e2a07 100644
--- a/tests/src/pathfinding/AStarPathing.cpp
+++ b/tests/src/pathfinding/AStarPathing.cpp
@@ -3,7 +3,6 @@
 #include "openvic-simulation/pathfinding/PointMap.hpp"
 #include "openvic-simulation/types/Vector.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 #include "Helper.hpp"
 #include "pathfinding/Pathing.hpp"
diff --git a/tests/src/pathfinding/FringePathing.cpp b/tests/src/pathfinding/FringePathing.cpp
index 252330914..11d22cce0 100644
--- a/tests/src/pathfinding/FringePathing.cpp
+++ b/tests/src/pathfinding/FringePathing.cpp
@@ -3,7 +3,6 @@
 #include "openvic-simulation/pathfinding/PointMap.hpp"
 #include "openvic-simulation/types/Vector.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 #include "Helper.hpp"
 #include "pathfinding/Pathing.hpp"
diff --git a/tests/src/pathfinding/Pathing.hpp b/tests/src/pathfinding/Pathing.hpp
index 61e390b45..4504289d1 100644
--- a/tests/src/pathfinding/Pathing.hpp
+++ b/tests/src/pathfinding/Pathing.hpp
@@ -4,9 +4,9 @@
 
 #include <fmt/core.h>
 
+#include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/pathfinding/PointMap.hpp"
 #include "openvic-simulation/types/Vector.hpp"
-#include "openvic-simulation/utility/Containers.hpp"
 
 #include "Helper.hpp"
 #include <snitch/snitch_macros_misc.hpp>
diff --git a/tests/src/types/FixedPoint.cpp b/tests/src/types/FixedPoint.cpp
index b0a48c47b..39a95e6ac 100644
--- a/tests/src/types/FixedPoint.cpp
+++ b/tests/src/types/FixedPoint.cpp
@@ -1,4 +1,6 @@
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
+#include "openvic-simulation/types/fixed_point/FixedPointStackString.hpp"
+#include "openvic-simulation/types/fixed_point/Math.hpp"
 
 #include <cstdint>
 #include <limits>
@@ -40,15 +42,15 @@ TEST_CASE("fixed_point_t Linear algebra methods", "[fixed_point_t][fixed_point_t
 	static constexpr fixed_point_t one = 1;
 	static constexpr fixed_point_t two = 2;
 	static constexpr fixed_point_t three = 3;
-	CONSTEXPR_CHECK(one.sin() == 0.8414306640625_a);
-	CONSTEXPR_CHECK(two.sin() == 0.9093170166015625_a);
-	CONSTEXPR_CHECK(three.sin() == 0.1412200927734375_a);
-	CONSTEXPR_CHECK(one.cos() == 0.5403900146484375_a);
-	CONSTEXPR_CHECK(two.cos() == -0.4160003662109375_a);
-	CONSTEXPR_CHECK(three.cos() == -0.989959716796875_a);
-
-	CONSTEXPR_CHECK(fixed_point_t::_0_50.sin() == 0.4793853759765625_a);
-	CONSTEXPR_CHECK(fixed_point_t::_0_50.cos() == 0.87762451171875_a);
+	CONSTEXPR_CHECK(fp::sin(one) == 0.8414306640625_a);
+	CONSTEXPR_CHECK(fp::sin(two) == 0.9093170166015625_a);
+	CONSTEXPR_CHECK(fp::sin(three) == 0.1412200927734375_a);
+	CONSTEXPR_CHECK(fp::cos(one) == 0.5403900146484375_a);
+	CONSTEXPR_CHECK(fp::cos(two) == -0.4160003662109375_a);
+	CONSTEXPR_CHECK(fp::cos(three) == -0.989959716796875_a);
+
+	CONSTEXPR_CHECK(fp::sin(fixed_point_t::_0_50) == 0.4793853759765625_a);
+	CONSTEXPR_CHECK(fp::cos(fixed_point_t::_0_50) == 0.87762451171875_a);
 }
 
 TEST_CASE("fixed_point_t Constant methods", "[fixed_point_t][fixed_point_t-constants]") {
@@ -132,33 +134,33 @@ TEST_CASE("fixed_point_t Parse methods", "[fixed_point_t][fixed_point_t-parse]")
 	CONSTEXPR_CHECK(fixed_point_t(10) == 10);
 	CONSTEXPR_CHECK(fixed_point_t::parse_raw(10) == fixed_point_t::epsilon * 10);
 
-	CONSTEXPR_CHECK(fixed_point_t::parse_capped(140737488355328LL) == fixed_point_t::max);
-	CONSTEXPR_CHECK(fixed_point_t::parse_capped(140737488355327LL) == fixed_point_t::max);
-	CONSTEXPR_CHECK(fixed_point_t::parse_capped(140737488355326LL).truncate<int64_t>() == 140737488355326LL);
+	CHECK(fixed_point_t::parse_capped(140737488355328LL) == fixed_point_t::max);
+	CHECK(fixed_point_t::parse_capped(140737488355327LL) == fixed_point_t::max);
+	CHECK(fixed_point_t::parse_capped(140737488355326LL).truncate<int64_t>() == 140737488355326LL);
 
 	static constexpr std::string_view fixed_point_str = "4.5432"sv;
-	CONSTEXPR_CHECK(fixed_point_t::parse(fixed_point_str) == 4.5432_a);
+	CHECK(fixed_point_t::parse(fixed_point_str) == 4.5432_a);
 	bool fixed_point_str_success;
 	CHECK(fixed_point_t::parse(fixed_point_str, &fixed_point_str_success) == 4.5432_a);
 	CHECK(fixed_point_str_success);
 
 	static constexpr std::string_view neg_fixed_point_str = "-4.5432"sv;
-	CONSTEXPR_CHECK(fixed_point_t::parse(neg_fixed_point_str) == -4.5432_a);
+	CHECK(fixed_point_t::parse(neg_fixed_point_str) == -4.5432_a);
 	CHECK(fixed_point_t::parse(neg_fixed_point_str, &fixed_point_str_success) == -4.5432_a);
 	CHECK(fixed_point_str_success);
 
 	static constexpr std::string_view plus_fixed_point_str = "+4.5432"sv;
-	CONSTEXPR_CHECK(fixed_point_t::parse(plus_fixed_point_str) == 4.5432_a);
+	CHECK(fixed_point_t::parse(plus_fixed_point_str) == 4.5432_a);
 	CHECK(fixed_point_t::parse(plus_fixed_point_str, &fixed_point_str_success) == 4.5432_a);
 	CHECK(fixed_point_str_success);
 
 	static constexpr std::string_view neg_zero_fixed_point_str = "-0"sv;
-	CONSTEXPR_CHECK(fixed_point_t::parse(neg_zero_fixed_point_str) == 0);
+	CHECK(fixed_point_t::parse(neg_zero_fixed_point_str) == 0);
 	CHECK(fixed_point_t::parse(neg_zero_fixed_point_str, &fixed_point_str_success) == 0);
 	CHECK(fixed_point_str_success);
 
 	static constexpr std::string_view neg_0_25_fixed_point_str = "-0.25"sv;
-	CONSTEXPR_CHECK(fixed_point_t::parse(neg_0_25_fixed_point_str) == -0.25_a);
+	CHECK(fixed_point_t::parse(neg_0_25_fixed_point_str) == -0.25_a);
 	CHECK(fixed_point_t::parse(neg_0_25_fixed_point_str, &fixed_point_str_success) == -0.25_a);
 	CHECK(fixed_point_str_success);
 
@@ -187,18 +189,18 @@ TEST_CASE("fixed_point_t string methods", "[fixed_point_t][fixed_point_t-string]
 	static constexpr fixed_point_t _0_55 = fixed_point_t::_0_50 + fixed_point_t::_1 / 20;
 	static constexpr fixed_point_t neg_0_55 = -_0_55;
 
-	CONSTEXPR_CHECK(constant_zero.to_array() == "0"sv);
-	CONSTEXPR_CHECK(one.to_array() == "1"sv);
-	CONSTEXPR_CHECK(constant_one.to_array() == "1"sv);
-	CONSTEXPR_CHECK(neg_one.to_array() == "-1"sv);
-	CONSTEXPR_CHECK(neg_two.to_array() == "-2"sv);
-	CONSTEXPR_CHECK(neg_three.to_array() == "-3"sv);
-	CONSTEXPR_CHECK(_2_55.to_array() == "2.54998779296875"sv);
-	CONSTEXPR_CHECK(neg_2_55.to_array() == "-2.54998779296875"sv);
-	CONSTEXPR_CHECK(_2_55.to_array(2) == "2.55"sv);
-	CONSTEXPR_CHECK(neg_2_55.to_array(2) == "-2.55"sv);
-	CONSTEXPR_CHECK(_0_55.to_array(2) == "0.55"sv);
-	CONSTEXPR_CHECK(neg_0_55.to_array(2) == "-0.55"sv);
+	CHECK(constant_zero.to_array() == "0"sv);
+	CHECK(one.to_array() == "1"sv);
+	CHECK(constant_one.to_array() == "1"sv);
+	CHECK(neg_one.to_array() == "-1"sv);
+	CHECK(neg_two.to_array() == "-2"sv);
+	CHECK(neg_three.to_array() == "-3"sv);
+	CHECK(_2_55.to_array() == "2.54998779296875"sv);
+	CHECK(neg_2_55.to_array() == "-2.54998779296875"sv);
+	CHECK(_2_55.to_array(2) == "2.55"sv);
+	CHECK(neg_2_55.to_array(2) == "-2.55"sv);
+	CHECK(_0_55.to_array(2) == "0.55"sv);
+	CHECK(neg_0_55.to_array(2) == "-0.55"sv);
 }
 
 TEST_CASE("fixed_point_t Other methods", "[fixed_point_t][fixed_point_t-other]") {
@@ -210,8 +212,8 @@ TEST_CASE("fixed_point_t Other methods", "[fixed_point_t][fixed_point_t-other]")
 	CONSTEXPR_CHECK_FALSE(fixed_point_t::_1_50.is_integer());
 	CONSTEXPR_CHECK_FALSE(fixed_point_t::_0_50.is_integer());
 	CONSTEXPR_CHECK_FALSE(fixed_point_t::_0_01.is_integer());
-	CONSTEXPR_CHECK(fixed_point_t::_0_50.sqrt() == 0.7071075439453125_a);
-	CONSTEXPR_CHECK((-fixed_point_t::_0_50).sqrt() == 0);
+	CONSTEXPR_CHECK(fp::sqrt(fixed_point_t::_0_50) == 0.7071075439453125_a);
+	CONSTEXPR_CHECK(fp::sqrt(-fixed_point_t::_0_50) == 0);
 }
 
 TEST_CASE("fixed_point_t Operators", "[fixed_point_t][fixed_point_t-operators]") {
@@ -288,7 +290,7 @@ TEST_CASE("fixed_point_t Operators", "[fixed_point_t][fixed_point_t-operators]")
 	CONSTEXPR_CHECK(((int32_t)decimal4) == 3);
 
 	CONSTEXPR_CHECK(
-		fixed_point_t::mul_div(
+		fp::mul_div(
 			fixed_point_t::parse_raw(2),
 			fixed_point_t::parse_raw(3),
 			fixed_point_t::parse_raw(6)
@@ -296,13 +298,13 @@ TEST_CASE("fixed_point_t Operators", "[fixed_point_t][fixed_point_t-operators]")
 	);
 
 	CONSTEXPR_CHECK(
-		fixed_point_t::multiply_truncate<int64_t>(
+		fp::multiply_truncate<int64_t>(
 			4294967295LL, //2^32 - 1
 			fixed_point_t::usable_max //2^31 / 2^16
 		) == 140737488322560LL //2^47 - 2^15
 	);
 	CONSTEXPR_CHECK(
-		fixed_point_t::multiply_truncate<int64_t>(
+		fp::multiply_truncate<int64_t>(
 			281474976710655LL, //2^48 - 1
 			fixed_point_t::_0_50
 		) == 140737488355327LL //2^47 - 1
diff --git a/tests/src/types/Vector2.cpp b/tests/src/types/Vector2.cpp
index 154605cc2..727f51844 100644
--- a/tests/src/types/Vector2.cpp
+++ b/tests/src/types/Vector2.cpp
@@ -3,6 +3,7 @@
 
 #include "openvic-simulation/types/Vector.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
+#include "openvic-simulation/types/fixed_point/Math.hpp"
 
 #include "Approx.hpp"
 #include "Helper.hpp" // IWYU pragma: keep
@@ -110,9 +111,9 @@ TEMPLATE_LIST_TEST_CASE("vec2_t Iterator", "[vec2_t][vec2_t-iterator]", VectorVa
 TEST_CASE("fvec2_t Length methods", "[vec2_t][fvec2_t][fvec2_t-length]") {
 	static constexpr fvec2_t vector1 = fvec2_t(10, 10);
 	static constexpr fvec2_t vector2 = fvec2_t(20, 30);
-	CONSTEXPR_CHECK(vector1.length_squared().sqrt() == testing::approx(testing::SQRT2 * 10));
-	CONSTEXPR_CHECK(vector2.length_squared().sqrt() == testing::approx(36.05551275463989293119));
-	CONSTEXPR_CHECK(vector1.distance_squared(vector2).sqrt() == testing::approx(22.36067977499789696409));
+	CONSTEXPR_CHECK(fp::sqrt(vector1.length_squared()) == testing::approx(testing::SQRT2 * 10));
+	CONSTEXPR_CHECK(fp::sqrt(vector2.length_squared()) == testing::approx(36.05551275463989293119));
+	CONSTEXPR_CHECK(fp::sqrt(vector1.distance_squared(vector2)) == testing::approx(22.36067977499789696409));
 }
 
 TEST_CASE("dvec2_t Length methods", "[vec2_t][dvec2_t][dvec2_t-length]") {
diff --git a/tests/src/types/Vector3.cpp b/tests/src/types/Vector3.cpp
index daecfa4ea..b6c4c1d9f 100644
--- a/tests/src/types/Vector3.cpp
+++ b/tests/src/types/Vector3.cpp
@@ -3,6 +3,7 @@
 
 #include "openvic-simulation/types/Vector.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
+#include "openvic-simulation/types/fixed_point/Math.hpp"
 
 #include "Approx.hpp"
 #include "Helper.hpp" // IWYU pragma: keep
@@ -100,9 +101,9 @@ TEMPLATE_LIST_TEST_CASE("vec3_t Iterator", "[vec3_t][vec3_t-iterator]", VectorVa
 TEST_CASE("fvec3_t Length methods", "[vec3_t][fvec3_t][fvec3_t-length]") {
 	static constexpr fvec3_t vector1 = fvec3_t(10, 10, 10);
 	static constexpr fvec3_t vector2 = fvec3_t(20, 30, 40);
-	CONSTEXPR_CHECK(vector1.length_squared().sqrt() == testing::approx(testing::SQRT3 * 10));
-	CONSTEXPR_CHECK(vector2.length_squared().sqrt() == testing::approx(53.8516480713450403125));
-	CONSTEXPR_CHECK(vector1.distance_squared(vector2).sqrt() == testing::approx(37.41657386773941385584));
+	CONSTEXPR_CHECK(fp::sqrt(vector1.length_squared()) == testing::approx(testing::SQRT3 * 10));
+	CONSTEXPR_CHECK(fp::sqrt(vector2.length_squared()) == testing::approx(53.8516480713450403125));
+	CONSTEXPR_CHECK(fp::sqrt(vector1.distance_squared(vector2)) == testing::approx(37.41657386773941385584));
 }
 
 TEST_CASE("dvec3_t Length methods", "[vec3_t][dvec3_t][dvec3_t-length]") {
diff --git a/tests/src/types/Vector4.cpp b/tests/src/types/Vector4.cpp
index 8f7ce9bb8..e5715d87f 100644
--- a/tests/src/types/Vector4.cpp
+++ b/tests/src/types/Vector4.cpp
@@ -3,6 +3,7 @@
 
 #include "openvic-simulation/types/Vector.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
+#include "openvic-simulation/types/fixed_point/Math.hpp"
 
 #include "Approx.hpp"
 #include "Helper.hpp" // IWYU pragma: keep
@@ -99,9 +100,9 @@ TEMPLATE_LIST_TEST_CASE("vec4_t Iterator", "[vec4_t][vec4_t-iterator]", VectorVa
 TEST_CASE("fvec4_t Length methods", "[vec4_t][fvec4_t][fvec4_t-length]") {
 	static constexpr fvec4_t vector1 = fvec4_t(10, 10, 10, 10);
 	static constexpr fvec4_t vector2 = fvec4_t(20, 30, 40, 50);
-	CONSTEXPR_CHECK(vector1.length_squared().sqrt() == 20);
-	CONSTEXPR_CHECK(vector2.length_squared().sqrt() == testing::approx(73.484692283495));
-	CONSTEXPR_CHECK(vector1.distance_squared(vector2).sqrt() == testing::approx(54.772255750517));
+	CONSTEXPR_CHECK(fp::sqrt(vector1.length_squared()) == 20);
+	CONSTEXPR_CHECK(fp::sqrt(vector2.length_squared()) == testing::approx(73.484692283495));
+	CONSTEXPR_CHECK(fp::sqrt(vector1.distance_squared(vector2)) == testing::approx(54.772255750517));
 }
 
 TEST_CASE("dvec4_t Length methods", "[vec4_t][dvec4_t][dvec4_t-length]") {