Составить цикл с заданной точностью с

Теги: Си циклы. C loops. Цикл с постусловием. Цикл с предусловием. Цикл со сщётчиком. while. do while. for. break. continue

Введение. Циклы с предусловием.

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

Любой цикл состоит из тела и проверки условия, при котором этот цикл должен быть прекращён. Тело цикла – это тот набор инструкций, который необходимо повторять. Каждое повторение цикла называют итерацией.

Рассмотрим цикл с предусловием.

int i = 0; while (i < 10) { f(“%dn”, i); i++; }

Этот цикл выполняется до тех пор, пока истинно условие, заданное после ключевого слова while. Тело цикла – это две строки, одна выводит число, вторая изменяет его. Очевидно, что этот цикл будет выполнен 10 раз и выведет на экран

1 2 3 и так далее до 9.

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

int i = 0; while (i < 10) { f(“%dn”, i); }

В этом цикле не изменяется переменная i, которая служит для определения условия останова, поэтому цикл не завершится.

int i = 0; while (i > 0) { f(“%dn”, i); i++; }

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

int i; while (i < 10) { f(“%dn”, i); i++; }

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

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

int i = 0; while (i < 10) f(“%dn”, i++);

Здесь мы инкрементируем переменную i при вызове функции f. Следует избегать такого стиля кодирования. Отсутствие фигурных скобок, особенно в начале обучения, может приводить к ошибкам. Кроме того, код читается хуже, да и лишние скобки не сильно раздувают листинги.

Циклы с постусловием.

Цикл с постусловием отличается от цикла while тем, что условие в нём проверяется после выполнения цикла, то есть этот цикл будет повторён как минимум один раз (в отличие от цикла while, который может вообще не выполняться). Синтаксис цикла

do { тело цикла } while(условие);

Предыдущий пример с использованием цикла do будет выглядеть как

int i = 0; do { f(“%dn”, i); i++; } while(i < 10);

Давайте рассмотрим пример использования цикла с постусловием и предусловием. Пусть нам необходимо проинтегрировать функцию.

Рис. 1 Численное интегрирование функции

∫ a b f &Apply; x d x

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

∫ a b f &Apply; x d x = ∑ i = a b f &Apply; i h

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

Рис. 2 Численное интегрирование функции методом

левых прямоугольников

Пусть искомой функцией будет x 2 . Нам понадобятся следующие переменные. Во-первых, аккумулятор sum для хранения интеграла. Во-вторых, левая и правая границы a и b, в третьих – шаг h. Также нам понадобится текущее значение аргумента функции x.

Для нахождения интеграла необходимо пройти от a до b с некоторым шагом h, и прибавлять к сумме площадь прямоугольника со сторонами f(x) и h.

#include<conio.h> #include<stdio.h> int main() { double sum = 0.0; double a = 0.0; double b = 1.0; double h = 0.01; double x = a; while (x < b) { sum += x*x * h; x += h; } f(“%.3f”, sum); getch(); }

Программа выводит 0.328.

Решение

∫ 0 1 x 2 d x = x 3 3 | 0 1 = 1 3 ≈ 0.333

Если посмотреть на график, то видно, что каждый раз мы находим значение функции в левой точке. Поэтому такой метод численного интегрирования называют методом левых прямоугольников. Аналогично, можно взять правое значение. Тогда это будет метод правых прямоугольников.

while (x < b) { x += h; sum += x*x * h; } Рис. 3 Численное интегрирование функции методом

правых прямоугольников

Сумма в этом случае будет равна 0.338. Метод левых и правых прямоугольников не очень точен. Мы фактически аппроксимировали (приблизили) гладкий график монотонно возрастающей функции гистограммой. Если немного подумать, то аппроксимацию можно проводить не только суммируя прямоугольники, но и суммируя трапеции.

Рис. 4 Численное интегрирование функции методом

трапеций

