Slidy+Mathjax presentation example

A few weeks ago, I blogged about using slidy and mathjax for writing presentations. I’ve put together a zip file with an example that allows you to try out this combination (the download link is at the end of this post), and perhaps even get you started at writing the presentation for that conference a few weeks down the road. Here are the instructons for it:

  1. Download and unpack the basic starter kit somewhere. The kit is just a two slide presentation framework with a title page and one page with interesting formulas. It includes some basic css to make the presentation look nice, and a logo I invented in five minutes.
  2. Download the MathJax zip archive, and unpack it into the directory where the slides are. Then rename the directory it made for itself to MathJax. It is important that the MathJax folder is in the same folder as the presentation slides, because otherwise some security features of firefox won’t allow mathjax to use the highest quality mathematics rendering. The issue is described here in more detail.
  3. Unpack the Slidy2 zip archive, also into the same folder as the starter kit.
  4. Open the slides with a current firefox or chromium browser. It should work. Hit F11 to get to full screen mode (and hit it again to return to normal mode).

That’s it.

Tips and tricks

  • You may want to usese firebug to debug the slides and do live repositioning/restyling of elements. This makes designing slides much faster.
  • You can embed videos into the presentations using html5 tags.
  • It is probably a good idea to obtain a decent html editor. I use emacs with nXhtml. It seems also bluefish is a good bet. I didn’t find any of the wysiwyg editors out there particularly useful.
  • If you use emacs, you can use cdlatex mode to edit latex formulas in html documents.
  • There is a lot of information on html and css in the mozilla developer network.

I wish you good luck and fun with the starter kit. Download it here here (click on “file” and select “download original”).

Disclaimer, etc.

There are no warranties of any kind associated with the starter kit.

The contents of the zip file are under the MIT license.


Leave a comment

Finally an alternative to LaTeX for writing mathematical presentations

For some time now I have been looking for an alternative to LaTeX for presenting mathematics. With MathJax, a Javascript package for displaying mathematics on the web, LaTeX lost its monopoly on typesetting equations. And the combination of MathJax with slidy, a framework for authoring presentations in html, finally provides a real alternative to LaTeX.

Until now, I, like most mathematicians, used LaTeX beamer for writing presentations on my research. I had been somewhat unhappy with that solution for some time, for a variety of reasons. One of them is that it is hard to embed anything into a LaTeX presentation. In theory, images are easy to embed, but there is quite a bit of quirkiness associated to that. Movies are a different matter, and it is a familiar sight that speakers interrupt the flow of their slides to launch another application for playing a video. Something fancy like an interactive graph? I have never seen anyone do it in LaTeX. In fact, the only interactive features I ever see are page-up and page-down.

Another problem is that LaTeX doesn’t really work well for the task of making presentation designs, and as a result most designs look clumsy. If you compare the designs that are available for blogs and web pages with the designs in the beamer theme matrix (in particular the yellow one) you will see what I mean. The acceptance of those themes is limited, and I estimate that 30% of all beamer presentations use the default theme, which incidentally is the least decorated. Adding a truetype font, like those you can find here is possible, but difficult and error prone. Granted, maybe it actually is easy, but I haven’t succeeded.

In a quest for alternatives I stumbled upon slidy, and my first impression was that it is much more convenient for creating slides, and that it is easier to get good looking results. Since slidy presentations are web pages, theming is much better supported than with LaTeX. Inserting images and arranging them as desired is very easy, and I look forward to embedding a video using a plugin that works reliably. Typesetting mathematics, the most important reason for using LaTeX, is handled fantastically well by MathJax. MathJax is fully compatible with latex, which means that I can continue to use the very same notation for equations and formulas that I use everywhere else. And the rendering quality of MathJax is completely on par with that of LaTeX.

The main drawbacks are that the presentations do not look exactly the same everywhere, and that it is not as easy to print them to produce handouts. I very rarely see handouts, and I have never produced them myself from slides. Whether it is a problem that the look of presentations is slightly different from device to device is something that I intend to find out. My first impression, though, is that the differences are small enough not to matter. If you use percentages for image sizes then the worst that can happen is that you need to scroll a slide down, or change the font size, which amounts to pressing the ‘-‘ key. Thus, at the moment these drawbacks seem to me like a very small price to pay for something that in other respects definitively looks like a better alternative. I will continue to use latex to write articles, but I am glad that I finally will be able to move away from it for presentations.

1 Comment

ASDF system definition files for Fortran 77 codes

One of the Common Lisp packages that I find very useful is f2cl, originally written by Kevin A. Broughan and Diane M. K. Willcock [1], with recent contributions by Richard J. Fateman and Raymond Toy [2]. It can convert a lot of the Fortran 77 codes out there fairly reliably into quite fast Common Lisp code. The lack of a fancy home page or even a separate project (it is currently part of CLOCC) makes it somewhat hard to find, but should not be taken as a sign of abandon. A more prominent project that uses f2cl is the open source CAS system Maxima.

The advantages of using f2cl over a foreign function interface are, among other things, that the generated Common Lisp code has far better error handling, and is much more convenient to use (for a Common Lisp programmer, at least).

