latest fixes for eval

.vscode/settings.json

@@ -1,59 +0,0 @@
-{
-	"files.associations": {
-		"array": "cpp",
-		"atomic": "cpp",
-		"bit": "cpp",
-		"cctype": "cpp",
-		"clocale": "cpp",
-		"cmath": "cpp",
-		"compare": "cpp",
-		"concepts": "cpp",
-		"cstdarg": "cpp",
-		"cstddef": "cpp",
-		"cstdint": "cpp",
-		"cstdio": "cpp",
-		"cstdlib": "cpp",
-		"cstring": "cpp",
-		"cwchar": "cpp",
-		"cwctype": "cpp",
-		"deque": "cpp",
-		"unordered_map": "cpp",
-		"vector": "cpp",
-		"exception": "cpp",
-		"algorithm": "cpp",
-		"functional": "cpp",
-		"iterator": "cpp",
-		"memory": "cpp",
-		"memory_resource": "cpp",
-		"numeric": "cpp",
-		"optional": "cpp",
-		"random": "cpp",
-		"string": "cpp",
-		"string_view": "cpp",
-		"system_error": "cpp",
-		"tuple": "cpp",
-		"type_traits": "cpp",
-		"utility": "cpp",
-		"initializer_list": "cpp",
-		"iosfwd": "cpp",
-		"iostream": "cpp",
-		"istream": "cpp",
-		"limits": "cpp",
-		"new": "cpp",
-		"numbers": "cpp",
-		"ostream": "cpp",
-		"ranges": "cpp",
-		"span": "cpp",
-		"stdexcept": "cpp",
-		"streambuf": "cpp",
-		"cinttypes": "cpp",
-		"typeinfo": "cpp",
-		"ctime": "cpp",
-		"iomanip": "cpp",
-		"sstream": "cpp",
-		"*.tpp": "cpp",
-		"chrono": "cpp",
-		"list": "cpp",
-		"ratio": "cpp"
-	}
-}

common.mk

@@ -21,9 +21,6 @@ all: $(NAME)
 
 -include $(OBJ:.o=.d)
 
-run: all
-	./$(NAME)
-
 $(NAME): $(OBJ)
 	$(CC) $(CFLAGS) $(OBJ) -o $(NAME)
 

ex00/Makefile

@@ -1,2 +1,5 @@
 NAME := btc
-include ../common.mk
+include ../common.mk
+
+run: all
+	./$(NAME) input.txt

ex00/inc/BitcoinExchange.hpp

@@ -2,24 +2,26 @@
 
 #include <map>
 #include <string>
-#include <stdexcept>
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <iomanip>
-#include <ctime>
 #include <exception>
 
 class BitcoinExchange
 {
 public:
+	// Constructors
 	BitcoinExchange() = delete;
 	BitcoinExchange(const std::string &data_file);
+
+	// Copy constructor and copy assignment operator
 	BitcoinExchange(const BitcoinExchange &other);
-	~BitcoinExchange();
 	BitcoinExchange &operator=(const BitcoinExchange &other);
 
-	void printData() const;
+	// Move constructor and move assignment operator
+	BitcoinExchange(BitcoinExchange &&other) noexcept;
+	BitcoinExchange &operator=(BitcoinExchange &&other) noexcept;
+
+	// Destructor
+	~BitcoinExchange();
+
 	void loadInputFile(const std::string &filename);
 
 	class FileNotFoundException : public std::exception
@@ -59,4 +61,4 @@ private:
 	void loadDataFile(const std::string &filename);
 	float getRate(long timestamp) const;
 	float getValue(long timestamp, float amount) const;
-};
+};

ex00/src/BitcoinExchange.cpp

@@ -2,7 +2,10 @@
 #include <fstream>
 #include <iostream>
 #include <string>
-#include <stdexcept>
+#include <cstdlib>
+#include <cctype>
+#include <chrono>
+#include <utility>
 
 BitcoinExchange::BitcoinExchange(const std::string &data_file)
 {
@@ -13,6 +16,10 @@ BitcoinExchange::BitcoinExchange(const BitcoinExchange &other) : _data(other._da
 {
 }
 
+BitcoinExchange::BitcoinExchange(BitcoinExchange &&other) noexcept : _data(std::move(other._data))
+{
+}
+
 BitcoinExchange::~BitcoinExchange()
 {
 }
@@ -26,21 +33,26 @@ BitcoinExchange &BitcoinExchange::operator=(const BitcoinExchange &other)
 	return *this;
 }
 
-void BitcoinExchange::printData() const
+BitcoinExchange &BitcoinExchange::operator=(BitcoinExchange &&other) noexcept
 {
-	for (std::map<long, float>::const_iterator it = _data.begin(); it != _data.end(); ++it)
+	if (this != &other)
 	{
-		std::cout << it->first << " => " << it->second << std::endl;
+		_data = std::move(other._data);
 	}
+	return *this;
 }
 
 void trimInPlace(std::string &str)
 {
-	// Trim from right
+	const std::string whitespace = " \t\n\r";
-	str.erase(str.find_last_not_of(" \t\n\r") + 1);
+	size_t first = str.find_first_not_of(whitespace);
-
+	if (first == std::string::npos)
-	// Trim from left
+	{
-	str.erase(0, str.find_first_not_of(" \t\n\r"));
+		str.clear();
+		return;
+	}
+	size_t last = str.find_last_not_of(whitespace);
+	str = str.substr(first, last - first + 1);
 }
 
 std::pair<std::string, std::string> split(const std::string &str, char delimiter)
@@ -61,14 +73,38 @@ std::pair<std::string, std::string> split(const std::string &str, char delimiter
 	{
 		throw BitcoinExchange::LineFormatException();
 	}
-	if (second.find_first_not_of("-0123456789.") != std::string::npos)
-	{
-		throw BitcoinExchange::LineFormatException();
-	}
 
 	return {first, second};
 }
 
+static bool isValidDateFormat(const std::string &date)
+{
+	if (date.size() != 10)
+		return false;
+	for (size_t i = 0; i < date.size(); ++i)
+	{
+		if (i == 4 || i == 7)
+		{
+			if (date[i] != '-')
+				return false;
+		}
+		else if (!std::isdigit(static_cast<unsigned char>(date[i])))
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+static float parseValue(const std::string &value)
+{
+	char *end = NULL;
+	float parsed = std::strtof(value.c_str(), &end);
+	if (end == value.c_str() || *end != '\0')
+		throw BitcoinExchange::LineFormatException();
+	return parsed;
+}
+
 void BitcoinExchange::loadDataFile(const std::string &filename)
 {
 	std::ifstream rate_file(filename);
@@ -83,12 +119,12 @@ void BitcoinExchange::loadDataFile(const std::string &filename)
 		{
 			std::pair<std::string, std::string> parts = split(line, ',');
 			long timestamp = getTimestamp(parts.first);
-			float value = std::stof(parts.second);
+			float value = parseValue(parts.second);
 			_data[timestamp] = value;
 		}
 		catch (std::exception &e)
 		{
-			std::cerr << e.what() << std::endl;
+			(void)e;
 		}
 	}
 }
@@ -108,26 +144,50 @@ void BitcoinExchange::loadInputFile(const std::string &filename)
 		try
 		{
 			std::pair<std::string, std::string> parts = split(line, '|');
-			long timestamp = getTimestamp(parts.first);
+			long timestamp;
-			float value = std::stof(parts.second);
+			try
+			{
+				timestamp = getTimestamp(parts.first);
+			}
+			catch (const DateInvalidException &e)
+			{
+				(void)e;
+				std::cerr << "Error: bad input => " << parts.first << std::endl;
+				continue;
+			}
+			float value = parseValue(parts.second);
 			if (value < 0)
 				throw ValueNegativeException();
 			if (value > 1000)
 				throw ValueTooLargeException();
-			std::cout << parts.first << " => " << getValue(timestamp, value) << std::endl;
+			float converted = getValue(timestamp, value);
+			std::cout << parts.first << " => " << parts.second << " = " << converted << std::endl;
+		}
+		catch (const ValueNegativeException &e)
+		{
+			std::cerr << e.what() << std::endl;
+		}
+		catch (const ValueTooLargeException &e)
+		{
+			std::cerr << e.what() << std::endl;
 		}
 		catch (std::exception &e)
 		{
-			std::cerr << e.what() << std::endl;
+			(void)e;
+			std::cerr << "Error: bad input => " << line << std::endl;
 		}
 	}
 }
 
 float BitcoinExchange::getRate(long timestamp) const
 {
-	auto it = _data.upper_bound(timestamp);
+	if (_data.empty())
-	if (it != _data.begin())
+		throw LineFormatException();
-		--it;
+
+	std::map<long, float>::const_iterator it = _data.upper_bound(timestamp);
+	if (it == _data.begin())
+		throw DateInvalidException();
+	--it;
 	return it->second;
 }
 
@@ -138,34 +198,45 @@ float BitcoinExchange::getValue(long timestamp, float amount) const
 
 long BitcoinExchange::getTimestamp(const std::string &date) const
 {
-	std::stringstream ss(date);
+	if (!isValidDateFormat(date))
-	std::tm tm = {};
+		throw DateInvalidException();
-	ss >> std::get_time(&tm, "%Y-%m-%d");
+
-	if (ss.fail())
+	int year = std::atoi(date.substr(0, 4).c_str());
-		throw std::invalid_argument("Error: Invalid date format: " + std::string(date));
+	int month = std::atoi(date.substr(5, 2).c_str());
-	return static_cast<long>(std::mktime(&tm));
+	int day = std::atoi(date.substr(8, 2).c_str());
+
+	const std::chrono::year_month_day ymd(
+		std::chrono::year(year),
+		std::chrono::month(static_cast<unsigned>(month)),
+		std::chrono::day(static_cast<unsigned>(day))
+	);
+
+	if (!ymd.ok())
+		throw DateInvalidException();
+
+	return static_cast<long>(year * 10000 + month * 100 + day);
 }
 
 const char *BitcoinExchange::FileNotFoundException::what() const noexcept
 {
-	return "Error: File not found";
+	return "Error: could not open file.";
 }
 
 const char *BitcoinExchange::LineFormatException::what() const noexcept
 {
-	return "Error: Line format is incorrect";
+	return "Error: bad input";
 }
 
 const char *BitcoinExchange::ValueNegativeException::what() const noexcept
 {
-	return "Error: Value is negative";
+	return "Error: not a positive number.";
 }
 const char *BitcoinExchange::ValueTooLargeException::what() const noexcept
 {
-	return "Error: Value is too large";
+	return "Error: too large a number.";
 }
 
 const char *BitcoinExchange::DateInvalidException::what() const noexcept
 {
-	return "Error: Date is invalid";
+	return "Error: bad input";
 }

ex00/src/main.cpp

@@ -1,13 +1,11 @@
 #include "BitcoinExchange.hpp"
-#include <fstream>
 #include <iostream>
-#include <string>
 
 int main (int argc, char **argv)
 {
 	if (argc != 2)
 	{
-		std::cerr << "Usage: " << argv[0] << " <data_file>" << std::endl;
+		std::cerr << "Error: could not open file." << std::endl;
 		return 1;
 	}
 
@@ -28,4 +26,4 @@ int main (int argc, char **argv)
 	}
 
 	return 0;
-}
+}

ex01/Makefile

@@ -1,2 +1,5 @@
 NAME := RPN
-include ../common.mk
+include ../common.mk
+
+run: all
+	./$(NAME) "8 9 * 9 - 9 - 9 - 4 - 1 +"

ex01/inc/RPN.hpp

@@ -6,11 +6,21 @@
 class RPN
 {
 public:
+	// Constructors
 	RPN();
 	RPN(std::string expression);
+
+	// Copy constructor and copy assignment operator
 	RPN(const RPN &other);
-	~RPN();
 	RPN &operator=(const RPN &other);
+	
+	// Move constructor and move assignment operator
+	RPN(RPN &&other) noexcept;
+	RPN &operator=(RPN &&other) noexcept;
+	
+	// Destructor
+	~RPN();
+	
 	void setExpression(std::string expression);
 	int evaluate();
 
@@ -44,5 +54,4 @@ private:
 	bool isWellformed() const;
 	bool isOperator(char c) const;
 	int applyOperator(int a, int b, char op) const;
-	void printStack(std::stack<int> stack) const;
 };

