Названия цветов 8 страница

На первых итерациях значение переменной Delta оказывается больше значения, заданного в переменной D. Это означает, что условие (Delta > D) является истинным, поэтому управление будет передано в тело цикла на следующую итерацию. Все переменные, участвующие в вычислениях, получат новые значения, и после достижения конца тела цикла управление снова будет передано в заголовок для проверки истинности условия.

Этот процесс будет продолжаться до тех пор, пока условие оператора цикла не станет ложным. В момент, когда значение переменной Delta окажется меньше или равным значению D, условие (Delta > D) перестанет соответствовать истине, а значит управление будет передано за пределы оператора цикла, в строку:

Alert("C=",C," Число Фибоначчи=",C/B," i=",i);//Сообщение на экран

В результате на экране появится окно оператора Alert(), в котором будет напечатано следующее:

С=317811 Число Фибоначчи=1.618 i=25

Это означает, что на 25-й итерации заданная точность достигнута, при этом максимальное значение элемента последовательности Фибоначчи, которое было обработано, равно 317811, а сам коэффициент Фибоначчи, как и ожидалось, равен 1.618. Это сообщение является решением поставленной задачи.

Здесь нужно заметить, что действительные числа в MQL4 вычисляются с точностью до 15-го знака. В то же время, коэффициент Фибоначчи отражён с точностью до 3-го знака. Это произошло потому, что свойством функции Alert() является отображение чисел с точностью до 4-го знака, но все последние ноли при этом не отображаются. Если бы у нас возникла необходимость отобразить на экране число Фибоначчи с некоторой наперёд заданной точностью, то нам пришлось бы несколько изменить код, например, так:

Alert("C=",C," Число Фибоначчи=",C/B*10000000," i=",i);// Сообщение

Особо нужно отметить следующее:

Возможна ситуация, при которой условие, указанное в заголовке оператора цикла, всегда будет оставаться истинным, в результате чего происходит зацикливание.

Зацикливание -бесконечное повторяющееся выполнение операторов, составляющих тело цикла; критическая ситуация, возникающая в результате реализации ошибочного алгоритма.

При зацикливании программа бесконечно исполняет блок операторов, составляющих тело цикла. Вот простой пример оператора цикла while с зацикливанием:

int i=1; // Формальн параметр (счётчик)
while (i > 0) // Заголовок оператора цикла
i++; // Увеличение значения i

В данном примере происходит накапливание (увеличение значения) переменной i на каждой итерации. В результате условие никогда не станет ложным. Аналогичная ситуация возникает в случае, когда в теле цикла вообще ничего не вычисляется. Например, в этом коде:

int i=1; // Формальн параметр (счётчик)
while (i > 0) // Заголовок оператора цикла
Alert("i= ",i); // Сообщение на экран

значение переменной i в цикле не изменяется. На каждой итерации на экран будет выводиться сообщение:

i= 1

Этот процесс будет повторяться бесконечно. Однажды попав в ловушку зацикленного кода, управление уже не может выйти из него. Особенно опасна эта ситуация в торгующих экспертах и скриптах. В таких случаях обычно не обновляются переменные окружения, т.к. специальная функция не заканчивает свою работу, а о факте зацикливания пользователю может быть ничего не известно. В результате управление в выполняемой программе не может быть передано в соответствующие программные строки, где принимается решение о закрытии или открытии ордеров.

Задача программиста состоит в том, чтобы не допустить возникновение условий, при которых неконтролируемое зацикливание становится возможным. Не существует метода, с помощью которого можно было бы обнаружить эту ситуацию программным способом ни на этапе компиляции программы, ни при её выполнении. Единственным возможным средством для выявления подобных алгоритмических ошибок является внимательный анализ кода - логические рассуждения и здравый смысл.

Оператор циклa for

Вторым оператором цикла является оператор for.

Формат оператора for

Полноформатный оператор цикла for состоит из заголовка, содержащего Выражение_1, Условие и Выражение_2, и исполняемого тела цикла, обрамлённого фигурными скобками.

for ( Выражение_1; Условие; Выражение_2 ) // Заголовок оператора цикла
{ // Открывающая фигурная скобка
Блок операторов, // Тело цикла может состоять..
составляющих тело цикла //.. из нескольких операторов
} // Закрывающая фигурная скобка

Если в операторе for тело цикла составляет один оператор, то фигурные скобки можно опустить.

for ( Выражение_1; Условие; Выражение_2 ) // Заголовок оператора цикла
Один оператор, тело цикла // Тело цикла - один оператор

Допускается отсутствие Выражения_1, Условия и Выражения_2. При этом наличие разделяющего знака; (точка с запятой) обязательно.

for (; Условие; Выражение_2 ) // Отсутствует Выражение_1
{ // Открывающая фигурная скобка
Блок операторов, // Тело цикла может состоять..
составляющих тело цикла //.. из нескольких операторов
} // Закрывающая фигурная скобка
// - ---------------------------------------------------------------------------------
for ( Выражение_1 ;; Выражение_2 ) // Отсутствует Условие
{ // Открывающая фигурная скобка
Блок операторов, // Тело цикла может состоять..
составляющих тело цикла //.. из нескольких операторов
} // Закрывающая фигурная скобка
// - ---------------------------------------------------------------------------------
for (;;) // Отсутств. Выражения и Условие
{ // Открывающая фигурная скобка
Блок операторов, // Тело цикла может состоять..
составляющих тело цикла //.. из нескольких операторов
} // Закрывающая фигурная скобка

Правило исполнения оператора for

При передаче управления оператору for исполнить Выражение_1. Пока Условие оператора for является истинным: передать управление первому оператору тела цикла, а после выполнения всех операторов тела цикла исполнить Выражение_2 и передать управление в заголовок для проверки истинности Условия. Если Условие оператора for является ложным, то: передать управление оператору, следующему за оператором for.

Посмотрим, как работает оператор цикла for. Для этого решим задачу.

Задача 13. Дана последовательность целых чисел: 1 2 3 4 5 6 7 8 9 10 11...Составить программу, вычисляющую сумму элементов этой последовательности, начиная с номера N1, заканчивая номером N2.

С точки зрения математики эта задача решается просто. Предположим, необходимо высчитать сумму элементов с третьего по седьмой. Решением будет сумма: 3 + 4 + 5 + 6 + 7 = 25. Такое решение годится только для частного случая, когда номера первого и последнего элементов, составляющих сумму, равны соответственно 3 и 7. Программа должна быть составлена так, чтобы при необходимости вычисления суммы в другом интервале последовательности (например, от 15-го до 23-го элемента) можно было легко заменить численные значения номеров элементов в одном месте, не меняя программные строки в других местах. Вот один из вариантов такой программы (скрипт sumtotal.mq4):

//--------------------------------------------------------------------

// sumtotal.mq4

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

//--------------------------------------------------------------------

int start() // Специальная функция start()

{

//--------------------------------------------------------------------

int

Nom_1, // Номер первого элемента

Nom_2, // Номер второго элемента

Sum, // Сумма чисел

i; // Формальн параметр (счётчик)

//--------------------------------------------------------------------

Nom_1=3; // Задаём численное значение

Nom_2=7; // Задаём численное значение

for(i=Nom_1; i<=Nom_2; i++) // Заголовок оператора цикла

{ // Скобка начала тела цикла

Sum=Sum + i; // Сумма накапливается

Alert("i=",i," Sum=",Sum); // Сообщение на экран

} // Скобка конца тела цикла

//--------------------------------------------------------------------

Alert("После выхода из цикла i=",i," Sum=",Sum);// Вывод на экран

return; // Выход из start()

}

//--------------------------------------------------------------------

В первых строках программы объявлены переменные (с комментариями, поясняющими смысл каждой переменной). В строках

Nom_1 = 3; // Задаём численное значение

Nom_2 = 7; // Задаём численное значение

численно определены значения первого и последнего элементов интервала. Обратите внимание, нигде в других местах программы эти значения не указываются. При необходимости эти значения можно легко изменить (в одном месте), не меняя код в других строках, и задача будет решена для другого интервала. После выполнения последнего из этих операторов управление передаётся оператору цикла for:

for(i=Nom_1; i<=Nom_2; i++) // Заголовок оператора цикла