Приближение с помощью трапеций на самом деле является кусочной аппроксимацией кривыми первого порядка (ax+b). Мы соединяем точки на графике с помощью отрезков. Можно усложнить, соединяя точки не отрезками, а кусками параболы, тогда это будет метод Симпсона. Если ещё усложнить, то придём к сплайн интерполяции, но это уже другой, очень долгий разговор.

Вернёмся к нашим баранам. Рассмотрим 4 цикла.

int i = 0; while ( i++ < 3 ) { f(“%d “, i); } int i = 0; while ( ++i < 3 ) { f(“%d “, i); } int i = 0; do { f(“%d “, i); } while(i++ < 3); int i = 0; do { f(“%d “, i); } while(++i < 3);

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

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

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

#include<conio.h> #include<stdio.h> int main() { int num = 0; int max = num; f(“To quit, enter 0n”); /*бесконечный цикл*/ while (1) { f(“Please, enter number: “); scanf(“%d”, &num); /*условие выхода из цикла*/ if (num == 0) { break; } if (num > max) { max = num; } } f(“max number was %d”, max); getch(); }

Напомню, что в си нет специального булевого типа. Вместо него используются числа. Ноль – это ложь, все остальные значения – это истина. Цикл while(1) будет выполняться бесконечно. Единственной точкой выхода из него является условие

if (num == 0)

В этом случае мы выходим из цикла с помощью break; Для начала в качестве максимального задаём 0. Пользователь вводит число, после чего мы проверяем, ноль это или нет. Если это не ноль, то сравниваем его с текущим максимальным.

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

Когда нам необходимо пропустить тело цикла, но при этом продолжить выполнение цикла, используется оператор continue. Простой пример: пользователь вводит десять чисел. Найти сумму всех положительных чисел, которые он ввёл.

#include<conio.h> #include<stdio.h> int main() { int i = 0; int positiveCnt = 0; float sum = 0.0f; float input; f(“Enter 10 numbersn”); while (i < 10) { i++; f(“%2d: “, i); scanf(“%f”, &input); if (input <= 0.0) { continue; } sum += input; positiveCnt++; } f(“Sum of %d positive numbers = %f”, positiveCnt, sum); getch(); }

Пример кажется несколько притянутым за уши, хотя в общем он отражает смысл оператора continue. В этом примере переменная positiveCnt является счётчиком положительных чисел, sum сумма, а input – временная переменная для ввода чисел.

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

do { f(“Please, enter number: “); scanf(“%d”, &n); if (n < 0 || n>100) { f(“bad number, try againn”); continue; } else { break; } } while (1);

Цикл for

Одним из самых используемых является цикл со счётчиком for. Его синтаксис

for (<инициализация>; <условие продолжения>; <изменение счётчика>){ <тело цикла> }

Например, выведем квадраты первых ста чисел.

int i; for (i = 1; i < 101; i++) { f(“%d “, i*i); }

Одним из замечательных моментов цикла for является то, что он может работать не только с целыми числами.

float num; for (num = 5.3f; num > 0f; num -= 0.2) { f(“%.2f “, num); }

Этот цикл выведет числа от 5.3 до 0.1. Цикл for может не иметь некоторых “блоков” кода, например, может отсутствовать инициализация, проверка (тогда цикл становится бесконечным) или изменение счётчика. Вот пример с интегралом, реализованный с применением счётчика for

#include<conio.h> #include<stdio.h> int main() { double sum = 0.0; double a = 0.0; double b = 1.0; double h = 0.01; double x; for (x = a; x < b; x += h) { sum += x*x * h; } f(“%.3f”, sum); getch(); }

Давайте рассмотрим кусок кода

double x ; for (x = a; x < b; x += h) { sum += x*x * h; }

Его можно изменить так

double x = a; for (; x < b; x+=h) { sum += x*x*h; }

Более того, используя оператор break, можно убрать условие и написать

