Move fixed_point_t to core/object

docs/ecs/threading-and-reductions.md

@@ -229,9 +229,9 @@ struct KeyedSumScratch {
 Adapted from `tests/src/ecs/KeyedReductions.cpp` (the `fixed_point_t` worker-count-invariance case):
 
 ```cpp
+#include "openvic-simulation/core/object/FixedPoint.hpp"
 #include "openvic-simulation/ecs/EcsThreadPool.hpp"
 #include "openvic-simulation/ecs/Reductions.hpp"
-#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 
 using namespace OpenVic::ecs;
 using OpenVic::fixed_point_t;

misc/scripts/exp_lut_generator.py

@@ -77,7 +77,7 @@ def generate_exp_lut(divisor_base: int, divisor_power: int, exp_base: decimal.De
     source += "}\n// clang-format on\n"
 
     fixed_point_lut_path: str = os.path.join(
-        os.path.dirname(__file__), f"../../src/openvic-simulation/types/fixed_point/FixedPointLUT_{lut_identifier}.hpp"
+        os.path.dirname(__file__), f"../../src/openvic-simulation/core/object/FixedPoint/LUT_{lut_identifier}.hpp"
     )
     with open(fixed_point_lut_path, "w", newline="\n") as file:
         file.write(source)

misc/scripts/sin_lut_generator.py

@@ -120,7 +120,7 @@ def generate_sin_lut(precision: int, count_log2: int):
     source += "}\n// clang-format on\n"
 
     fixed_point_sin_path: str = os.path.join(
-        os.path.dirname(__file__), "../../src/openvic-simulation/types/fixed_point/FixedPointLUT_sin.hpp"
+        os.path.dirname(__file__), "../../src/openvic-simulation/core/object/FixedPoint/LUT_sin.hpp"
     )
     with open(fixed_point_sin_path, "w", newline="\n") as file:
         file.write(source)

src/openvic-simulation/core/Math.hpp

@@ -6,11 +6,12 @@
 #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(const T num);
+	class fixed_point_t;
+
+	template<typename T>
+	[[nodiscard]] constexpr T abs(const T num);
 
 	template<typename T>
 	requires std::integral<T> || std::floating_point<T>
@@ -22,13 +23,8 @@ 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> || std::is_same_v<T, fixed_point_t>))
+	template<typename T>
+	requires(!(std::integral<T> || std::floating_point<T> || std::same_as<T, fixed_point_t>))
 	[[nodiscard]] OV_SPEED_INLINE constexpr T abs(T const& num);
 
 	template<std::floating_point T>

src/openvic-simulation/types/fixed_point/FixedPoint.cpp → src/openvic-simulation/core/object/FixedPoint.cpp

@@ -6,16 +6,15 @@
 #include <fmt/base.h>
 #include <fmt/format.h>
 
+#include "openvic-simulation/core/object/FixedPoint/String.hpp"
 #include "openvic-simulation/core/Typedefs.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
 
-#include "String.hpp"
-
 /* Base e exponential lookup table */
-#include "openvic-simulation/types/fixed_point/FixedPointLUT_2_16_EXP_e.hpp"
+#include "openvic-simulation/core/object/FixedPoint/LUT_2_16_EXP_e.hpp"
 
 /* Base 2001 exponential lookup table */
-#include "openvic-simulation/types/fixed_point/FixedPointLUT_2_16_EXP_2001.hpp"
+#include "openvic-simulation/core/object/FixedPoint/LUT_2_16_EXP_2001.hpp"
 
 using namespace OpenVic;
 static_assert(_detail::LUT::_2_16_EXP_e_DIVISOR == 1 << fixed_point_t::PRECISION);

src/openvic-simulation/types/fixed_point/FixedPoint.hpp → src/openvic-simulation/core/object/FixedPoint.hpp

@@ -13,11 +13,12 @@
 
 namespace OpenVic {
 	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 {
+	class fixed_point_t {
+	public:
 		/* PROPERTY generated getter functions will return fixed points by value, rather than const reference. */
 		using ov_return_by_value = void;
 		using value_type = int64_t;
@@ -40,6 +41,7 @@ namespace OpenVic {
 
 	private:
 		value_type value;
+
 	public:
 		[[nodiscard]] constexpr value_type const& get_raw_value() const {
 			return value;
@@ -48,6 +50,7 @@ namespace OpenVic {
 		OV_ALWAYS_INLINE constexpr fixed_point_t get_frac() const {
 			return parse_raw(value & FRAC_MASK);
 		}
+
 	private:
 		struct raw_value_t {
 			explicit raw_value_t() = default;
@@ -267,7 +270,7 @@ namespace OpenVic {
 
 		static fixed_point_t parse_capped(const int64_t value);
 		static fixed_point_t parse_capped(const uint64_t value);
-		
+
 		template<std::integral T>
 		requires (sizeof(T) >= 4)
 		static fixed_point_t parse_capped(const T value) {

src/openvic-simulation/types/fixed_point/Atomic.hpp → src/openvic-simulation/core/object/FixedPoint/Atomic.hpp

@@ -2,7 +2,7 @@
 
 #include <atomic>
 
-#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
+#include "openvic-simulation/core/object/FixedPoint.hpp"
 #include "openvic-simulation/core/Typedefs.hpp"
 
 namespace std {

src/openvic-simulation/types/fixed_point/Fraction.hpp → src/openvic-simulation/core/object/FixedPoint/Fraction.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/types/fixed_point/Math.hpp"
+#include "openvic-simulation/core/object/FixedPoint.hpp"
+#include "openvic-simulation/core/object/FixedPoint/Math.hpp"
 #include "openvic-simulation/core/Typedefs.hpp"
 
 namespace OpenVic {
@@ -17,4 +17,4 @@ namespace OpenVic {
 			return fp::mul_div(lhs, rhs.numerator, rhs.denominator);
 		}
 	};
-}
+}

src/openvic-simulation/types/fixed_point/Math.hpp → src/openvic-simulation/core/object/FixedPoint/Math.hpp

@@ -1,18 +1,25 @@
 #pragma once
 
-#include "FixedPoint.hpp"
-
 #include <cassert>
 
+#include "openvic-simulation/core/Math.hpp"
 #include "openvic-simulation/core/MathSqrt.hpp"
+#include "openvic-simulation/core/object/FixedPoint.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"
+#include "openvic-simulation/core/object/FixedPoint/LUT_sin.hpp"
+
+namespace OpenVic {
+	template<>
+	[[nodiscard]] OV_SPEED_INLINE constexpr fixed_point_t abs(const fixed_point_t num) {
+		return num.abs();
+	}
+}
 
 namespace OpenVic::fp {
-	static_assert(_detail::LUT::SIN_PRECISION == fixed_point_t::PRECISION);	
+	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;
@@ -30,9 +37,7 @@ namespace OpenVic::fp {
 
 		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
-		);
+		return fixed_point_t::parse_raw(!negative ? result : -result);
 	}
 
 	OV_SPEED_INLINE static constexpr fixed_point_t cos(fixed_point_t const& v) {
@@ -41,29 +46,28 @@ namespace OpenVic::fp {
 
 	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::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.
+	// 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) {
+	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) {
+	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) {
+	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>(
@@ -73,33 +77,30 @@ namespace OpenVic::fp {
 
 	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
-		));
+		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)
+			(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
 		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
+		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));
 	}
-}
+}

src/openvic-simulation/types/fixed_point/String.hpp → src/openvic-simulation/core/object/FixedPoint/String.hpp

@@ -3,9 +3,9 @@
 #include <charconv>
 
 #include "openvic-simulation/core/Math.hpp"
+#include "openvic-simulation/core/object/FixedPoint.hpp"
 #include "openvic-simulation/core/stl/containers/StackString.hpp"
 #include "openvic-simulation/core/string/CharConv.hpp"
-#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
 
 namespace OpenVic::fp {
@@ -229,4 +229,4 @@ namespace OpenVic::fp {
 
 		return fixed_point_t::parse_raw(integer_value);
 	}
-}
+}

src/openvic-simulation/core/object/Vector.hpp

@@ -6,10 +6,11 @@
 #include <fmt/format.h>
 
 #include "openvic-simulation/core/Math.hpp" // IWYU pragma: keep
+#include "openvic-simulation/core/object/FixedPoint.hpp"
+#include "openvic-simulation/core/object/FixedPoint/Math.hpp" // IWYU pragma: keep
 #include "openvic-simulation/core/stl/BasicIterator.hpp" // IWYU pragma: keep
 #include "openvic-simulation/core/template/Concepts.hpp" // IWYU pragma: keep
 #include "openvic-simulation/core/Typedefs.hpp" // IWYU pragma: keep
-#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 
 #define VEC_TYPE vec2_t
 #define FOR_VEC_COMPONENTS(F, SEP) F(x) SEP F(y)

src/openvic-simulation/core/random/WeightedSampling.hpp

@@ -4,8 +4,8 @@
 #include <limits>
 #include <span>
 
+#include "openvic-simulation/core/object/FixedPoint.hpp"
 #include "openvic-simulation/core/Typedefs.hpp"
-#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 
 namespace OpenVic {
 	OV_SPEED_INLINE static size_t sample_weighted_index(

src/openvic-simulation/country/CountryInstance.cpp

@@ -11,6 +11,8 @@
 
 #include "openvic-simulation/core/error/ErrorMacros.hpp"
 #include "openvic-simulation/core/object/Date.hpp"
+#include "openvic-simulation/core/object/FixedPoint.hpp"
+#include "openvic-simulation/core/object/FixedPoint/Math.hpp"
 #include "openvic-simulation/core/object/Timespan.hpp"
 #include "openvic-simulation/core/Typedefs.hpp"
 #include "openvic-simulation/country/CountryDefinition.hpp"
@@ -48,8 +50,6 @@
 #include "openvic-simulation/research/Invention.hpp"
 #include "openvic-simulation/research/Technology.hpp"
 #include "openvic-simulation/types/ClampedValue.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/types/TypedIndices.hpp"
 #include "openvic-simulation/types/UnitBranchType.hpp"
@@ -381,7 +381,7 @@
 		case BuildingRestrictionCategory::FACTORY:
 			return rule_set.may_invest_in_building_factory_abroad();
 	}
 }
 
 CountryRelationManager::relation_value_type CountryInstance::get_relations_with(CountryInstance const& country) const {
 	return country_relations_manager.get_country_relation(this, &country);

src/openvic-simulation/country/CountryInstance.hpp

@@ -8,6 +8,8 @@
 #include "openvic-simulation/core/memory/SmartPtr.hpp"
 #include "openvic-simulation/core/memory/Vector.hpp"
 #include "openvic-simulation/core/object/Date.hpp"
+#include "openvic-simulation/core/object/FixedPoint.hpp"
+#include "openvic-simulation/core/object/FixedPoint/Atomic.hpp"
 #include "openvic-simulation/core/object/Timespan.hpp"
 #include "openvic-simulation/core/stl/containers/TypedSpan.hpp"
 #include "openvic-simulation/core/thread/SpinMutex.hpp"
@@ -21,8 +23,6 @@
 #include "openvic-simulation/population/PopsAggregate.hpp"
 #include "openvic-simulation/research/TechnologyUnlockLevel.hpp"
 #include "openvic-simulation/types/ClampedValue.hpp"
-#include "openvic-simulation/types/fixed_point/Atomic.hpp"
-#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/FlagStrings.hpp"
 #include "openvic-simulation/types/HasIndex.hpp"
 #include "openvic-simulation/types/OrderedContainers.hpp"

src/openvic-simulation/country/SharedCountryValues.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
+#include "openvic-simulation/core/object/FixedPoint.hpp"
 #include "openvic-simulation/population/PopNeedsMacro.hpp"
 #include "openvic-simulation/types/IndexedFlatMap.hpp"
-#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/UnitBranchType.hpp"
 #include "openvic-simulation/utility/reactive/MutableState.hpp"
 

src/openvic-simulation/dataloader/NodeTools.cpp

@@ -16,10 +16,10 @@
 #include <range/v3/view/enumerate.hpp>
 
 #include "openvic-simulation/core/object/Colour.hpp"
+#include "openvic-simulation/core/object/FixedPoint/String.hpp"
 #include "openvic-simulation/core/object/Timespan.hpp"
 #include "openvic-simulation/core/object/Vector.hpp"
 #include "openvic-simulation/core/ui/TextFormat.hpp"
-#include "openvic-simulation/types/fixed_point/String.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
 using namespace OpenVic;

src/openvic-simulation/defines/AIDefines.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
+#include "openvic-simulation/core/object/FixedPoint.hpp"
 #include "openvic-simulation/core/object/Timespan.hpp"
 #include "openvic-simulation/dataloader/NodeTools.hpp"
-#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {

src/openvic-simulation/defines/CountryDefines.hpp

@@ -2,9 +2,9 @@
 
 #include <cstddef>
 
+#include "openvic-simulation/core/object/FixedPoint.hpp"
 #include "openvic-simulation/core/object/Timespan.hpp"
 #include "openvic-simulation/dataloader/NodeTools.hpp"
-#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/map/LifeRating.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 

src/openvic-simulation/defines/DiplomacyDefines.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
+#include "openvic-simulation/core/object/FixedPoint.hpp"
 #include "openvic-simulation/core/object/Timespan.hpp"
 #include "openvic-simulation/dataloader/NodeTools.hpp"
-#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {