Update project to version 2.0.0 with modular architecture and enhanced features

- Bump version from 1.0.0 to 2.0.0 in CMakeLists.txt
- Add BUILD_REPL option and calc_repl executable target
- Refactor CMake to include modular header directory structure
- Rename example executables for consistency (advanced_usage → example_functions, error_handling_demo → example_errors, numeric_types_demo → example_types)
- Rename benchmark executable from 'benchmark' to 'calc_benchmark'
- Update test configuration

Author: AstroAir

.gitignore

@@ -31,8 +31,68 @@
 *.out
 *.app
 
-# CMake
+# CMake build artifacts
 build/
+cmake-build-*/
+CMakeCache.txt
+CMakeFiles/
+cmake_install.cmake
+CTestTestfile.cmake
+compile_commands.json
+Makefile
+*.sln
+*.vcxproj
+*.vcxproj.filters
+*.vcxproj.user
+Testing/
 
+# xmake build artifacts
+.xmake/
+.build/
+
+# IDE specific files
+# Visual Studio
+.vs/
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+*.VC.db
+*.VC.opendb
+
+# Visual Studio Code
+.vscode/
+*.code-workspace
+
+# CLion
+.idea/
+cmake-build-*/
+
+# Clangd
+.clangd/
 .cache/
-site/
+
+# Documentation
+site/
+docs/_build/
+docs/.buildinfo
+
+# OS specific
+.DS_Store
+Thumbs.db
+*.swp
+*.swo
+*~
+
+# Python (for documentation tools)
+__pycache__/
+*.py[cod]
+*$py.class
+.Python
+venv/
+env/
+ENV/
+
+# Test and benchmark outputs
+*.log
+*.tlog

CMakeLists.txt

@@ -1,17 +1,21 @@
 cmake_minimum_required(VERSION 3.20)
-project(calculator VERSION 1.0.0 LANGUAGES CXX)
+project(calculator VERSION 2.0.0 LANGUAGES CXX)
 
 option(BUILD_TESTS "Build tests" ON)
 option(BUILD_EXAMPLES "Build examples" ON)
 option(BUILD_BENCHMARKS "Build benchmarks" OFF)
+option(BUILD_REPL "Build REPL executable" ON)
 
 if(NOT CMAKE_CXX_STANDARD)
     set(CMAKE_CXX_STANDARD 17)
     set(CMAKE_CXX_STANDARD_REQUIRED ON)
 endif()
 
 add_library(calculator INTERFACE)
