Class.php

<?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);

Dynamic.js

'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);

})();

Fixed.js

'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);

})();

Functions.php

<?php

define('ROWS', 1024);
define('COLUMNS', 1024);
define('LAST_ROW', 1023);
define('LAST_COLUMN', 1023);

    function create() {

        $array = array_fill(0, ROWS, array_fill(0, COLUMNS, 50.0));
        for ($i = 1; $i < COLUMNS; $i++) {
            $array[0][$i] = 0;
            $array[$i][0] = 100.0;
            $array[$i][LAST_COLUMN] = 100.0;
            $array[LAST_ROW][$i] = 100.0;
        }
        $row_cache =& $array[400];
        for ($column = 1; $column < 330; $column++) {
            $row_cache[$column] = 100;
        }
        $array[200][500] = 100;
        return $array;
    }

    function isSteady(array $array, $startRow, $startColumn) {

        $column = $startColumn;
        for ($row = $startRow; $row < LAST_ROW; $row++) {
            $row_cache =& $array[$row];
            if ($row == 400) {
                $column = 330;
            }
            for (; $column < LAST_COLUMN; $column++) {
                if ($column == 500 && $row == 200) {
                    $column++;
                }
                $isSteady = abs(
                   $row_cache[$column]
                   - (
                       $array[$row - 1][$column]
                       + $array[$row + 1][$column]
                       + $row_cache[$column - 1]
                       + $row_cache[$column + 1]
                   ) / 4
                ) < 0.1;
                if (!$isSteady) {
                    return [false, $row, $column];
                }
            }
            $column = 1;
        }
        return [true, LAST_ROW, LAST_COLUMN];
    }

    function recalculate(array &$to, array $from) {
        for ($row = 1; $row < LAST_ROW; $row++) {
            $to_cache =& $to[$row];
            $from_cache = $from[$row];
            for ($column = 1; $column < LAST_COLUMN; $column++) {
                $to_cache[$column] = (
                    $from[$row - 1][$column]
                    + $from[$row + 1][$column]
                    + $from_cache[$column - 1]
                    + $from_cache[$column + 1]
                    + (4 * $from_cache[$column])
                ) / 8;
            }
        }
        $to_cache =& $to[400];
        for ($column = 1; $column < 330; $column++) {
            $to_cache[$column] = 100;
        }
        $to[200][500] = 100;
    }


$start = microtime(true);

$from = create();
$to = create();

$steady = true;
$startRow = 1;
$startColumn = 1; 
$iterations = 0;
do {
    $tmp = $from;
    $from = $to;
    $to = $tmp;

    recalculate($to, $from); 
    list($steady, $startRow, $startColumn) = isSteady($to, $startRow, $startColumn);
    $iterations++;

} while (!$steady);

$stop = microtime(true);

printf("%d iterations took %f seconds.\n", $iterations, $stop - $start);

Lists.dart

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);

}

Scalarlist.dart

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);

}