Small additions

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 
 project(folf-namespace
-        VERSION 1.0.1
+        VERSION 1.0.2
         DESCRIPTION "FOLF - A C++ library developed by a fox and a wolf for testing and making development easier!"
         HOMEPAGE_URL "https://github.com/FOLF-projects/folf-namespace"
         LANGUAGES CXX)

examples/time-operations.cpp

@@ -11,7 +11,7 @@ int main()
 {
     const long double days = 9.97879;
     const double newDays = 9.97879;
-    std::cout << "num = " << daysToHours(days) << std::endl;
+    std::cout << "num = " << folf_daysToHours(days) << std::endl;
     std::cout << "NewNum = " << newDays * 24 << std::endl;
 
     return 0;

folf/calcTools.cpp

@@ -49,7 +49,3 @@ bool folf::calcTools::isChance(int chanceDenominator)
 {
     return calcTools::randomNum(chanceDenominator) == 0;
 }
-signed int folf::calcTools::createVector(const unsigned int *from, const unsigned int *to)
-{
-    return *to - *from;
-}

folf/calcTools.hpp

@@ -7,6 +7,10 @@
 // =============================================================================================
 #pragma once
 
+// creates a vector of two numbers by deviding the second from the first
+// createVector(X,Y)
+#define folf_vectorCreate(from,to) to - from
+
 // includes various functions for benchmarking and common tasks
 namespace folf
 {
@@ -21,8 +25,5 @@ namespace folf
         bool isChance(int);
         // returns a random number up to x
         unsigned long long randomNum(int);
-        // creates a vector of two numbers by deviding the second from the first
-        // createVector(X,Y)
-        signed int createVector(const unsigned int*, const unsigned int*);
     }
 }

folf/timeTools.hpp

@@ -8,25 +8,25 @@
 #pragma once
 
 // macro functions
-#define daysToHours(days) days * (long long)24
-#define daysToMinutes(days) days * (long long)1440
-#define daysToSeconds(days) days * (long long)86400
-#define hoursToDays(hours) hours / (double)24
-#define hoursToMinutes(hours) hours * (long long)60
-#define hoursToSeconds(hours) hours * (long long)3600
-#define minutesToDays(minutes) minutes / (double)1440
-#define minutesToHours(minutes) minutes / (double)60
-#define minutesToSeconds(minutes) minutes * (long long)60
-#define minutesToMilliseconds(minutes) minutes * (long long)60000
-#define secondsToHours(seconds) seconds / (double)3600
-#define secondsToMinutes(seconds) seconds / (double)60
-#define secondsToMilliseconds(seconds) seconds * (long long)1000
-#define secondsToMicroseconds(seconds) seconds  * (long long)1000000
-#define millisecondsToMinutes(milliseconds) milliseconds / (double)60000
-#define millisecondsToSeconds(milliseconds) milliseconds / (double)1000
-#define millisecondsToMicroseconds(milliseconds) milliseconds * (long long)1000
-#define microsecondsToSeconds(microseconds) microseconds / (double)1000000
-#define microsecondsToMilliseconds(microseconds) microseconds / (double)1000
+#define folf_daysToHours(days) days * (long long)24
+#define folf_daysToMinutes(days) days * (long long)1440
+#define folf_daysToSeconds(days) days * (long long)86400
+#define folf_hoursToDays(hours) hours / (double)24
+#define folf_hoursToMinutes(hours) hours * (long long)60
+#define folf_hoursToSeconds(hours) hours * (long long)3600
+#define folf_minutesToDays(minutes) minutes / (double)1440
+#define folf_minutesToHours(minutes) minutes / (double)60
+#define folf_minutesToSeconds(minutes) minutes * (long long)60
+#define folf_minutesToMilliseconds(minutes) minutes * (long long)60000
+#define folf_secondsToHours(seconds) seconds / (double)3600
+#define folf_secondsToMinutes(seconds) seconds / (double)60
+#define folf_secondsToMilliseconds(seconds) seconds * (long long)1000
+#define folf_secondsToMicroseconds(seconds) seconds  * (long long)1000000
+#define folf_millisecondsToMinutes(milliseconds) milliseconds / (double)60000
+#define folf_millisecondsToSeconds(milliseconds) milliseconds / (double)1000
+#define folf_millisecondsToMicroseconds(milliseconds) milliseconds * (long long)1000
+#define folf_microsecondsToSeconds(microseconds) microseconds / (double)1000000
+#define folf_microsecondsToMilliseconds(microseconds) microseconds / (double)1000
 
 
 // includes various functions for benchmarking and common tasks