-target_include_directories(calculator INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
+target_include_directories(calculator INTERFACE 
+    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
 
 if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
     if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0")
@@ -26,32 +30,32 @@ endif()
 install(FILES calculator.hpp DESTINATION calculator)
 
 if (BUILD_EXAMPLES)
-    # Main comprehensive example
+    # Main example
     add_executable(example example/main.cpp)
     target_link_libraries(example PRIVATE calculator)
 
-    # Advanced usage patterns
-    add_executable(advanced_usage example/advanced_usage.cpp)
-    target_link_libraries(advanced_usage PRIVATE calculator)
+    # Functions example
+    add_executable(example_functions example/functions.cpp)
+    target_link_libraries(example_functions PRIVATE calculator)
 
-    # Error handling demonstration
-    add_executable(error_handling_demo example/error_handling_demo.cpp)
-    target_link_libraries(error_handling_demo PRIVATE calculator)
+    # Error handling example
+    add_executable(example_errors example/errors.cpp)
+    target_link_libraries(example_errors PRIVATE calculator)
 
-    # Numeric types demonstration
-    add_executable(numeric_types_demo example/numeric_types_demo.cpp)
-    target_link_libraries(numeric_types_demo PRIVATE calculator)
+    # Numeric types example
+    add_executable(example_types example/types.cpp)
+    target_link_libraries(example_types PRIVATE calculator)
 
     # Ensure math constants like M_PI and M_E are available on MSVC
     if (MSVC)
         target_compile_definitions(example PRIVATE _USE_MATH_DEFINES)
-        target_compile_definitions(advanced_usage PRIVATE _USE_MATH_DEFINES)
-        target_compile_definitions(error_handling_demo PRIVATE _USE_MATH_DEFINES)
-        target_compile_definitions(numeric_types_demo PRIVATE _USE_MATH_DEFINES)
+        target_compile_definitions(example_functions PRIVATE _USE_MATH_DEFINES)
+        target_compile_definitions(example_errors PRIVATE _USE_MATH_DEFINES)
+        target_compile_definitions(example_types PRIVATE _USE_MATH_DEFINES)
     endif()
 
     # Set output directory for examples
-    set_target_properties(example advanced_usage error_handling_demo numeric_types_demo
+    set_target_properties(example example_functions example_errors example_types
         PROPERTIES
         RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/example
     )
@@ -60,13 +64,25 @@ endif()
 if (BUILD_TESTS)
     enable_testing()
     find_package(GTest REQUIRED)
-    add_executable(calc_test test/main.cpp)
-    target_link_libraries(calc_test PRIVATE calculator GTest::gtest)
+    add_executable(calc_test test/main.cpp test/test_parser.cpp)
+    target_link_libraries(calc_test PRIVATE calculator GTest::gtest GTest::gtest_main)
+    if (MSVC)
+        target_compile_definitions(calc_test PRIVATE _USE_MATH_DEFINES)
+    endif()
     add_test(NAME CalcTest COMMAND calc_test)
 endif()
 
 if (BUILD_BENCHMARKS)
     find_package(benchmark REQUIRED)
-    add_executable(benchmark benchmark/main.cpp)
-    target_link_libraries(benchmark PRIVATE calculator benchmark::benchmark)
+    add_executable(calc_benchmark benchmark/main.cpp)
+    target_link_libraries(calc_benchmark PRIVATE calculator benchmark::benchmark)
+endif()
+
+if (BUILD_REPL)
+    add_executable(calc_repl example/repl_main.cpp)
+    target_link_libraries(calc_repl PRIVATE calculator)
+    if (MSVC)
+        target_compile_definitions(calc_repl PRIVATE _USE_MATH_DEFINES)
+    endif()
+    set_target_properties(calc_repl PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 endif()

README.md

@@ -1,24 +1,30 @@
-# Modern C++ Calculator
+# Modern C++ Calculator v2.1
 
 [![CodeQL](https://github.com/ElementAstro/calculator/actions/workflows/codeql.yml/badge.svg)](https://github.com/ElementAstro/calculator/actions/workflows/codeql.yml)
 [![MinGW](https://github.com/ElementAstro/calculator/actions/workflows/windows-mingw.yml/badge.svg)](https://github.com/ElementAstro/calculator/actions/workflows/windows-mingw.yml)
 [![Bugs](https://sonarcloud.io/api/project_badges/measure?project=ElementAstro_calculator&metric=bugs)](https://sonarcloud.io/summary/new_code?id=ElementAstro_calculator)
 [![Documentation](https://img.shields.io/badge/docs-mkdocs-blue.svg)](https://elementastro.github.io/calculator/)
 
-A modern, high-performance C++ header-only calculator library for evaluating mathematical expressions. Built with C++17/20 features, this library provides a robust and flexible expression parser that supports variables, functions, and comprehensive mathematical operations.
+A modern, high-performance C++ header-only calculator library for evaluating mathematical expressions. Built with C++17/20 features, this library provides a robust and flexible expression parser that supports variables, functions, comparison/logical operators, conditional expressions, complex numbers, symbolic differentiation, and a REPL interface.
 
 📖 **[Complete Documentation](https://elementastro.github.io/calculator/)** | 🚀 **[Quick Start Guide](https://elementastro.github.io/calculator/getting-started/quick-start/)** | 📋 **[API Reference](https://elementastro.github.io/calculator/api-reference/)**
 
 ## ✨ Key Features
 
-- **🚀 Header-only**: Single file, easy integration
-- **🔢 Multiple numeric types**: Support for `int`, `float`, and `double`
+- **🚀 Header-only**: Modular design, easy integration
+- **🔢 Multiple numeric types**: Support for `int`, `float`, `double`, and `std::complex<double>`
 - **⚡ High performance**: Optimized expression parsing and evaluation
-- **🧮 Comprehensive operations**: Arithmetic, bitwise, and exponentiation
-- **📐 Mathematical functions**: Support for custom functions and variables
+- **🧮 Comprehensive operations**: Arithmetic, bitwise, comparison, logical, and power operations
+- **📐 Mathematical functions**: 60+ built-in functions (trigonometric, hyperbolic, combinatorics, etc.)
+- **🔀 Conditional expressions**: Ternary operator support (`condition ? true : false`)
+- **📝 User-defined functions**: Define custom functions like `f(x) = x^2 + 2*x + 1`
+- **🔣 Complex numbers**: Full complex number arithmetic support
+- **📊 Symbolic differentiation**: Compute derivatives symbolically
+- **💻 REPL interface**: Interactive calculator with history support
 - **🛡️ Robust error handling**: Detailed error messages with position information
 - **📏 Operator precedence**: Follows standard mathematical precedence rules
 - **🔧 Template-based**: Type-safe generic implementation
+- **🔬 Physics constants**: Built-in physical constants (c, G, h, Na, etc.)
 
 ## 🚀 Quick Start
 
@@ -60,17 +66,48 @@ int main() {
 | Category | Operators | Example | Types |
 |----------|-----------|---------|-------|
 | **Arithmetic** | `+`, `-`, `*`, `/`, `%` | `3 + 4 * 2` | All |
-| **Bitwise** | `\|`, `^`, `&`, `<<`, `>>`, `~` | `5 & 3` | `int` only |
-| **Exponentiation** | `**`, `e`/`E` | `2 ** 3`, `1.5e2` | All |
-| **Unary** | `+`, `-`, `~` | `+5`, `-3`, `~7` | All/`int` |
+| **Floor Division** | `//` | `7 // 3` → `2` | All |
+| **Power** | `^`, `**` | `2^3`, `2**3` | All |
+| **Comparison** | `>`, `<`, `>=`, `<=`, `==`, `!=` | `5 > 3` | All |
+| **Logical** | `&&`, `\|\|`, `!` | `(5>3) && (2<4)` | All |
+| **Bitwise** | `&`, `\|`, `~`, `<<`, `>>` | `5 & 3` | `int` only |
+| **Conditional** | `? :` | `x > 0 ? x : -x` | All |
+| **Assignment** | `=` | `x = 10` | All |
 | **Grouping** | `(`, `)` | `(2 + 3) * 4` | All |
 
+### Built-in Functions
+
+| Category | Functions |
+|----------|-----------|
+| **Trigonometric** | `sin`, `cos`, `tan`, `cot`, `sec`, `csc` |
+| **Inverse Trig** | `asin`, `acos`, `atan`, `acot`, `asec`, `acsc` |
+| **Hyperbolic** | `sinh`, `cosh`, `tanh`, `coth`, `sech`, `csch` |
+| **Inverse Hyperbolic** | `asinh`, `acosh`, `atanh` |
+| **Logarithmic** | `log`, `log10`, `log2`, `ln`, `exp`, `exp2`, `expm1`, `log1p` |
+| **Power/Root** | `sqrt`, `cbrt`, `sqr`, `cube`, `pow(x,y)`, `hypot(x,y)` |
+| **Rounding** | `floor`, `ceil`, `round`, `trunc`, `frac`, `abs` |
+| **Factorial/Gamma** | `fact`, `factorial`, `gamma`, `lgamma` |
+| **Combinatorics** | `nCr(n,r)`, `nPr(n,r)`, `comb`, `perm` |
+| **Number Theory** | `gcd(a,b)`, `lcm(a,b)` |
+| **Error Functions** | `erf`, `erfc` |
+| **Utility** | `sign`, `heaviside`, `recip`, `inv`, `deg`, `rad` |
+| **Two-Argument** | `max`, `min`, `mod`, `atan2`, `logb`, `avg`, `clamp`, `wrap` |
+
+### Built-in Constants
+
+| Category | Constants |
+|----------|-----------|
+| **Mathematical** | `pi`, `e`, `phi` (golden ratio), `tau` (2π), `sqrt2`, `sqrt3`, `ln2`, `ln10` |
+| **Special** | `inf` (infinity), `nan` (not a number) |
+| **Physics (SI)** | `c` (speed of light), `G` (gravitational), `h` (Planck), `kb` (Boltzmann), `Na` (Avogadro), `qe` (elementary charge) |
+
 ### Advanced Features
 
-- **Variables**: `parser.set("x", 5.0)` → `"x + 10"`
-- **Functions**: `parser.set("sqrt", [](double x) { return std::sqrt(x); })` → `"sqrt(16)"`
-- **Multiple Types**: `int`, `float`, `double` with type-specific behaviors
-- **Error Handling**: Detailed error messages with position information
+- **Variables**: `x = 10` then use `x + 5`
+- **User-defined functions**: `f(x) = x^2 + 2*x + 1` then call `f(3)`
+- **Complex numbers**: `(3 + 4*i) * (1 + 2*i)` with `std::complex<double>`
+- **Symbolic differentiation**: `parser.diff("x^2", "x")` returns `"2 * x"`
+- **REPL interface**: Interactive calculator with command history
 
 **[📋 Complete operator reference and examples →](https://elementastro.github.io/calculator/reference/operators/)**
 

benchmark/main.cpp

@@ -1,39 +1,109 @@
 #include "calculator.hpp"
 #include <benchmark/benchmark.h>
+#include <complex>
 
 using namespace calculator;
 
-static void BM_CalculatorInt(benchmark::State &state) {
-  ExpressionParser<int> parser;
+// Basic arithmetic benchmarks
+static void BM_BasicArithmetic(benchmark::State &state) {
+  ExpressionParser<double> parser;
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(parser.eval("1 + 2 * 3 - 4 / 2"));
+  }
+}
+
+static void BM_ComplexExpression(benchmark::State &state) {
+  ExpressionParser<double> parser;
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(parser.eval("(1.5 + 2.5) * (3.5 - 4.5) / (5.5 + 6.5) * (7.5 - 8.5) + 9.5"));
+  }
+}
+
+// Power operations
+static void BM_PowerOperations(benchmark::State &state) {
+  ExpressionParser<double> parser;
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(parser.eval("2^10 + 3^5 - 4^3"));
+  }
+}
+
+// Comparison and logical operators
+static void BM_ComparisonLogical(benchmark::State &state) {
+  ExpressionParser<double> parser;
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(parser.eval("(5 > 3) && (2 < 4) || (1 == 1)"));
+  }
+}
+
+// Ternary expression
+static void BM_TernaryExpression(benchmark::State &state) {
+  ExpressionParser<double> parser;
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(parser.eval("10 > 5 ? 100 + 50 : 200 - 50"));
+  }
+}
+
+// Built-in functions
+static void BM_BuiltinFunctions(benchmark::State &state) {
+  ExpressionParser<double> parser;
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(parser.eval("sqrt(16) + sin(0) + cos(0) + abs(-5)"));
+  }
+}
+
+// Variables
+static void BM_Variables(benchmark::State &state) {
+  ExpressionParser<double> parser;
+  parser.set("x", 10.0);
+  parser.set("y", 20.0);
   for (auto _ : state) {
-    parser.eval("1 + 2 * 3 - 4 / 2");
+    benchmark::DoNotOptimize(parser.eval("x + y * 2 - x / 2"));
   }
 }
 
-static void BM_CalculatorDouble(benchmark::State &state) {
+// User-defined functions
+static void BM_UserDefinedFunction(benchmark::State &state) {
   ExpressionParser<double> parser;
+  parser.eval("f(x) = x^2 + 2*x + 1");
   for (auto _ : state) {
-    parser.eval("1.5 + 2.5 * 3.5 - 4.5 / 2.5");
+    benchmark::DoNotOptimize(parser.eval("f(10)"));
   }
 }
 
-static void BM_CalculatorComplexInt(benchmark::State &state) {
-  ExpressionParser<int> parser;
+// Complex numbers
+static void BM_ComplexNumbers(benchmark::State &state) {
+  ExpressionParser<std::complex<double>> parser;
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(parser.eval("(3 + 4*i) * (1 + 2*i)"));
+  }
+}
+
+// Nested expressions
+static void BM_NestedExpressions(benchmark::State &state) {
+  ExpressionParser<double> parser;
   for (auto _ : state) {
-    parser.eval("(1 + 2) * (3 - 4) / (5 + 6) * (7 - 8) + 9");
+    benchmark::DoNotOptimize(parser.eval("((((1 + 2) * 3) + 4) * 5) + 6"));
   }
 }
 
-static void BM_CalculatorComplexDouble(benchmark::State &state) {
+// Symbolic differentiation
+static void BM_Differentiation(benchmark::State &state) {
   ExpressionParser<double> parser;
   for (auto _ : state) {
-    parser.eval("(1.5 + 2.5) * (3.5 - 4.5) / (5.5 + 6.5) * (7.5 - 8.5) + 9.5");
+    benchmark::DoNotOptimize(parser.diff("x^3 + 2*x^2 + x + 1", "x"));
   }
 }
 
-BENCHMARK(BM_CalculatorInt);
-BENCHMARK(BM_CalculatorDouble);
-BENCHMARK(BM_CalculatorComplexInt);
-BENCHMARK(BM_CalculatorComplexDouble);
+BENCHMARK(BM_BasicArithmetic);
+BENCHMARK(BM_ComplexExpression);
+BENCHMARK(BM_PowerOperations);
+BENCHMARK(BM_ComparisonLogical);
+BENCHMARK(BM_TernaryExpression);
+BENCHMARK(BM_BuiltinFunctions);
+BENCHMARK(BM_Variables);
+BENCHMARK(BM_UserDefinedFunction);
+BENCHMARK(BM_ComplexNumbers);
+BENCHMARK(BM_NestedExpressions);
+BENCHMARK(BM_Differentiation);
 
 BENCHMARK_MAIN();