ex01/src/RPN.cpp

@@ -1,9 +1,9 @@
 #include "RPN.hpp"
 
-#include <algorithm>
 #include <stdexcept>
 #include <stack>
-#include <iostream>
+#include <cctype>
+#include <utility>
 
 RPN::RPN() : _expression("")
 {
@@ -17,6 +17,10 @@ RPN::RPN(const RPN &other) : _expression(other._expression)
 {
 }
 
+RPN::RPN(RPN &&other) noexcept : _expression(std::move(other._expression))
+{
+}
+
 RPN::~RPN()
 {
 }
@@ -30,6 +34,15 @@ RPN &RPN::operator=(const RPN &other)
 	return *this;
 }
 
+RPN &RPN::operator=(RPN &&other) noexcept
+{
+	if (this != &other)
+	{
+		_expression = std::move(other._expression);
+	}
+	return *this;
+}
+
 void RPN::setExpression(std::string expression)
 {
 	_expression = expression;
@@ -64,8 +77,6 @@ int RPN::evaluate()
 		{
 			throw RPN::InvalidCharacterException();
 		}
-		// std::cout << "Stack after processing '" << c << "': ";
-		// printStack(stack);
 	}
 	if (stack.size() != 1)
 		throw RPN::InvalidExpressionException();
@@ -124,33 +135,6 @@ int RPN::applyOperator(int a, int b, char op) const
 		return 0;
 	}
 }
-
-void RPN::printStack(std::stack<int> stack) const
-{
-	if (stack.empty())
-	{
-		std::cout << "[]\n";
-		return;
-	}
-
-	std::stack<int> temp;
-	while (!stack.empty())
-	{
-		temp.push(stack.top());
-		stack.pop();
-	}
-
-	std::cout << "[";
-	while (!temp.empty())
-	{
-		std::cout << temp.top();
-		temp.pop();
-		if (!temp.empty())
-			std::cout << ", ";
-	}
-	std::cout << "]\n";
-}
-
 const char *RPN::NoExpressionException::NoExpressionException::what() const noexcept
 {
 	return "No expression provided.";
@@ -169,4 +153,4 @@ const char *RPN::DivisionByZeroException::DivisionByZeroException::what() const
 const char *RPN::InvalidCharacterException::InvalidCharacterException::what() const noexcept
 {
 	return "Invalid character in expression.";
-}
+}

ex02/Makefile

@@ -1,2 +1,5 @@
 NAME = PmergeMe
-include ../common.mk
+include ../common.mk
+
+run: all
+	./$(NAME) $$(shuf -i 1-100000 -n 30 | tr '\n' ' ')

ex02/inc/Jacobstahl.hpp

@@ -7,12 +7,12 @@ class Jacobstahl
   public:
     Jacobstahl();
     Jacobstahl(const Jacobstahl &other);
+    Jacobstahl(Jacobstahl &&other) noexcept;
     Jacobstahl &operator=(const Jacobstahl &other);
+    Jacobstahl &operator=(Jacobstahl &&other) noexcept;
     ~Jacobstahl();
 
     int get(int n);
-    std::vector<int> getUpTo(int n);
-    int getAfter(int n);
 
   private:
     int              getRecursive(int n);

ex02/inc/PmergeMe.hpp

@@ -1,9 +1,7 @@
 #pragma once
 #include "Jacobstahl.hpp"
 #include <vector>
-#include <deque>
 #include <ostream>
-#include <stdexcept>
 
 template <typename Container>
 class PmergeMe
@@ -12,18 +10,21 @@ public:
     PmergeMe() = delete;
     PmergeMe(const int argc, const char **argv);
     PmergeMe(const PmergeMe &other);
+    PmergeMe(PmergeMe &&other) noexcept;
     ~PmergeMe();
 
     PmergeMe &operator=(const PmergeMe &other);
