Hi!
- Ruby Q., 09.03.2007 13:58:
The goal is to create a simulation of frost.
My aim was not to solve the task in a very object-oriened way or to
have a shiny output. My major objectives were
-
Writing a Ruby program that can easily be ported to C, porting it
and then compare the performance. It turned out that the C
implementation is faster by a factor of about 100.
-
Finding a simple way of animating the produced data without
having to implement a GUI.
For the implementation see source below, let’s turn to animation:
I use numbered PGM files as output format. For tick 0 (initial state
tick_00000.pgm is written, for tick 1 tick_00001.pgm and so forth.
For large simulations - I ran a C 1280x1024 C simulation with 25%
vapor that took about 7 minutes (with the bottleneck being the
Journaling File System) that took 3472 ticks meaning 3473 output
frames - it can be a good idea not to display all of the frames but
only every 10th or so. This goal can easily achieved by not looking
at all frames but only at those matching “tick_0.pgm". For every
20th one could use "tick_[02468]*.pgm” and so on.
One way of animating the output is using “convert” to create an
animated gif in the following manner:
convert -delay 0 -loop 0 tick_*.pgm simfrost.gif
Beware that this can require quite a lot of RAM!
A less demanding way of animtin the output is using an appropriate
display program. Personally I perfer qiv. To use this program to
animate the output all one has to do is issue
qiv -s -d 0 tick_*pgm
Where ‘-s’ orders qiv to display the images as a slideshow and ‘-d’
provides a delay in seconds between the individual images, for I was
using the program for 1280x1024 images I set this delay to 0.
qiv is available at http://www.klografx.net/qiv/
The second major advantage of using PGM or PBM or PGM besides the
simplicity of output is that they can be converted to virtually any
other graphics format because they are the generic formats used by
the netpbm tools, see http://netpbm.sourceforge.net/
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Follows Ruby implementation
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
#!/usr/bin/ruby -w
#####################################################################
Ruby Q. 117, SimFrost
The simulation uses an array of integers.
It seems to make sense to use
0 to represent vacuum
1 to represent vapor
2 to represent ice
Note that your terminal emulation should support ANSI escape
sequences
#####################################################################
#####################################################################
Integer#even - see if Integer is even
#####################################################################
class Integer
def even?
self/2*2 == self
end
end
#####################################################################
cls - clear screen
#####################################################################
def cls
print “\e[2J”
end
#####################################################################
home - move cursor to home position
#####################################################################
def home
print “\e[1;1H”
end
#####################################################################
Get even positive number
#####################################################################
def get_even_positive(desc)
n = 0
until n > 0 && n.even?
print "Please enter #{desc} (must be even and positive): "
n = gets.to_i
end
return n
end
#####################################################################
Read probability
Input is probability in percent, return value is probability
#####################################################################
def get_probability(desc)
p = -1.0
while p < 0.0 or p > 100.0
print "Please enter probability for #{desc} (in %, float): "
p = gets.to_f
end
return p / 100.0
end
#####################################################################
Read settings
#####################################################################
def get_settings
okay = “no”
while okay != “yes”
cls
cols = get_even_positive(“number of columns”)
rows = get_even_positive(“number of rows”)
prob = get_probability(“vapor”)
puts <<-EOF
You want:
\t#{cols}\tcolums
\t#{rows}\trows
\t#{prob*100.0}\tas the initial probabilty for vapor in percent
IS THAT CORRECT? If so please answer with: yes
EOF
okay = gets.chomp
puts “Please re-enter data.” unless okay == “yes”
end
return { “cols” => cols, “rows” => rows, “prob” => prob }
end
#####################################################################
generate initial state for simulation
#####################################################################
def initial_state(cols, rows, prob)
a =
Array.new(rows) do |row|
Array.new(cols) do |elem|
rand < prob ? 1 : 0
end
end
a[rows/2][cols/2] = 2
return a
end
#####################################################################
output current simulation state
#####################################################################
def output_state(state, tick)
home
puts “Simulation tick #{tick}”
filename = “tick_#{‘%05d’ % tick}.pgm”
File.open(filename, ‘w’) do |file|
file.puts <<-EOF
P2
#{filename}
#{state.first.length} #{state.length}
2
EOF
state.each do |row|
row.each do |elem|
file.puts elem.to_s
end
end
end
end
#####################################################################
see if state is frozen out (i.e. no more vapor is present)
#####################################################################
class Array
def frozen_out?
not self.flatten.member?(1)
end
end
#####################################################################
the simulation itself
#####################################################################
settings = get_settings
cols = settings[“cols”],
rows = settings[“rows”],
prob = settings[“prob”]
state = initial_state(cols, rows, prob)
tick = 0
cls
while true
output_state(state, tick)
break if state.frozen_out?
tick += 1
offset = (tick + 1) % 2
i = offset
while i < rows
i1 = (i + 1) % rows
j = offset
while j < cols
j1 = (j + 1) % cols
if [ state[i][j],
state[i][j1],
state[i1][j],
state[i1][j1] ].member?(2)
state[i][j] = 2 if state[i][j] == 1
state[i][j1] = 2 if state[i][j1] == 1
state[i1][j] = 2 if state[i1][j] == 1
state[i1][j1] = 2 if state[i1][j1] == 1
else
if rand < 0.5
state[i][j], state[i][j1], state[i1][j], state[i1][j1] =
state[i][j1], state[i1][j1], state[i][j], state[i1][j]
else
state[i][j], state[i][j1], state[i1][j], state[i1][j1] =
state[i1][j], state[i][j], state[i1][j1], state[i][j1]
end
end
j += 2
end
i += 2
end
end
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Follows C implementation
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void cls(void)
{
printf(“\033[2J”);
}
void home(void)
{
printf(“\033[1;1H”);
}
int get_even_positive(char* desc)
{
int n = 0;
char s[21];
while( n <= 0 || n/2*2 != n)
{
printf(“Please enter %s (must be even and positive): “, desc);
scanf(”%20s”, s);
n = atoi(s);
}
return n;
}
double get_probability(char* desc)
{
double p = -1.0;
char s[21];
while (p < 0.0 || p > 100.0)
{
printf(“Please enter probability for %s (in percent, float): “,
desc);
scanf(”%20s”, s);
p = atof(s);
}
return p / 100.0;
}
int **initialize_state(int cols, int rows, double prob)
{
int i;
int j;
int **a;
a = (int **) calloc(rows, sizeof(int *));
for (i = 0; i < rows; i++)
{
a[i] = (int *) calloc(cols, sizeof(int));
}
for (i = 0; i < rows; i++)
{
for (j = 0; j < cols; j++)
{
a[i][j] = (rand() < RAND_MAX * prob) ? 1 : 0;
}
}
a[rows/2][cols/2] = 2;
return a;
}
void display_state(int **state, int tick, int cols, int rows)
{
int i;
int j;
char filename[15];
FILE *file;
home();
printf(“Simulation tick %d\n”, tick);
sprintf(filename, “tick_%05d.pgm”, tick);
file = fopen(filename, “w”);
fprintf(file, “P2\n”);
fprintf(file, “# %s\n”, filename);
fprintf(file, “%d %d\n”, cols, rows);
fprintf(file, “2/n”);
for (i = 0; i < rows; i++)
{
for (j = 0; j < cols; j++)
{
putc(“012”[state[i][j]], file);
putc(‘\n’, file);
}
}
fclose(file);
}
int frozen_out(int **state, int cols, int rows)
{
int i;
int j;
for (i = 0; i < rows; i++)
{
for (j = 0; j < cols; j++)
{
if (state[i][j] == 1)
{
return 0;
}
}
}
return 1;
}
int main(void)
{
int okay = 0;
int tick = 0;
int offset;
int cols;
int rows;
int i, i1;
int j, j1;
int h00, h01, h10, h11;
double prob;
char s[21];
int **state;
while (!okay)
{
cls();
cols = get_even_positive(“number of columns”);
rows = get_even_positive(“number of rows”);
prob = get_probability(“vapor”);
printf(“You want:\n”);
printf(“\t%d\tcolums\n”, cols);
printf(“\t%d\trows\n”, rows);
printf(“\t%f\tas the initial probabilty for vapor in percent\n”,
prob * 100.0);
printf(“IS THAT CORRECT? If so please answer with: yes\n”);
scanf(“%20s”, s);
okay = !strcmp(s, “yes”);
if (!okay)
{
puts(“Please re-enter data.”);
}
}
state = initialize_state(cols, rows, prob);
cls();
while(1)
{
display_state(state, tick, cols, rows);
if (frozen_out(state, cols, rows))
{
return 0;
}
offset = (tick++ + 1) % 2;
for (i = offset; i < rows; i += 2)
{
i1 = (i + 1) % rows;
for (j = offset; j < cols; j += 2)
{
j1 = (j + 1) % cols;
if (state[i][j] == 2 ||
state[i][j1] == 2 ||
state[i1][j] == 2 ||
state[i1][j1] == 2)
{
if (state[i][j] == 1) state[i][j] = 2;
if (state[i][j1] == 1) state[i][j1] = 2;
if (state[i1][j] == 1) state[i1][j] = 2;
if (state[i1][j1] == 1) state[i1][j1] = 2;
}
else
{
h00 = state[i][j];
h01 = state[i][j1];
h10 = state[i1][j];
h11 = state[i1][j1];
if (rand() < RAND_MAX/2)
{
state[i][j] = h01;
state[i][j1] = h11;
state[i1][j] = h00;
state[i1][j1] = h10;
}
else
{
state[i][j] = h10;
state[i][j1] = h00;
state[i1][j] = h11;
state[i1][j1] = h01;
}
}
}
}
}
return 0;
}
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Even if you’ve never seen C before you ought to be able to understand
the C implementation by comparing it to the Ruby one.
Josef ‘Jupp’ Schugt
but the ppm files will stay for