PagePrint
This provides a simple way
to print a graphic on a single page without header or footer.
I use it all the time at work to produce handouts for presentations.
RandomWalkMetropolis
This package implements the random-walk Metropolis
version of the Markov Chain Monte Carlo (MCMC) algorithm.
MCMC algorithms are used to draw from probability distributions.
To use this package, put the file RandomWalkMetropolis.m in the directory
ToFileName[{$UserAddOnsDirectory, "Applications", "RandomWalkMetropolis"}].
Load the package with Get["RandomWalkMetropolis`"] or
Needs["RandomWalkMetropolis`"].
PagePrint
This provides a simple way
to print a graphic on a single page without header or footer.
DotPlot
The package DotPlot.m defines the function DotPlot,
an enhnaced version of ListPlot combining points with
"connecting" lines that leave a gap near the points. DotPlot
effectively replicates the kind of plot used in Edward R. Tufte's
SpinGraphics
This package defines the function SpinGraphics,
which has the same functionality as SpinShow (from
Graphics`Animation`), except that SpinGraphics returns the list of
graphics objects it produces, facilitating the construction of
animated GIFs, for example.
StereoImagery
The package contains two main functions, MakeStereo and MakeAnaglyph.
MakeStereo takes a Graphics3D object (or SurfaceGraphics object) and
returns a pair of Graphics3D objects viewed from slightly different
angles in a GraphicsArray. Positive values of the option AngularSeparation
correspond to parrallel viewing (as opposed to cross-eyed viewing).
MakeAnaglyph takes a pair of Graphics3D objects (such as the output
of ShowStereo) or a pair of Graphics objects, converts them to
bitmaps (using Rasterize, which uses the portable bitmap format),
removes (1) the green and blue from the left image and (2) the
red from the right image, and combines the two images into one.
MakeStereo was modified from ShowStero by Larry Calmer.
His version was designed to work with external graphics device.
I modified (and simplified and updated) the code to produce a
GraphicsArray in a notebook.
ShowLive
This package provides a function (ShowLive)
that passes 3-dimensional graphics objects
and animations to a "live" window using LiveGrahics3D.
ShowLive.m is adapted from code found at
Omega Consulting. It uses
LiveGraphics3D .
Difference
The file Difference.m contains the code for
Difference for differencing vectors (and higher order tensors).
Difference is implemented using polynomials in the lag operator to
compute the kernel for ListConvolve. Note: There is a Difference
function in the Times Series package available from Wolfram. Loading both
packages creates a name "shadowing" problem.
DateFunctions
This package provides a number of functions to convert dates between list,
string, and integer representations. The options have the same form as
ConversionOptions for Import for "CSV" files. Also included are functions
to convert between dates and index numbers suitable for alignment and plotting.
ItosLemma
This package implements Ito's lemma for any number of
Ito processes with any number of arbitrarily-correlated Brownian motions.
The notebook ItosLemma.nb contains usage examples.
EulerSimulate
EulerSimulate.m provides tools to simulate Ito processes
with using the Euler approximation. Some usage examples are included.
(Previous versions of this package required my package StandardNormal.
This version of the package takes advantage of the speed improvements
to RandomArray in Version 4 of Mathematica.)
MaxEntSimplexDistribution
This package provides functions for working with the Maximum Entropy distribution
on a simplex. It is a useful alternative to the Dirichlet distribution
(for example). A companion paper is available.
JRandomArray
JRandomArray uses JLink to implement a
variety of pseudo random number generators from the colt.jar
Java library. The library includes a number of "random engines"
(including the Mersenne Twister) that drive a number of probability
distributions.
Unfortunately, most of the random number distributions do not produce arrays. However, the tiny class JRandomArray.class computes arrays of random numbers directly in Java, making the overall speed competitive with Mathematica itself. (If you are interested, see the code in JRandomArray.java.)
You will need to modify the line (in JRandomArray.m)
AddToClassPath["d:/data/packages/java"]
to reflect the directory where you place colt.jar and JRandomArray.class.
Note that if you want to produce an array of 10^7 random deviates, you
will probably need to install JLink with the CommandLine
option in order to increase the maximum amount of memory Java is allowed.
(See the notes in JRandomArray.m and JRandomArray.nb.)
Additional information on the colt library
(including documentation) can be found at
http://hoschek.home.cern.ch/hoschek/colt/index.htm
ParticleFilter
This package implements a sampling-importance-resampling particle filter and
backward simulation particle smoother.
MetropolisMCMC
This package implements the Metropolis
version of the Markov Chain Monte Carlo (MCMC) algorithm.
MCMC algorithms are used to draw from probability distributions.
GMM
The package GMM.m implements the Generalized Method of Moments
estimator. This package requires the package EmpiricalLikelihood.m.
EmpiricalLikelihood
The package EmpiricalLikelihood.m implements Art Owen's empirical likelihood
estimator. This package requires the package MetropolisMCMC.m.
YieldCurve
The file YieldCurve.zip contains the Mathematica code files
and the sample data files. The included version of BSplineBasis incorporates
the bug fix. For further information read the included ReadMe.txt.
Bug fix for YieldCurve/BSplineBasis
The file BSplineBasisFix.m contains a bug fix the package
BSplineBasis.m, which is included with the YieldCurve
splining package that accompanied Computational economics and finance:
Modeling and analysis with Mathematica, (1996, Springer-Verlag)
edited by Hal Varian. The file fixes a problem that arose in Version 3
when the internal structure of InterpolatingFunction was changed.
The problem occurs when the option FunctionalForm -> DLogDelta is
set for the function DiscountFunction.
The bug fix covers Versions 3 and 4 of Mathematica.
A comment at the beginning of BSplineBasisFix.m explains
how to use the fix.
User's Guide for YieldCurve
This is a user's guide for the package YieldCurve. The guide was written
when the typsetting capabilities of Mathematica were not as
well developed as now. Consequently, mathematical expressions within the
text is written in TeX (between dollar signs).
AnnuitySolve
The package AnnuitySolve.m is designed to compute the series
solution to a quasi-linear 2nd-order PDE. This PDE is central to
general equilibrium models where the representative agent has
recursive preferences. In such models, equilibrium consumption can be
viewed as a dividend to be capitalized. By a change of numeraire, the
problem can be transformed into an annuity problem.
The notebook AnnuitySolve Examples.nb
provides some examples. The notebook is, however, a work in progress.
GaussianQuadrature
This package provides two functions: GaussianQuadraturePairs and
GaussianProductRule.
GaussianQuadraturePairs produces a list of n abscissa/weight pairs {x,
w} for n-point Gaussian quadrature. Four types of orthogonal
polynomials are supported: HermiteH, LaguerreL, LegendreP, and
ChebyshevT. (The Standard Package NumericalMath`GaussianQuadrature`
computes abscissa/weight pairs only for the LegendreP case.)
WorkingPrecision can be specified (including Infinity). The option
ScalingParameters can be used to rescale the interval and/or weight
function, depending on the type. GaussianProductRule takes a sequence of
pairs (produced by
GaussianQuadraturePairs) and returns a tensor array of abscissa/weight
tuples that can be used for multidimensional Gaussian quadrature.
PartialEvaluation
The file PartialEvaluation.m contains the code for
PartialEvaluation, a debugging tool.
PartialEvaluation[f[args], n]
evaluates the first n expressions in the "main" CompoundExpression
in f[args]. (The position of the "main" CompoundExpression
can be specified by an option.) An arbitrary expression can be appended as an
optional third argument: PartialEvaluation[f[args], n, expr].
DifferentialEvolution
(Note: Differential evolution is built into version 5.0 of
Mathematica as an option to NMinimize.)
The package DifferentialEvolution.m implements a genetic algorithm for optimization. The algorithm is due to Kenneth Price and Rainer Storn (Dr. Dobb's Journal, April 1997).
The algorithm starts with a randomly chosen population of n real vectors, each with d >= 2 components. A cost function is given. (Cost is "negative fitness.") The cost of each member of the current population is determined. Each member then becomes a "target." The target is "mated" with a noisy vector randomly constructed from other members of the current generation to produce an offspring. The offspring replaces the target in the next generation if its cost is lower.
The mate is the sum of a "base" vector (whose construction is described below) and the scaled difference between two randomly chosen vectors. (The scale is given by the "weighting factor.") The offspring is constructed from the target and the mate by randomly choosing "genes" (i.e. components) from either the target or the mate. The probability that a gene comes from the mate is determined by the "cross-over rate." (At least one gene always comes from the mate, even if the cross-over rate is zero.) There are two ways to choose the base vector: (1) the base vector is chosen randomly from the current generation; (2) the base vector is a linear combination of the target and the "best" vector of the current generation (in terms of cost). The linear combination is determined by the "use-best weighting factor."
There is no convergence criterion built in. One simply runs the
algorithm for a given number of generations. Convergence could be
based on the dispersion of the costs or the population.
Back to
Home page for Mark Fisher