+    PmergeMe &operator=(PmergeMe &&other) noexcept;
 
     void sort();
     std::string getString() const;
     int getComparisons() const;
+    long long getTimeUs() const;
 
 private:
     Container _data;
-    std::vector<int> _jacobstahl_numbers;
     int _comparisons;
+    long long _time_us;
 
     bool less(int a, int b);
     bool areAllUnique() const;
@@ -34,4 +35,4 @@ private:
 template <typename Container>
 std::ostream &operator<<(std::ostream &os, const PmergeMe<Container> &obj);
 
-#include "PmergeMe.tpp"
+#include "PmergeMe.tpp"

ex02/inc/PmergeMe.tpp

@@ -3,15 +3,12 @@
 #include "PmergeMe.hpp"
 
 #include <algorithm>
-#include <cmath>
 #include <cstring>
 #include <deque>
-#include <iomanip>
-#include <iostream>
 #include <stdexcept>
 #include <string>
-#include <vector>
 #include <chrono>
+#include <utility>
 
 template <typename T>
 std::string getTypeName()
@@ -24,7 +21,7 @@ std::string getTypeName()
 }
 
 template <typename Container>
-PmergeMe<Container>::PmergeMe(const int argc, const char **argv) : _comparisons(0)
+PmergeMe<Container>::PmergeMe(const int argc, const char **argv) : _comparisons(0), _time_us(0)
 {
 	for (int i = 1; argv[i] != nullptr; ++i)
 	{
@@ -54,13 +51,17 @@ PmergeMe<Container>::PmergeMe(const int argc, const char **argv) : _comparisons(
 
 	if (_data.size() != static_cast<std::size_t>(argc) - 1 || _data.empty())
 		throw std::invalid_argument("Invalid input detected");
-
-	_jacobstahl_numbers = Jacobstahl().getUpTo(_data.size());
 }
 
 template <typename Container>
 PmergeMe<Container>::PmergeMe(const PmergeMe<Container> &other)
-	: _data(other._data), _jacobstahl_numbers(other._jacobstahl_numbers)
+	: _data(other._data), _comparisons(other._comparisons), _time_us(other._time_us)
+{
+}
+
+template <typename Container>
+PmergeMe<Container>::PmergeMe(PmergeMe<Container> &&other) noexcept
+	: _data(std::move(other._data)), _comparisons(other._comparisons), _time_us(other._time_us)
 {
 }
 
@@ -73,7 +74,20 @@ PmergeMe<Container> &PmergeMe<Container>::operator=(const PmergeMe<Container> &o
 	if (this != &other)
 	{
 		_data = other._data;
-		_jacobstahl_numbers = other._jacobstahl_numbers;
+		_comparisons = other._comparisons;
+		_time_us = other._time_us;
+	}
+	return *this;
+}
+
+template <typename Container>
+PmergeMe<Container> &PmergeMe<Container>::operator=(PmergeMe<Container> &&other) noexcept
+{
+	if (this != &other)
+	{
+		_data = std::move(other._data);
+		_comparisons = other._comparisons;
+		_time_us = other._time_us;
 	}
 	return *this;
 }
@@ -89,8 +103,7 @@ void PmergeMe<Container>::sort()
 	// std::cout << "Total comparisons: " << _comparisons << std::endl;
 	// std::cout << (std::is_sorted(_data_vector.begin(), _data_vector.end()) ? "Sorted!!!" : "ERROR!!") << std::endl;
 	auto time_end = std::chrono::high_resolution_clock::now();
-	auto time_diff = std::chrono::duration_cast<std::chrono::microseconds>(time_end - time_start).count();
+	_time_us = std::chrono::duration_cast<std::chrono::microseconds>(time_end - time_start).count();
-	std::cout << "Time to process a range of " << _data.size() << " elements with " << getTypeName<Container>() << ":  " << time_diff << " us" << std::endl;
 }
 
 template <typename Container>
@@ -100,7 +113,7 @@ std::string PmergeMe<Container>::getString() const
 	for (auto it = _data.begin(); it != _data.end(); ++it)
 	{
 		if (it != _data.begin())
-			result += ", ";
+			result += " ";
 		result += std::to_string(*it);
 	}
 	return result;
@@ -112,6 +125,12 @@ int PmergeMe<Container>::getComparisons() const
 	return _comparisons;
 }
 
