We'll meet at 9am in Altgeld Hall 239 and go over the previous day's projects. Then, we'll cover new concepts with hands-on exercises along the way. Finally, we'll break for lunch at 12:00 until 1:30 and then finish the day with some projects covering the newly introduced concepts.

Discussed printing output, basic expressions, conditionals, functions and looping. Also briefly introduced the assert statement as a rudimentary way to test code.

Introduced a few fundamental data structures in Python: Lists, tuples, dictionaries and sets. Also introduced generator and iterator based techniques in light of some questions which were asked. As a reminder, we saw some compact ways to construct lists, sets and use generators with functions like `min`, `max` and `sum`.

We started out with a brief intro to getting around a Linux system and manipulating files. Then, we saw the basics of opening files and reading and writing their contents. Along the way we covered basic string processing and formatting. We closed the day with some first steps towards basic analysis and visualization on our sample client data using Scipy and Matplotlib.

Today was a broad overview of Numpy arrays and features. We saw how to construct arrays, including helper functions for common ones like uniform subdivision of an interval or a bunch of zeros. We also saw some basic operations, functions and restructuring methods like stacking and reshaping. Finally, we did a little bit of 2D computation and plotting.

Introduced direct and iterative solvers. The main examples we used were the LU-factorization approach to solving systems and GMRES / CG as iterative solvers. Sparse representation also showed up in regard to iterative solvers. Finally, I mentioned conditioning briefly, in the context of wanting small changes in the problem to only induce small changes in the solution. In particular, systems which have nearly linearly dependent columns tend to be poorly conditioned.

Completed our coverage of fundamental numerical linear algebra tools like linear least squares and eigenvalue computations. We applied linear least squares to do some data regression and fitting. We also looked at more general data fitting using Numpy's `polyfit` and `poly1d` interface as well as spline fitting using Scipy's 1D spline interface.

Introduced `odeint` as a way to numerically integrate a single or systems of ODEs. We also saw streamplots as a way to visualize systems of ODEs in the plane. As a first step towards PDEs, we went over the 1D advection equation as an example of a hyperbolic PDE and looked at some basic finite difference methods to solve it numerically. We ended by looking at the Poisson equation as a model elliptic PDE. I showed a short demo of FEniCS, a tool greaded towards solving such problems using finite elements. As complementary tools, I also mentioned Paraview, a powerful data visualizer, and Triangle, a 2D mesh generator.

Outline of directed and undirected graphs and how to work with them using NetworkX. Introduces a few fundamental graph algorithms such as traversal, shortest path, minimal spanning tree and maximum flow.

Covered some basic tools from `scipy.optimize` for solving both unconstrained and constrained optimization problems. As I mentioned, since these have shown up in more recent versions of Scipy, I'm not aware of how they compete with most well-known tools such as the Matlab Optimization Toolbox or CVXOPT. With this in mind, be cautious about how you use them. As always, make sure you do a sanity check on your results and data when using them.

That's it for this summer. Thank you for providing your attention over these last couple weeks. Also, special thanks to Ben Fulan and Pat Szuta for all their help in keeping things running smoothly!

Content developed and curated by Sean Shahkarami: sean.shahkarami@gmail.com