tests/timeToolsTest.cpp

@@ -5,42 +5,42 @@
 
 TEST(timeToolsTest, timeConversionTest)
 {
-    EXPECT_EQ(daysToHours(3248), 77952);
-    EXPECT_FLOAT_EQ(daysToHours(45.93), 1102.32);
-    EXPECT_EQ(daysToMinutes(3248), 4677120);
-    EXPECT_FLOAT_EQ(daysToMinutes(45.93), 66139.2);
-    EXPECT_EQ(daysToSeconds(3248), 280627200);
-    EXPECT_EQ(daysToSeconds(45.93), 3968352);
-    EXPECT_FLOAT_EQ(hoursToDays(3248), 135.33333);
-    EXPECT_FLOAT_EQ(hoursToDays(45.93), 1.91375);
-    EXPECT_EQ(hoursToMinutes(3248), 194880);
-    EXPECT_FLOAT_EQ(hoursToMinutes(45.93), 2755.8);
-    EXPECT_EQ(hoursToSeconds(3248), 11692800);
-    EXPECT_EQ(hoursToSeconds(45.93), 165348);
-    EXPECT_FLOAT_EQ(minutesToDays(3248), 2.2555556);
-    EXPECT_FLOAT_EQ(minutesToDays(45.93), 0.031895833);
-    EXPECT_FLOAT_EQ(minutesToHours(3248), 54.133333);
-    EXPECT_FLOAT_EQ(minutesToHours(45.93), 0.7655);
-    EXPECT_EQ(minutesToSeconds(3248), 194880);
-    EXPECT_FLOAT_EQ(minutesToSeconds(45.93), 2755.8);
-    EXPECT_EQ(minutesToMilliseconds(3248), 194880000);
-    EXPECT_EQ(minutesToMilliseconds(45.93), 2755800);
-    EXPECT_FLOAT_EQ(secondsToHours(3248), 0.90222222);
-    EXPECT_FLOAT_EQ(secondsToHours(45.93), 0.012758333);
-    EXPECT_FLOAT_EQ(secondsToMinutes(3248), 54.133333);
-    EXPECT_FLOAT_EQ(secondsToMinutes(45.93), 0.7655);
-    EXPECT_EQ(secondsToMilliseconds(3248), 3248000);
-    EXPECT_EQ(secondsToMilliseconds(45.93), 45930);
-    EXPECT_EQ(secondsToMicroseconds(324), 324000000);
-    EXPECT_EQ(secondsToMicroseconds(45.93), 45930000);
-    EXPECT_FLOAT_EQ(millisecondsToMinutes(3248), 0.054133333);
-    EXPECT_FLOAT_EQ(millisecondsToMinutes(45.93), 0.0007655);
-    EXPECT_FLOAT_EQ(millisecondsToSeconds(3248), 3.248);
-    EXPECT_FLOAT_EQ(millisecondsToSeconds(45.93), 0.04593);
-    EXPECT_EQ(millisecondsToMicroseconds(3248), 3248000);
-    EXPECT_EQ(millisecondsToMicroseconds(45.93), 45930);
-    EXPECT_FLOAT_EQ(microsecondsToSeconds(3248), 0.003248);
-    EXPECT_FLOAT_EQ(microsecondsToSeconds(145.93), 0.00014593);
-    EXPECT_FLOAT_EQ(microsecondsToMilliseconds(3248), 3.248);
-    EXPECT_FLOAT_EQ(microsecondsToMilliseconds(45.93), 0.04593);
+    EXPECT_EQ(folf_daysToHours(3248), 77952);
+    EXPECT_FLOAT_EQ(folf_daysToHours(45.93), 1102.32);
+    EXPECT_EQ(folf_daysToMinutes(3248), 4677120);
+    EXPECT_FLOAT_EQ(folf_daysToMinutes(45.93), 66139.2);
+    EXPECT_EQ(folf_daysToSeconds(3248), 280627200);
+    EXPECT_EQ(folf_daysToSeconds(45.93), 3968352);
+    EXPECT_FLOAT_EQ(folf_hoursToDays(3248), 135.33333);
+    EXPECT_FLOAT_EQ(folf_hoursToDays(45.93), 1.91375);
+    EXPECT_EQ(folf_hoursToMinutes(3248), 194880);
+    EXPECT_FLOAT_EQ(folf_hoursToMinutes(45.93), 2755.8);
+    EXPECT_EQ(folf_hoursToSeconds(3248), 11692800);
+    EXPECT_EQ(folf_hoursToSeconds(45.93), 165348);
+    EXPECT_FLOAT_EQ(folf_minutesToDays(3248), 2.2555556);
+    EXPECT_FLOAT_EQ(folf_minutesToDays(45.93), 0.031895833);
+    EXPECT_FLOAT_EQ(folf_minutesToHours(3248), 54.133333);
+    EXPECT_FLOAT_EQ(folf_minutesToHours(45.93), 0.7655);
+    EXPECT_EQ(folf_minutesToSeconds(3248), 194880);
+    EXPECT_FLOAT_EQ(folf_minutesToSeconds(45.93), 2755.8);
+    EXPECT_EQ(folf_minutesToMilliseconds(3248), 194880000);
+    EXPECT_EQ(folf_minutesToMilliseconds(45.93), 2755800);
+    EXPECT_FLOAT_EQ(folf_secondsToHours(3248), 0.90222222);
+    EXPECT_FLOAT_EQ(folf_secondsToHours(45.93), 0.012758333);
+    EXPECT_FLOAT_EQ(folf_secondsToMinutes(3248), 54.133333);
+    EXPECT_FLOAT_EQ(folf_secondsToMinutes(45.93), 0.7655);
+    EXPECT_EQ(folf_secondsToMilliseconds(3248), 3248000);
+    EXPECT_EQ(folf_secondsToMilliseconds(45.93), 45930);
+    EXPECT_EQ(folf_secondsToMicroseconds(324), 324000000);
+    EXPECT_EQ(folf_secondsToMicroseconds(45.93), 45930000);
+    EXPECT_FLOAT_EQ(folf_millisecondsToMinutes(3248), 0.054133333);
+    EXPECT_FLOAT_EQ(folf_millisecondsToMinutes(45.93), 0.0007655);
+    EXPECT_FLOAT_EQ(folf_millisecondsToSeconds(3248), 3.248);
+    EXPECT_FLOAT_EQ(folf_millisecondsToSeconds(45.93), 0.04593);
+    EXPECT_EQ(folf_millisecondsToMicroseconds(3248), 3248000);
+    EXPECT_EQ(folf_millisecondsToMicroseconds(45.93), 45930);
+    EXPECT_FLOAT_EQ(folf_microsecondsToSeconds(3248), 0.003248);
+    EXPECT_FLOAT_EQ(folf_microsecondsToSeconds(145.93), 0.00014593);
+    EXPECT_FLOAT_EQ(folf_microsecondsToMilliseconds(3248), 3.248);
+    EXPECT_FLOAT_EQ(folf_microsecondsToMilliseconds(45.93), 0.04593);
 }