+template <typename Container>
+long long PmergeMe<Container>::getTimeUs() const
+{
+	return _time_us;
+}
+
 template <typename Container>
 bool PmergeMe<Container>::less(int a, int b)
 {

ex02/src/Jacobstahl.cpp

@@ -1,6 +1,7 @@
 #include "Jacobstahl.hpp"
 
 #include <stdexcept>
+#include <utility>
 
 Jacobstahl::Jacobstahl() : _jacobstahl_numbers()
 {
@@ -20,6 +21,17 @@ Jacobstahl &Jacobstahl::operator=(const Jacobstahl &other)
     return *this;
 }
 
+Jacobstahl::Jacobstahl(Jacobstahl &&other) noexcept : _jacobstahl_numbers(std::move(other._jacobstahl_numbers)) {}
+
+Jacobstahl &Jacobstahl::operator=(Jacobstahl &&other) noexcept
+{
+    if (this != &other)
+    {
+        _jacobstahl_numbers = std::move(other._jacobstahl_numbers);
+    }
+    return *this;
+}
+
 Jacobstahl::~Jacobstahl() {}
 
 int Jacobstahl::get(int n)
@@ -46,34 +58,3 @@ int Jacobstahl::getRecursive(int n)
     _jacobstahl_numbers[n] = getRecursive(n - 1) + 2 * getRecursive(n - 2);
     return _jacobstahl_numbers[n];
 }
-
-std::vector<int> Jacobstahl::getUpTo(int n)
-{
-    if (n < 0)
-        throw std::invalid_argument("n must be non-negative");
-
-    std::vector<int> result;
-    while (true)
-    {
-        int number = get(result.size());
-        if (number > n)
-            break;
-        result.push_back(number);
-    }
-    return result;
-}
-
-int Jacobstahl::getAfter(int n)
-{
-    if (n < 0)
-        throw std::invalid_argument("n must be non-negative");
-
-    int index = 0;
-    while (true)
-    {
-        int number = get(index);
-        if (number > n)
-            return number;
-        index++;
-    }
-}

ex02/src/main.cpp

@@ -1,4 +1,3 @@
-#include "Jacobstahl.hpp"
 #include "PmergeMe.hpp"
 #include <iostream>
 #include <vector>
@@ -8,18 +7,25 @@
 int main(const int argc, const char **argv)
 {
 
-    try
+	try
-    {
+	{
-        PmergeMe<std::vector<int> > sorter_vector(argc, argv);
+		PmergeMe<std::vector<int> > sorter_vector(argc, argv);
-        std::cout << "Before: " << sorter_vector << std::endl;
+		PmergeMe<std::deque<int> > sorter_deque(argc, argv);
-        sorter_vector.sort();
-        PmergeMe<std::deque<int> > sorter_deque(argc, argv);
-        sorter_deque.sort();
-        std::cout << "After: " << sorter_deque << std::endl;
-        std::cout << "Total comparisons (vector): " << sorter_vector.getComparisons() << std::endl;
-        std::cout << "Total comparisons (deque): " << sorter_deque.getComparisons() << std::endl;
 
-    }
+		std::cout << "Before: " << sorter_vector << std::endl;
+
+		sorter_vector.sort();
+		sorter_deque.sort();
+
+		std::cout << "After: " << sorter_deque << std::endl;
+		std::cout << "Time to process a range of " << argc - 1 << " elements with std::vector<int> : "
+				  << sorter_vector.getTimeUs() << " us" << std::endl;
+		std::cout << "Time to process a range of " << argc - 1 << " elements with std::deque<int> : "
+				  << sorter_deque.getTimeUs() << " us" << std::endl;
+		// std::cout << "Total comparisons (vector): " << sorter_vector.getComparisons() << std::endl;
+		// std::cout << "Total comparisons (deque): " << sorter_deque.getComparisons() << std::endl;
+
+	}
     catch (const std::invalid_argument &e)
     {
         std::cerr << "Error: " << e.what() << std::endl;