double x; for (x = a;; x += h){ if (x>b){ break; } sum += x*x*h; }

или так

double x = a; for (;;){ if (x > b){ break; } sum += x*x*h; x += h; }

кроме того, используя оператор “,”, можно часть действий перенести

double x ; for (x = a; x < b; x += h, sum += x*x*h) ;

ЗАМЕЧАНИЕ: несмотря на то, что так можно делать, пожалуйста, не делайте так! Это ухудшает читаемость кода и приводит к трудноуловимым ошибкам.

Давайте решим какую-нибудь практическую задачу посложнее. Пусть у нас имеется функция f(x). Найдём максимум её производной на отрезке. Как найти производную функции численно? Очевидно, по определению). Производная функции в точке – это тангенс угла наклона касательной.

Рис. 5 Численное дифференцирование функции

f &Apply; x ′ = d x d y

Возьмём точку на кривой с координатами (x; f(x)), сдвинемся на шаг h вперёд, получим точку (x+h, f(x+h)), тогда производная будет

d x d y = f &Apply; ( x + h ) – f &Apply; x ( x + h – x ) = tg &Apply; α

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

d x d y = f &Apply; x – f &Apply; ( x – h ) h = tg &Apply; β

Возьмём среднее от этих двух значений, получим

f &Apply; ( x + h ) – f &Apply; ( x – h ) 2h

В общем-то теперь задача становится тривиальной: идём от точки a до точки b и находим минимальное значение производной, а также точку, в которой производная принимает это значение. Для решения нам понадобятся, как и в задаче с интегралом, переменные для границ области поиска a и b, текущее значение x и шаг h. Кроме того, необходимо максимальное значение maxVal и координата maxX этого максимального значения. Для работы возьмём функцию x • sin &Apply; x

#include<conio.h> #include<math.h> #include<stdio.h> int main() { double a = 0; double b = 3.0; double h = 0.001; double h2 = h * 2.0; double maxVal = a*sin(a); double maxX = a; double curVal; double x; // Проходим по всей области от a до b // и ищем максимум первой производной // Используем функцию x*sin(x) for (x = a; x < b; x += h) { curVal = ( (x+h)*sin(x+h)-(x-h)*sin(x-h) )/h2; if (curVal > maxVal) { maxVal = curVal; maxX = x; } } f(“max value = %.3f at %.3f”, maxVal, maxX); getch(); }

На выходе программа выдаёт max value = 1.391 at 1.077

Рис. 6 График производной функции x*sin(x)

Численное решение даёт такие же (с точностью до погрешности) результаты, что и наша программа.

Вложенные циклы

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

#include<conio.h> #include<math.h> #include<stdio.h> int main() { int i, j; // Для каждого i for (i = 1; i < 11; i++) { // Выводим строку из произведения i на j for (j = 1; j < 11; j++) { f(“%4d”, i*j); } // После чего переходим на новую строку f(“n”); } getch(); }

В этом примере в первый цикл по переменной i вложен второй цикл по переменной j. Последовательность действий такая: сначала мы входим в цикл по i, после этого для текущего i 10 раз подряд осуществляется вывод чисел. После этого необходимо перейти на новую строку. Теперь давайте выведем только элементы под главной диагональю

for (i = 1; i < 11; i++) { for (j = 1; j < 11; j++) { if (j > i) { break; } f(“%4d”, i*j); } f(“n”); }

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

for (i = 1; i < 11; i++) { for (j = 1; j <= i; j++) { f(“%4d”, i*j); } f(“n”); }

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

Q&A

Всё ещё не понятно? – пиши вопросы на ящик

Источник

В этом уроке мы расскажем как вычислить сумму бесконечного сходящегося ряда (последовательности) с определенной точностью. Будет рассмотрена соответствующая программа, написанная на языке программирования Си. В конце статьи можно скачать исходник этой программы для Visual Studio.

Читайте также: Циклы углерода и воды

Сходящийся ряд – это числовая последовательность элементов множества X, имеющая предел в этом множестве.

Графическое изображение сходящегося ряда

Сходящийся ряд

Рассмотрим задачу вычисления суммы сходящегося ряда с определенной точностью на примере. Пусть дан ряд:

Вычисление суммы ряда с определенной точностью ε означает, что сумма ряда вычисляется до тех пор, пока модуль разности между текущим и предыдущим членом последовательности больше ε. В виде формулы это утверждение можно записать так: |an – an-1| > ε, то есть пока это выражение истинно, вычисления продолжаются.

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

double f(int k)

{

double res;

res = -32.0;

res *= (double)powf(-0.5, k);

return res;

}

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

Выражение res *= (double)powf(-0.5, k); эквивалентно выражению res = res * (double)powf(-0.5, k);

Оператор powf – это оператор возведения числа в степень. В нашем случае он вычисляет: -0.5k.

Функцию f можно записать короче:

double f(int k)

{

return -32.0 * powf(-0.5, k);

}

Теперь перейдем к функции main. Для начала считаем с консоли число e – это и будет заданная точность вычислений ε.

float e;

f(“e = “);

scanf_s(“%f”, &e);

Объявим переменные, в которых будут хранится: значение предыдущего, значение текущего члена ряда, сумма ряда и номер текущего члена ряда (число k) соответственно.

double previous, current;

double sum = 0;

int k = 0;

Отдельно вычислим первый член ряда (потом он станет “предыдущим”), чтобы затем перейти к вычислениям в цикле.

current = f(k);

sum += current;

k++;

Запись выражения sum += current; эквивалентна записи: sum = sum + current;

Теперь перейдем к вычислениям в цикле. Условием выхода из цикла будет ложность выражения: |an – an-1| > ε.

{

previous = current;

current = f(k);

sum += current;

k++;

} while (abs(current – previous) > e);

Сумма посчитана. Осталось вывести результат вычислений в консоль.

f(“sum = %fn”, sum);

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

#include <stdio.h>

#include <math.h>

#include <conio.h>

double f(int k)

{

double res;

res = -32.0;

res *= (double)powf(-0.5, k);

return res;

}

int main()

{

float e;

f(“e = “);

scanf_s(“%f”, &e);

double previous, current;

double sum = 0;

int k = 0;

current = f(k);

sum += current;

k++;

{

previous = current;

current = f(k);

sum += current;

k++;

} while (abs(current – previous) > e);

f(“sum = %fn”, sum);

_getch();

return 0;

}

Оператор _getch(); в строке 34 нужен для того, чтобы консоль не закрывалась сразу по завершении исполнения программы.

Демонстрация работы программы для нашего ряда представлена на скриншоте ниже. Точность вычислений составляет: ε = 0.01.

Вычисление суммы ряда с заданной точностью. Работа программы

Скачать исходник

Вычисление суммы ряда с заданной точностью

Источник

Цель лабораторной работы: изучение концепций и освоение технологии процедурного программирования, приобретение навыков процедурного программирования на языке C/C++ циклических вычислений.

Задание на программирование: используя технологию процедурного программирования разработать программу решения индивидуальной задачи тремя видами циклических управляющих структур: Цикл – Пока (с предусловием), Цикл – До (с постусловием), Цикл – Для (с параметром).

Порядок выполнения работы:

1) Получить у преподавателя индивидуальное задание. Выполнить постановку задачи: сформулировать условие, определить входные и выходные данные.

2) Разработать математическую модель.

3) Построить схему алгоритма, последовательно используя для решения задачи все три циклические управляющие структуры (операторы while, do…while, for). Каждое решение должно быть реализовано в виде отдельной функции.

При этом:

– запрещается использовать оператор if для проверки условия входа в циклы и в качестве одного из операторов тела цикла;

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

4) Составить программу на языке C/C++.