{ // Скобка начала тела цикла

Sum = Sum + i; // Сумма накапливается

Alert("i=",i," Sum=",Sum); // Сообщение на экран

} // Скобка конца тела цикла

Ключевая фраза - правило исполнения оператора for такая: "Начиная с.., до тех пор пока.., с шагом.. выполнять следующее:..". Употребление слов "с шагом" уместно в том случае, если в качестве Выражения_2 используется накопительный счётчик, например, i++ или i=i+2. В данном примере ключевая фраза звучит так: начиная с i, равного Nom_1, до тех пор, пока i меньше или равно Nom_2, с шагом 1 выполнять следующее: (и далее - анализ тела цикла).

В соответствии с правилом исполнения оператора for в этом блоке программы будет выполнено следующее:

1. Исполнение Выражения_1:

i=Nom_1

Переменная i получит численное значение переменной Nom_1, т.е. целое число 3. Выражение_1 выполняется один раз, - в тот момент, когда управление передаётся оператору for и ни в каких последующих событиях Выражение_1 не участвует.

2. Выполняется проверка Условия:

i<=Nom_2

Значение переменной Nom_2 на первой итерации - целое число 7, а значение переменной i равно 3. Это значит, что Условие является истинным (т.к. 3 меньше 7), а значит управление будет передано в тело цикла для его исполнения.

3. В данном примере тело цикла составляют два оператора, которые будут последовательно исполнены:

Sum = Sum + i; // Сумма накапливается
Alert("i=",i," Sum=",Sum); // Сообщение на экран

Переменная Sum не получила при инициализации какое-либо начальное значение, поэтому до начала первой итерации её значение равно нулю. В процессе вычислений значение переменной Sum увеличивается на величину i и по окончании первой итерации равно 3. Это значение можно увидеть в окне функции Alert():

i=3 Sum=3

4. Последним событием, которое происходит при выполнении оператора цикла, является исполнение Выражения_2:

i++

Значение переменной i увеличивается на единицу. На этом заканчивается первая итерация, и управление передаётся на проверку Условия.

Далее начинается вторая итерация, пункты 2 - 4. В процессе вычислений переменные получают новые значения. В частности, на второй итерации значение переменной i будет равно 4, а Sum будет равно 7, о чём появится соответствующее сообщение. В целом, события в этой программе будут развиваться в соответствии со схемой:

Рис. 43. Функциональная схема исполнения оператора цикла for в программе sumtotal.mq4.

Программа будет циклически повторять исполнение оператора цикла, до тех пор, пока Условие не окажется ложным. Это произойдёт, когда значение переменной i будет равно 8, т.е. больше заданного значения переменной Nom_2, равного 7. В этом случае управление будет передано за пределы оператора for, а именно в строку:

Alert("После выхода из цикла i=",i," Sum=",Sum);// Вывод на экран

и дальше, на исполнение оператора return, завершающего работу специальной функции start().

Можно использовать эту программу для вычислений суммы любого другого интервала значений. Например, если заменить константы 3 и 7 на 10 и 15, то в результате исполнения этой же программы будет вычислена сумма значений для указанного интервала.

В некоторых языках программирования переменные, указанные в заголовке оператора цикла, после выхода из цикла теряют свои значения. В MQL4 это не так. Все переменные, участвующие в любых вычислениях, являются полноценными и сохраняют свои значения после завершения цикла. Вместе с тем, есть особенности, а скорее подробности, касающиеся значений переменных, участвующих в вычислениях.

Обратите внимание на 2 последние строки сообщений, оставшиеся после завершения всех вычислений и выгрузки скрипта:

i=7 Sum=25

После выхода из цикла i=8 Sum=25

Первое из этих сообщений появилось на стадии последней итерации, ещё до завершения цикла, а последнее сообщение выдано последней функцией Alert() перед завершением программы. Примечательно, что в этих строках отображаются разные значения переменной i. Ещё при выполнении цикла это значение равно 7, а после завершения цикла равно 8. Чтобы понять, почему это произошло, обратимся ещё раз к рис. 43.

