Numerical Methods for Partial Differential Equations

Documents and resources

Here are some resources in PDF files.

• The previous Scheme standard. Use this to find out what is in standard Scheme; there are a lot of very general mathematics functions in Scheme, see the examples.
• The Gambit Scheme manual. Important parts to know are the interpreter, the compiler, the debugger, declarations, loading and including files, and homogeneous vectors.
• The Meroon manual. The first project describes the differences between Meroon as described in the manual and how it's installed here.

To learn how to program in this style, work through the first two chapters of the Structure and Interpretation of Computer Programs.

There are sources for various software packages.

• Gambit web site. You can download install packages for Windows and MacOS or source you can build yourself. (It's not that hard on Linux/MacOS/Unix/BSD/...:

  ./configure CC='gcc -special-options-here' --prefix=/where-you-want-to-stick-it --enable-single-host
  make
  make install

  The "where-you-want-to-stick-it" part defaults to /usr/local/Gambit-C/. The special options might include "-m64 -march=your-architecture", where your architecture might be "nocona" on a Core 2 Duo or "970" or "G5" on a Power Macintosh G5.
• The Meroon sources. This is easy to build, just:

  tar zxf MeroonV3-2008Jan10.tgz
  cd MeroonV3-2008Jan10
  ./make_meroon

  Unfortunately, this will take a few gigabytes of memory to compile, and the default Gambit installer on MacOS builds both Intel and PowerPC versions at the same time, so if you want to build Meroon on MacOS you should download the Gambit sources and build it yourself.
• And, there is the software page for this class.
• There is now an updated software page for this class. Functionally, there are few changes, but it has been cleaned up (instead of numerical declarations, it uses R6RS-type flonum- and fixnum-specific operations (fl+, fl-, fl*, fx+, fx-, fx*, etc.) and makes some utility functions more general).

Project suggestions

I've collected some suggestions for projects. You don't need to choose a project from this list, you can choose any other project with my approval. You will need to choose a project soon after spring break. If we haven't yet covered a project on this list yet (for parabolic problems, hyperbolic problems, etc.) then look in the textbook to see what these problems are like and decide whether you'd like to work on them.

Exercises and notes

• The first draft of the first part of the first project (just to get you going with Scheme/Gambit/Meroon).
• The zeroth draft of the second part of the first project (lots of typos, unfortunately).
• Note: Your code should not depend on the implementation technique of terms or termlists. The code in SICP uses lists for both terms and termlists of polynomials, but that can be confusing, especially for debugging. So here is some code that, first, checks the invariants of polynomials that there should be no zero coefficients and the terms should be in decreasing order (look at the Meroon documentation for initialize!), and, second, gives two alternate implementations of terms and termlists. Your code should work no matter the implementation strategy of terms or termlists.

  (define-class Polynomial Object
    ((= variable immutable:)
     (= terms    immutable:)))
  
  (define-method (initialize! (p Polynomial))
    (let ((terms (Polynomial-terms p)))
      ;; check that
      ;; (a) termlists are in decreasing order
      (let loop ((terms terms))
        (cond ((or (empty-termlist? terms)
  		 (empty-termlist? (rest-terms terms))))
  	    ((> (term-order (first-term terms))
  		(term-order (first-term (rest-terms terms))))
  	     (loop (rest-terms terms)))
  	    (else
  	     (error "initialize! for Polynomials: terms are not in decreasing order" p))))
      ;; (b) check that coeffs are not zero
      (let loop ((terms terms))
        (cond ((empty-termlist? terms))
  	    ((not (zero? (term-coeff (first-term terms))))
  	     (loop (rest-terms terms)))
  	    (else
  	     (error "initialize! for Polynomials: not all term coefficients are zero" p))))
    (call-next-method)))
  
  
  ;; implementation of termlists using Meroon objects
  
  (define-class kons Object
    ((= kar immutable:)
     (= kdr immutable:)))
  
  (define (the-empty-termlist)
    'empty-termlist)
  
  (define (first-term termlist)
    (kons-kar termlist))
  
  (define (rest-terms termlist)
    (kons-kdr termlist))
  
  (define (empty-termlist? termlist)
    (eq? termlist (the-empty-termlist)))
  
  (define (adjoin-term term term-list)
    (if (=zero? (term-coeff term))
        term-list
        (make-kons term term-list)))
  
  ;; end
  
  #|
  ;; implementation of termlists using lists
  
  (define (the-empty-termlist)
    '())
  
  (define first-term car)
  (define rest-terms cdr)
  (define empty-termlist? null?)
  (define (adjoin-term term term-list)
    (if (=zero? (term-coeff term))
        term-list
        (cons term termlist)))
  
  ;; end
  |#
  
  ;; the following works no matter the definition of termlist
  
  (define (empty-termlist? termlist)
    (equal? termlist (the-empty-termlist)))
  
  #|
  ;; implementation of terms using Meroon objects
  
  (define-class term Object
    ((= order immutable:)
     (= coeff immutable:)))
  
  ;; end
  |#
  
  ;; implementation of terms using cons
  
  (define make-term cons)
  (define term-order car)
  (define term-coeff cdr)