Статья I.Машинная программа модели

Программа имитационного программирования на языке Java

<td>Время окончания симуляции</td>

<td><input type="text" id="time_stop" value="8.0"></td>

<input type="radio" name="completion_delay_distr" value="exponential" onclick="javascript:onSelectExponential('completion_delay_param','1.5')">экспоненциальный<br>

<td>Количество обработчиков</td>

<td><input type="text" id="workers" value="4"></td>

<td>Максимальная длина очереди</td>

<td><input type="text" id="queue" value="3"></td>

<td>Количество симуляций</td>

<td><input type="text" id="total" value="300"></td>

<td>Допустимая погрешность (ε)</td>

<td><input type="text" id="error" value="0.15"></td>

<td>Статистическая значимость (α)</td>

<input type="button" value="Симулировать один раз" onclick="javascript:Simulate(1)">

<input type="reset" value="Очистить результаты" onclick="javascript:ClearOutput()">

Другие параметры:

time_stop - время окончания симуляции;

workers - количество обслуживающих приборов;

queue - максимальная длина очереди;

arrival_delay_distribution - закон распределения длительности интервала времени

между прибытием двух последовательных заявок ;

arrival_delay_param1 - среднее значение длительности времени между прибытием

двух последовательных заявок;

completion_delay_distribution - закон распределения длительности обслуживания

заявки ;

completion_delay_param1 - среднее значение длительности обслуживания заявки;

function internalSimulate(visible, time_stop, workers, queue,

arrival_delay_distribution, arrival_delay_param1,

arrival_distr,

completion_delay_distribution, completion_delay_param1,

completion_distr,

functions_code

)