Последняя (в данном случае - пятая) итерация начинается с проверки Условия. Значение i в этот момент равно 7. Поскольку 7 не больше, чем значение переменной Nom_2, то Условие истинно, а значит будет выполняться тело цикла. По окончании выполнения операторов, составляющих тело цикла, осуществляется последняя операция: исполняется Выражение_2. Это необходимо ещё раз подчеркнуть особо:

Последним событием, происходящим на каждой итерации при исполнении цикла for, является вычисление Выражения 2.

В результате этого значение переменной i увеличивается на 1 и становится равным 8. Очередная проверка Условия (в начале следующей итерации) подтверждает, что теперь условие ложно, поэтому после проверки управление передаётся за пределы оператора цикла. При этом переменная i выходит из оператора цикла со значением 8, а значение переменной Sum остаётся равным 25, потому что исполнение тела цикла на этом этапе уже не происходит. Это замечание необходимо учитывать в случаях, когда количество итераций заранее неизвестно, и судить об этом программист предполагает, ориентируясь на значение переменной, вычисленной в Выражении_2.

Исключительным случаем можно считать ситуацию, при которой возникает зацикливание. Это становится возможным при различных ошибках. Например, если в качестве Выражения_2 ошибочно использовать оператор:

i--

то значение счётчика на каждой итерации будет уменьшаться, поэтому Условие никогда не станет ложным.

Другим ошибочным случаем может быть неправильно составленное Условие:

for(i=Nom_1; i>=Nom_1; i++) // Заголовок оператора цикла

В данном случае значение переменной i всегда будет больше или равным значению переменной Nom_1, поэтому Условие всегда будет оставаться истинным.

Взаимозаменяемость операторов циклов while и for

Использование того или иного оператора цикла полностью зависит от решения программиста. Здесь только нужно отметить, что эти операторы взаимозаменяемы; зачастую необходимо лишь немного доработать код программы.

Например, при решении Задачи 13, был использован оператор цикла for:

for (i=Nom_1; i<=Nom_2; i++) // Заголовок оператора цикла

{ // Скобка начала тела цикла

Sum = Sum + i; // Сумма накапливается

Alert("i=",i," Sum=",Sum); // Сообщение на экран

} // Скобка конца тела цикла

А так может выглядеть тот же фрагмент программы, но с использованием оператора цикла while:

i=Nom_1; // Оператор присваивания

while (i<=Nom_2) // Заголовок оператора цикла

{ // Скобка начала тела цикла

Sum = Sum + i; // Сумма накапливается

Alert("i=",i," Sum=",Sum); // Сообщение на экран

i++; // Увеличение номера элемента

} // Скобка конца тела цикла

Легко увидеть, что для подобной замены достаточно вынести Выражение_1 в строку, предшествующую оператору цикла, а Выражение_2 указать последним в теле цикла. Вы можете самостоятельно внести изменения в программу и запустить её на выполнение, чтобы убедиться, что результат при исполнении обоих вариантов окажется одинаковым.

Оператор break

В ряде случаев, например, при программировании циклических операций, возникает необходимость прервать выполнение цикла ещё до того, когда условие оператора цикла станет ложным. Для решения подобных задач необходимо использовать оператор break.

Формат оператора break

Оператор break состоит из одного слова, заканчивается знаком; (точка с запятой).

break; // Оператор break

Правило исполнения оператора break

Оператор break прекращает исполнение ближайшего внешнего оператора while, for или switch. Исполнением оператора break является передача управления за пределы составного оператора while, for или switch, ближайшему следующему оператору. Оператор break может использоваться только для прерывания выполнения указанных операторов.

Исполнение оператора break можно проиллюстрировать на следующем примере.

Задача 14. Дана нить длиной 1 метр. Требуется сложить нить в форме прямоугольника, имеющего максимально возможную площадь. Путём последовательного перебора вариантов найти площадь этого прямоугольника и длины сторон с точностью до 1 мм.

Из цельного отрезка нити можно сложить бесконечное количество прямоугольников различных размеров. Учитывая, что по условиям задачи точность вычислений составляет 1 мм, мы можем рассмотреть всего 499 вариантов. Первый, самый "тонкий", прямоугольник будет иметь размеры 1 х 499 мм, второй - 2 х 498 мм и так далее, а размеры последнего будут составлять 499 х 1 мм. Нам необходимо перебрать все эти прямоугольники и выбрать из них один, имеющий максимальную площадь.

