In the beginning...

quantity/irradiance.odin

@@ -0,0 +1,7 @@
+package quantity
+
+import "base:intrinsics"
+
+Watts_Per_Square_Meter :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
+	v: V,
+}

quantity/pressure.odin

@@ -0,0 +1,134 @@
+package quantity
+
+import "base:intrinsics"
+
+PASCALS_PER_TORR :: 101325.0 / 760.0
+KILO_PASCALS_PER_PSI :: 6.894757293168364
+
+//----- Pascals ----------------------------------
+Pascals :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
+	v: V,
+}
+
+@(private = "file")
+pascals_to_kilo_pascals :: #force_inline proc "contextless" (
+	pascals: Pascals($V),
+) -> Kilo_Pascals(V) where intrinsics.type_is_numeric(V) {
+	return Kilo_Pascals(V){pascals.v / KILO}
+}
+
+@(private = "file")
+pascals_to_torr :: #force_inline proc "contextless" (
+	pascals: Pascals($V),
+) -> Torr(V) where intrinsics.type_is_float(V) {
+	return Torr(V){pascals.v / PASCALS_PER_TORR}
+}
+
+//----- Kilopascals ----------------------------------
+Kilo_Pascals :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
+	v: V,
+}
+
+@(private = "file")
+kilo_pascals_to_pascals :: #force_inline proc "contextless" (
+	kilo_pascals: Kilo_Pascals($V),
+) -> Pascals(V) where intrinsics.type_is_numeric(V) {
+	return Pascals(V){kilo_pascals.v * KILO}
+}
+
+kilo_pascals_to_psi :: #force_inline proc "contextless" (
+    kilo_pascals: Kilo_Pascals($V),
+) -> Psi(V) where intrinsics.type_is_float(V) {
+	return Psi(V){kilo_pascals.v / KILO_PASCALS_PER_PSI}
+}
+
+//----- Torr ----------------------------------
+Torr :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
+	v: V,
+}
+
+@(private = "file")
+torr_to_pascals :: #force_inline proc "contextless" (
+	torr: Torr($V),
+) -> Pascals(V) where intrinsics.type_is_float(V) {
+	return Pascals(V){torr.v * PASCALS_PER_TORR}
+}
+
+//----- PSI ----------------------------------
+Psi :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
+	v: V,
+}
+
+psi_to_kilo_pascals :: #force_inline proc "contextless" (
+	psi: Psi($V),
+) -> Kilo_Pascals(V) where intrinsics.type_is_float(V) {
+	return Kilo_Pascals(V){psi.v * KILO_PASCALS_PER_PSI}
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// ----- Conversion Overloads ------------------------
+// ---------------------------------------------------------------------------------------------------------------------
+to_pascals :: proc {
+	kilo_pascals_to_pascals,
+	torr_to_pascals,
+}
+
+to_kilo_pascals :: proc {
+	pascals_to_kilo_pascals,
+	psi_to_kilo_pascals,
+}
+
+to_torr :: proc {
+    pascals_to_torr,
+}
+
+to_psi :: proc {
+    kilo_pascals_to_psi,
+}
+
+
+// ---------------------------------------------------------------------------------------------------------------------
+// ----- Tests ------------------------
+// ---------------------------------------------------------------------------------------------------------------------
+import "core:testing"
+
+@(test)
+test_pascals_to_kilo_pascals :: proc(t: ^testing.T) {
+	pascals := Pascals(int){1000}
+	kilo_pascals := to_kilo_pascals(pascals)
+
+	testing.expect_value(t, kilo_pascals, Kilo_Pascals(int){1})
+}
+
+@(test)
+test_kilo_pascals_to_pascals :: proc(t: ^testing.T) {
+	kilo_pascals := Kilo_Pascals(int){1}
+	pascals := to_pascals(kilo_pascals)
+
+	testing.expect_value(t, pascals, Pascals(int){1000})
+}
+
+@(test)
+test_pascals_to_torr :: proc(t: ^testing.T) {
+    pascals := Pascals(f32){1000}
+    torr := to_torr(pascals)
+
+    testing.expect(t, torr.v > 7.49 && torr.v < 7.51)
+}
+
+@(test)
+test_torr_to_pascals :: proc(t: ^testing.T) {
+    torr := Torr(f32){7.5}
+    pascals := to_pascals(torr)
+
+    testing.expect(t, pascals.v > 999.91 && pascals.v < 999.92)
+}
+
+@(test)
+test_psi_kilo_pascals :: proc(t: ^testing.T) {
+    psi := Psi(f32){2.5}
+    kilo_pascals := Kilo_Pascals(f32){17.23689323292091}
+
+    testing.expect(t, to_kilo_pascals(psi).v > 17.22 && to_kilo_pascals(psi).v < 17.24)
+    testing.expect(t, to_psi(kilo_pascals).v > 2.49 && to_psi(kilo_pascals).v < 2.51)
+}

quantity/quantity.odin

@@ -0,0 +1,12 @@
+package quantity
+
+DECA :: 10;
+DECI :: 10;
+HECTO :: 100;
+CENTI :: 100;
+KILO :: 1_000;
+MILLI :: 1_000;
+MEGA :: 1_000_000;
+MICRO :: 1_000_000;
+GIGA :: 1_000_000_000;
+NANO :: 1_000_000_000;

quantity/resistance.odin

@@ -0,0 +1,7 @@
+package quantity
+
+import "base:intrinsics"
+
+Ohms :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
+	v: V,
+}