{

/* объекты HTML документа, используемые для вывода информации */

var output, table, row, cell;

/* переменные для хранения информации, которая будет в том числе выводиться

в соответствующие столбцы текущей строки таблицы хода одной симулиции */

var arrived = 0.0;

var started;

var delay;

var worker;

var finished;

var waiting_time;

var waiting_time_sum = 0.0, waiting_time_sum_wrong = 0.0;

var denial_count = 0, denial_count_wrong = 0;

var waiting; /* счётчик количества заявок, ожидающих начала обработки (т.е.

текущая длина очереди) */

var working; /* счётчик количества задействованных в данный момент

обработчиков (т.е. приборов) */

var tasks = new Array(); /* динамический массив, состоящий из элементов,

каждый из которых содержит следующую информацию:

смещение 0 - время начала обработки заявки;

смещение 1 - время окончания обработки заявки;

смещение 2 - номер обработчика (т.е. номер прибора);

смещение 3 - флаг занятости времени окончания обработки (см. ниже). */

var tasks_num = 0; /* текущее количество элементов в массиве tasks */

var next_finished; /* индекс в массиве tasks. Индекс используется для

"запоминания" той заявки, в результате завершения обработки которой

освободится обработчик, которому будет делегирована помещенная в очередь

заявка. Таким образом, указанное время завершения будет помечано и больше

не будет помечаться в качестве времени начала обработки последующих

заявок, поступающих в очередь. */

var i; /* индекс многоцелевого назначения (для прохода по массивам) */

/* массив для помечания задействованных в данный момент обработчиков. Индекс

соответствует номеру обработчика (внутри программы первый обработчик имеет

номер 0), а значение 0 соответсвует состоянию "свободен". */

var busy = new Array(workers);

eval(functions_code);

if(visible) {

output = document.getElementById("output");

table = document.createElement("table");

table.setAttribute("border", "1");

row = table.insertRow(0);

cell = row.insertCell(0);

cell.innerHTML = "Номер заявки";

cell = row.insertCell(1);

cell.innerHTML = "Время прибытия";

cell = row.insertCell(2);

cell.innerHTML = "Время начала обработки";

cell = row.insertCell(3);

cell.innerHTML = "Номер обработчика";

cell = row.insertCell(4);

cell.innerHTML = "Длительность обработки";

cell = row.insertCell(5);

cell.innerHTML = "Время окончания обработки";

cell = row.insertCell(6);

cell.innerHTML = "Номер в очереди";

cell = row.insertCell(7);

cell.innerHTML = "Время ожидания";

output.appendChild(table);

}

var n = 0;

while(arrived < time_stop) {

n++;

waiting = 0;

working = 0;

next_finished = -1;

worker = 0;

/* снова полагаем, что все обработчики - свободны */

for(i = 0; i < workers; i++) busy[i] = 0;

for(i = 0; i < tasks_num; i++) {

if(tasks[i][0] > arrived) {

/* поскольку время начала обработки заявки с индексом i

по-прежнему в будущем, то инкрементируем счётчик заявок,

находящихся в очереди */

waiting++;

} else if(tasks[i][1] > arrived) {

/* в противном случае время начала обработки заявки с индексом i

приходится либо на настоящее, либо на прошлом, поэтому если

время завершения обработки заявки по-прежнему в будущем, то

инкрементируем счётчик задействованных обработчиков (приборов)

и рассматриваем соответствующий обработчик как несвободный */

working++;

busy[tasks[i][2]] = 1;

}

/* если заявка, обработка которой завершится в будущем, ещё не

помечена, то запоминаем её индекс */

if(tasks[i][3] == 0 && tasks[i][1] >= arrived) {

if(next_finished == -1) next_finished = i;

if(tasks[i][1] < tasks[next_finished][1]) next_finished = i;

}

}

if(working >= workers && waiting >= queue) {

/* все обработчики задействованы, а очередь достигла максимальной

длины */

started = "(нет данных)";

delay = "(нет данных)";

finished = "(нет данных)";

worker = "(нет данных)";

waiting = "отказ";

waiting_time = 0.0;

denial_count++;

denial_count_wrong++;

} else {

if(working < workers) {

/* есть по меньшей мере один свободный

обработчик */

started = arrived;

/* выбрать первый незанятый обработчик (прибор);

FIXME: в полноценной программе возможно рандомизировать выбор,

чтобы распределить нагрузку равномерно */

for(i = 0; i < workers; i++) {

if(busy[i] == 0) {

worker = i;

break;

}

}

waiting = 0;

} else {

/* свободных обработчиков нет, но есть место в очереди; чуть

ранее мы запомнили индекс заявки, обработка которой завершится

в ближайшее время; упомянутое время и будет временем

начала обработки этой заявки (помещаемой в очередь), а

обработчиком будет конечно же освободившийся обработчик */

started = tasks[next_finished][1];

worker = tasks[next_finished][2];

/* ставим флаг занятости времени окончания обработки */

tasks[next_finished][3] = 1;

/* инкрементируем счётчик заявок, находящихся в очереди,

поскольку мы только что твёрдо решили поместить эту заявку в

очередь */

waiting++;

}

if(completion_distr != undefined) delay = completion_distr.getQuantile(Math.random());

else if(completion_delay_distribution == "custom") delay = completion_delay_param_Quantile();

else if(completion_delay_distribution == "const") delay = completion_delay_param1;

else if(completion_delay_distribution == "exponential") delay = - completion_delay_param1 * Math.log(1.0 - Math.random());

else delay = 1.0;

finished = started + delay;

tasks.length = tasks_num + 1;

tasks[tasks_num] = new Array(4);

tasks[tasks_num][0] = started;

tasks[tasks_num][1] = finished;

tasks[tasks_num][2] = worker;

tasks[tasks_num][3] = 0;

tasks_num++;

if(finished > time_stop) {

if(started > time_stop) started = time_stop;

waiting = "не обслужена";

finished = "(нет данных)";

waiting_time = started - arrived;

denial_count++;

} else {

waiting_time = started - arrived;

waiting_time_sum_wrong += waiting_time;

}

worker++;

}

if(visible) {

row = table.insertRow(n);

cell = row.insertCell(0);

cell.innerHTML = n;

cell = row.insertCell(1);

cell.innerHTML = arrived;

cell = row.insertCell(2);

cell.innerHTML = started;

cell = row.insertCell(3);

cell.innerHTML = worker;

cell = row.insertCell(4);

cell.innerHTML = delay;

cell = row.insertCell(5);

cell.innerHTML = finished;

cell = row.insertCell(6);

cell.innerHTML = waiting;

cell = row.insertCell(7);

cell.innerHTML = waiting_time;

}

if(arrival_distr != undefined) arrived += arrival_distr.getQuantile(Math.random());

else if(arrival_delay_distribution == "custom") arrived += arrival_delay_param_Quantile();

else if(arrival_delay_distribution == "const") arrived += arrival_delay_param1;

else if(arrival_delay_distribution == "exponential") arrived += - arrival_delay_param1 * Math.log(1.0 - Math.random());

else arrived++;

waiting_time_sum += waiting_time;

}

var result = new Array(8);

result[0] = waiting_time_sum_wrong / n;

result[1] = waiting_time_sum / n;

result[2] = denial_count_wrong / n;

result[3] = denial_count / n;

result[4] = 1.0 - result[2];

result[5] = 1.0 - result[3];

result[6] = result[4] / arrival_delay_param1;

result[7] = result[5] / arrival_delay_param1;

if(!visible) return result;

var node = document.createElement("P");

node.innerHTML =

"Среднее время ожидания : " + result[0] + "<br>" +

"Среднее время ожидания: " + result[1] + "<br>" +

"Вероятность отказа (по методичке): " + result[2] + "<br>" +

"Вероятность отказа: " + result[3] + "<br>" +

"Относительная пропускная способность: " + result[4] + "<br>" +

"Относительная пропускная способность: " + result[5] + "<br>" +

"Абсолютная пропускная способность (по методичке): " + result[6] + "<br>" +

"Абсолютная пропускная способность: " + result[7] + "<br>";

output.appendChild(node);

}