Легко заметить, что в рассматриваемом наборе прямоугольников встречаются повторяющиеся размеры. Например, первый и последний прямоугольники имеют одинаковый размер: 1 х 499 (то же, что 499 х 1). Аналогично этому, размер второго прямоугольника совпадает с размером предпоследнего и т.д. Нам необходимо составить алгоритм перебора всех оригинальных вариантов, но перебирать повторяющиеся нет необходимости.

Для начала проведём предварительную оценку: определим, как площадь прямоугольника будет зависеть от его размеров. Легко понять, что у первого прямоугольника, с размерами сторон 1 х 499, будет самая маленькая площадь. Далее, по мере увеличения малой стороны, площадь прямоугольников будет увеличиваться. По достижении некоторого значения площади прямоугольников начнут снижаться. Эта зависимость отражена на рис. 44:

Рис. 44. Зависимость размера площади прямоугольника от размера одной стороны.

Глядя на рис. 44, несложно прийти к выводу, что искать максимальную площадь, перебирая варианты, начиная с первого, необходимо лишь до тех пор, пока площадь в процессе вычислений увеличивается. Как только она начнёт снижаться, необходимо закончить перебор и выйти из цикла перебора вариантов. Ниже представлен скрипт rectangle.mq4, в котором реализован такой алгоритм.

//--------------------------------------------------------------------

// rectangle.mq4

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

//--------------------------------------------------------------------

int start() // Специальная функция start()

{

//--------------------------------------------------------------------

int

L=1000, // Заданная длина нити

A, // Первая сторона прямоугольн.

B, // Вторая сторона прямоугольн.

S, // Площадь прямоугольника

a,b,s; // Текущие значения

//--------------------------------------------------------------------

for(a=1; a<L/2; a++) // Заголовок оператора цикла

{ // Скобка начала тела цикла

b=(L/2) - a; // Текущее значение сторон

s=a * b; // Текущее значение площади

if (s<=S) // Выбираем большее значение

break; // Выходим за пределы цикла

A=a; // Запоминаем лучшее значение

B=b; // Запоминаем лучшее значение

S=s; // Запоминаем лучшее значение

} // Скобка конца тела цикла

//--------------------------------------------------------------------

Alert("Максимальная площадь = ",S," A=",A," B=",B);// Сообщение

return; // Оператор выхода из функции

}

//--------------------------------------------------------------------

Проследим, как эта программа работает. В начале программы объявлены и прокомментированы переменные. В пределах цикла for реализуется собственно алгоритм решения задачи. В Выражении_1 задано начальное значение размера стороны а прямоугольника, равное 1. В соответствии с Условием, перебор ведётся до тех пор, пока размер стороны прямоугольника а остаётся меньше половины длины нити. Выражение_2 предписывает увеличивать размер стороны прямоугольника а на каждом шаге итерации.

Переменные a, b и s - текущие переменные, значения которых перебираются. Переменные A, B и S - искомые значения. В начале цикла вычисляется вторая сторона b и площадь s текущего прямоугольника.

b = (L/2) - a; // Текущее значение сторон

s = a * b; // Текущее значение площади

В операторе if проверяется условие выхода из цикла:

if (s <= S) // Выбираем большее значение

break; // Выходим за пределы цикла

Если только что вычисленная площадь текущего прямоугольника s оказывается больше площади S, вычисленной на предыдущей итерации, то это новое значение s и становится лучшим достигнутым результатом. В этом случае Условие оператора if не выполняется, а управление передаётся ближайшему оператору, следующему за оператором if. В этих строках запоминаются лучшие достигнутые результаты:

A = a; // Запоминаем лучшее значение
B = b; // Запоминаем лучшее значение
S = s; // Запоминаем лучшее значение

При достижении ближайшей закрывающей фигурной скобки итерация заканчивается и управление передаётся в заголовок оператора for для выполнения Выражения_2 и проверки Условия. Если на момент проверки размер стороны а ещё не вырос до указанных пределов, то выполнение цикла продолжится.

