Calculator Application

Functional Requirements

Use the comprehensive test case dataset to validate your calculator implementation. The CSV file contains expressions with expected results for automated testing:

Dataset Schema

Sample Test Cases Preview

Here are sample test cases from the dataset showing different difficulty levels:

Your project must include all of the following components. Structure your code with clear separation of concerns and comprehensive documentation.

class ExpressionParser {
    std::vector<Token> tokenize(const std::string& expr);
    double evaluate(const std::string& expr);
    bool validate(const std::string& expr);
    
private:
    std::stack<double> values;
    std::stack<char> operators;
    int getPrecedence(char op);
    double applyOp(double a, double b, char op);
};

class MemoryManager {
    double memory = 0.0;
public:
    void clear() { memory = 0.0; }
    double recall() const { return memory; }
    void add(double value) { memory += value; }
    void subtract(double value) { memory -= value; }
    void store(double value) { memory = value; }
};

struct HistoryEntry {
    std::string expression;
    double result;
    std::chrono::time_point<std::chrono::system_clock> timestamp;
};

class HistoryManager {
    std::vector<HistoryEntry> history;
    int currentIndex = -1;
public:
    void add(const std::string& expr, double result);
    HistoryEntry* getPrevious();
    HistoryEntry* getNext();
    void clear();
    void saveToFile(const std::string& filename);
};

Implement all of the following features. Each feature should be well-tested and handle edge cases appropriately.

Sample Implementation

// Operator precedence handling
int getPrecedence(char op) {
    switch(op) {
        case '+': case '-': return 1;
        case '*': case '/': case '%': return 2;
        case '^': return 3;
        default: return 0;
    }
}

// Right associativity for power operator
bool isRightAssociative(char op) {
    return op == '^';
}

// Scientific function evaluation
double evalFunction(const std::string& func, double arg) {
    if (func == "sin") return std::sin(toRadians(arg));
    if (func == "cos") return std::cos(toRadians(arg));
    if (func == "tan") return std::tan(toRadians(arg));
    if (func == "sqrt") return std::sqrt(arg);
    if (func == "log") return std::log10(arg);
    if (func == "ln") return std::log(arg);
    throw std::runtime_error("Unknown function: " + func);
}

Organize your code following this modular structure. Each class should have a single responsibility and be well-documented.

calculator-app/
├── include/
│   ├── Calculator.h         # Main calculator class
│   ├── Parser.h             # Expression tokenizer and parser
│   ├── Evaluator.h          # Expression evaluator
│   ├── Operations.h         # Operation base class and implementations
│   ├── MemoryManager.h      # Memory functions (MC, MR, M+, M-)
│   ├── HistoryManager.h     # Calculation history
│   ├── Token.h              # Token structure for parsing
│   └── Exceptions.h         # Custom exception classes
├── src/
│   ├── main.cpp             # Entry point and UI loop
│   ├── Calculator.cpp       # Calculator implementation
│   ├── Parser.cpp           # Parser implementation
│   ├── Evaluator.cpp        # Evaluator implementation
│   ├── Operations.cpp       # Operation implementations
│   ├── MemoryManager.cpp    # Memory implementation
│   └── HistoryManager.cpp   # History implementation
├── tests/
│   ├── test_parser.cpp      # Parser unit tests
│   ├── test_evaluator.cpp   # Evaluator unit tests
│   ├── test_operations.cpp  # Operation unit tests
│   └── test_integration.cpp # Integration tests with CSV data
├── data/
│   └── test_cases.csv       # Test cases from dataset
├── Makefile                 # Build configuration
└── README.md                # Project documentation

Class Diagram

Create a public GitHub repository with the exact name shown below:

Required Project Structure

cpp-calculator-app/
├── include/                    # Header files
│   ├── Calculator.h
│   ├── Parser.h
│   ├── Evaluator.h
│   ├── Operations.h
│   ├── MemoryManager.h
│   └── HistoryManager.h
├── src/                        # Source files
│   ├── main.cpp
│   ├── Calculator.cpp
│   ├── Parser.cpp
│   └── ... (other implementations)
├── tests/                      # Unit tests
│   └── test_*.cpp
├── data/                       # Test data files
│   └── test_cases.csv
├── screenshots/                # Application screenshots
│   ├── basic_operations.png
│   ├── scientific_functions.png
│   └── error_handling.png
├── Makefile                    # Build configuration
└── README.md                   # Project documentation

Your project will be graded on the following criteria. Total: 400 points.

Grading Levels

Use this checklist to verify you have completed all requirements before submitting your project.