Assignments

Assignments

Notes

• Create a Github repository that will remain fixed for the entire class.
• The repository should be private.
• Add the instructor (gordon.erlebach@gmail.com) and the TA to your repository as collaborators. Allow them to edit.
• Use VSCode together with Github CoPilot for all your assignments.
• Make sure you know how to compile with C++xx, where xx=11, 14, 17 or 20.
• When you don't understand a concept, ask the AI, then the TA, then the instructor. Communicate by email or in person. Be prepared for in-person or Zoom meetings.
• The homework is due precisely 7 days after it is assigned. You CANNOT start early as the homework might change. They were generated by AI, and might be either simplified or made more difficult.
• Include files ending in .h cannot be used. For example, <stdio.h> is not allowed.
• Every homework has its own folder in your github repository, which contains a README.md file that contains the question posed, along with a Makefile.
• There are often multiple approaches to solving each question.
• To generate an executable, construct a Makefile based on the examples shown in class, and execute make (from the commandline)
• Any plot created must have a title, x-axis label, and y-axis label to avoid losing half your points assigned to the plot. Save data to a file and use another program to read data from this file and make the plot.
• The makefile should have a clean section. In other words, the comamdn make clean should remove all executable (.x) and object (.o) files.
• Every function in your submitted C++ source code must be documented both inline and in the associated README.md file.
  • Errors created by AI count against you.