Повторяющиеся циклические вычисления будут продолжаться до тех пор, пока не произойдёт одно из событий: либо размер стороны а превысит допустимые пределы (в соответствии с Условием оператора for), либо размер вычисленной площади s окажется меньше ранее достигнутого значения, хранящегося в переменной S. У нас есть все основания считать, что раньше произойдёт выход из цикла по условию оператора if:

if (s <= S) // Выбираем большее значение
break; // Выходим за пределы цикла

Действительно, оператор цикла for составлен так, что перебирает все возможные варианты без исключения (половина длины нити L/2 - это сумма двух сторон). В то же время максимальная площадь прямоугольника будет достигнута где-то в середине перебираемого набора вариантов. И как только это событие произойдёт (площадь текущего прямоугольника s окажется меньше или равной ранее достигнутого значения S), в рамках исполнения оператора if управление будет передано оператору break, который, в свою очередь, передаст управление за пределы оператора for в строку:

Alert("Максимальная площадь = ",S," A=",A," B=",B);// Сообщение

В результате исполнения встроенной функции Alert() будет напечатана следующая строка:

Максимальная площадь = 62500 А=250 В=250

После этого управление будет передано оператору return, в результате чего специальная функция start() завершит свою работу. Это, в свою очередь, приведёт к окончанию работы скрипта и выгрузке его клиентским терминалом из окна финансового инструмента.

В данном примере оператор break прекращает работу (передаёт управление за пределы) оператора цикла for, а именно того оператора цикла, внутри которого он находится. Ниже приведена функциональная схема цикла for, в котором используется специальный выход:

Рис. 45. Функциональная схема цикла for с использованием оператора break (rectangle.mq4).

На схеме видно, что из цикла имеется два выхода: нормальный выход (выход из цикла в результате срабатывания условия, заключённого в заголовке оператора цикла) и специальный выход из цикла (выход из тела цикла по дополнительному условию с помощью оператора break).

Возможность специального выхода из цикла в языке MQL4 трудно переоценить. В нашем примере использование оператора break позволило составить алгоритм, при котором выполняются только необходимые вычисления. Алгоритм, составленный без специального выхода из цикла, был бы неэффективным - в этом случае производились бы повторяющиеся вычисления, что привело бы к необоснованной трате вычислительных ресурсов и времени. Заштрихованная область на рис. 44 наглядно показывает область параметров, которые не обрабатывались в рассматриваемой программе (почти половина всех вычислений!), что не помешало получить правильный результат.

Необходимость использования эффективных алгоритмов становится особенно очевидна, когда время работы программы растягивается на секунды и даже минуты, что может оказаться больше, чем промежуток времени между тиками. В этом случае сохраняется риск пропустить обработку некоторых содержательных тиков и как результат - потерять инициативу в управлении торговлей. Кроме этого, снижение времени вычислений особенно остро ощущается при выполнении тестирования программ на тестере стратегий. Тестирование сложных программ на большом промежутке исторических данных может занимать часы и дни. Снижение времени тестирования наполовину в этой ситуации оказывается очень важной возможностью.

В правиле указано, что оператор break прекращает действие ближайшего внешнего оператора. Посмотрим, как работает программа, в которой используются вложенные циклы.

Задача 15. Используя алгоритм Задачи 14, подобрать наименьшую нить, кратную 1 метру, достаточную, чтобы образовать прямоугольник площадью 1.5 м ².

В этой задаче необходимо последовательно перебирать имеющиеся длины нитей, для каждой из которых нужно вычислить максимально достижимую площадь. Решение задачи 15 реализовано в скрипте area.mq4. Варианты решения перебираются в двух циклах - во внешнем и во внутреннем. Внешний цикл перебирает длину нити с шагом 1000 мм, а внутренний находит максимальную площадь для текущей длины нити. В данном случае оператор break используется для выхода из внешнего и внутреннего циклов.

//--------------------------------------------------------------------

// area.mq4

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

//--------------------------------------------------------------------

int start() // Специальная функция start()

{

//--------------------------------------------------------------------

Дата добавления: 2014-12-29