task 12.20: calculator

Author: c71n93

week-15/task-12-20/CMakeLists.txt

@@ -1,5 +1,3 @@
 include_directories(include)
 
 add_subdirectory(test)
-
-add_executable(ae main.cpp)

week-15/task-12-20/include/calculator.hpp

@@ -1,27 +1,41 @@
 #pragma once
 
-#include <stack>
+#include <cassert>
 #include <sstream>
+#include <stack>
 
-bool is_operator(char c) {
+inline bool is_operator(const std::string& str) {
+    if (str.size() != 1) {
+        return false;
+    }
+    const char c = str[0];
     return c == '+' || c == '-' || c == '*' || c == '/';
 }
 
-int calculate(const std::string& str) {
-    std::stack<int> stack;
-    for (auto it = std::cbegin(str); it != std::cend(str);) {
-        if (static_cast<bool>(std::isspace(*it))) {
-            while (it != std::cend(str) && static_cast<bool>(std::isspace(*it))) { ++it; }
-        } else if (static_cast<bool>(std::isdigit(*it))) {
-            std::istringstream iss(std::string(it, std::cend(str)));
-            int val;
-            iss >> val;
-            stack.push(val);
-            std::advance(it, iss.tellg());
-        } else if (is_operator(*it)) {
-            const int b = stack.top(); stack.pop();
-            const int a = stack.top(); stack.pop();
-            switch (*it) {
+inline bool may_be_number(const std::string& str) {
+    return (str[0] == '-' && str.size() > 1) || static_cast<bool>(std::isdigit(str[0]));
+}
+
+double calculate(const std::string& str) {
+    if (str.empty()) {
+        throw std::invalid_argument("empty string");
+    }
+    std::stack<double> stack;
+    std::istringstream iss(str);
+    std::string token;
+    while (iss >> token) {
+        assert(!token.empty());
+        if (may_be_number(token)) {
+            stack.push(std::stod(token));
+        } else if (is_operator(token)) {
+            if (stack.size() < 2) {
+                throw std::invalid_argument("too few arguments for operation");
+            }
+            const double b = stack.top();
+            stack.pop();
+            const double a = stack.top();
+            stack.pop();
+            switch (token[0]) {
                 case '+':
                     stack.push(a + b);
                     break;
@@ -35,11 +49,10 @@ int calculate(const std::string& str) {
                     stack.push(a / b);
                     break;
                 default:
-                    throw std::runtime_error("unexpected operator");
+                    throw std::invalid_argument("unexpected operator");
             }
-            ++it;
         } else {
-            throw std::runtime_error("unexpected symbol");
+            throw std::invalid_argument("unexpected token");
         }
     }
     return stack.top();

week-15/task-12-20/main.cpp

@@ -1,43 +1,63 @@
-#include "gtest/gtest.h"
 #include "calculator.hpp"
+#include "gtest/gtest.h"
 
 TEST(RPNCalculatorTest, BasicOperations) {
-    EXPECT_EQ(calculate("3 4 +"), 7);      // 3 + 4
-    EXPECT_EQ(calculate("5 2 -"), 3);      // 5 - 2
-    EXPECT_EQ(calculate("2 3 *"), 6);      // 2 * 3
-    EXPECT_EQ(calculate("6 2 /"), 3);      // 6 / 2
+    EXPECT_DOUBLE_EQ(calculate("3 4 +"), 7.0);
+    EXPECT_DOUBLE_EQ(calculate("5 2 -"), 3.0);
+    EXPECT_DOUBLE_EQ(calculate("2 3 *"), 6.0);
+    EXPECT_DOUBLE_EQ(calculate("6 2 /"), 3.0);
+}
+
+TEST(RPNCalculatorTest, FloatingPointOperations) {
+    EXPECT_DOUBLE_EQ(calculate("3.5 4.2 +"), 7.7);
+    EXPECT_DOUBLE_EQ(calculate("5.1 2.3 -"), 2.8);
+    EXPECT_DOUBLE_EQ(calculate("2.5 3.2 *"), 8.0);
+    EXPECT_DOUBLE_EQ(calculate("7.5 2.5 /"), 3.0);
 }
 
 TEST(RPNCalculatorTest, ComplexExpressions) {
-    EXPECT_EQ(calculate("3 4 2 * +"), 11);     // 3 + (4 * 2)
-    EXPECT_EQ(calculate("5 1 2 + 4 * + 3 -"), 14); // 5 + ((1+2)*4) - 3
-    EXPECT_EQ(calculate("4 2 5 * + 1 3 - /"), -7); // (4 + 2*5) / (1-3)
+    EXPECT_DOUBLE_EQ(calculate("3 4 2 * +"), 11.0);
+    EXPECT_DOUBLE_EQ(calculate("5 1 2 + 4 * + 3 -"), 14.0);
+    EXPECT_DOUBLE_EQ(calculate("4 2 5 * + 1 3 - /"), -7.0);
 }
 
 TEST(RPNCalculatorTest, EdgeCases) {
-    EXPECT_EQ(calculate("0 5 +"), 5);       // 0 + 5
-    EXPECT_EQ(calculate("1 1 -"), 0);       // 1 - 1
-    EXPECT_EQ(calculate("999 1 +"), 1000);  // large number
-    EXPECT_EQ(calculate("-5 3 +"), -2);     // negative number
+    EXPECT_DOUBLE_EQ(calculate("0 5 +"), 5.0);
+    EXPECT_DOUBLE_EQ(calculate("1 1 -"), 0.0);
+    EXPECT_DOUBLE_EQ(calculate("999 1 +"), 1000.0);
+    EXPECT_DOUBLE_EQ(calculate("-5 3 +"), -2.0);
 }
 
 TEST(RPNCalculatorTest, InvalidInput) {
-    EXPECT_THROW(calculate(""), std::invalid_argument);      // empty
-    EXPECT_THROW(calculate("3 +"), std::invalid_argument);   // missing operand
-    EXPECT_THROW(calculate("3 4 + -"), std::invalid_argument); // extra operator
-    EXPECT_THROW(calculate("a b +"), std::invalid_argument); // non-numbers
-    EXPECT_THROW(calculate("3 0 /"), std::runtime_error);    // division by zero
+    EXPECT_THROW(calculate(""), std::invalid_argument);
+    EXPECT_THROW(calculate("3 +"), std::invalid_argument);
+    EXPECT_THROW(calculate("3 4 + -"), std::invalid_argument);
+    EXPECT_THROW(calculate("a b +"), std::invalid_argument);
 }
 
 TEST(RPNCalculatorTest, WhitespaceHandling) {
-    EXPECT_EQ(calculate("  3   4  +  "), 7);  // extra spaces
-    EXPECT_EQ(calculate("3\n4\t+"), 7);       // different whitespace
-    EXPECT_EQ(calculate("3 4 + "), 7);        // trailing space
+    EXPECT_DOUBLE_EQ(calculate("  3   4  +  "), 7.0);
+    EXPECT_DOUBLE_EQ(calculate("3\n4\t+"), 7.0);
+    EXPECT_DOUBLE_EQ(calculate("3 4 + "), 7.0);
 }
 
 TEST(RPNCalculatorTest, MultiDigitNumbers) {
-    EXPECT_EQ(calculate("10 20 +"), 30);      // 10 + 20
-    EXPECT_EQ(calculate("100 50 -"), 50);     // 100 - 50
-    EXPECT_EQ(calculate("12 34 *"), 408);     // 12 * 34
-    EXPECT_EQ(calculate("100 5 /"), 20);      // 100 / 5
+    EXPECT_DOUBLE_EQ(calculate("10 20 +"), 30.0);
+    EXPECT_DOUBLE_EQ(calculate("100 50 -"), 50.0);
+    EXPECT_DOUBLE_EQ(calculate("12 34 *"), 408.0);
+    EXPECT_DOUBLE_EQ(calculate("100 5 /"), 20.0);
+}
+
+TEST(RPNCalculatorTest, PrecisionHandling) {
+    EXPECT_DOUBLE_EQ(calculate("0.1 0.2 +"), 0.3);
+    EXPECT_DOUBLE_EQ(calculate("1.234 2.345 +"), 3.579);
+    EXPECT_NEAR(calculate("1.0 3.0 /"), 0.333333, 1e-6);
+    EXPECT_NEAR(calculate("2.0 3.0 /"), 0.666666, 1e-6);
+}
+
+TEST(RPNCalculatorTest, MixedIntegerAndFloatingPoint) {
+    EXPECT_DOUBLE_EQ(calculate("3 4.5 +"), 7.5);
+    EXPECT_DOUBLE_EQ(calculate("5.2 2 -"), 3.2);
+    EXPECT_DOUBLE_EQ(calculate("2 3.5 *"), 7.0);
+    EXPECT_DOUBLE_EQ(calculate("6.6 2.2 /"), 3.0);
 }