Version 0
	Initial release at Agent2003 Conference

Version 1
	mason and mason3d directories collapsed.
	mousetraps application included.
	Various small bugs squashed.
	Documentation updated.
	Known bug: 3D Heat information not provided (bug in inspector)

Version 2
	sim.app.networktest.CustomNode now specifies its font
	sim.portrayal.FieldPortrayal's CustomInspector properly sets its
		SimState instance variable.  This enables 3D HeatBugs, among
		other things, to properly update their inspectors.
	Various static variables converted to instance variables to
		facilitate simultaneous parallel models in one
		process.
	Improved class docs
	Moved the color mapping functionality out of FastValueGrid2DPortrayal
		and ValueGrid2DPortrayal.  Now they use sim.guil.ColorMap.
		This is slightly slower; however we've compensated with an
		improved code in ColorMap so it's about the same speed still.
		This change will require applications which use these 
		portrayals to change themselves slightly: no longer is there
		a setLevels() or setColors() function -- it's gone -- and 
		instead, there's a setMap() function which does the same
		thing.  See HeatBugsWithUI.java for an example of how to
		convert over (it's a one-line change).
	The info HTML page may now be loaded in the Console via a file
		rather than specified by a string.  See GUIState.getInfo()
	Fixes to 3D inspectors to avoid flashing
	Cleanups and fixes to 3D applications
	2D displays update when their options are modified (in the wrench 
		window)
	Bug fix so 2D display backgrounds are striped rather than white
		in MacOS X Panther (10.3)
	Reformatting
	MacOS X Panther 1.3.1 has a bug which causes a number of drawing
		events to reset the clip afterwards (messing up later
		drawing events).  I don't know HOW they messed this up.
		We've only worked around this where it wouldn't impact
		redrawing significantly: clips are set before stretched
		image drawing, before drawing sparse grids (because
		they're often circles, which trigger the bug for some
		reason).  Expect a slight slow-down in sparse grid
		graphics until Apple fixes this stupidity and we can
		remove our fix hack.
	New nifty Makefile
	Released at the 2003 Workshop on the Mathematics and Algorithms
                of Social Insects

Version 3
	Scale can no longer be 0
	Display2Ds may be offset (see the options pane -- useful
		for Tutorial 5 and Lsystem).  Lsystem's offset facility
		has been eliminated as a result.
	If the inspector pane has been removed, switching to it will no
		longer generate an error -- it just won't do anything
	LabelledPortrayal2D added.  This is a "wrapper Portrayal" which
		is meant to use an underlying portrayal to draw the
		main object -- then LabelledPortrayal2D will add a label.
	Added some Triangular grid code to the Grid2D objects.  No
		FieldPortrayal yet tho.
	CircledPortrayal2D added.  Another "wrapper Portrayal" which
		draws a circle around the underlying portrayal.  Will
		be useful for showing selection.
	Added sim.util.DoubleDimension2D, which is a concrete subclass
		of Dimension2D that stores dimension information as
		doubles.  For some reason Java doesn't have such
		a class (nor a "FloatDimension2D") -- it only has
		Dimension (for ints).  Yet it has equivalents for
		Point2D (Point2D.Double, Point2D.Float, Point),
		Rectangle2D (Rectangle2D.Double, Rectangle2D.Float,
		Rectangle), etc.  Totally inexplicable.  Anyway, this
		class should make the new movement and selection APIs
		easy to implement.
	Partially implemented the movement and selection APIs in
		FieldPortrayal2D and SimplePortrayal2D.  More yet to
		do however.
	Modified sim.util.Indexed so that it has consistent naming
		(setValue and getValue).  Neither approach is good,
		but this is better.  Updated Bag, DoubleBag, IntBag
		with the new function name.
	Made DoubleBag Indexed.  Dunno why it wasn't.
	Slight bugfix which properly brings up the dialog box when
		jmf.jar is missing but the user asks to make a movie.
	Modified PropertyField to be able to switch among property
		display styles.
	Replaced deprecated getClipRect() with getClipBounds.  Dunno
		why we didn't see that earlier.  No biggie.
	Bug fix to Bag.resize(), IntBag.resize(), and 
		DoubleBag.resize().  If requested size to resize to
		is the same size as the bag, now nothing happens.
		Previously the bag doubled in size.
	Bug fix to [Double|Int|]Bag.addAll(...).  numObjs was not
		being correctly changed.
	Addition of [Double|int|]Bag.doubleCapacityPlusOne() private
		function in order to bring add(...) and push(...)
		back under 35 bytes for inlining.  Couldn't use
		normal resize() function because it wasted a few
		bytes (ARG!!!)
	Added a little efficiency to SparseField.getObjectsAtLocations,
		SparseGrid[2|3]D.getObjectsAtLocations, and
		Continuous[2|3]D.getObjectsWithinDistance: if the
		discovered object bags are null or empty, they're
		not added to the result; if they're 1 they're added
		using Bag.add, and if the're > 1 in size they're
		added using Bag.addAll.  With any luck this should
		be a bit faster.	
	Added some further discussion in the hashCode() code for
		Int2D, Int3D, Double2D, and Double3D.  We may want
		to simplify the code to make it faster, though it
		is of very high quality, particularly for Java
		1.4.1.  Any comments would be welcome.
	Bag Iterators now allow remove(), and next() now throws
		an exception if we're at the end, rather than
		returning null.
	Major revisions to Display3D and various portrayal3D objects,
		including complete revisions of updating and creating
		scene graphs, updating and creating models,
		transformations, facility for resetting rotations 
		etc. on option panel, etc.  This will NOT be very
		backward-compatible, sorry.  But now we have a 
		more orthogonal approach to 3D, and the start() and 
		init() methods in the example applications are much 
		cleaner and simpler.
	Added Oriented2D and OrientedPortrayal2D to make it easier
		to describe oriented objects.  OrientedPortrayal2D
		is yet another "wrapper portrayal".
	Display3D no longer puts a black band at the bottom of
		pictures and movies (oops).
	getPolygonAttributes is now polygonAttributes in order to
		prevent it from showing up as a property in the
		inspector.
	Addition of CircledPortrayal3D, LabeledPortrayal3D, and 
		TransformedPortrayal3D "wrapper portrayals", the equivalent
		of their counterparts in 2D more or less.
	Addition of ConePortrayal3D, CylinderPortrayal3D,
		(untested)Shape3DPortrayal.
	Removed FixPortrayal3D.  Added SharedGroupPortrayal3D in its place.
	Removed DirectionalLightPortrayal3D and replaced it with
		the general LightPortrayal3D.
	Added Scale to the Display3D.  This is different from zoom.  Scale 
		magnifies.  Zoom moves the eye closer to center (and thus 
		possibly past some objects which are now behind you).
		We may remove this if it proves too confusing.
	Modified ImagePortrayal2D so that it no longer requires square images 
		(or tries to squish them into a square).
	Added ImagePortrayal3D
	fastgridcell package renamed to quad package
	GridQuadCellPortrayal renamed to QuadPortrayal.
	MeshCellPortrayal renamed to MeshPortrayal.
	TileGridCellPortrayal renamed to TilePortrayal.
	NoZGridCellPortrayal deleted (it's the same as TileGridCellPortrayal 
		at 0 z scale)
	Color map and scaling moved into QuadPortrayal.
	setData() method on QuadPortrayals now has a width and a height.  
		Accordingly all QuadPortrayals have had changes in their 
		constructors.
	QuadPortrayals now have their getName() methods called.  Previously 
		that was interrupted by the ValueGrid2D3DPortrayal which used 
		its own getName method.
	GridCellInfo renamed to ValueGridCellInfo
	Display2D now creates BufferedImages using getGraphicsConfiguration
		rather than the older way of just using Component.createImage
		and casting it to a BufferedImage and hoping for the best. :-)
	Moved Axes to 3D Options.  Added the ability to have a backdrop.
	Can now turn on/off left/right vs. up/down rotation and translation
	Can now autospin negative values.  Still don't know what to think about
		bugs in Java3D's handling of autospinning.  :-(
	Added Tutorial6 and Tutorial7
	Display3D used to hang until you moved the mouse if there's *no* 
		change to the underlying model in-between steps.  This is due 
		to a stupidity in Java3D.  Now we get around that by adding a
		single (supposedly invisible) point and reset its location
		each timestep.
	Fixed little bug in GUIState which generated a null pointer exception
		when trying to load the index.html and discovering that one
		doesn't exist.  Oops!
	If the user doesn't set the location of the Console in the GUIState's
		init() method, then the Console will attempt to place itself
		to the far right of the rightmost attached window; if there
		is no room, it'll go to the default location.
	Bug fix to Bag.iterator.next() and Bag.iterator.remove(); they had
		a comparator wrong and thus were always throwing exceptions.
		Thanks to Matthew Nelson (mnelson@mailsnare.net).
	SimpleInspector has slightly more space between labels and widgets
	Added the (temporary) convert and convert_h scripts and UPGRADING
		file to help upgrade
	SwarmGame added
	null inspectors not added to the list.
	GREAT RENAMING.  We've renamed all the 2D and 3D field portrayals 
		to be consistent with the rest of the system.  Well, more 
		consistent.  Anyway, it's better than it used to be.  Now 
		the system is as follows: if a 2D field portrayal can handle 
		(or will in the future be able to handle :-) both 2D and 3D 
		fields, it's called FooPortrayal2D.  Similarly, a 3D field 
		portrayal would be FooPortrayal3D.  If the field portrayal 
		is designed specifically for 2D fields only, it's 
		Foo2DPortrayal2D or Foo2DPortrayal3D.  Similarly for 3D fields 
		only...  At present none of the 2D field portrayals can display 
		3D fields; but they will in the future so they're named
		appropriately.  Renamed portrayals:

		ValueGridPortrayal2D
		FastValueGridPortrayal2D
		HexaValueGridPortrayal2D
		ObjectGridPortrayal2D
		HexaObjectGridPortrayal2D
		SparseGridPortrayal2D
		HexaSparseGridPortrayal2D
		ContinuousPortrayal2D
		NetworkPortrayal2D
		ValueGrid2DPortrayal3D
		SparseGrid2DPortrayal3D
		SparseGridPortrayal3D
		ContinuousPortrayal3D

	Changed some demos to use loaded index.html files rather than embedded
		HTML.  No particularly good reason other than demonstration.
	MAVs in the MAV demo no longer can have their size changed.  This is
		because we're using OrientedPortrayal2Ds and OvalPortrayal2Ds
		to portray the MAVs rather than having them portray themselves,
		also primarily for demonstration purposes.  To see a portrayal
		which changes its size, Tutorial5 is useful.
	Set Oriented2D's sole method to be "orientation2D" rather than
		our original "get2DOrientation".  The reason is that we don't
		necessarily want it showing up as a property of the underlying
		object.  It's in radians rather than degrees (the Java3D stuff
		we've done is in degrees) because the vast majority of time
		you'll already have it in radians:  Math.atan2(dy,dx).  So
		yeah, an inconsistency there...

