Add std math translation (#4)

README.md

@@ -128,8 +128,7 @@ This demonstrates successful translation of:
 pytocplusplus/
 ├── src/
 │   ├── analyzer/           # Python code analysis components
-│   │   ├── code_analyzer.py     # Original analyzer with bug
-│   │   └── code_analyzer_fixed.py  # Fixed implementation
+│   │   └── code_analyzer_fixed.py  # Analyzer implementation
 │   ├── converter/          # C++ conversion components
 │   │   ├── code_generator.py    # Original generator
 │   │   └── code_generator_fixed.py  # Fixed implementation
@@ -160,6 +159,7 @@ Currently, PyToC++ effectively handles:
 - **Method overriding** and polymorphism
 - **Constructor translation** with proper initialization
 
+- **Math function translation**: `math.sqrt`, `math.sin`, and `math.cos` are translated to their C++ `std` equivalents.
 More complex features are under development, including:
 - Exception handling
 - Standard library mapping

docs/ComprehensiveCodeAnalysisReport.md

@@ -0,0 +1,122 @@
+# Comprehensive Code Analysis Report
+
+## Top-Level Files
+
+### `./README.md`
+*   **Purpose**: Main entry point for project information, setup, usage.
+*   **Completion Status/Key Observations**: Largely up-to-date with recent "Sprint 2" achievements (class support, Union types). Details installation, usage for simple and class examples, output structure, and basic project structure. Mentions supported features and areas for development.
+*   **Key Relations**: Links to LICENSE, references `requirements.txt`, `examples/`, `src/main.py`.
+*   **Potential Enhancements/Improvements**:
+    *   Explicitly state that `class_example.py` is the primary example for current advanced features.
+    *   Link to or summarize key findings from `docs/` for a fuller picture of limitations.
+
+### `./requirements.txt`
+*   **Purpose**: Lists Python dependencies.
+*   **Completion Status/Key Observations**: Contains standard tools for analysis, testing, formatting (`astroid`, `pylint`, `mypy`, `pytest`, `black`, `networkx`, `typing-extensions`). Appears complete for current needs.
+*   **Key Relations**: Used in `CONTRIBUTING.md` for setup, essential for development environment.
+*   **Potential Enhancements/Improvements**: Consider version pinning for more reproducible builds if issues arise.
+
+### `./CONTRIBUTING.md`
+*   **Purpose**: Provides guidelines for contributing to the project.
+*   **Completion Status/Key Observations**: Outlines setup, coding standards (Black, Pylint, Mypy), testing procedures, and commit message format. Appears comprehensive.
+*   **Key Relations**: References `requirements.txt`, `tox.ini`.
+*   **Potential Enhancements/Improvements**: None apparent at this time.
+
+### `./LICENSE`
+*   **Purpose**: Specifies the legal terms under which the project is distributed.
+*   **Completion Status/Key Observations**: Uses the MIT License, a permissive open-source license.
+*   **Key Relations**: Referenced in `README.md`.
+*   **Potential Enhancements/Improvements**: None.
+
+### `./tox.ini`
+*   **Purpose**: Configuration file for tox, an automation tool for Python testing.
+*   **Completion Status/Key Observations**: Defines test environments for linting (Pylint, Mypy, Black) and unit testing (pytest). Includes commands and dependencies for each environment.
+*   **Key Relations**: Used by `tox` for automated testing and linting. Crucial for CI/CD.
+*   **Potential Enhancements/Improvements**: Could be expanded with more specific test targets or coverage analysis.
+
+### `./.gitignore`
+*   **Purpose**: Specifies intentionally untracked files that Git should ignore.
+*   **Completion Status/Key Observations**: Includes common Python-related files/directories (`__pycache__`, `*.pyc`, `.env`), virtual environment directories (`venv`, `env`), build artifacts (`dist`, `build`), and IDE-specific files. Seems well-configured.
+*   **Key Relations**: Standard Git configuration file.
+*   **Potential Enhancements/Improvements**: None apparent.
+
+## `src/` Directory
+
+### `src/main.py`
+*   **Purpose**: Main executable script for the Python to DOT graph conversion. Handles command-line arguments, file processing, and DOT graph generation.
+*   **Completion Status/Key Observations**: Core logic for parsing Python code using `astroid`, building a graph with `networkx`, and outputting DOT format. Supports basic types, functions, classes, and modules. Recent additions include handling of Union types and improved class member representation.
+*   **Key Relations**: Uses `astroid` for AST parsing, `networkx` for graph representation. Interacts with `src/output_graphs.py`. Reads Python files from `examples/`.
+*   **Potential Enhancements/Improvements**:
+    *   Refactor large functions for better modularity.
+    *   Enhance error handling for malformed Python inputs.
+    *   Add support for more complex type hints and Python features.
+
+### `src/output_graphs.py`
+*   **Purpose**: Responsible for generating the DOT language output from the `networkx` graph.
+*   **Completion Status/Key Observations**: Contains functions to format nodes and edges according to DOT syntax, including styling for different Python constructs (classes, functions, modules, variables, types).
+*   **Key Relations**: Consumes `networkx` graph objects generated by `src/main.py`.
+*   **Potential Enhancements/Improvements**:
+    *   Offer more customization options for graph appearance (colors, shapes).
+    *   Support different output formats beyond DOT (e.g., GML, GraphML).
+
+## `examples/` Directory
+
+### `examples/simple_example.py`
+*   **Purpose**: Provides a basic Python script for demonstrating the tool's functionality with simple functions, variables, and type hints.
+*   **Completion Status/Key Observations**: Contains straightforward examples of global variables, functions with typed arguments and return values.
+*   **Key Relations**: Used as an input for `src/main.py` for testing and demonstration.
+*   **Potential Enhancements/Improvements**: Could include a slightly more complex function or a basic class to showcase more features.
+
+### `examples/class_example.py`
+*   **Purpose**: Demonstrates the tool's capabilities with Python classes, including methods, attributes, inheritance, and Union type hints.
+*   **Completion Status/Key Observations**: Contains classes with constructors, methods (with `self`), class variables, instance variables, and inheritance. Uses `Union` and `Optional` type hints. This is the primary example for current advanced features.
+*   **Key Relations**: Used as a key input for `src/main.py` for testing class-related feature support.
+*   **Potential Enhancements/Improvements**: Add examples of multiple inheritance or more complex class interactions if those features are further developed.
+
+### `examples/module_example/`
+*   **Purpose**: Directory containing multiple Python files (`module1.py`, `module2.py`) to demonstrate inter-module dependencies and imports.
+*   **Completion Status/Key Observations**: `module1.py` defines functions and classes, `module2.py` imports and uses them.
+*   **Key Relations**: Shows how `src/main.py` handles imports and represents module relationships in the graph.
+*   **Potential Enhancements/Improvements**: Could include more complex import scenarios (e.g., `from ... import ... as ...`, wildcard imports if supported).
+
+## `tests/` Directory
+
+### `tests/test_main.py`
+*   **Purpose**: Contains unit tests for the core functionality in `src/main.py`.
+*   **Completion Status/Key Observations**: Uses `pytest`. Tests cover graph generation for simple types, functions, classes, and basic module imports. Mocks file system operations and `astroid` parsing where necessary. Checks for expected nodes and edges in the generated `networkx` graph.
+*   **Key Relations**: Tests the logic within `src/main.py`. Relies on example files in `examples/` as input for some tests.
+*   **Potential Enhancements/Improvements**:
+    *   Increase test coverage, especially for error conditions and edge cases.
+    *   Add tests for newly supported features (e.g., specific Union type scenarios).
+    *   Test DOT output validation more rigorously if `src/output_graphs.py` becomes more complex.
+
+## `docs/` Directory
+
+### `docs/DevelopmentLog.md`
+*   **Purpose**: Tracks development progress, decisions, and future plans.
+*   **Completion Status/Key Observations**: Contains entries for "Sprint 1" and "Sprint 2", detailing features implemented (basic types, functions, classes, Union types, module handling), bugs fixed, and next steps.
+*   **Key Relations**: Internal development document.
+*   **Potential Enhancements/Improvements**: Maintain regular updates as development progresses.
+
+### `docs/Limitations.md`
+*   **Purpose**: Documents known limitations and unsupported features of the tool.
+*   **Completion Status/Key Observations**: Lists issues like lack of support for decorators, generators, context managers, advanced `typing` features (Generics, Protocols), and dynamic aspects of Python.
+*   **Key Relations**: Important for users to understand the current scope of the tool.
+*   **Potential Enhancements/Improvements**: Update as new limitations are discovered or existing ones are addressed.
+
+### `docs/sprint2_notes.md`
+*   **Purpose**: Contains detailed notes and findings from the "Sprint 2" development cycle, focusing on class and Union type support.
+*   **Completion Status/Key Observations**: Records observations about `astroid` behavior with classes, methods, attributes, inheritance, and Union types. Discusses how to represent these in the graph.
+*   **Key Relations**: Informal notes supporting `DevelopmentLog.md` and guiding implementation in `src/main.py`.
+*   **Potential Enhancements/Improvements**: Key insights should be summarized and moved to more permanent documentation like `DevelopmentLog.md` or design documents if they exist.
+
+## `generated/` Directory
+
+### `generated/example_graphs/`
+*   **Purpose**: Stores the output DOT graph files generated by `src/main.py` when run on the example Python scripts.
+*   **Completion Status/Key Observations**: Contains `.dot` files like `simple_example.dot`, `class_example.dot`, `module_example.dot`. These serve as visual references and can be used for regression testing (though not formally done yet).
+*   **Key Relations**: Outputs of `src/main.py` using inputs from `examples/`.
+*   **Potential Enhancements/Improvements**:
+    *   Implement automated visual diffing or structural comparison of DOT files for regression testing.
+    *   Ensure graphs are kept up-to-date with code changes.
+```

docs/conversion_patterns.md

@@ -305,6 +305,8 @@ with open("file.txt") as f:
 | Python | C++ |
 |--------|-----|
 | `math.sqrt(x)` | `std::sqrt(x)` |
+| `math.sin(x)` | `std::sin(x)` |
+| `math.cos(x)` | `std::cos(x)` |
 | `random.random()` | `std::uniform_real_distribution<double>(0.0, 1.0)(generator)` |
 | `len(container)` | `container.size()` |
 | `min(a, b)` | `std::min(a, b)` |

docs/core_bug_and_testing_report.md

@@ -16,7 +16,7 @@ a, b = 0, 1  # This causes: AttributeError: 'Tuple' object has no attribute 'id'
 
 This error prevents the tool from processing any Python code with tuple assignments—a common pattern in Python. Since the Fibonacci example uses tuple unpacking, the tool fails to analyze even the simplest example provided.
 
-The bug occurs in `src/analyzer/code_analyzer.py` in the `_infer_variable_type` method when handling tuple assignments. The code attempts to access an 'id' attribute on an AST.Tuple node, which doesn't exist:
+The bug occurred in the now-deprecated `src/analyzer/code_analyzer.py` in the `_infer_variable_type` method when handling tuple assignments. The code attempted to access an 'id' attribute on an AST.Tuple node, which doesn't exist:
 
 ```python
 self.type_info[node.targets[0].id] = f'std::tuple<{", ".join(elt_types)}>'