.. _homework3: Homework 3 (Due 6 pm, Monday, 10/30/2017) ########################################################################## Please submit your homework to your git repo by **6 pm, Friday, 10/30/2017**. For Problem 1, you also need to make your website viewable online. This means that you need to provide your web address to both Instructor and TA in order for us to view your website (a file ``website_address.txt`` containing your web address under ``hw3/prob1`` directory in your git repo sounds like a good idea!). For each problem in Problems 2, 3 and 4, create a subdirectory for each, e.g., ``hw3/prob1``, etc. and please submit: (i) all your source codes (i.e., all the given example codes with your own modifications. Please work on the codes to add your own modifications, change things, leave comments, etc.), (ii) a short note how to run your codes (e.g., a text file for each problem such as ``Readme.prob2``, etc. which will include compiler flag options, or the use of makefile, etc.), and (iii) a report describing your work/findings (pdf). 1. Let's learn how to host your one personal webpage on a webserver. For this, you are going to setup your own website on the UCSC web server which is freely available for any members of UCSC. Later on, I encourage you learn how to polish your webpage over the quarter, post your academic work, update your research schedules, etc. Please note that you are going to do build a good looking website as part of the final coding project in this class. So, let's begin to learn about it. (1) First step: Go visit the `UCSC website on personal homepage `_ and carefully read the how-to instruction on setting up and publishing your web page. (2) Second step: Login to the webserver using your UCSC ID, say, ``myID`` (where your UCSC email is ``myID@ucsc.edu``) and your CruzID Blue password:: ssh -Y myID@sftp.ic.ucsc.edu and then you're prompted to type in your password which is your CruzID Blue password. Opon login, you will see a directory ``public_html``, where you are going to upload your html files to post your website. At this point, you will see nothing there. (3) Third step: You now need to design your website. What we are going to do is to use `Sphinx `_ in order to build your website. To install Sphinx, you will first need to download *one* of the Python packages (see :ref:`preparations`). For instance, installing `Anaconda `_ will be sufficient. Go to `the Sphinx website `_ and follow the instruction for download, that is:: $ pip install -U Sphinx (4) Fourth step: Upon installing Anaconda and Step (3), you should be ready to use Sphinx to buid your website. Make sure if you can now use a Sphinx command by checking:: $ which sphinx-quickstart $ /Users/dongwook/anaconda/bin/sphinx-quickstart If you don't see a path like this, your Anaconda installation is not complete in the worst case. Most likely you will just need to add your anaconda path in your ``.bash_profile``. For instance, adding a line as the following will fix the problem assuming you installed anaconda under your ``$HOME`` directory, say, ``$HOME/anaconda``:: $ export PATH="$HOME/anaconda/bin:$PATH" and make sure you source it using:: $ source $HOME/.bash_profile or open a new terminal. Now you run the command line:: $ sphinx-quickstart upon which you will see questions for initial configuration and you answer them. This will create a source directory with *conf.py* and a master document called *index.rst*. Don't know what to answer? Don't be afraid, there are default answers at the end of the questions, and you can always go with them first and fix them later. In case you want to fix your setup configuration, you can manually modify *conf.py* file at the top level directory. (5) Fifth step: Watch a quick `Youtube video tutorial on Sphinx `_ and learn how to start working on your webdesign (For example, at this step, you are going to edit those files with *.rst* extensions, beginning with the master file *index.rst*.). When you do this, please make a directory under your git repo (not the course git repo) and work on there. You can name it such as ``Sphinx_web``. So, in case you already have a directory like ``ams209_Einstein``, you should see:: $ ls $ ams209_Einstein Sphinx_web Make sure you make this new directory ``Sphinx_web`` git version controlled, and push it to your own git repo. (6) Sixth step: Upon following the Youtube instruction under your ``Sphinx_web`` directory, you should be able to view your Sphinx website locally. You now want to upload the contents in ``Sphinx_web/_build/html/`` to the remote UCSC website under your account, ``myID@sftp.ic.ucsc.edu``. There are two ways to upload the contents in ``Sphinx_web/_build/html/`` to ``myID@sftp.ic.ucsc.edu:~/public_html/``. (a) First way is to use ``scp`` command:: $ cd Sphinx_web/_build/html/ $ scp -r * myID@sftp.ic.ucsc.edu:~/public_html/ (b) Second way is to use ``sftp`` command (please read more on `sftp `_):: $ cd Sphinx_web/_build/html/ $ sftp myID@sftp.ic.ucsc.edu --> this will log you onto the remote machine sftp.ic.ucsc.edu $ cd public_html $ put -r * ./ During the process of building your web locally on your computer using Sphinx, push your local changes to your git repo, make revision histories, and be free of losing any data! (7) Seventh step: You are now ready to view your online webpage you just posted. Use your web brower to open:: http://people.ucsc.edu/~myID (8) Eight step: Bravo! Congratulation! You just posted your own website on the public domain. Follow *Step 4* in `UCSC website on personal homepage `_ in order to link your site to make more visible. Make sure you let me and TA know about your link address. 2. Practice your Fortran module-based programming by studying the Fortran sample code to find a root of a given function (see :ref:`ch02-fortran-example`). Solve all 8 exercise problems. The sample program implements a `Newton's method `_ by successively searching for a better approximation to one of the roots of a real-valued function. Understanding the sample code is very crucial because the code will serve as a good reference programming example for the following homework problem 3. 3. Let's consider again to solve the :math:`\pi` approximatation problem from Homework 2. This time, however, you're going to program modular based implementations where you need to split your code into several different pieces. The code splitting should be designed carefully based on the role and functionality of each subroutine. Here is a suggestion for the code split and the organization (the followings are just a suggestion and you are welcome to come up with your own code design, which is better!): (a) ``makefile`` (Yes, you will need this) (b) ``pi_driver.F90`` (a driver routine which calls the following subroutines) (i) ``setup_module.F90`` (initialize parameters from reading in a runtime parameter file, say, ``pi_approx.init``. (ii) ``pi_module.F90`` (a module implementation which include a subroutine called ``pi_summation.F90``) (iii) ``pi_summation.F90`` (a subroutine in ``pi_module.F90`` which sums the series to evaluate the approximated :math:`\pi_{appx}`.) (iv) ``pi_errorCheck.F90`` (checks if the :math:`\pi_{appx}` is accurate enough by comparing with a user specific threshold value -- this is one of the runtime parameters in ``pi_approx.init`` file.) (v) ``pi_writeOutput.F90`` (writes output consisting of the iteration history of summation number :math:`N`, :math:`\pi_{appx}`, threshold value, and residual (or diff). Finally, plot the history of approximated :math:`\pi` (:math:`y` axis) versus number of summations :math:`N` (:math:`x` axis) using `GNU plot `_. 4. In this problem, you are going to practice to write four different types of Fortran 90 (potential) coding error, each of which is to be tested and debugged by Valgrind. Your implementations will exercise the following three types of Valgrind Memcheck detections: * Valgrind monitors memory leaks associated with out-of-bound array operations. * Valgrind monitors uninitialized variables. However, it does not complain unless such a variable is used in a way that means its value affects the program's results, that is, the value is printed, or computed with. Simply copying the unitialized data to another variable is of no concern. * Valgrind checks reading/writing memory errors after it has been free'd. Based on the above facts, you are asked to: (a) Write three Fortran routines each of which associates with one of the above three cases. In each case, Valgrind should successfully produce line numbers of potential bugs, or presumably the origin of bugs, in your source files when producing its error message. (b) Write one Fortran routine with any potential issue(s) listed above but Valgrind fails to produce any line numbers when producing its error message. Use the template code below and modify it to do Parts a and b: .. literalinclude:: ./buggy_code_1.f90 :language: fortran :linenos: Make sure you use the Fortran debugging flags to compile your source codes before running Valgrind against your executables. See :ref:`ch02-fortran-debugging`. You need to submit four Valgrind outputs of errors using ``2>``, for example, with ``k=1, 2, 3, 4``: On Mac:: valgrind --leak-check=full --dsymutil=yes --track-origins=yes ./yourExecutable_k 2> output_k On Linux:: valgrind --leak-check=full --track-origins=yes ./yourExecutable_k 2> output_k You should check your solution correctness by being able to produce desired results (i.e., three non-empty results and one empty result) from executing:: grep -in 'f90\|line' output_k