Created
March 5, 2013 17:08
-
-
Save anonymous/5091913 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<?php | |
/** | |
* Note that the static members are shared across two instances for simplicity; | |
* it certainly could be coded otherwise. | |
*/ | |
class Hotplate { | |
public $array = []; | |
private $rows = 0; | |
private $coumns = 0; | |
private static $startRow = 1; | |
private static $startColumn = 1; | |
/** | |
* @param int $rows | |
* @param int $columns | |
*/ | |
function __construct($rows, $columns) { | |
$this->rows = $rows; | |
$this->columns = $columns; | |
$last_column = $columns - 1; | |
$last_row = $rows - 1; | |
$this->array = array_fill(0, $rows, array_fill(0, $columns, 50.0)); | |
for ($i = 1; $i < $columns; $i++) { | |
$this->array[0][$i] = 0; | |
$this->array[$i][0] = 100.0; | |
$this->array[$i][$last_column] = 100.0; | |
$this->array[$last_row][$i] = 100.0; | |
} | |
$row_cache =& $this->array[400]; | |
for ($column = 1; $column < 330; $column++) { | |
$row_cache[$column] = 100; | |
} | |
$this->array[200][500] = 100; | |
} | |
function isSteady() { | |
$last_row = $this->rows - 1; | |
$last_column = $this->columns - 1; | |
$column = self::$startColumn; | |
for ($row = self::$startRow; $row < $last_row; $row++) { | |
$row_cache =& $this->array[$row]; | |
if ($row == 400) { | |
$column = 330; | |
} | |
for (; $column < $last_column; $column++) { | |
if ($column == 500 && $row == 200) { | |
$column++; | |
} | |
$isSteady = abs( | |
$row_cache[$column] | |
- ( | |
$this->array[$row - 1][$column] | |
+ $this->array[$row + 1][$column] | |
+ $row_cache[$column - 1] | |
+ $row_cache[$column + 1] | |
) / 4 | |
) < 0.1; | |
if (!$isSteady) { | |
self::$startRow = $row; | |
self::$startColumn = $column; | |
return false; | |
} | |
} | |
$column = 1; | |
} | |
self::$startRow = $last_row; | |
self::$startColumn = $last_column; | |
return true; | |
} | |
function recalculate(Hotplate $that) { | |
$last_row = $this->rows - 1; | |
$last_column = $this->columns - 1; | |
for ($row = 1; $row < $last_row; $row++) { | |
$row_cache =& $this->array[$row]; | |
$that_cache =& $that->array[$row]; | |
for ($column = 1; $column < $last_column; $column++) { | |
$row_cache[$column] = ( | |
$that->array[$row - 1][$column] | |
+ $that->array[$row + 1][$column] | |
+ $that_cache[$column - 1] | |
+ $that_cache[$column + 1] | |
+ (4 * $that_cache[$column]) | |
) / 8; | |
} | |
} | |
$row_cache =& $this->array[400]; | |
for ($column = 1; $column < 330; $column++) { | |
$row_cache[$column] = 100; | |
} | |
$this->array[200][500] = 100; | |
} | |
} | |
define('ROWS', 1024); | |
define('COLUMNS', 1024); | |
$start = microtime(true); | |
$from = new Hotplate(ROWS, COLUMNS); | |
$to = clone $from; | |
$steady = true; | |
$iterations = 0; | |
do { | |
$tmp = $from; | |
$from = $to; | |
$to = $tmp; | |
$to->recalculate($from); | |
$steady = $to->isSteady(); | |
$iterations++; | |
} while (!$steady); | |
$stop = microtime(true); | |
printf("%d iterations took %f seconds.\n", $iterations, $stop - $start); |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
'use strict'; | |
var ROWS = 1024, | |
COLUMNS = 1024, | |
LAST_ROW = 1023, | |
LAST_COLUMN = 1023, | |
PRECISION = 0.1; | |
function resetFixed(plate) { | |
var column; | |
for (column = 1; column < 330; column++) { | |
plate[400][column] = 100; | |
} | |
plate[200][500] = 100; | |
} | |
function create() { | |
var plate = []; | |
var row, column; | |
for (row = 0; row < ROWS; row++) { | |
plate[row] = []; | |
plate[row][0] = 0; | |
plate[row][LAST_ROW] = 0; | |
for (column = 1; column < LAST_COLUMN; column++) { | |
plate[row][column] = 50; | |
} | |
} | |
for (column = 1; column < LAST_COLUMN; column++) { | |
plate[0][column] = 100; | |
plate[LAST_ROW][column] = 0; | |
} | |
resetFixed(plate); | |
return plate; | |
} | |
function recalculate(to, from) { | |
var row, column; | |
for (row = 1; row < LAST_ROW; row++) { | |
for (column = 1; column < LAST_COLUMN; column++) { | |
to[row][column] = ( | |
4 * from[row][column] | |
+ from[row][column - 1] | |
+ from[row][column + 1] | |
+ from[row - 1][column] | |
+ from[row + 1][column] | |
) / 8; | |
} | |
} | |
resetFixed(to); | |
} | |
function reduce(plate, startRow, startColumn) { | |
var row, column = startColumn, steady; | |
for (row = startRow; row < LAST_ROW; row++) { | |
if (400 === row) { | |
column = 330; | |
} | |
for (; column < LAST_COLUMN; column++) { | |
if (200 === row && 500 === column) { | |
column++; | |
} | |
steady = Math.abs( | |
plate[row][column] - ( | |
plate[row][column - 1] | |
+ plate[row][column + 1] | |
+ plate[row - 1][column] | |
+ plate[row + 1][column] | |
) / 4 | |
); | |
if (steady >= PRECISION) { | |
return [false, row, column]; | |
} | |
} | |
column = 1; | |
} | |
return [true, LAST_ROW, LAST_COLUMN]; | |
} | |
(function() { | |
var start = +new Date(), stop; | |
var to = create(), | |
from = create(), | |
swap, tmp; | |
var isSteady = true, iterations = 0; | |
var row = 1, column = 1; | |
do { | |
recalculate(to, from); | |
tmp = reduce(to, row, column); | |
isSteady = tmp[0]; | |
row = tmp[1]; | |
column = tmp[2]; | |
iterations++; | |
swap = from; | |
from = to; | |
to = swap; | |
} while (!isSteady); | |
stop = +new Date(); | |
print(stop - start); | |
})(); |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
'use strict'; | |
var ROWS = 1024, | |
COLUMNS = 1024, | |
LAST_ROW = 1023, | |
LAST_COLUMN = 1023, | |
PRECISION = 0.1; | |
function resetFixed(plate) { | |
var column; | |
for (column = 1; column < 330; column++) { | |
plate[400][column] = 100; | |
} | |
plate[200][500] = 100; | |
} | |
function create() { | |
var plate = new Array(ROWS); | |
var row, column; | |
for (row = 0; row < ROWS; row++) { | |
plate[row] = new Array(COLUMNS); | |
plate[row][0] = 0; | |
plate[row][LAST_ROW] = 0; | |
for (column = 1; column < LAST_COLUMN; column++) { | |
plate[row][column] = 50; | |
} | |
} | |
for (column = 1; column < LAST_COLUMN; column++) { | |
plate[0][column] = 100; | |
plate[LAST_ROW][column] = 0; | |
} | |
resetFixed(plate); | |
return plate; | |
} | |
function recalculate(to, from) { | |
var row, column; | |
for (row = 1; row < LAST_ROW; row++) { | |
for (column = 1; column < LAST_COLUMN; column++) { | |
to[row][column] = ( | |
4 * from[row][column] | |
+ from[row][column - 1] | |
+ from[row][column + 1] | |
+ from[row - 1][column] | |
+ from[row + 1][column] | |
) / 8; | |
} | |
} | |
resetFixed(to); | |
} | |
function reduce(plate, startRow, startColumn) { | |
var row, column = startColumn, steady; | |
for (row = startRow; row < LAST_ROW; row++) { | |
if (400 === row) { | |
column = 330; | |
} | |
for (; column < LAST_COLUMN; column++) { | |
if (200 === row && 500 === column) { | |
column++; | |
} | |
steady = Math.abs( | |
plate[row][column] - ( | |
plate[row][column - 1] | |
+ plate[row][column + 1] | |
+ plate[row - 1][column] | |
+ plate[row + 1][column] | |
) / 4 | |
); | |
if (steady >= PRECISION) { | |
return [false, row, column]; | |
} | |
} | |
column = 1; | |
} | |
return [true, LAST_ROW, LAST_COLUMN]; | |
} | |
(function() { | |
var start = +new Date(), stop; | |
var to = create(), | |
from = create(), | |
swap, tmp; | |
var isSteady = true, iterations = 0; | |
var row = 1, column = 1; | |
do { | |
recalculate(to, from); | |
tmp = reduce(to, row, column); | |
isSteady = tmp[0]; | |
row = tmp[1]; | |
column = tmp[2]; | |
iterations++; | |
swap = from; | |
from = to; | |
to = swap; | |
} while (!isSteady); | |
stop = +new Date(); | |
print(stop - start); | |
})(); |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This is a placeholder while I finish a rewrite to make it a more fair comparison. |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
int ROWS = 1024; | |
int COLUMNS = 1024; | |
int LAST_ROW = 1023; | |
int LAST_COLUMN = 1023; | |
double PRECISION = 0.1; | |
void resetFixed(List<List<double>> plate) { | |
int column; | |
for (column = 1; column < 330; column++) { | |
plate[400][column] = 100.0; | |
} | |
plate[200][500] = 100.0; | |
} | |
List<List<double>> create() { | |
List<List<double>> plate = new List.fixedLength(ROWS); | |
int row, column; | |
plate[0] = new List.fixedLength(COLUMNS, fill: 100.0); | |
for (row = 1; row < LAST_ROW; row++) { | |
plate[row] = new List.fixedLength(COLUMNS, fill: 50.0); | |
plate[row][0] = 0.0; | |
plate[row][LAST_COLUMN] = 0.0; | |
} | |
plate[LAST_ROW] = new List.fixedLength(COLUMNS, fill: 0.0); | |
resetFixed(plate); | |
return plate; | |
} | |
void recalculate(List<List<double>> to, List<List<double>> from) { | |
int row, column; | |
for (row = 1; row < LAST_ROW; row++) { | |
for (column = 1; column < LAST_COLUMN; column++) { | |
to[row][column] = ( | |
4 * from[row][column] | |
+ from[row][column - 1] | |
+ from[row][column + 1] | |
+ from[row - 1][column] | |
+ from[row + 1][column] | |
) / 8; | |
} | |
} | |
resetFixed(to); | |
} | |
reduce(List<List<double>> plate, int startRow, int startColumn) { | |
int row = startRow, column = startColumn; | |
double steady; | |
for (; row < LAST_ROW; row++) { | |
if (400 == row) { | |
column = 330; | |
} | |
for (; column < LAST_COLUMN; column++) { | |
if (200 == row && 500 == column) { | |
column++; | |
} | |
steady = | |
plate[row][column] - ( | |
plate[row][column - 1] | |
+ plate[row][column + 1] | |
+ plate[row - 1][column] | |
+ plate[row + 1][column] | |
) / 4; | |
if (!(steady.abs() < PRECISION)) { | |
return [false, row, column]; | |
} | |
} | |
column = 1; | |
} | |
return [true, LAST_ROW, LAST_COLUMN]; | |
} | |
main() { | |
DateTime start = new DateTime.now(); | |
DateTime stop; | |
var to = create(); | |
var from = create(); | |
var swap, tmp; | |
bool isSteady = true; | |
int iterations = 0; | |
int row = 1, column = 1; | |
do { | |
recalculate(to, from); | |
tmp = reduce(to, row, column); | |
isSteady = tmp[0]; | |
row = tmp[1]; | |
column = tmp[2]; | |
swap = from; | |
from = to; | |
to = swap; | |
iterations++; | |
if (iterations > 400) break; | |
} while (!isSteady); | |
stop = new DateTime.now(); | |
print(iterations); | |
print(stop.difference(start).inMilliseconds); | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
import 'dart:scalarlist'; | |
var ROWS = 1024; | |
var COLUMNS = 1024; | |
var LAST_ROW = 1023; | |
var LAST_COLUMN = 1023; | |
var PRECISION = 0.1; | |
void resetFixed(plate) { | |
int column; | |
for (column = 1; column < 330; column++) { | |
plate[400][column] = 100; | |
} | |
plate[200][500] = 100; | |
} | |
List<Float32List> create() { | |
List<Float32List> plate = []; | |
int row, column; | |
for (row = 0; row < ROWS; row++) { | |
plate[row] = new Float32List(COLUMNS); | |
for (column = 1; column < LAST_COLUMN; column++) { | |
plate[row][column] = 50; | |
} | |
} | |
for (column = 1; column < LAST_COLUMN; column++) { | |
plate[0][column] = 100; | |
} | |
resetFixed(plate); | |
return plate; | |
} | |
void recalculate(List<Float32List> to, List<Float32List> from) { | |
int row, column; | |
for (row = 1; row < LAST_ROW; row++) { | |
for (column = 1; column < LAST_COLUMN; column++) { | |
to[row][column] = ( | |
4 * from[row][column] | |
+ from[row][column - 1] | |
+ from[row][column + 1] | |
+ from[row - 1][column] | |
+ from[row + 1][column] | |
) / 8; | |
} | |
} | |
resetFixed(to); | |
} | |
reduce(List<Float32List> plate, int startRow, int startColumn) { | |
int row = startRow, column = startColumn; | |
for (; row < LAST_ROW; row++) { | |
if (400 == row) { | |
column = 330; | |
} | |
for (; column < LAST_COLUMN; column++) { | |
if (200 == row && 500 == column) { | |
column++; | |
} | |
if (abs( | |
plate[row][column] - ( | |
plate[row][column - 1] | |
+ plate[row][column + 1] | |
+ plate[row - 1][column] | |
+ plate[row + 1][column] | |
) / 4 | |
) >= PRECISION) { | |
return [false, row, column]; | |
} | |
} | |
column = 1; | |
} | |
return [true, LAST_ROW, LAST_COLUMN]; | |
} | |
main() { | |
var to = create(); | |
var from = create(); | |
var swap; | |
bool isSteady = true; | |
int iterations = 0; | |
int row = 1, column = 1; | |
do { | |
recalculate(to, from); | |
[isSteady, ro, column] = reduce(to, row, column); | |
[from, to] = [to, from]; | |
iterations++; | |
if (iterations > 400) break; | |
} while (!isSteady); | |
print(iterations); | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment