adding area

Author: noah1510

README.md

@@ -67,6 +67,7 @@ unit_t -> an unit template that is the basis of all of the units
 
 ### Common
 
+* area -> area with `m^2` as base unit
 * speed -> speed with `m / s` as base unit
 * acceleration -> acceleration with `m / s^2` as base unit
 * momentum -> momentum with `kg * m / s` as base unit

common/include/area.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "unit_t.hpp"
+#include "length.hpp"
+
+namespace sakurajin{
+    namespace unit_system{
+        namespace common{
+            class area : public unit_t<22>{
+            public:
+                area();
+                area(unit_t<22> val);
+                explicit area(long double val);
+                area(long double val, long double mult);
+            };
+            
+            base::length operator/(const area& a, const base::length& l);
+            
+            area operator*(const base::length& l1, const base::length& l2);
+            area square(const base::length& l);
+            
+            inline namespace literals{
+                area operator "" _km2(long double val);
+                area operator "" _m2(long double val);
+                area operator "" _mm2(long double val);
+
+                area operator "" _km2(unsigned long long int val);
+                area operator "" _m2(unsigned long long int val);
+                area operator "" _mm2(unsigned long long int val);
+            }
+            
+        }
+            
+    }
+}
+

common/include/common.hpp

@@ -7,6 +7,7 @@
 #include "force.hpp"
 #include "energy.hpp"
 #include "power.hpp"
+#include "area.hpp"
 
 #if __has_include(<iostream>)
 
@@ -16,6 +17,8 @@
         namespace unit_system{
             namespace common{
                 std::ostream& operator<<(std::ostream& os, const acceleration& v);
+
+                std::ostream& operator<<(std::ostream& os, const area& a);
 
                 std::ostream& operator<<(std::ostream& os, const energy& v);
 

common/meson.build

@@ -1,6 +1,7 @@
 cc = meson.get_compiler('cpp')
 
 sources = [
+    'src/area.cpp',
     'src/speed.cpp',
     'src/acceleration.cpp',
     'src/momentum.cpp',

common/src/area.cpp

@@ -0,0 +1,53 @@
+#include "area.hpp"
+#include "prefix.hpp"
+
+using namespace sakurajin::unit_system;
+using namespace prefix;
+
+common::area::area(): area(0){};
+common::area::area(unit_t<22> val): area(val.value,val.multiplier){};
+common::area::area(long double val): area(val,1){};
+common::area::area(long double val, long double mult): unit_t<22>(val,mult){};
+
+base::length common::operator/(const common::area& a, const base::length& l){
+    auto a1 = sakurajin::unit_system::unit_cast(a,a.multiplier,0);
+    auto l1 = sakurajin::unit_system::unit_cast(l,l.multiplier,0);
+    return base::length{a1.value/l1.value,a1.multiplier/l1.multiplier};
+}
+            
+common::area common::operator*(const base::length& l1, const base::length& l2){
+    auto _l1 = sakurajin::unit_system::unit_cast(l1,l1.multiplier,0);
+    auto _l2 = sakurajin::unit_system::unit_cast(l2,l2.multiplier,0);
+
+    return common::area{_l1.value*_l2.value,_l1.multiplier*_l2.multiplier};
+}
+
+common::area common::square(const base::length& l){
+    return l*l;
+}
+
+
+common::area common::literals::operator "" _km2(long double len){
+    return common::area{len, kilo*kilo};
+}
+
+common::area common::literals::operator "" _m2(long double len){
+    return common::area{len,1};
+}
+
+common::area common::literals::operator "" _mm2(long double len){
+    return common::area{len, milli*milli};
+}
+
+
+common::area common::literals::operator "" _km2(unsigned long long int len){
+    return common::area{static_cast<long double>(len), kilo*kilo};
+}
+
+common::area common::literals::operator "" _m2(unsigned long long int len){
+    return common::area{static_cast<long double>(len),1};
+}
+
+common::area common::literals::operator "" _mm2(unsigned long long int len){
+    return common::area{static_cast<long double>(len), milli*milli};
+}

common/src/common.cpp

@@ -9,6 +9,11 @@
         return os << a1.value << " meter per second^2";
     }
 
+    std::ostream& common::operator<<(std::ostream& os, const common::area& a){
+        auto a1 = sakurajin::unit_system::unit_cast(a,1);
+        return os << a1.value << " meters^2";
+    }
+
     std::ostream& common::operator<<(std::ostream& os, const common::energy& p){
         auto p1 = sakurajin::unit_system::unit_cast(p,1);
         return os << p1.value << " Joules";

common/tests/common_test.cpp

@@ -25,6 +25,7 @@ static const auto p1 = 25_kgmps;
 static const auto F1 = 2.5_N;
 static const auto E1 = 25_J;
 static const auto P1 = 2.5_W;
+static const auto A1 = 100_m2;
 
 TEST( common_tests, speed_test) {
 
@@ -87,7 +88,6 @@ TEST( common_tests, energy_test ) {
 
 };
 
-
 TEST( common_tests, power_test ) {
 
     const auto _P2 = 10_kg * 1_G * 1_mps;
@@ -98,6 +98,15 @@ TEST( common_tests, power_test ) {
 
 };
 
+TEST( common_tests, area_test ) {
+    
+    const auto _A2 = s1 * s2;
+    EXPECT_TRUE(_A2 == 2500_m2);
+
+    EXPECT_TRUE(square(s2) == A1);
+    EXPECT_TRUE(A1/s2 == s2);
+};
+
 int main(int argc, char **argv){
     ::testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();