quantity/temperature.odin

@@ -0,0 +1,157 @@
+package quantity
+
+import "base:intrinsics"
+
+// ---------------------------------------------------------------------------------------------------------------------
+// ----- Constants ------------------------
+// ---------------------------------------------------------------------------------------------------------------------
+@(private = "file")
+kelvins_celsius_offset :: #force_inline proc "contextless" (
+	$V: typeid,
+) -> V where intrinsics.type_is_numeric(V) {
+	when intrinsics.type_is_float(V) {
+		OFFSET :: 273.15
+	} else {
+		OFFSET :: 273
+	}
+	return OFFSET
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// ----- Types ------------------------
+// ---------------------------------------------------------------------------------------------------------------------
+//----- Kelvins ----------------------------------
+Kelvins :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
+	v: V,
+}
+
+@(private = "file")
+kelvins_to_celsius :: #force_inline proc "contextless" (
+	kelvins: Kelvins($V),
+) -> Celsius(V) where intrinsics.type_is_numeric(V) {
+	return Celsius(V){kelvins.v - kelvins_celsius_offset(V)}
+}
+
+@(private = "file")
+kelvins_to_deci_kelvins :: #force_inline proc "contextless" (
+	kelvins: Kelvins($V),
+) -> Deci_Kelvins(V) where intrinsics.type_is_numeric(V) {
+	return Deci_Kelvins(V){kelvins.v * DECI}
+}
+
+//----- Decikelvins ----------------------------------
+Deci_Kelvins :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
+	v: V,
+}
+
+@(private = "file")
+deci_kelvins_to_kelvins :: #force_inline proc "contextless" (
+	deci_kelvins: Deci_Kelvins($V),
+) -> Kelvins(V) where intrinsics.type_is_numeric(V) {
+	return Kelvins(V){deci_kelvins.v / DECI}
+}
+
+//----- Degrees Celsius ----------------------------------
+Celsius :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
+	v: V,
+}
+
+@(private = "file")
+celsius_to_kelvins :: #force_inline proc "contextless" (
+	degrees_celsius: Celsius($V),
+) -> Kelvins(V) where intrinsics.type_is_numeric(V) {
+	return Kelvins(V){degrees_celsius.v + kelvins_celsius_offset(V)}
+}
+
+@(private = "file")
+celsius_to_deci_celsius :: #force_inline proc "contextless" (
+	degrees_celsius: Celsius($V),
+) -> Deci_Celsius(V) where intrinsics.type_is_numeric(V) {
+	return Deci_Celsius(V){degrees_celsius.v * DECI}
+}
+
+//----- Deci Degrees Celsius ----------------------------------
+Deci_Celsius :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
+	v: V,
+}
+
+@(private = "file")
+deci_celsius_to_celsius :: #force_inline proc "contextless" (
+	deci_degrees_celsius: Deci_Celsius($V),
+) -> Celsius(V) where intrinsics.type_is_numeric(V) {
+	return Celsius(V){deci_degrees_celsius.v / DECI}
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// ----- Conversion Overloads ------------------------
+// ---------------------------------------------------------------------------------------------------------------------
+to_kelvins :: proc {
+	deci_kelvins_to_kelvins,
+	celsius_to_kelvins,
+}
+
+to_deci_kelvins :: proc {
+	kelvins_to_deci_kelvins,
+}
+
+to_celsius :: proc {
+	kelvins_to_celsius,
+	deci_celsius_to_celsius,
+}
+
+to_deci_celsius :: proc {
+	celsius_to_deci_celsius,
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// ----- Tests ------------------------
+// ---------------------------------------------------------------------------------------------------------------------
+import "core:testing"
+
+@(test)
+test_kelvins_to_celsius :: proc(t: ^testing.T) {
+	kelvins := Kelvins(f32){273.15}
+	celsius := to_celsius(kelvins)
+
+	testing.expect_value(t, celsius, Celsius(f32){0})
+}
+
+@(test)
+test_kelvins_to_deci_kelvins :: proc(t: ^testing.T) {
+	kelvins := Kelvins(int){100}
+	deci_kelvins := to_deci_kelvins(kelvins)
+
+	testing.expect_value(t, deci_kelvins, Deci_Kelvins(int){1000})
+}
+
+@(test)
+test_deci_kelvins_to_kelvins :: proc(t: ^testing.T) {
+    deci_kelvins := Deci_Kelvins(int){1000}
+    kelvins := to_kelvins(deci_kelvins)
+
+    testing.expect_value(t, kelvins, Kelvins(int){100})
+}
+
+@(test)
+test_celsius_to_kelvins :: proc(t: ^testing.T) {
+    degrees_celsius := Celsius(f32){0}
+    kelvins := to_kelvins(degrees_celsius)
+
+    testing.expect_value(t, kelvins, Kelvins(f32){273.15})
+}
+
+@(test)
+test_celsius_to_deci_celsius :: proc(t: ^testing.T) {
+    degrees_celsius := Celsius(int){100}
+    deci_degrees_celsius := to_deci_celsius(degrees_celsius)
+
+    testing.expect_value(t, deci_degrees_celsius, Deci_Celsius(int){1000})
+}
+
+@(test)
+test_deci_celsius_to_celsius :: proc(t: ^testing.T) {
+    deci_degrees_celsius := Deci_Celsius(int){1000}
+    degrees_celsius := to_celsius(deci_degrees_celsius)
+
+    testing.expect_value(t, degrees_celsius, Celsius(int){100})
+}

quantity/voltage.odin

@@ -0,0 +1,59 @@
+package quantity
+
+import "base:intrinsics"
+
+//----- Volts ----------------------------------
+Volts :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
+	v: V,
+}
+
+@(private = "file")
+volts_to_milli_volts :: #force_inline proc "contextless" (
+	volts: Volts($V),
+) -> Milli_Volts(V) where intrinsics.type_is_numeric(V) {
+	return Milli_Volts(V){volts.v * MILLI}
+}
+
+//----- Millivolts ----------------------------------
+Milli_Volts :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
+	v: V,
+}
+
+@(private = "file")
+milli_volts_to_volts :: #force_inline proc "contextless" (
+	milli_volts: Milli_Volts($V),
+) -> Volts(V) where intrinsics.type_is_numeric(V) {
+	return Volts(V){milli_volts.v / MILLI}
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// ----- Conversion Overloads ------------------------
+// ---------------------------------------------------------------------------------------------------------------------
+to_volts :: proc {
+    milli_volts_to_volts,
+}
+
+to_milli_volts :: proc {
+    volts_to_milli_volts,
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// ----- Tests ------------------------
+// ---------------------------------------------------------------------------------------------------------------------
+import "core:testing"
+
+@(test)
+test_volts_to_milli_volts :: proc(t: ^testing.T) {
+	volts := Volts(int){1}
+	milli_volts := to_milli_volts(volts)
+
+	testing.expect_value(t, milli_volts, Milli_Volts(int){1000})
+}
+
+@(test)
+test_milli_volts_to_volts :: proc(t: ^testing.T) {
+    milli_volts := Milli_Volts(int){1000}
+    volts := to_volts(milli_volts)
+
+    testing.expect_value(t, volts, Volts(int){1})
+}

quantity/volume.odin

@@ -0,0 +1,59 @@
+package quantity
+
+import "base:intrinsics"
+
+//----- Liters ----------------------------------
+Liters :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
+	v: V,
+}
+
+@(private = "file")
+liters_to_milli_liters :: #force_inline proc "contextless" (
+    liters: Liters($V),
+) -> Milli_Liters(V) where intrinsics.type_is_numeric(V) {
+    return Milli_Liters(V){liters.v * MILLI}
+}
+
+//----- Milliliters ----------------------------------
+Milli_Liters :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
+	v: V,
+}
+
+@(private = "file")
+milli_liters_to_liters :: #force_inline proc "contextless" (
+	milli_liters: Milli_Liters($V),
+) -> Liters(V) where intrinsics.type_is_numeric(V) {
+	return Liters(V){milli_liters.v / MILLI}
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// ----- Conversion Overloads ------------------------
+// ---------------------------------------------------------------------------------------------------------------------
+to_liters :: proc {
+    milli_liters_to_liters,
+}
+
+to_milli_liters :: proc {
+    liters_to_milli_liters,
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// ----- Tests ------------------------
+// ---------------------------------------------------------------------------------------------------------------------
+import "core:testing"
+
+@(test)
+test_liters_to_milli_liters :: proc(t: ^testing.T) {
+    liters := Liters(int){12}
+    milli_liters := to_milli_liters(liters)
+
+    testing.expect_value(t, milli_liters, Milli_Liters(int){12_000})
+}
+
+@(test)
+test_milli_liters_to_liters :: proc(t: ^testing.T) {
+    milli_liters := Milli_Liters(int){12_000}
+    liters := to_liters(milli_liters)
+
+    testing.expect_value(t, liters, Liters(int){12})
+}

quantity/volume_rate.odin

@@ -0,0 +1,7 @@
+package quantity
+
+import "base:intrinsics"
+
+Liters_Per_Minute :: struct($V: typeid) where intrinsics.type_is_numeric(V) {
+	v: V,
+}