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.
···
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Follows Ruby implementation
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
#!/usr/bin/ruby -w
#####################################################################
# Ruby Quiz 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
--
Blog available at http://www.mynetcologne.de/~nc-schugtjo/blog/
PGP key with id 6CC6574F available at http://wwwkeys.de.pgp.net/