I think it would be nice to have ASDF system definitions for the Fortran 77 packages bundled with f2cl. This would complement the mk:defsystem definitions already available. A small difficulty is that the f2cl compiler has a lot of options, and it is desirable to want to set them globally, eventually overriding them on a file by file basis. At least, this is what is done in some of the .system files. I managed to convince ASDF to do this, but I am not sure if the way i did it is the best solution. From the point of view of OOP this can be (and will be) improved, of course. I’m referring more to the need of things like accessing ASDF symbols that are not exported. In any case, having global options that can be overriden on a component basis looks like a feature one would like to have every now and then.

A typical f2cl .system file looks like this (for example):

(mk:define-language :f2cl
    :compiler #'f2cl:f2cl-compile
    :source-extension "f")

(mk:defsystem minpack
    :source-pathname "clocc:src;f2cl;packages;minpack"
    ((:file "minpack"
		      :language :lisp)
     (:module "minpack"
	      :source-pathname ""
	      :source-extension "f"
	      :package :minpack
	      :language :f2cl
	      :compiler-options (:include-comments t
				 :keep-lisp-file t
				 :relaxed-array-decls nil
				 :array-type :array
				 :array-slicing t
				 :package :minpack)
;; etc

Note that :file components can also have a :compiler-options, although I don’t know how the overriding behavior really is.

To convince ASDF to behave in a similar way, I subclassed the asdf:module class, adding an f2cl-options slot.

(defclass f2cl-module (module)
  ((f2cl-options :initform nil
		 :initarg :f2cl-options
		 :accessor f2cl-options)))

To have an f2cl source file type with corresponding compilation, one does

(defclass f77-source-file (cl-source-file)
  ((f2cl-options :initform nil
		 :initarg :f2cl-options)))

(defmethod source-file-type ((c f77-source-file) (s module)) "f")

(defmethod perform ((o compile-op) (f f77-source-file))
  (apply #'f2cl:f2cl-compile
	 (cons (make-pathname :name (component-name f)
			      :type "f"
			      :defaults (component-pathname f))
	       (compiler-options f))))

But here is the catch. Compiler options have to be computed from the module *and* the file. I did it like this

(defmethod f2cl-options ((c f77-source-file))
  (let* ((c-c-o (slot-value c 'f2cl-options))
	 (p-c-o (when (typep (parent c) 'f2cl-module)
		  (f2cl-options (parent c)))))

    ;; override global options.
    (append c-c-o p-c-o)))


(defmethod parent ((c f77-source-file))
  (slot-value c 'asdf::parent)) ;; Oops

Anyway, it works. Now I am wondering if I overlooked the apropriate feature in ASDF, or another way of doing this. Accessing ‘asdf::parent is good enough for me, but before attempting to contribute .asd files to f2cl, I would prefer to have a more solid solution.

Read the rest of this entry »

1 Comment

Grid Restrained Nelder-Mead

The Nelder-Mead algorithm is a rather popular algorithm for (low dimensional) nonlinear programming. The original version (from 1965, see [1]) has known and varied failure modes, but never really had to fear for its popularity. It doesn’t need derivatives, which can be quite convenient, and has a reputation to work well even with noisy and rough functions.

Recently, a few provably convergent variants have been devised (see [2], [3], and [4]). The one by A. Bürmen et al [4], the “Grid Restrained Nelder-Mead Algorithm” (GRNMA) is notable because it does not impose a “sufficient descent” condition at each iteration, which makes it closer to the original algorithm.

A reliable, simple-to-use derivative free minimization routine is a handy little tool to have around. It turns out that implementing the GRNMA is also a pleasant programming project.

Read the rest of this entry »

Leave a comment

More on the alias method

It turns out that, as pointed out by Jens Axel Søgaard, the method I wrote about a few days ago is the alias method by Walker, as found in D. Knuth’s TAOCP, but with a modification by R. A. Kronmal and A. V. Peterson. Their contribution, it seems, was the algorithm to rearrange the intervals in O(N) operations.

In any case, there is a very good and complete textbook, nowadays available freely on the net, where all these things are explained, disected, and thoroughly overengineered in every good sense of the word. The book is “Non-Uniform Random Variate Generation”, by Luc Devroye (thanks to Brad Lucier for mailing me this great link).

Below you’ll find some additional notes about the method, prompted by reading part of the book, and a link to an updated version of the CL code. (For simplicity, I will write as if in the context of my first post).

Read the rest of this entry »


Slime 2.0

A new version of slime has been released. See here, or download it directly as a gzipped tar archive or as a zip file.

Leave a comment

The Alias Method

Some days ago, there was some discussion in #lisp about how to program a random variable with nontrivial probability distribution. That is, given values x1,…,xn, and probabilities p1,…,pn, how to write a function that randomly returns one of those values with the corresponding probability each time it is called.

It turns out this problem has a beautiful, simple, and efficient solution called the alias method (R. A. Kronmal and A. V. Peterson. On the alias method for generating random variables from a discrete distribution. The American Statistician, 33:214–218, 1979.), that requires only one call to the random number generator. While I haven’t read any complete explanation of it (only the one in R. A. Kronmal, A. V. Peterson, The alias and alias-rejection-mixture methods for generating random variables from probability distributions. Proc. 1979 Winter Simulation Conference (ed. H.J. Highland et al.) 269–280, 1979, which isn’t complete), I think it is highly unlikely that it is different from the method I describe below.

An Common Lisp implementation can be found here.

Read the rest of this entry »



Get every new post delivered to your Inbox.