Version 4
	Added a main() to sim.display.Console so that if you run
		java sim.app.Console
		... you're presented with the ComboBox of available simulations
		and can choose one immediately.
	Fixed some bugs in the Makefile indent feature
	Slightly modified the stx and tx functions and documentation so that
		they'd run a little faster in some cases.
	Fixed a bug where if a Display2D was playing, then pressing the movie 
		button would hang the bug.  Now the behavior is that pressing
		the movie button temporarily pauses the Display2D (if it's 
		playing), and cancelling will unpause again if necessary.
	Similar fix in Display3D.  This required making Console.getPlayState() 
		public, which shouldn't be much of a problem (probably would be
		useful anyway).  Similarly, when the user does Open... in the 
		Console, the current simulation is paused (if it's playing).  
		The new model is still opened in a paused state.  But if the 
		user cancels, we automatically unpause again if necessary.
	Fixed a documentation bug in MersenneTwisterFast that suggested that
		nextDouble() returned a number in [0,1].  It does not.  
		It's [0,1), just like java.util.Random.
	MovieMaker now displays its default frame rate as the frame rate
		of the simulation currently.
	SimulatorLayout.graffle and SimulatorLayout.pdf updated.
	Added hardware acceleration for old Powerbook G4s and iBooks
	Switched to using TYPE_INT_ARGB_PRE for buffers in 
		FastValueGridPortrayal2D as it's supported natively by MacOS X
	convert and convert_h removed
	removed UPGRADING
	new [Int|Double|]Bag(bag) can accept a null bag now
	[Int|Double|]Bag all have new fill(), sort(), reverse(), and shuffle()
		methods.  The shuffle method will make [Int|Double|]Bag reliant
		on ec.util.MersenneTwister; but you can snip that out if you
		don't need it.  Suggestion by Russ Abbott rabbott@calstatela.edu
	Added numObjectsAtLocation per suggestion by Norman Makoto Su 
		(normsu@uci.edu).  Also modified Continuous[2|3]D documentation
		to warn against using numObjectsAtLocation or 
		getObjectsAtLocation, both of which look up discretized regions
		and that'd give unexpected results.
	Console's JEditorPane is now public.  Suggestion by Russ Abbott
		rabbott@calstatela.edu
	Well, it appears that changing to TYPE_INT_RGB_PRE in fact is SLOWER
		on MacOS X 1.3.1. By 1/3!  So we're undoing that change.
	Released at the 2004 SwarmFest conference

Version 5
	Fixed bug in 2D offset -- they weren't being considered for hit testing
	Continuous[2|3]D's toroidal neighborhood had a bug where objects on the
		0 x or y or z border weren't grabbing values wrapped around, due
		to truncation of negatives rather than flooring them.
	Bags, IntBags, and DoubleBags can be initialized with a given capacity
	Added toroidal distance functions to Continuous2D and Continuous3D.
	Console's JEditorPane now has a back button and properly handles 
		hyperlinks.  Of course, now that the JEditorPane is public,
		people can mess this up if they please -- we trust you to
		be gentle.
	Made the DEFAULT_... stuff in [Oriented|Circled|Labelled]Portrayal2D 
		final.
	Added two more shapes to OrientedPortrayal2D options
	Added new Flockers demo

Version 6
	Fixed minor bug in ObjectGridPortrayal2D which displayed null object
		slots as "null" in the inspectors.
	Fixed bugs in tx/ty/tz: if the width/height/length is >= half the
		maximal size of an integer, the toroidal computation doesn't
		work properly.  In the process of fixing it we got rid of a 
		modulo, so they probably run faster now as well.
	Slight improvements in the speed of 
		Continuous[2|3]D.getObjectsWithinDistance(...).  I believe
		that it should still run correctly for all possible values
		of width, height, and length (see tx/ty/tz fixes above),
		but uses slightly less code and a few minor speedups.
	Slight fix to [Int|Double|]Bag.resize method so it doubles in size
		more often (correctly)
	Fix to our recent Continuous[2|3]D fixes: non-point objects
		now properly increase the size of the lookup.  Maybe we
		should revisit the non-point object issue in the future and
		consider a different approach (perhaps increasing the range
		of the lookup by exactly the maximum dimension of the
		object?)
	Added toPoint() to Int2D
	Bug fixes in CollectionProperties' handling of Bags etc.  I think
		we should move to a table mechanism anyway.
	In order to implement ObjectGridPortrayal3D, it's necessary to
		modify the completedWrapper(...) function to include
		a PickResult object as well.  We could deprecate the
		older function and create a new one which default calls
		the older one; but I highly doubt anyone is creating 3D
		fields at this time, so we'll just go ahead and modify it.
	Added ObjectGridPortrayal3D
	ObjectGrid3D's field moved from Bags (why was this here?) to Objects
	Deleted extraneous HeatBugPortrayal3D code
	Fixed bug in SparseFieldPortrayal3D and SparseGrid2DPortrayal3D which
		wouldn't properly handle new models created during getModel()
	Heavy bug fixes to ObjectGridPortrayal3D
	ValueGrid2DPortrayal3D allows cells to be displayed EITHER as squares
		or as two triangles.  This is because squares trigger a Java3D
		bug (well, Sun insists its a "misfeature" that's part of the
		spec, but IT'S A BUG) where squares bent at strong angles
		won't pick right, so selecting them goes all haywire -- the
		wrong squares get selected by far.  Why not just do it always
		as two triangles?  Why bother with the option?  Because if
		you just show the mesh's lines, the diagonal line of the
		triangles shows up.  That's the only reason.
	Gouraud Shading added to ValueGrid2DPortrayal3D's cells.
	Previously if you loaded a simulation from checkpoint in the Console
		while STOPPED, what happened was that pause() was pressed
		first.  This resulted in a fresh model getting spuriously 
		start()ed and then immediately wiped out by the newly-loaded 
		model.  This confused people who saw a start() happening
		even though it was generally harmless.  But we've modified
		Console.doOpen() now so that this doesn't happen.  To do 
		this we've modified Console.pressPause() so that it now 
		calls an underlying pressPause(bool) which optionally does
		startSimulation() only if in stopped mode and bool == true.
		Thus we can control whether or not pausing the model in
		stopped mode starts the simulation proper.
		All this is no big deal, I think (hope!).
	Modification to HeatBugs.setRandomMovementProbability() so it doesn't
		change all the bugs' probabilities mid-stream.  This helps
		us in an upcoming parameter-loading tutorial.
	Hard-code-inlined Int2D and Int3D's hash codes into Double2D and
		Double3D, eliminating the hashCodeFor() function which
		couldn't get inlined.  This saves us a few percent on
		Flockers etc.
	Added FastHexaValueGridPortrayal2D
	Moved the Buffering property up to FieldPortrayal2D.
	Modified hexabugs's model inspector to show how you can change
		the two kinds of hex grids
	All FieldPortrayals now store three new instance variables:
		an Object called field, an immutableField boolean, and a 
		dirtyField boolean.  This promoted the field and immutableField
		variables up from FieldPortrayal3D.  In the process we have also
		eliminated all references to instance variables called field
		in various FieldPortrayal2Ds; they all now use the central field
		variable (which is an Object) and so must ensure its validity
		in the setField(...) method (which they already do).  Added some
		lines at the beginning of relevant methods which say basically
			final MyFieldType field = (MyFieldType) this.field;
		for compatability with existing code.  The dirtyField flag
		is supposed to be set during all setField() operations and
		cleared (if the field cares about immutableFields at all).
	Tutorial 4 had referenced SparseGridPortrayal2D's field variable;
		now that it's an Object and not a SparseGrid2D (and it's not
		public any more also), we replaced it with getField().
	Console now kills all existing inspectors and rebuilds the model 
		inspector (if there is one) when the user loads from a 
		checkpoint.  Oops, we should have done that before!
	Replaced SelectionBehavior.SetInspectorsRunnable with a smaller,
		simpler anonymous class.
	Random number seed now shown when the model is first displayed.
	When a model is loaded from a checkpoint, who knows what the random
		number seed is; so we display "Unknown" instead.
	When the user enters an invalid random number seed, it's replaced with
		the original seed (previously we had been randomizing it).
	We were not performing the specified check for valid classes when
		loading simulations in the Console (validSimState()).
		Now we do.
	Additional minor functions added to Schedule
	Fixed a bug in Schedule.scheduleRepeating(event,interval) which
		scheduled for time() and not time()+1.
	Reduced the division count in spheres used for Woims3D from 15 to 6.
		This makes it usable at 200-300 Woims (by default it's 40).
		With 15 divisions, for 200 woims you have about 15*200*4=12,000
		polygons which for Java3D is horribly unusable, at least on 
		a Mac powerbook (our test). Here's hoping Java3D speeds up now
		that it's open source.
	Added some clearCapabilityIsFrequent(...) statements to possibly improve
		Java3D optimization
	Makefile revisions
	Tiny speed tweaks to SimpleColorMap
	Made MutableDouble a subclass of Number
	NetworkField.getEdgesOut(...) and NetworkField.getEdgesIn(...) no longer
		return null if there are no edges.  Instead they return an empty
		Bag.  In fact, they all return the *same* empty Bag.  This is 
		okay because your contract is to never modify the Bag returned 
		by these methods.  Modified NetworkPortrayal2D and NetworkField
		in a few places to obviate the need to do a null check as
		a result.
	Added NetworkField.getEdges(...)
	Added Edge.getWeight(...)
	Added methods to [Int|Double][2|3]D which bring them to approximate
		parity with Point2D.
	Added NetworkField.getAdjacencyMatrix(...) and
		NetworkField.getMultigraphAdjacencyMatrix(...)

Version 7
	Added Edge.getOtherNode(node), which simplifies algorithms which operate
		both on directed and undirected graphs.
	Bug fix to ImagePortrayal3D to set oriented polygon attributes without
		triggering a null pointer exception
	FieldPortrayal3D.defaultPortrayal now protected
	Added ColorMap.getAlpha(value), which simplifies some Java3D stuff.
	Fixed a bug in ParallelSequence which generated an error if the
		model thread was interrupted while waiting for the
		ParallelSequence to finish up.
	Worked around a MacOS X bug where if a Canvas3D is in a window which is
		hidden and then reshown, the Canvas3D doesn't redisplay itself.
	Worked around a Linux bug where if a Canvas3D is in a window which is
		hidden, the whole Java3D system hangs until the window is
		reshown.
	Added MutableInt2D and MutableInt3D, and modified SparseGrid2D,
		SparseGrid3D, Continuous2D, and Continuous3D to take advantage
		of the mutable versions.  MutableInt[2|3]D is hash-equivalent 
		with Int[2|3]D, and can be used to look up objects in hash
		tables keyed internally by Int[2|3]D.  This is helpful because
		normally in these SparseFields, lots of Int[2|3]Ds are created
		over and over again to look up neighbors.  Reusing a single 
		MutableInt[2|3]D thus saves a LOT of unneeded GCing.
	Replaced DecimalFormat with NumberFormat universally, including in
		Tutorial5
	Added SimpleEdgePortrayal2D.getLabel(), which is a hook you can
		override to customize the label without rewriting the drawing.
        Early version of the NetworkPortrayal3D and ValueGridPortrayal3D 
                provided; they may have bugs.
        OrientedPortrayal2D now fits in smallest dimension rather than largest.
	Added the balls3d and particles3d examples
	Numerical properties can now include domains (either min and max, or a 
		list of strings representing integer values' "names") in order
		to make possible pop-up lists and sliders in the various
		inspectors.  To do so, you create a function called domFoo()
		where Foo is your property name (along with setFoo and
		getFoo).  This function returns either an array of objects
		(representing the "names" to display for the values 0 ...
		array.length - 1) on a pop-up list, or a sim.util.Interval, 
		which represents either a double-valued or long-values min 
		and max range for a slider.
	Removed unneccessary checks for index < 0 and other == null, plus
		in Bag, IntBag, and DoubleBag, and allAll(...) now throws
		an exception of other == null or if index > numObjs or
		index < 0 rather than returning false (incorrectly).
	Added ThreadedDiffuser and made HeatBugs multithreadable.  Results
		in almost twice the speed in the underlying model when
		using two processors.  When multithreaded, the heatbugs console
		says so. Nifty!  I've noticed that Linux is bizarre in how
		well it does multithreading (or *doesn't*) in java.  Linux's
		threading is an unbelievable mess.  MacOS X is much more
		straightforward: 2x speedup give or take.
	Added a few sliders to HeatBugs and HexaBugs, and made a few more
		HexaBugs properties writable.
	Changed HexaBugs' Hexagonal/Rectangular popup to use the new
		Domain Property code (mostly to test it that's all).
	Made some methods in Schedule non-final (in case you want to override
		'em.  Also, Console now uses schedule.getTimestamp to get
		the timestamp to display -- you can thus override Schedule
		to provide a more interesting timestamp of your own if you
		like.
	Fixed typo in the license.  Thanks to Rob Alexander (rda@cs.york.ac.uk)