function Simulate(retries, error)

{

var n, result, output, table, row;

var time_stop = document.getElementById("time_stop").value;

var workers = document.getElementById("workers").value;

var queue = document.getElementById("queue").value;

var arrival_distr;

var arrival_delay_distribution = getRadioVal("arrival_delay_distr");

var arrival_delay_param1 = document.getElementById("arrival_delay_param1").value;

var arrival_delay_param2 = parseFloat(document.getElementById("arrival_delay_param2").value);

var completion_distr;

var completion_delay_distribution = getRadioVal("completion_delay_distr");

var completion_delay_param1 = document.getElementById("completion_delay_param1").value;

var completion_delay_param2 = parseFloat(document.getElementById("completion_delay_param2").value);

var functions_code = "";

if(arrival_delay_distribution == "custom") functions_code = functions_code + document.getElementById("arrival_delay_param1").value;

else arrival_delay_param1 = parseFloat(arrival_delay_param1);

if(arrival_delay_distribution == "normal") arrival_distr = new NormalDistribution(arrival_delay_param1, arrival_delay_param2);

if(completion_delay_distribution == "custom") functions_code = functions_code + document.getElementById("completion_delay_param1").value;

else completion_delay_param1 = parseFloat(completion_delay_param1);

if(completion_delay_distribution == "normal") completion_distr = new NormalDistribution(completion_delay_param1, completion_delay_param2);

if(retries <= 1) {

internalSimulate(true, time_stop, workers, queue,

arrival_delay_distribution, arrival_delay_param1,

arrival_distr,

completion_delay_distribution, completion_delay_param1,

completion_distr,

functions_code);

return;

}

output = document.getElementById("output");

table = document.createElement("table");

table.setAttribute("border", "1");

row = table.insertRow(0);

cell = row.insertCell(0);

cell.innerHTML = "Номер симуляции";

cell = row.insertCell(1);

cell.innerHTML = "Среднее время ожидания ";

cell = row.insertCell(2);

cell.innerHTML = "Среднее время ожидания";

cell = row.insertCell(3);

cell.innerHTML = "Вероятность отказа";

cell = row.insertCell(4);

cell.innerHTML = "Вероятность отказа";

cell = row.insertCell(5);

cell.innerHTML = "Относительная пропускная способность";

cell = row.insertCell(6);

cell.innerHTML = "Относительная пропускная способность";

cell = row.insertCell(7);

cell.innerHTML = "Абсолютная пропускная способность";

cell = row.insertCell(8);

cell.innerHTML = "Абсолютная пропускная способность";

output.appendChild(table);

var waiting_time_wrong = 0.0;

var waiting_time = 0.0;

var denial_chance_wrong = 0.0;

var denial_chance = 0.0;

var capacity_wrong = 0.0;

var capacity = 0.0;

var abs_capacity_wrong = 0.0;

var abs_capacity = 0.0;

result = new Array(retries);

for(n = 0; n < retries; n++) {

result[n] = internalSimulate(false, time_stop, workers, queue,

arrival_delay_distribution, arrival_delay_param1,

arrival_distr,

completion_delay_distribution, completion_delay_param1,

completion_distr,

functions_code);

row = table.insertRow(n + 1);

cell = row.insertCell(0);

cell.innerHTML = n + 1;

cell = row.insertCell(1);

cell.innerHTML = result[n][0];

waiting_time_wrong += result[n][0];

cell = row.insertCell(2);

cell.innerHTML = result[n][1];

waiting_time += result[n][1];

cell = row.insertCell(3);

cell.innerHTML = result[n][2];

denial_chance_wrong += result[n][2];

cell = row.insertCell(4);

cell.innerHTML = result[n][3];

denial_chance += result[n][3];

cell = row.insertCell(5);

cell.innerHTML = result[n][4];

capacity_wrong += result[n][4];

cell = row.insertCell(6);

cell.innerHTML = result[n][5];

capacity += result[n][5];

cell = row.insertCell(7);

cell.innerHTML = result[n][6];

abs_capacity_wrong += result[n][6];

cell = row.insertCell(8);

cell.innerHTML = result[n][7];

abs_capacity += result[n][7];

}

waiting_time_wrong /= retries;

waiting_time /= retries;

denial_chance_wrong /= retries;

denial_chance /= retries;

capacity_wrong /= retries;

capacity /= retries;

abs_capacity_wrong /= retries;

abs_capacity /= retries;

row = table.insertRow(retries + 1);

cell = row.insertCell(0);

cell.innerHTML = "<b>Среднее арифметическое</b>";

cell = row.insertCell(1);

cell.innerHTML = "<b>" + waiting_time_wrong + "</b>";

cell = row.insertCell(2);

cell.innerHTML = "<b>" + waiting_time + "</b>";

cell = row.insertCell(3);

cell.innerHTML = "<b>" + denial_chance_wrong + "</b>";

cell = row.insertCell(4);

cell.innerHTML = "<b>" + denial_chance + "</b>";

cell = row.insertCell(5);

cell.innerHTML = "<b>" + capacity_wrong + "</b>";

cell = row.insertCell(6);

cell.innerHTML = "<b>" + capacity + "</b>";

cell = row.insertCell(7);

cell.innerHTML = "<b>" + abs_capacity_wrong + "</b>";

cell = row.insertCell(8);

cell.innerHTML = "<b>" + abs_capacity + "</b>";

var waiting_time_variance_wrong = 0.0;

var waiting_time_variance = 0.0;

var denial_chance_variance_wrong = 0.0;

var denial_chance_variance = 0.0;

var capacity_variance_wrong = 0.0;

var capacity_variance = 0.0;

var abs_capacity_variance_wrong = 0.0;

var abs_capacity_variance = 0.0;

for(n = 0; n < retries; n++) {

waiting_time_variance_wrong += Math.pow(result[n][0] - waiting_time_wrong, 2);

waiting_time_variance += Math.pow(result[n][1] - waiting_time, 2);

denial_chance_variance_wrong += Math.pow(result[n][2] - denial_chance_wrong, 2);

denial_chance_variance += Math.pow(result[n][3] - denial_chance, 2);

capacity_variance_wrong += Math.pow(result[n][4] - capacity_wrong, 2);

capacity_variance += Math.pow(result[n][5] - capacity, 2);

abs_capacity_variance_wrong += Math.pow(result[n][6] - abs_capacity_wrong, 2);

abs_capacity_variance += Math.pow(result[n][7] - abs_capacity, 2);

}

waiting_time_variance_wrong /= retries - 1;

waiting_time_variance /= retries - 1;

denial_chance_variance_wrong /= retries - 1;

denial_chance_variance /= retries - 1;

capacity_variance_wrong /= retries - 1;

capacity_variance /= retries - 1;

abs_capacity_variance_wrong /= retries - 1;

abs_capacity_variance /= retries - 1;

row = table.insertRow(retries + 2);

cell = row.insertCell(0);

cell.innerHTML = "<b>Дисперсия</b>";

cell = row.insertCell(1);

cell.innerHTML = waiting_time_variance_wrong;

cell = row.insertCell(2);

cell.innerHTML = waiting_time_variance;

cell = row.insertCell(3);

cell.innerHTML = denial_chance_variance_wrong;

cell = row.insertCell(4);

cell.innerHTML = denial_chance_variance;

cell = row.insertCell(5);

cell.innerHTML = capacity_variance_wrong;

cell = row.insertCell(6);

cell.innerHTML = capacity_variance;

cell = row.insertCell(7);

cell.innerHTML = abs_capacity_variance_wrong;

cell = row.insertCell(8);

cell.innerHTML = abs_capacity_variance;

var waiting_time_deviance_wrong = Math.sqrt(waiting_time_variance_wrong);

var waiting_time_deviance = Math.sqrt(waiting_time_variance);

var denial_chance_deviance_wrong = Math.sqrt(denial_chance_variance_wrong);

var denial_chance_deviance = Math.sqrt(denial_chance_variance);

var capacity_deviance_wrong = Math.sqrt(capacity_variance_wrong);

var capacity_deviance = Math.sqrt(capacity_variance);

var abs_capacity_deviance_wrong = Math.sqrt(abs_capacity_variance_wrong);

var abs_capacity_deviance = Math.sqrt(abs_capacity_variance);

row = table.insertRow(retries + 3);

cell = row.insertCell(0);

cell.innerHTML = "<b>Среднеквадратичное отклонение</b>";

cell = row.insertCell(1);

cell.innerHTML = waiting_time_deviance_wrong;

cell = row.insertCell(2);

cell.innerHTML = waiting_time_deviance;

cell = row.insertCell(3);

cell.innerHTML = denial_chance_deviance_wrong;

cell = row.insertCell(4);

cell.innerHTML = denial_chance_deviance;

cell = row.insertCell(5);

cell.innerHTML = capacity_deviance_wrong;

cell = row.insertCell(6);

cell.innerHTML = capacity_deviance;

cell = row.insertCell(7);

cell.innerHTML = abs_capacity_deviance_wrong;

cell = row.insertCell(8);

cell.innerHTML = abs_capacity_deviance;

var dist = new StudentTDistribution(retries - 1);

var quantile = dist.getQuantile(1.0 - parseFloat(document.getElementById("significance").value));

row = table.insertRow(retries + 4);

cell = row.insertCell(0);

cell.innerHTML = "<b>Верхняя оценка числа испытаний для достижения статистической значимости с p=0.95 согласно ЦПТ</b>";

cell = row.insertCell(1);

cell.innerHTML = 16 * waiting_time_variance_wrong / Math.pow(2 * error * waiting_time_wrong, 2);

cell = row.insertCell(2);

cell.innerHTML = 16 * waiting_time_variance / Math.pow(2 * error * waiting_time, 2);

cell = row.insertCell(3);

cell.innerHTML = 16 * denial_chance_variance_wrong / Math.pow(2 * error * denial_chance_wrong, 2);

cell = row.insertCell(4);

cell.innerHTML = 16 * denial_chance_variance / Math.pow(2 * error * denial_chance, 2);

cell = row.insertCell(5);

cell.innerHTML = 16 * capacity_variance_wrong / Math.pow(2 * error * capacity_wrong, 2);

cell = row.insertCell(6);

cell.innerHTML = 16 * capacity_variance / Math.pow(2 * error * capacity, 2);

cell = row.insertCell(7);

cell.innerHTML = 16 * abs_capacity_variance_wrong / Math.pow(2 * error * abs_capacity_wrong, 2);

cell = row.insertCell(8);

cell.innerHTML = 16 * abs_capacity_variance / Math.pow(2 * error * abs_capacity, 2);

var retries_sqrt = Math.sqrt(retries);

var waiting_time_delta_wrong = waiting_time_deviance_wrong * quantile;

var waiting_time_delta = waiting_time_deviance * quantile;

var denial_chance_delta_wrong = denial_chance_deviance_wrong * quantile;

var denial_chance_delta = denial_chance_deviance * quantile;

var capacity_delta_wrong = capacity_deviance_wrong * quantile;

var capacity_delta = capacity_deviance * quantile;

var abs_capacity_delta_wrong = abs_capacity_deviance_wrong * quantile;

var abs_capacity_delta = abs_capacity_deviance * quantile;

row = table.insertRow(retries + 5);

cell = row.insertCell(0);

cell.innerHTML = "<b>Половина доверительного интервала (T = " + quantile + ")</b>";

cell = row.insertCell(1);

cell.innerHTML = "<b>" + waiting_time_delta_wrong + "</b>";

cell = row.insertCell(2);

cell.innerHTML = "<b>" + waiting_time_delta + "</b>";

cell = row.insertCell(3);

cell.innerHTML = "<b>" + denial_chance_delta_wrong + "</b>";

cell = row.insertCell(4);

cell.innerHTML = "<b>" + denial_chance_delta + "</b>";

cell = row.insertCell(5);

cell.innerHTML = "<b>" + capacity_delta_wrong + "</b>";

cell = row.insertCell(6);

cell.innerHTML = "<b>" + capacity_delta + "</b>";

cell = row.insertCell(7);

cell.innerHTML = "<b>" + abs_capacity_delta_wrong + "</b>";

cell = row.insertCell(8);

cell.innerHTML = "<b>" + abs_capacity_delta + "</b>";

var waiting_time_errors_wrong = 0;

var waiting_time_errors = 0;

var denial_chance_errors_wrong = 0;

var denial_chance_errors = 0;

var capacity_errors_wrong = 0;

var capacity_errors = 0;

var abs_capacity_errors_wrong = 0;

var abs_capacity_errors = 0;

for(n = 0; n < retries; n++) {

if(Math.abs(result[n][0] - waiting_time_wrong) > waiting_time_delta_wrong) waiting_time_errors_wrong++;

if(Math.abs(result[n][1] - waiting_time) > waiting_time_delta) waiting_time_errors++;

if(Math.abs(result[n][2] - denial_chance_wrong) > denial_chance_delta_wrong) denial_chance_errors_wrong++;

if(Math.abs(result[n][3] - denial_chance) > denial_chance_delta) denial_chance_errors++;

if(Math.abs(result[n][4] - capacity_wrong) > capacity_delta_wrong) capacity_errors_wrong++;

if(Math.abs(result[n][5] - capacity) > capacity_delta) capacity_errors++;

if(Math.abs(result[n][6] - abs_capacity_wrong) > abs_capacity_delta_wrong) abs_capacity_errors_wrong++;

if(Math.abs(result[n][7] - abs_capacity) > abs_capacity_delta) abs_capacity_errors++;

}

row = table.insertRow(retries + 6);

cell = row.insertCell(0);

cell.innerHTML = "<b>Количество результатов вне доверительного интервала</b>";

cell = row.insertCell(1);

cell.innerHTML = waiting_time_errors_wrong;

cell = row.insertCell(2);

cell.innerHTML = waiting_time_errors;

cell = row.insertCell(3);

cell.innerHTML = denial_chance_errors_wrong;

cell = row.insertCell(4);

cell.innerHTML = denial_chance_errors;

cell = row.insertCell(5);

cell.innerHTML = capacity_errors_wrong;

cell = row.insertCell(6);

cell.innerHTML = capacity_errors;

cell = row.insertCell(7);

cell.innerHTML = abs_capacity_errors_wrong;

cell = row.insertCell(8);

cell.innerHTML = abs_capacity_errors;

row = table.insertRow(retries + 7);

cell = row.insertCell(0);

cell.innerHTML = "<b>Доля результатов вне доверительного интервала</b>";

cell = row.insertCell(1);

cell.innerHTML = waiting_time_errors_wrong / retries;

cell = row.insertCell(2);

cell.innerHTML = waiting_time_errors / retries;

cell = row.insertCell(3);

cell.innerHTML = denial_chance_errors_wrong / retries;

cell = row.insertCell(4);

cell.innerHTML = denial_chance_errors / retries;

cell = row.insertCell(5);

cell.innerHTML = capacity_errors_wrong / retries;

cell = row.insertCell(6);

cell.innerHTML = capacity_errors / retries;

cell = row.insertCell(7);

cell.innerHTML = abs_capacity_errors_wrong / retries;

cell = row.insertCell(8);

cell.innerHTML = abs_capacity_errors / retries;

}

/* Событийная функция, вызываемая при нажатии кнопки "Очистить результаты".

Удаляет все дочерние элементы, по отношению к которым элемент div с

идентификатором "output" является родительским. */

function ClearOutput()

{

var parent = document.getElementById("output");

while(parent.hasChildNodes()) parent.removeChild(parent.firstChild);

}

/* Событийная функция, вызываемая при выборе radiobutton, соответствующего

"закону распределения", функция которого принимает постоянное значение.*/

function onSelectConst(param, value)

{

document.getElementById(param + "1_name").innerHTML = "Значение величины";

document.getElementById(param + "1").removeAttribute("disabled");

document.getElementById(param + "1").value = value;

}

/* Событийная функция, вызываемая при выборе radiobutton, соответствующего

экспоненциальному закону распределения. */

function onSelectExponential(param, value)

{

document.getElementById(param + "1_name").innerHTML = "Параметр λ";

document.getElementById(param + "1").removeAttribute("disabled");

document.getElementById(param + "1").value = value;

document.getElementById(param + "2_name").innerHTML = "(не используется)";

document.getElementById(param + "2").setAttribute("disabled", "1");

}