5) Входные данныевводить с клавиатуры по запросу.

6) Вывод результатов должен осуществляться в функции main(). Выходные данные выводить на экран в развернутой форме с пояснениями.

7) Использовать стандартные потоковые объекты ввода/вывода cin и cout.

8) Проверить и продемонстрировать преподавателю работу программы на полном наборе тестов, в том числе с ошибочными входными данными.

9) Оформить отчет о лабораторной работе в составе: постановка задачи, математическая модель, схема алгоритма решения, текст программы, контрольные примеры.

Варианты индивидуальных заданий

Вычислить предел последовательности {Yn} при n ® , где Yn вычисляется по формуле:

Yn = 0.25 sin(Yn-1) + cos(Yn-3); n = 3, 4, 5,…

Значения Y0, Y1, Y2 и точность вычисления e вводятся с клавиатуры. Вычисления прекратить при выполнении условия ïYn – Yn-1ï < e.

Вычислить предел последовательности {Yn} при n ® ∞, где Yn вычисляется по формуле:

Yn = 0.3 sin(Yn-1) + Yn-3; n = 3,.4, 5,…

Вычислить предел последовательности {Yn} при n ® , где Yn вычисляется по формуле:

Yn=0.1 tg (Yn-1) + 0.3 tg (Yn-3); n = 3, 4, 5,…

Вычислить предел последовательности {Yn} при n ® , где Y0=0, а Yn вычисляется по формуле:

n = 1, 2, 3,…

Значение точности вычисления e вводится с клавиатуры. Вычисления прекратить при выполнении условия ïYn – Yn-1ï < e.

Вычислить предел последовательности {Yn} при n ® , где Yn вычисляется по формуле:

Yn = 0.352 * Yn-1 + cos(π/2 + Yn-3); n = 3, 4, 5,…

2) Вычислить предел последовательности {Yn} при n ® , где Yn вычисляется по формуле:

n = 3, 4, 5,…

Вычислить предел последовательности {Yn} при n ® , где Yn вычисляется по формуле:

n = 3, 4, 5,…

Вычислить предел последовательности {Yn} при n ® , где Yn вычисляется по формуле:

n = 3, 4, 5,…

Вычислить предел последовательности {Yn} при n ® , где Yn вычисляется по формуле:

n = 3, 4, 5,…

10.

Вычислить предел последовательности {Yn} при n , где Yn вычисляется по формулам:

n = 2, 3, 4…

Значение X (0 ≤ X < 1) и точность вычисления e вводятся с клавиатуры. Вычисления прекратить при выполнении условия ïYn – Yn-1ï < e.

11.

Вычислить предел последовательности {Yn} при n , где Yn вычисляется по формулам:

Y1 = X; Yn = Yn-1(2 – X*Yn-1); n = 2, 3, 4,…

Значение X (0 < X ≤ 1.4) и точность вычисления e вводятся с клавиатуры. Вычисления прекратить при выполнении условия ïYn – Yn-1ï < e.

12.

Найти предел произведения для последовательности {Yn}, пользуясь рекуррентной формулой

Y1 = 1; Yn = n*(Yn-1 + 1); n = 2, 3, 4,…

Вычисления прекратить при выполнении условия |Yn – Yn-1| <ε.

13.

Вычислить – корень k-ой степени из положительного числа A, пользуясь последовательным приближением

n = 1, 2, 3,…

Значение точности вычисления e вводится с клавиатуры. За корень принять такое Xn, при котором |Xn – Xn-1| < ε.

14.

Для приближенного решения уравнения Кеплера X-q*sin(X)=m, 0 < q < 1

полагают X0 = m, X1 = m + q*sin(X0),…, Xn = m + q*sin(Xn-1),…

Значения m и q и точность вычисления e вводятся с клавиатуры. Найти решение уравнения Кеплера, принимая за него такое Xn, при котором |Xn – Xn-1| < ε.

15.