I have to say, I think Martin provided a great quiz here… His
description was old-school, and most of the solutions have that
feeling. In return, I’m looked at the solutions from a similar
viewport. While the solution from Jesse Brown is simple and makes
use of gnuplot – and would generally be a good way to solve the
problem – it ain’t old-school. (Of course, this means that if you
have a real graphing problem, using gnuplot would be a good idea.)
Michael Suchanek provided a solution using RubyX11. Oh man, does
that bring back memories… Michael just opened up a can of X11
goodness that, with Ruby, looks trivial compared to my old X11 C code.
I am rather tempted to study this library and start playing, but I do
have papers to write and books to analyze. Please take a look at
Michael’s code, because X11 is definitely old-school, definitely
powerful, and RubyX11 makes it definitely cool.
The ASCII solution from brabuhr is also several flavors of awesome.
Heck, if we geeks can still be entertained playing ASCII games like
Nethack and Dwarf Fortress, then why not our function
plotters? This solution is also totally Ruby, with a single, trivial
function that accepts your “equation” as a block… Top notch, dear
sir.
I am going to go into a bit of detail with Martin DeMello’s
solution, not because he wrote the quiz, but it reminded me most of my
oldest coding experience: BASIC. Sure, there’s a class and a
function or two in there, but I could imagine line numbers in front of
the code and almost expected to see a GOTO statement in there
somewhere.
Plus, it makes use of the cool, little, cross-platform Ruby library
for making little applications: Shoes. While Shoes still seems a
little rough around the edges, it’s a fun environment and API, a kind
of toy that recalls days on the Commodore 64. (I use Apple computers
nowadays, but back then, Commondore was king!)
Here’s the main body:
Shoes.app :height => Y, :width => X do
g = Grapher.new
background rgb(255, 255, 255)
fill white
stroke black
strokewidth 1
u, v = nil
Xmin.step(Xmax, (Xmax - Xmin)/(X*1.0)) {|i|
begin
x0, y0 = g.at(u,v)
u, v = i, g.fn(i)
x, y = g.at(u,v)
if g.bounded?(x,y) and g.bounded?(x0,y0)
line(x0, y0, x, y)
end
rescue
end
}
end
There are three essential things going on here. First, the creation of
a Shoes application and the calls to prepare it, such as fill white
and strokewidth 1. Second is the creation of a Grapher object and
the calls into it: we’ll come back to that. Finally, the main loop is
here, contained in this one line:
Xmin.step(Xmax, (Xmax - Xmin)/(X*1.0)) {|i|
Numeric#step is a method that works for either integers or floats,
and counts from the first number (Xmin) up to the second number
(Xmax) by the provided increment. Martin divides the window width
into the user-specified domain. This increment will ensure the
evaluations contained within the loop are evaluated once per
horizontal pixel.
The multiplication by 1.0 serves to convert X (and the rest of that
expression) to floating-point. Now, typically this might be done with
the to_f method. But multiplying by 1.0 seems old-school, especially
as it is one character less that .to_f. Rad.
The Grapher is a simple class containing three methods. bounded?
and fn are fairly straightforward; the former checks that a
coordinate pair is contained within the window’s drawing area, while
the latter evaluates the function provided by the user. Then there’s
Grapher#at:
def at(x,y)
[((x - Xmin) * XScale).to_i, Y - ((y - Ymin) * YScale).to_i]
rescue nil
end
This function converts the pair (x, y) from function-space values to
window-space values. That is, it maps the evaluation of the function
to the appropriate coordinate within the Shoes window. There is some
repetition here that could stand to be refactored into a general
lerp method (i.e. linear interpolation), but as we’re in old-school
mode, I’ll let it slide.
So, back in the main loop, we can now read this easily. For each
iteration, we evaluate the provided function at each pixel column of
the domain (i, stored to u) to get the pixel row (v) via method
fn. The (u, v) pair is converted to window coordinates (x, y)
via method at. The previous window coordinate is recalculated into
(x0, y0), and the Shoes’ line method is called to draw a line
between the two window coordinates.
Good show, gents. Now, if I can get Ruby running on this ol’ Commodore
64 sitting in the closet, my life will be complete.
New quiz will show up later this evening, or early tomorrow morning.
Quick hint: it’s about time to finish the final part of the
Statistician quiz.