From fe6a5da3f44adf35d03c296d21d4f21f4a453f73 Mon Sep 17 00:00:00 2001
From: Mateusz Pusz <mateusz.pusz@gmail.com>
Date: Wed, 16 Oct 2019 17:03:24 +0200
Subject: [PATCH] More units added for energy and power

---
 src/include/units/dimensions/energy.h | 22 +++++++++++++++++++++-
 src/include/units/dimensions/power.h  | 20 ++++++++++++++++++++
 2 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/src/include/units/dimensions/energy.h b/src/include/units/dimensions/energy.h
index 912a5d0d..68245abf 100644
--- a/src/include/units/dimensions/energy.h
+++ b/src/include/units/dimensions/energy.h
@@ -27,13 +27,17 @@
 #include <units/dimensions/pressure.h>
 
 namespace units {
-
+  
   struct energy : derived_dimension<energy, exp<force, 1>, exp<length, 1>> {};
 
   template<typename T>
   concept Energy =  QuantityOf<T, energy>;
 
   struct joule : derived_unit<joule, decltype("J"_fs), energy, kilogram, metre, second> {};
+  struct millijoule : derived_unit<millijoule, decltype("mJ"_fs), milli<joule>> {};
+  struct kilojoule : derived_unit<kilojoule, decltype("kJ"_fs), kilo<joule>> {};
+  struct megajoule : derived_unit<megajoule, decltype("MJ"_fs), mega<joule>> {};
+  struct gigajoule : derived_unit<gigajoule, decltype("GJ"_fs), giga<joule>> {};
 
   inline namespace literals {
 
@@ -41,6 +45,22 @@ namespace units {
     constexpr auto operator""_J(unsigned long long l) { return quantity<joule, std::int64_t>(l); }
     constexpr auto operator""_J(long double l) { return quantity<joule, long double>(l); }
 
+    // mJ
+    constexpr auto operator""mJ(unsigned long long l) { return quantity<millijoule, std::int64_t>(l); }
+    constexpr auto operator""mJ(long double l) { return quantity<millijoule, long double>(l); }
+
+    // kJ
+    constexpr auto operator""kJ(unsigned long long l) { return quantity<kilojoule, std::int64_t>(l); }
+    constexpr auto operator""kJ(long double l) { return quantity<kilojoule, long double>(l); }
+
+    // MJ
+    constexpr auto operator""MJ(unsigned long long l) { return quantity<megajoule, std::int64_t>(l); }
+    constexpr auto operator""MJ(long double l) { return quantity<megajoule, long double>(l); }
+
+    // GJ
+    constexpr auto operator""GJ(unsigned long long l) { return quantity<gigajoule, std::int64_t>(l); }
+    constexpr auto operator""GJ(long double l) { return quantity<gigajoule, long double>(l); }
+
   }  // namespace literals
 
 }  // namespace units
diff --git a/src/include/units/dimensions/power.h b/src/include/units/dimensions/power.h
index ad76a4fa..0f09ec3f 100644
--- a/src/include/units/dimensions/power.h
+++ b/src/include/units/dimensions/power.h
@@ -33,6 +33,10 @@ namespace units {
   concept Power =  QuantityOf<T, power>;
 
   struct watt : derived_unit<watt, decltype("W"_fs), power, kilogram, metre, second> {};
+  struct milliwatt : derived_unit<milliwatt, decltype("mW"_fs), milli<watt>> {};
+  struct kilowatt : derived_unit<kilowatt, decltype("kW"_fs), kilo<watt>> {};
+  struct megawatt : derived_unit<megawatt, decltype("MW"_fs), mega<watt>> {};
+  struct gigawatt : derived_unit<gigawatt, decltype("GW"_fs), giga<watt>> {};
 
   inline namespace literals {
 
@@ -40,6 +44,22 @@ namespace units {
     constexpr auto operator""W(unsigned long long l) { return quantity<watt, std::int64_t>(l); }
     constexpr auto operator""_W(long double l) { return quantity<watt, long double>(l); }
 
+    // mW
+    constexpr auto operator""mW(unsigned long long l) { return quantity<milliwatt, std::int64_t>(l); }
+    constexpr auto operator""mW(long double l) { return quantity<milliwatt, long double>(l); }
+
+    // kW
+    constexpr auto operator""kW(unsigned long long l) { return quantity<kilowatt, std::int64_t>(l); }
+    constexpr auto operator""kW(long double l) { return quantity<kilowatt, long double>(l); }
+
+    // MW
+    constexpr auto operator""MW(unsigned long long l) { return quantity<megawatt, std::int64_t>(l); }
+    constexpr auto operator""MW(long double l) { return quantity<megawatt, long double>(l); }
+
+    // GW
+    constexpr auto operator""GW(unsigned long long l) { return quantity<gigawatt, std::int64_t>(l); }
+    constexpr auto operator""GW(long double l) { return quantity<gigawatt, long double>(l); }
+
   }  // namespace literals
 
 }  // namespace units