• Your README.md file must be created in Markdown. Make sure you install a Markdown viewer on your computer. Personally, I use Marked 2 on my Mac (cost \$13). Free versions can be found at Free Markdown Editors. Most of the time, I use hyphens for lists, hash tags (#, ##, ###) for headers, and [text](link) for links. Basic latex equations should be surrounded by double dollar signs (for equations on its own line): $$α = \frac{\log x}{β}$$ or single dollar signs, i.e., $α=\frac{\log x}{β}$ to get an equations inline. Code can be included via triple backquotes combined with the required language. Example:

  cpp void main(int argc, char** argv) { return 0 }

• Repository structure

  text Week_#/Question_#/ README.md homework.cpp homework.h Makefile images/ additional_files and folders/ Week_03/Question_1/ ... Week_03/Question_2/ ... Week_04/Question_1/ ...

  where Week_# is Week01, Week02, etc., and Question_# is Question1 or Question2.

Week 1: Introduction and Basic C++ Concepts

Assigned Aug. 28, Due Sept. 5

• Class Demonstration: (not the homework)

  • Task: Implement a program that reads a dataset of temperature measurements over time from a CSV file, normalizes the data to a specific range, and then writes the normalized data to a new file. The file name and the range to normalize to must be read from the command line. A separate program should allow the user to specify the number of time steps and generated the CSV file to be read by the main program homework.cpp. Visualize the temperature as a function of time. Read data from this file and create a line plot of temperature as a function of time.
  • Tool Assistance: Use AI to help structure the file I/O operations and handle edge cases like missing data and file read errors. The AI can help write the code to generate synthetic temperature measurements. You should ask the AI how to enhance your code once you have a basic code running (by copy/pasting your code into the AI).

• Question 1:

  • Task: Create a command-line tool that accepts input parameters (e.g., grid size $N$, initial temperature) for a simple 1D heat distribution simulation on a uniform grid and outputs the initial grid configuration $(x, T)$ to an output file. The input and output files must also be read from the separate command line. As in the previous question, create a separate program to generate the 1D heat distribution. Use Python to plot the initial temperature profile: write the 1D heat distribution to a file and read this file using Python. For the 1D heat distribution, use $T = 1. - x^2$, and the grid is defined by $x ∈ [a, b]$, where $a$ and $b$ are read from the command line, as well as the number of points $N$. It is understood that the homework statement is slightly vague. That means that we can more easily detect if you are copying from each other, which results in a score of zero.
  • Tool Assistance: Use AI to generate boilerplate code for parsing command-line arguments and error handling. Ask the AI for the kind of error handling that would be useful once the code without error handling is created.
  • Grading
    • 5 pts. Functional Makefile.
    • 10 pts. Inline documentation of functions. Errors by the AI count against you.
    • 5 pts. Correct repository structure.
    • 10 pts. Code to handle missing data.
    • 15 pts. Code to handle file read errors.
    • 15 pts. Code to generate the CSV file.
    • 10 pts. Read the temperature file.
    • 10 pts. Write the temperature file out to the file system.
    • 10 pts. Visualize the temperature correctly.
    • 10 pts. README.md file with description of work performed including
      1. A copy of the question asked
      2. documentation for the various functions,
      3. the type of error handling that was implemented (and additional ones that could be implemented),
      4. the visuailzation of the temperature profile,

Week 2: Object-Oriented Programming Basics

Assigned Sept. 5, Due Sept. 12

• Question 1:
  • Task: Extend the Vector class to add operator overloading for the product of a double and a Vector and the dot product. Enhance the Particle class to include both velocity and position, initialize a time vector, and update the particle velocity and position according to the Euler discretization. Visualize particle trajectory in the $x-y$ plane using a Python program. All class properties must be private. Create accessors (get/set) as needed.
  • Tool Assistance: Use GPT-4o to create tests to verify that the code works as expected.
  • More details can be found in the associated pdf file.

Week 3: Memory Management

Assigned Sept. 12, Due Sept. 19

• Question 1:

  • Task: Develop a small memory manager that dynamically allocates and deallocates a 3D grid used in fluid dynamics simulations, using raw pointers.
  • Tool Assistance: Use GPT-4o to review pointer arithmetic and ensure proper memory management techniques are applied.

• Question 2:

  • Task: Refactor an existing particle system simulation to use std::shared_ptr for managing particles' lifetimes, ensuring no memory leaks when particles are removed.
  • Tool Assistance: Use Sonnet 3.5 to automate the conversion from raw pointers to smart pointers and verify memory safety.

Week 4: Advanced OOP Concepts

Assigned Sept. 26, Due Oct. 3

• Question 1:

  • Task: Implement a base class DifferentialEquationSolver and derived classes EulerSolver and RungeKuttaSolver for solving ordinary differential equations (ODEs). Use polymorphism to switch between solvers in a simulation.
  • Tool Assistance: Use GPT-4o to guide the design of the class hierarchy and to ensure the correct implementation of virtual functions.

• Question 2:

  • Task: Define an abstract class BoundaryCondition with concrete derived classes representing Dirichlet and Neumann boundary conditions in a CFD simulation. Implement a simulation that applies these boundary conditions to a grid.
  • Tool Assistance: Use Sonnet 3.5 to generate code templates for the abstract class and derived classes, ensuring proper inheritance and implementation.

Week 5: Templates and Generic Programming

Assigned Oct. 3, Due Oct.10

• Question 1:

  • Task: Create a template class Matrix<T> that supports basic matrix operations (addition, subtraction, multiplication). Use the class to perform operations on matrices of double and float types.
  • Tool Assistance: Use GPT-4o to ensure type safety and proper template syntax, and to assist in implementing generic operations.

• Question 2:

  • Task: Implement a variadic template function to compute the product of an arbitrary number of matrices, simulating a series of coordinate transformations in computational geometry.
  • Tool Assistance: Use Sonnet 3.5 to generate the base case and recursive template function, ensuring correct handling of multiple parameters.

Week 6: The Standard Template Library (STL) Part 1

Assigned Oct. 10, Due Oct.17

• Question 1:

  • Task: Use std::vector to store and manage a dynamic list of particles in a molecular dynamics simulation. Implement functions to add, remove, and iterate over particles, updating their positions.
  • Tool Assistance: Use GPT-4o to ensure efficient use of std::vector, including understanding capacity management and avoiding unnecessary reallocations.

• Question 2:

  • Task: Implement a heat distribution simulation on a 2D grid, where std::unordered_map maps grid points to temperature values. Optimize access to temperature data using the map.
  • Tool Assistance: Use Sonnet 3.5 to generate optimized lookup functions and to ensure correct use of std::unordered_map.

Week 7: The Standard Template Library (STL) Part 2

Assigned Oct. 17, Due Oct.24

• Question 1:

  • Task: Use std::list to manage a queue of tasks in a simulation, where each task represents a different time step or process to be executed. Implement functions to enqueue, dequeue, and execute tasks in order.
  • Tool Assistance: Use GPT-4o to generate examples of managing tasks with std::list and to explore the trade-offs compared to other containers like std::deque.

• Question 2:

  • Task: Store multiple properties of a simulation result (e.g., time, energy, entropy) in a std::tuple. Implement a function that returns this tuple, and use structured bindings to unpack the values.
  • Tool Assistance: Use Sonnet 3.5 to write and test the function returning a std::tuple, ensuring correct usage of structured bindings.

Week 8: Algorithms and Data Structures Part 1

Assigned Oct. 24, Due Oct.31

• Question 1:

  • Task: Implement a binary search tree to store and retrieve simulation parameters (e.g., material properties) indexed by a key. Include functions to insert, search, and delete nodes in the tree.
  • Tool Assistance: Use GPT-4o to assist in writing efficient search and insertion functions, and to explore balancing the tree if needed.

• Question 2:

  • Task: Create a linked list to store the history of states in a time-stepping simulation. Implement functions to traverse the list, retrieve a specific state, and rollback the simulation to a previous state.
  • Tool Assistance: Use Sonnet 3.5 to verify the linked list implementation and explore different traversal techniques.

Week 9: Algorithms and Data Structures Part 2

Assigned Oct. 31, Due Nov. 7

• Question 1:

  • Task: Implement a recursive algorithm to solve the N-body problem, simulating gravitational interactions between celestial bodies using a divide-and-conquer approach.
  • Tool Assistance: Use GPT-4o to help with optimizing the recursion and managing the computational complexity.

• Question 2:

  • Task: Solve the Tower of Hanoi problem using recursion, and extend the problem to simulate a recursive operation in a scientific context, such as refining a mesh in finite element analysis.
  • Tool Assistance: Use Sonnet 3.5 to visualize the recursion steps and ensure the implementation is correct.

Week 10: Modern C++ Features Part 1

Assigned Nov. 7, Due Nov. 14

• Question 1:

  • Task: Optimize a large matrix manipulation operation in a finite element analysis program by implementing move semantics, reducing unnecessary data copying.
  • Tool Assistance: Use GPT-4o to refactor existing code to use move semantics, identifying areas where copy operations can be avoided.

• Question 2:

  • Task: Implement a function template that forwards arguments to another function, useful for passing parameters efficiently in computational kernels.
  • Tool Assistance: Use Sonnet 3.5 to write and test the function, ensuring proper use of universal and forwarding references.

Week 11: Modern C++ Features Part 2

Assigned Nov. 14, Due Nov. 21

• Question 1:

  • Task: Use lambda expressions to implement a numerical integration method (e.g., trapezoidal rule), where the function to integrate is defined as a lambda.
  • Tool Assistance: Use GPT-4o to ensure the lambda syntax is correct and to explore the flexibility of passing lambdas as arguments.

• Question 2:

  • Task: Enhance the robustness of a numerical solver by adding exception handling with std::exception_ptr, ensuring that the program can recover from runtime errors.
  • Tool Assistance: Use Sonnet 3.5 to generate exception handling boilerplate code and test various scenarios that could cause exceptions.

Week 12: Multithreading and Concurrency Part 1

Assigned Nov. 21, Due Dec. 3

A few extra days to account for Thanksgiving.

• Question 1:

  • Task: Parallelize a Monte Carlo simulation using std::thread and ensure thread-safe access to shared resources (e.g., random number generators) using std::mutex.
  • Tool Assistance: Use GPT-4o to help design the threading model and implement safe locking mechanisms.

• Question 2:

  • Task: Implement an atomic counter using std::atomic to track the number of completed tasks in a parallel processing environment, ensuring consistent results across threads.
  • Tool Assistance: Use Sonnet 3.5 to explore atomic operations and validate the correctness of the counter in a multithreaded context.

Week 13: Multithreading and Concurrency Part 2

Assigned Dec. 3, Due Dec. 10

Finals begin Dec. 9

• Question 1:

  • Task: Use std::async to launch parallel tasks for a large matrix multiplication, ensuring that shared data is protected using std::scoped_lock.
  • Tool Assistance: Use GPT-4o to explore different parallelization strategies and measure the performance gains.

• Question 2:

  • Task: Measure and compare the execution time of different numerical algorithms (e.g., direct vs. iterative solvers) using std::chrono.
  • Tool Assistance: Use Sonnet 3.5 to

implement the timing functions and visualize the performance comparison.

Week 14: Miscellaneous Topics and Final Review

Homework is optional, and not graded. Consider it a challenge.

• Question 1:

  • Task: Implement safe and efficient type casting in a polymorphic simulation framework, where different types of solvers might need to be cast between base and derived types using static_cast, dynamic_cast, const_cast, and reinterpret_cast.
  • Tool Assistance: Use GPT-4o to review the appropriate use cases for each type of cast and implement them in a practical context.

• Question 2:

  • Task: Apply the knowledge from the course to optimize a simple scientific computing program, such as modeling heat diffusion in a 2D plate, using a combination of the techniques learned.
  • Tool Assistance: Use Sonnet 3.5 to analyze the program’s performance, identify bottlenecks, and suggest optimizations.

This structured set of homework problems ensures that students can apply their learning directly to scientific computing tasks while leveraging AI tools to deepen their understanding and solve complex issues effectively.