Размещено на http://www.allbest.ru/

МИНОБРНАУКИ РОССИИ

Федеральное государственное бюджетное образовательное учреждение

высшего образования «Тульский государственный университет»

Институт прикладной математики и компьютерных наук

Кафедра вычислительной техники

Курсовая работа по дисциплине

ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ

на тему: ИССЛЕДОВАНИЕ ВЫЧИСЛИТЕЛЬНОЙ ЭФФЕКТИВНОСТИ ОБЪЕКТНО-ОРИЕНТИРОВАННЫХ ПРИЛОЖЕНИЙ

Студент группы 220692 Стрельников Е.О.

Руководитель работы к.т.н. доцент Берсенев Г.Б.

Тула 2021



МИНОБРНАУКИ РОССИИ

ФГБОУ ВО «Тульский государственный университет»

Институт прикладной математики и компьютерных наук

Кафедра «Вычислительная техника»

З а д а н и е

На курсовую работу по дисциплине «Объектно-ориентированное программирование» студенту группы 220692 Стрельникову Евгению Олеговичу

Тема работы:

«Исследование вычислительной эффективности объектно-ориентированных приложений»

Входные данные: Вариант №18:

задача: определение площади фигуры методом Монте-Карло;

фигура: nomced;

приложение №1: процедурное приложение на базе Console/C#;

приложение №2: объектно-ориентированное приложение на базе Console/C#.

Задание получил ____________________ «19» февраля 2021 г.

Срок представления задания «1» июня 2021 г.

Руководитель ___________________ ___________________________

(подпись) (расшифровка подписи)

«__» ________________ 20___г.

К защите. Руководитель ________________ ____________________

(подпись) (расшифровка подписи)

Замечания руководителя________________________________________

«__» ________________ 20___г.

При защите курсового проекта (работы) наличие рецензии обязательно.



Содержание

Введение

1. Постановка задачи

2. Разработка технического задания

2.1 Анализ вариантов использования программы

2.2 Требования к приложениям

3. Анализ алгоритма решения

3.1 Метод Монте-Карло

3.2 Определение попадания точки внутрь фигуры

4. Процедурное приложение на базе Console/C#

4.1 Программные средства разработки

4.2 Логическое проектирование

4.3 Системные требования

4.4 Структура приложения

4.5 Результаты работы

5. Объектно-ориентированное приложение

5.1 Программные средства разработки

5.2 Логическое проектирование

5.3 Описание программы

5.4 Структура приложения

5.5 Руководство системного программиста

5.6 Руководство программиста

5.7 Руководство оператора

5.8 Результаты работы

6. Анализ вычислительной эффективности приложений

7. Улучшение характеристик качества приложений

7.1 Использование встроенной оптимизации

7.2 Профилирование

7.3 Результаты улучшения характеристик

Заключение

Список литературы

Приложение

Файл Program.cs (процедурное приложение)

Файл Program.cs (объектно-ориентированное приложение)

Файл Point.cs

Файл Rect.cs

Файл Circle.cs

Файл Triangle.cs

Файл Figura.cs

Файл IAbstractFigure.cs



Введение

приложение вычислительный процедурный объектны

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

Использование объектно-ориентированного (ОО) подхода при разработке программного обеспечения (ПО) позволяет преодолеть естественную сложность разрабатываемого ПО, упростить процесс отладки и последующего сопровождения, расширения и переноса ПО на другие платформы.

Основным понятием ООП является класс. Класс (class) определяет группу объектов с общими свойствами (атрибутами), поведением (функциями), семантикой и связями с другими объектами. Класс можно трактовать как шаблон для создания объектов. Каждый объект является экземпляром некоторого класса, причем только одного. Класс может наследовать один или нескольких интерфейсов, реализуя свойства, события и методы каждого из них.

В данной курсовой работе создаются процедурно-ориентированная и объектно-ориентированная реализации конкретного приложения и проводится сравнительный анализ их вычислительной эффективности. В курсовой работе используется интегрированная среда разработки - Microsoft Visual Studio.

Microsoft Visual Studio - интегрированная среда разработки программного обеспечения и ряда других инструментальных средств. Данная среда позволяет разрабатывать консольные приложения, приложения с графическим интерфейсом, так и веб-сайты, веб-приложения, веб-службы.



1. Постановка задачи

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

Вариант задания №18:

· геометрическая фигура: ;

· приложение 1: процедурное приложение на базе Console/C#;

· приложение 2: Объектно-ориентированное приложение на базе Console/C#.

Геометрическая фигура представляет собой прямоугольник, из которого вырезаны треугольники , , полукруг с диаметром , центр окружности которой и радиус (рис. 1.).

Расположение точек вершин фигуры приведено на рис. 1.

Размещено на http://www.allbest.ru/

Рис. 1 Фигура

Для построения данной фигуры будет достаточно задать точки b и d, другие будут рассчитаны автоматически. Для расчёта площади фигуры методом Монте-Карло необходимо N раз сгенерировать по два случайных числа для координат x и y, определяющих точку внутри прямоугольника. Генерируемые случайным образом точки равномерно заполнят площадь прямоугольника, для этого случайные числа имеют равномерное распределение.

Для каждой точки выполняется проверка, попала ли точка внутрь заданной фигуры. Если из N точек M точек оказалось внутри фигуры, а площадь прямоугольника равна S, то площадь фигуры будет приближенно равна .

Поскольку площадь фигуры легко определяется по правилам геометрии, мы можем определить относительную погрешность приближенного вычисления этой площади методом Монте-Карло. Естественно, чем больше N, тем меньше погрешность такого вычисления.

Каждое приложение шесть раз повторяет эксперимент и вычисляет площадь фигуры методом Монте-Карло для соответственно. В каждом эксперименте определяется относительная погрешность вычисления площади (в процентах) и его длительность (в миллисекундах).

Поскольку площадь фигуры легко определяется по правилам геометрии, мы можем определить относительную погрешность приближенного вычисления этой площади методом Монте-Карло. Естественно, чем больше N, тем меньше погрешность такого вычисления.

Каждое приложение шесть раз повторяет эксперимент и вычисляет площадь фигуры методом Монте-Карло для соответственно. В каждом эксперименте определяется относительная погрешность вычисления площади (в процентах) и его длительность (в миллисекундах).

Задачами курсовой работы являются:

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

практическое освоение современных инструментальных систем разработки ПО;

сравнительный анализ вычислительной эффективности процедурных и объектно-ориентированных программ;

получение навыков создания программ на языке C#;

приобретение практических навыков оформления и выпуска документации в соответствии с требованиями стандартов (ЕСПД, UML).



2. Разработка технического задания

2.1 Анализ вариантов использования программы

Необходимо разработать программу, которая вычисляет площадь фигуры методом Монте-Карло. Программа должна выполнять следующие функции:

· ввод координат (вручную, из контрольного примера или случайным образом);

· расчёт площади фигуры методом Монте-Карло;

· повторный расчёт;

· выход.

Диаграмма вариантов использования процедурного и объектно-ориентированного приложений представлена на рис. 2.

Рис. 2 Диаграмма вариантов использования приложений

На данной диаграмме были использованы такие виды отношений как включение, расширение и наследование.

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

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

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

2.2 Требования к приложениям

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

· позволять вводить данные вручную, случайным образом или выбирать заранее определенные координаты;

· выводить сообщения об ошибках;

· вычислять площадь заданной фигуры методом Монте-Карло для каждого N=10³, 10⁴, 10⁵, 10⁶, 10⁷ количества точек;

· рассчитывать погрешности вычислений и измерять время расчётов;

· выводить на экран таблицу, содержащую результаты всех расчётов.

Для приложений характерны следующие особенности.

Процедурное приложение на базе Console/C#:

· парадигма программирования: процедурная;

· язык программирования: C#;

· интерфейс: Console;

· тип: настольное приложение;

· параметр оптимизации: время выполнения.

Объектно-ориентированное приложение на базе Console/C#:

· парадигма программирования: объектно-ориентированная;

· язык программирования: C#;

· интерфейс: Console;

· тип: настольное приложение;

· параметр оптимизации: время выполнения.



3. Анализ алгоритма решения

3.1 Метод Монте-Карло

Метод Монте-Карло - численный метод решения математических задач при помощи моделирования случайных величин.

Введем обозначения для координат точек (см. рис. 1):

, m, b.

Определим координаты точек. Точки , задаются вручную пользователем:

= + _, = ;

=, y_o = ;

= - r, = ;

= + , ;

=, = ;

r = .

Рассмотрим последовательность определения площади методом Монте-Карло.

1) Впишем исходную фигуру в прямоугольник , площадь которого:

= ( - ) (-).

2) Сгенерируем в этом прямоугольнике N точек, координаты которых будем выбирать случайным образом.

3) Определим число точек M, которые попадут в фигуру.

4) Вычислим точную площадь фигуры, используя следующую формулу:

= - (+),

где - площадь треугольника - площадь полуокружности :

= (-) (-);

= р.

5) Приближённую площадь исследуемой фигуры вычислим по формуле:

= _.

6) Определим относительную погрешность по формуле:

? = ||/ 100%.

3.2 Определение попадания точки внутрь фигуры

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

Расположение точек вершин фигуры и расположение случайной точки приведены на рис. 3.

Размещено на http://www.allbest.ru/

Рис. 3 Попадание случайной точки в фигуру nomced

Уравнение прямой имеет вид:

(x) = () +, где = )/).

Уравнение прямой имеет вид:

(x) = () +, где = )/).

Уравнение окружности:

+ = .

Квадрат расстояния от точки p до центра окружности g:

= + .

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

1) если < , то точка принадлежит фигуре, если > () и < );

2) если > , то точка принадлежит фигуре, если > ;

3) если > > , то точка принадлежит фигуре.



4. Процедурное приложение на базе Console/C#

4.1 Программные средства разработки приложения

Для создания консольного приложения на языке C# была выбрана интегрированная среда разработки Microsoft Visual Studio Community 2019, в которой присутствует большой выбор инструментов для отладки и оптимизации программы. Данная среда была использована как при разработке процедурного, так и объектно-ориентированного приложения

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

4.2 Логическое проектирование приложения

В соответствии с техническим заданием в процессе проектирования процедурного приложения на базе Console/С# был создан консольный класс Program, определяющий интерфейс приложения.

В соответствии с предметной областью приложение должно выполнять:

· вычисление площади заданной фигуры методом Монте-Карло;

· проверка введённых данных;

· определение попадания точки внутрь фигуры;

· вычисление искомой площади фигуры;

· вычисление площади фигуры методом Монте-Карло;

· оценивание относительной погрешности метода Монте-Карло;

· вывод результатов на экран.

Все перечисленные функции реализованы в классе Program, диаграмма которого представлена на рисунке 4.

Рис. 4 Диаграмма класса Program

Приложение содержит следующие поля:

private static double n_x, n_y, o_x, o_y, e_x, e_y, m_x, m_y, d_x, d_y, b_x, b_y - координаты точек заданной фигуры;

private static double r - радиус окружности;

private static double width, height - ширина и высота прямоугольника.

Приложение содержит следующие функции:

static bool Check_points(double x, double y) - проверка точки на попадание в фигуру;

static void Enter_data() - ввод данных с клавиатуры;

static void Fill_points() - расчёт дополнительных точек фигуры;

static void Main(string[] args) - основная функция приложения;

static double Numer_check(string str, string name) - проверка введённых значений;

static double Square_MonteKarlo(int n) - расчёт площади методом Монте-Карло;

static double Square_original() - вычисление точной площади фигуры.

Схема программы методов Main и Square_MonteKarlo представлена на рис. 5.

Рис. 5 Схема программы методов Main (a) и Square_MonteKarlo (б)



4.3 Структура приложения

Настольное процедурное приложение на базе Console/C# имеет следующие файлы (рис. 6):

Program.cs -процедурная реализация метода Монте-Карло;

ClassDiagram2.cd -диаграмма класса Program.

Рис. 6 Структура проекта процедурного приложения

4.4 Системные требования

Для корректной работы приложения требуется:

· операционная система Windows 7 и выше;

· платформа.NET Framework 2.0 и выше;

· архитектура 32-разрядная (х86)/64-разрядная (х64);

· оперативная память 32 Мб и более;

· устройства ввода: клавиатура.



4.5 Результаты работы

Результаты работы настольного процедурного приложения на базе Console/C# представлены на рис. 7-9.

Рис. 7 Результаты работы процедурного приложения на базе Console/C# при контрольном примере

Рис. 8 Результаты работы процедурного приложения на базе Console/C# при случайном примере



Рис. 9 Результаты работы процедурного приложения на базе Console/C# при вводе своих значений



5. Объектно-ориентированное приложение

5.1 Программные средства разработки приложения

Microsoft Visual Studio Community 2019 - линейка продуктов компании Microsoft, включающих интегрированную среду разработки программного обеспечения и ряд других инструментальных средств. Данные продукты позволяют разрабатывать как консольные приложения, так и приложения с графическим интерфейсом, в том числе с поддержкой технологии Windows Forms, а также вебсайты, веб-приложения, веб-службы.

C# - это объектно-ориентированный язык со строгой типизацией, позволяющий разработчикам создавать различные безопасные и надежные приложения, работающие на платформе.NET Framework. C# можно использовать для создания клиентских приложений Windows, XML-веб-служб, распределенных компонентов, приложений клиент-сервер, приложений баз данных и т. д.

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

5.2 Логическое проектирование приложения

Предметная область содержит следующие сущности: точка, круг, треугольник, прямоугольник и фигура. Для приложения данные сущности были реализованы в виде классов Point, Circle, Triangle, Rect и Figura.

Диаграмма классов объектно-ориентированного приложения представлена на рис. 10.



Рис. 10 Диаграмма классов приложения

Классы Triangle, Circle и Rect наследуются от интерфейса IAbstractFigure, описывающего основные свойства двумерных фигур.

На рис. 11 представлена диаграмма интерфейса IAbstractFigure.

Рис. 11 Диаграмма интерфейса IAbstractFigure

Интерфейс IAbstractFigure содержит свойство:

public Square - площадь фигуры.

Интерфейс IAbstractFigure объявляет следующий метод-предикат:

public bool CheckPoint(Point point) - проверяет принадлежность точки фигуре.

На рис. 12 представлена диаграмма класса Point.

Рис. 12 Диаграмма класса Point

Класс Point содержит следующие поля:

private double x, y - координаты точек.

Класс Point содержит следующие свойства:

public X, Y - координаты, однозначно определяющие точку на плоскости.

Класс Point содержит следующие конструкторы:

public Point() - по умолчанию;

public Point(double xx, double yy) - инициализации.

Класс Point содержит следующий метод:

public double Length(Point b) - вычисляет длину отрезка между текущей и заданной точками.

На рис. 13 представлена диаграмма класса Triangle, реализующего треугольник.



Рис. 13 Диаграмма класса Triangle

Класс Triangle содержит следующие поля:

private Point m,n,o - точки треугольника.

Класс Triangle содержит следующее свойство:

public Square - площадь треугольника.

Класс Triangle содержит следующие конструкторы:

public Triangle() - по умолчанию;

public Triangle(Point m, Point n, Point o) - инициализации.

Класс Triangle содержит следующий метод-предикат:

public bool CheckPoint(Point point) - проверяет принадлежность точки данному треугольнику.

На рис. 14 представлена диаграмма класса Circle, описывающего основные свойства круга.

Рис. 14 Диаграмма класса Circle

Класс Circle содержит следующее поле:

private double radius - радиус круга.

Класс Circle содержит следующие свойства:

public Square - площадь данного круга;

public Radius - радиус круга.

Класс Circle содержит следующие конструкторы:

public Circle() - по умолчанию;

public Circle(Point e, double r) - инициализации.

Класс Circle содержит следующий метод-предикат:

public bool CheckPoint(Point point) - проверяет принадлежность точки данному кругу.

На рис. 15 представлена диаграмма класса Rect, реализующего прямоугольник.

Рис. 15 Диаграмма класса Rect

Класс Rect содержит следующие поля:

private Point b, d - точки вершин прямоугольника.

Класс Rect содержит следующие свойства:

public Square - площадь данного круга;

public Width - длина прямоугольника;

public Height - высота прямоугольника.

Класс Rect содержит следующие конструкторы:

public Rect() - по умолчанию;

public Rect(Point b, Point d) - инициализации.

На рис. 16 представлена диаграмма класса Figura, описывающего фигуру, заданную по заданию.

Рис. 16 Диаграмма класса Figura

Класс Figura содержит следующие поля:

private Point n,o,m,b,e,d - точки фигуры;

private Rect rect - прямоугольник;

private Circle circle - окружность;

private Triangle triangle - треугольник.

Класс Figura содержит следующее свойство:

public Square_original - площадь фигуры.

Класс Figura содержит следующие конструкторы:

public Figura() - по умолчанию;

public Figura(Point b, Point d) - инициализации.

Класс Figura содержит следующие методы:

public double Square_Monte_Karlo(int n) - вычисляет площадь фигуры методом Монте-Карло;

bool Check(Point point) - проверяет принадлежность точки данной фигуре.

На рис. 17 представлена диаграмма класса Program.

Рис. 17 Диаграмма класса Program

Класс Program содержит следующие поля:

static Point b,d - точки фигуры;

Класс Program содержит следующие методы:

static void Enter_data() - ввод данных с клавиатуры;

static void Main(string[] args) - основная функция приложения;

static double Numer(string str, string name) - проверка введённых значений.

Схема программы методов Main, класс которого Program, и Square_Monte_Karlo, класс которого Figura, представлены на рис. 18.



Рис. 18 Схема программы методов Main (a) и Square_Monte_Karlo (б)

5.3 Описание программы

Общие сведения о приложении

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

Используемые технические средства

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

· операционная система Windows 7 и выше;

· платформа.NET Framework 2.0 и выше;

· архитектура 32-разрядная (х86)/64-разрядная (х64);

· оперативная память 1 Гб и более;

· устройства ввода: клавиатура.

Входные и выходные данные

Входными данными являются основные координаты фигуры: b,d.

Выходными данными является таблица, содержащая:

· количество точек, генерируемых и участвующих в расчётах;

· площадь фигуры, вычисленная методом Монте-Карло;

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

· относительная погрешность вычисления площади;

· время выполнения расчётов.

5.4 Структура приложения

Настольное объектно-ориентированное приложение на базе Console/C# имеет следующие файлы:

Program.cs - основной файл приложения, содержащий саму реализацию программы;

ClassDiagram.cd - диаграмма классов приложения;

Point.cs - файл содержащий реализацию класса Point;

Triangle.cs - реализация класса Triangle;

Circle.cs - реализация класса Circle;

Rect.cs - реализация класса Rect;

Figura.cs - реализация класса Figura;

IAbstractFigure.cs - интерфейс IAbstractFigure.

Проект настольного объектно-ориентированного приложения на базе Console/C# представлены на рис. 19.

Рис. 19 Структура объектно-ориентированного приложения

5.5 Руководство системного программиста

Общие сведения о приложении

Данное приложение разработано для расчёта площади фигуры методом Монте-Карло, приложение было реализовано с объектно-ориентированным подходом в консольном интерфейсе на языке программирования C#.

Системные требования

Системные требования приложения:

· операционная система Windows 7 и выше;

· платформа.NET Framework 2.0 и выше;

· архитектура 32-разрядная (х86)/64-разрядная (х64);

· оперативная память 32 Мб и более;

· устройства ввода: клавиатура.

Настройка приложения

Программа не требует дополнительной настройки.

5.6 Руководство программиста

Назначение и условия применения приложения

Приложение было разработано для расчёта площади фигуры методом Монте-Карло, а также для вычисления погрешности вычислений и времени выполнения программы. Все данные полученные в ходе работы приложения выводятся на экран в виде таблицы. Было разработано два консольных приложения на языке C# с использованием процедурного и объектно-ориентированного подхода.

Входные и выходные данные

Входными данными являются координаты две координаты прямоугольника b и d.

Выходными данными является таблица, содержащая:

· количество точек, генерируемых и участвующих в расчётах;

· площадь фигуры, рассчитанная с помощью геометрических формул;

· площадь фигуры, вычисленная методом Монте-Карло;

· относительная погрешность вычисления площади;

· время выполнения расчётов.

Пространство имён

При разработке приложения использовались следующее пространство имён:

System - пространство имен содержащее фундаментальные и базовые классы, определяющие часто используемые типы значений и ссылочных данных, события и обработчики событий, интерфейсы, атрибуты и исключения обработки.



5.7 Руководство оператора

Назначение приложения

Программа предназначена для вычисления площади фигуры методом Монте-Карло, погрешности и времени измерения.

Условия выполнения приложения

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

Выполнение приложения

Для выполнения программы необходимо запустить исполняемый файл «КР_ООП_объектно_ориентированное_приложение.exe», в результате чего должно открыться окно приложения.

После успешного запуска приложения на выбор предлагается 4 пункта меню, а именно «Контрольный пример», «Случайный пример», «Свои значения», «Выход из приложения».

После вычислений результаты будут выведены на экран в виде таблицы.

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

Сообщения оператору

Данная программа может также выводить на экран сообщения об ошибках. При вводе недопустимых символов в поля, предназначенные для ввода координат фигуры программа выводит на экран сообщение об ошибке (рис. 20).



Рис. 20 Сообщение об ошибке

5.8 Результаты работы

Результаты работы объектно-ориентированного приложения на базе Console/C# при случайных значениях представлен на рис. 21.

Рис. 21 Результаты работы приложения при случайных значениях

Результаты работы объектно-ориентированного приложения на базе Console/C# при контрольных значениях представлен на рис. 22.

Рис. 22 Результаты работы приложения при контрольном примере

Результаты работы объектно-ориентированного приложения на базе Console/C# при вводе своих значений представлен на рис. 23.

Рис. 23 Результаты работы приложения при вводе своих значений



6. Анализ вычислительной эффективности приложений

Анализ вычислительной эффективности приложений проводился путём установления зависимости времени расчёта площади фигуры методом Монте-Карло от количества генерируемых точек, необходимых для расчёта.

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

Таблица 1

Сравнение вычислительной эффективности приложений

Количество точек	Время выполнения, мс
	Процедурное приложение на базе Console/C#	Объектно-ориентированное приложение на базе Console/C#
1000	0	0
10000	1	9
100000	4	8
1000000	70	78
10000000	413	789

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

Системная конфигурация машины, на которой проводились исследования:

операционная система: Windows 8.1 Professional;

центральный процессор: Intel Pentium 3558U (2 ядра, тактовая частота ~1.7GHz);

оперативная память: 4 Гб.



7. Улучшение характеристик качества приложений

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

В проектах Microsoft Visual Studio используется конфигурация решений Debug, что позволяет искать ошибки и отлаживать программу. При использовании Release в сборку не включаются отладочные ресурсы, что позволяет повысить скорость работы проекта.

7.1 Использование встроенной оптимизации кода

Сравнение скорости работы процедурного и объектно-ориентированного приложений в Debug и Release представлены на рис. 24-27.

Рис. 24 Результаты работы процедурного приложения в Debug



Рис. 25 Результаты работы процедурного приложения в Release

Рис. 26 Результаты работы объектно-ориентированного приложения в Debug

Рис. 27 Результаты работы объектно-ориентированного приложения в Release

Результаты работы представлены на таблице 2. Из таблицы видно, что процедурное приложение стало работать примерно в 1,5 раза, а объектно-ориентированное почти в 4 раза, чем те же приложения в Debug.

Таблица 2

Сравнение вычислительной эффективности после оптимизации

Количество точек	Время выполнения, мс
	Процедурное приложение на базе Console/C#	Объектно-ориентированное приложение на базе Console/C#
1000	0	0
10000	1	0
100000	5	3
1000000	49	27
10000000	487	269

В ходе выполнения данной курсовой работы был проведён ряд улучшений характеристик как процедурного, так и объектно-ориентированного приложений. Эти улучшения касаются в основном ускорения работы приложений и уменьшения количества занимаемой памяти. Проекты Visual Studio имеют отдельные конфигурации выпуска и отладки для программы. Ранее в проектах использовалась конфигурация решений Debug, которая позволяла делать отладку программ и таким образом выявлять её ошибки. Так как приложения готовы к использованию и не требуют исправления ошибок, в проектах будет использоваться конфигурация решений Release, которая будет значительно улучшать характеристики приложений за счет того, что в Debug-режиме в сборку записываются все отладочные ресурсы, а в Release - нет.

7.2 Профилирование

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

Метод выборки собирает сведения о функциях, которые выполняются в приложении, через заданные интервалы времени. После завершения сеанса профилирования представление «Сводка» показывает дерево вызовов наиболее активных функций, которое называется горячим или критическим путем, где была выполнена основная часть работы в приложении. Кроме того, в этом представлении перечислены функции, которые выполнили максимальный объем индивидуальной работы, а также представлен график временной шкалы, который позволяет сосредоточить внимание на определенных сегментах сеанса выборки рис. 28.

Рис. 28 Профилирование ЦП

7.3 Результаты улучшения характеристик

Как видно из рис. 26, функции get_Width, get_Height класса Rect занимают 6,79 % и 6,4 % времени выполнения соответственно, поэтому их расчёт нужно перенести в конструктор.

Как видно из рис. 29 удалось увеличить скорость работы объектно-ориентированного приложения до 255 мс. по сравнению с начальными 789 мс.



Рис. 29 Результаты работы приложения после оптимизации



Заключение

В ходе работы были разработаны процедурное и объектно-ориентированное приложения, предназначенные для вычисления площади фигуры методом Монте-Карло на базе Console/C#. Для каждого приложения была исследована вычислительная эффективность используемых технологий программирования. Произведено улучшение качества исходных приложений, что позволило достичь более высокой производительности.

Результатом выполнения данной курсовой работы стало закрепление знаний по курсу «Объектно-ориентированное программирование» и приобретение практических навыков написания приложений.



Список литературы

1. ГОСТ 19.701-90 ЕСПД. Схемы алгоритмов, программ, данных и систем. Условные обозначения и правила выполнения.

2. ГОСТ 19.401-78 ЕСПД. Текст программы. Требования к содержанию и оформлению.

3. ГОСТ 19.402-78 ЕСПД. Описание программы.

4. ГОСТ 19.404-79 ЕСПД. Пояснительная записка. Требования к содержанию и оформлению.

5. ГОСТ 2.105-95. Общие требования к текстовым документам.

6. ГОСТ 19.503-79. Руководство системного программиста. Требования к содержанию и оформлению.

7. ГОСТ 19.504-79. Руководство программиста. Требования к содержанию и оформлению.

8. ГОСТ 19.505-79. Руководство оператора. Требования к содержанию и оформлению.

9. Гамма Э., Хелем Р., Джонсон Р., Влиссидес Дж. Приемы объектно-ориентированного проектирования. Паттерны проектирования. СПб.: Питер, 2014. 368 с.

10. Жарков, В.А. Visual C# 2005 в учебе, науке и технике / В.А.Жарков. М.: Жарков Пресс, 2007. 818с.

11. Нэш Т. C# 2010: ускоренный курс для профессионалов.: Пер. с англ. М.: ООО "И.Д. Вильяме", 2010. 592 с.: ил.

12. Дейтел, Х.М. C#: пер.с англ. / Х.М.Дейтел [и др.]. СПб.: БХВ-Петербург, 2006. 1056 с.

13. MSDN - сеть разработчиков Майкрософт [Электронный ресурс] URL: http://msdn.microsoft.com/ru-ru (дата обращения 3.10.17).

14. Метод Монте-Карло [Электронный ресурс] URL: https://ru.wikipedia.org/wiki/%CC%E5%F2%EE%E4_%CC%EE%ED%F2%E5-%CA%E0%F0%EB%EE (дата обращения 3.10.17).

Приложение

Файлы процедурного приложения на базе Console/C#

Файл Program.cs

using System;

namespace Kursovay_Procedure

{

class Program

{

static double n_x, n_y, o_x, o_y, m_x, m_y, b_x, b_y,e_x,e_y, d_x, d_y, r;

static double width, height;

static void Fill_points()

{

m_x = b_x + (d_y - b_y) / 2; m_y = b_y;

n_x = m_x; n_y = b_y;

o_x = m_x; o_y = (d_y + b_y)/2;

r = (b_y - d_y) / 2;

e_x = d_x - r; e_y = o_y;

width = (d_x - o_x);

height = (b_y - d_y);

}

static bool Check_points(double x, double y)

{

if (x > e_x)

{

return (Math.Pow((x - d_x), 2) + Math.Pow((y - o_y), 2)) >= Math.Pow(r, 2);

}

else if (x < n_x)

{

double om = (m_y - o_x) / (m_x - o_x);

double on = (n_y - o_y) / (n_x - o_x);

double yom = (x - o_x) * om + o_y;

double yon = (x - o_x) * on + o_y;

return (yom >= y && yon <= y);

}

return true;

}

static double Square_MonteKarlo(int n)

{

int m = 0;//точек попало

double x, y;

Random rand = new Random();

for (int i = 0; i < n; i++)

{

x = d_x - rand.NextDouble() * width;

y = d_y + rand.NextDouble() * height;

if (Check_points(x, y))

m++;

}

return (width * height) * ((double)m / n);

}

static double Square_original()

{

double square = Math.Abs((d_x - o_x) * (b_y - d_y));

square -= (Math.PI * Math.Pow(r, 2)) / 2;

square -= 1/2 * (m_x - o_x) * (n_y - m_y);

return square;

}

static double Numer_check(string str, string name)

{

while (true)

if (Double.TryParse(str, out double value))

return value;

else

{

Console.Write("Введено неверное значение\n {0} = ", name);

str = Console.ReadLine();

continue;

}

}

static void Enter_data()

{

Console.Write("Введите координаты точки 'b': \n x = ");

b_x = Numer_check(Console.ReadLine(), "x");

Console.Write(" y = ");

b_y = Numer_check(Console.ReadLine(), "y");

koor_d:

Console.Write("Введите координаты точки 'd': \n x = ");

d_x = Numer_check(Console.ReadLine(), "x");

Console.Write(" y = ");

d_y = Numer_check(Console.ReadLine(), "y");

if (b_x > d_x || b_y < d_y)

{

Console.WriteLine("Введена неверная координат 'd'");

goto koor_d;

}

}

static void Main(string[] args)

{

Console.WriteLine("Курсовая работа по Объектно-ориентированному программированию");

Console.WriteLine("студента группы 220692 Стрельникова Е. О.");

Console.WriteLine("Программа для расчёта площади фигуры методом Монте-Карло");

Console.WriteLine(" b_______________m _____________________________________c");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" o¦ * e * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ ______________*_n__________________________________*_¦d");

bool check = false;

while (true)

{

Console.WriteLine("Для ввода контрольного примера нажмите 1");

Console.WriteLine("Для ввода случайного примера нажмите 2");

Console.WriteLine("Для ввода своих значений нажмите 3");

Console.WriteLine("Для выхода нажмите 4");

if (check) Console.WriteLine("Для повторного расчёта нажмите 5");

switch (Console.ReadLine())

{

case "1":

b_x = 5; b_y = 20;

d_x = 20; d_y = 5;

break;

case "2":

Random rand = new Random();

b_x = rand.Next(0, 200); b_y = rand.Next(0, 200);

d_y = b_y - rand.Next(1, 200); d_x = b_x + rand.Next(1, 200);

break;

case "3":

Enter_data();

break;

case "4":

return;

case "5":

break;

default:

Console.WriteLine("Нажата неверная клавиша");

continue;

}

Fill_points();

Console.WriteLine(" ____________________________________________________________________________");

Console.WriteLine(" ¦ Количество ¦ Площадь ¦ Площадь ¦ Погрешность ¦ Время выполнения ¦");

Console.WriteLine(" ¦ точек ¦ фигуры ¦ Монте-Карло ¦ % ¦ мс ¦");

Console.WriteLine(" ¦_____________¦___________¦_______________¦_____________¦__________________¦");

double square_orig = Square_original();

double square;

for (int i = 1000; i <= 10000000; i *= 10)

{

DateTime time1 = DateTime.Now;

square = Square_MonteKarlo(i);

DateTime time2 = DateTime.Now;

Console.WriteLine(" ¦" + (i).ToString().PadLeft(13) + "¦"

+ (Math.Round(square_orig, 3)).ToString().PadLeft(11) + "¦"

+ Math.Round(square, 3).ToString().PadLeft(15) + "¦"

+ Math.Abs(Math.Round((square_orig - square) * 100 / square_orig, 3)).ToString().PadLeft(13) + "¦"

+ Math.Round((time2 - time1).TotalMilliseconds, 0).ToString().PadLeft(18) + "¦");

Console.WriteLine(" ¦_____________¦___________¦_______________¦_____________¦__________________¦");

}

check = true;

}

}

}

}

Файлы объектно-ориентированного приложения на базе Console/C#

Файл Program.cs



using System;

using КР_ООП_объектно_ориентированное_приложение;

namespace Kusovoy_oop

{

class Program

{

static Point b = new Point();

static Point d = new Point();

static double Numer(string str, string name)

{

while (true)

{

if (Double.TryParse(str, out double value))

return value;

else

{

Console.Write("Введено неверное значение\n {0} = ", name);

str = Console.ReadLine();

continue;

}

}

}

static void Enter_data()

{

Console.Write("Введите координаты точки 'b': \n x = ");

b.X = Numer(Console.ReadLine(), "x");

Console.Write(" y = ");

b.Y = Numer(Console.ReadLine(), "y");

koor_d:

Console.Write("Введите координаты точки 'd': \n x = ");

d.X = Numer(Console.ReadLine(), "x");

Console.Write(" y = ");

d.Y = Numer(Console.ReadLine(), "y");

if (b.X > d.X || b.Y < d.Y)

{

Console.WriteLine("Введена неверная координат 'd'");

goto koor_d;

}

}

static void Main(string[] args)

{

Console.WriteLine("Курсовая работа по Объектно-ориентированному программированию");

Console.WriteLine("студента группы 220692 Стрельникова Е. О.");

Console.WriteLine("Программа для расчёта площади фигуры методом Монте-Карло");

Console.WriteLine(" b_______________m _____________________________________c");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" o¦ * e * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ * * ¦");

Console.WriteLine(" ¦ ______________*_n__________________________________*_¦d");

bool check = false;

while (true)

{

Console.WriteLine("Для ввода контрольного примера нажмите 1");

Console.WriteLine("Для ввода случайного примера нажмите 2");

Console.WriteLine("Для ввода своих значений нажмите 3");

Console.WriteLine("Для выхода нажмите 4");

if (check) Console.WriteLine("Для повторного расчёта нажмите 5");

switch (Console.ReadLine())

{

case "1":

b.X = 5; b.Y = 20;

d.X = 20; d.Y = 5;

break;

case "2":

Random rand = new Random();

b.X = rand.Next(0, 200); b.Y = rand.Next(0, 200);

d.Y = b.Y - rand.Next(1, 200); d.X = b.X + rand.Next(1, 200);

break;

case "3":

Enter_data();

break;

case "4":

return;

case "5":

break;

default:

Console.WriteLine("Нажата неверная клавиша");

continue;

}

Figura figura = new Figura(b, d);

Console.WriteLine(" ____________________________________________________________________________");

Console.WriteLine(" ¦ Количество ¦ Площадь ¦ Площадь ¦ Погрешность ¦ Время выполнения ¦");

Console.WriteLine(" ¦ точек ¦ фигуры ¦ Монте-Карло ¦ % ¦ мс ¦");

Console.WriteLine(" ¦_____________¦___________¦_______________¦_____________¦__________________¦");

double square_orig = figura.Square_original;

double square;

for (int i = 1000; i <= 10000000; i *= 10)

{

DateTime time1 = DateTime.Now;

square = figura.Square_Monte_Karlo(i);

DateTime time2 = DateTime.Now;

Console.WriteLine(" ¦" + (i).ToString().PadLeft(13) + "¦"

+ (Math.Round(square_orig, 3)).ToString().PadLeft(11) + "¦"

+ Math.Round(square, 3).ToString().PadLeft(15) + "¦"

+ Math.Abs(Math.Round((square_orig - square) * 100 / square_orig, 3)).ToString().PadLeft(13) + "¦"

+ Math.Round((time2 - time1).TotalMilliseconds, 0).ToString().PadLeft(18) + "¦");

Console.WriteLine(" ¦_____________¦___________¦_______________¦_____________¦__________________¦");

}

check = true;

}

}

}

}

Файл Point.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace КР_ООП_объектно_ориентированное_приложение

{

class Point

{

double x, y;

public Point() { x = 0; y = 0; }

public Point(double xx, double yy) { x = xx; y = yy; }

public double Length(Point b)

{

return Math.Sqrt(Math.Pow(b.x - x, 2) + Math.Pow(b.y - y, 2));

}

public double X

{

get { return x; }

set { x = value; }

}

public double Y

{

get { return y; }

set { y = value; }

}

}

}

Файл Rect.cs

using System;

using КР_ООП_объектно_ориентированное_приложение;

namespace Kusovoy_oop

{

class Rect

{

Point b, d;

double width, height;

public Rect()

{

b = new Point();

d = new Point();

width = 0;

height = 0;

}

public Rect(Point b, Point d)

{

this.b = b;

this.d = d;

width = Math.Abs(d.X - b.X);

height = Math.Abs(b.Y - d.Y);

}

public double Square

{

get

{

return Math.Abs((d.X - b.X) * (b.Y - d.Y));

}

}

public double Width

{

get

{

return width;

}

}

public double Height

{

get

{

return height;

}

}

}

}

Файл Circle.cs

using System;

using КР_ООП_объектно_ориентированное_приложение;

namespace Kusovoy_oop

{

class Circle: Point, IAbstractFigure

{

double radius;

public Circle(): base()

{

radius = 0;

}

public Circle(Point e, double r): base(e.X, e.Y)

{

radius = r;

}

public double Radius

{

get

{

return radius;

}

}

public double Square

{

get

{

return Math.PI * Math.Pow(radius, 2);

}

}

public bool CheckPoint(Point point)

{

return ((Math.Pow((point.X - X), 2) + Math.Pow((point.Y - Y), 2)) >= Math.Pow((radius), 2));

}

}

}

Файл Triangle.cs

using System;

using КР_ООП_объектно_ориентированное_приложение;

namespace Kusovoy_oop

{

class Triangle: IAbstractFigure

{

Point o, m, n;

double om;

double on;

public Triangle()

{

o = new Point();

m = new Point();

n = new Point();

}

public Triangle(Point o, Point m, Point n)

{

this.o = o;

this.m = m;

this.n = n;

om = (m.Y - o.Y) / (m.X - o.X);

on = (n.Y - o.Y) / (n.X - o.X);

}

public double Square

{

get

{

double l1 = n.Y - m.Y;

double l2 = m.Y - o.Y;

return 1 / 2 * l1 * l2;

}

}

public bool CheckPoint(Point point)

{

double y_om = (point.X - o.X) * om + o.Y;

double y_on = (point.X - o.X) * on + o.Y;

return (point.Y <= y_om && point.Y >= y_on);

}

}

}

Файл Figura.cs

using System;

using КР_ООП_объектно_ориентированное_приложение;

namespace Kusovoy_oop

{

class Figura: Rect

{

Point n = new Point();

Point o = new Point();

Point m = new Point();

Point b = new Point();

Point e = new Point();

Point d = new Point();

Rect rect;

Circle circle;

Triangle triangle;

public Figura()

{

n = new Point();

o = new Point();

m = new Point();

b = new Point();

e = new Point();

d = new Point();

circle = new Circle();

triangle = new Triangle();

}

public Figura(Point b, Point d): base(new Point(b.X, b.Y), new Point(d.X, d.Y))

{

m = new Point(b.X + (d.Y - b.Y) / 2, b.Y);

n = new Point(b.X + (d.Y - b.Y) / 2, d.Y);

o = new Point(b.X + (d.Y - b.Y) / 2, (d.Y+b.Y)/2);

e = new Point(d.X - (d.Y-b.Y)/2, (d.Y+b.Y)/2);

triangle = new Triangle(o,m, n);

rect = new Rect(b, d);

circle = new Circle(e, (b.Y - d.Y) / 2);

this.b = b;

this.d = d;

}

public double Square_original

{

get

{

return (rect.Square - circle.Square / 2 - triangle.Square);

}

}

public double Square_Monte_Karlo(int n)

{

int count = 0;//точек попало

double x, y;

Random rand = new Random();

for (int i = 0; i < n; i++)

{

x = d.X - rand.NextDouble() * Width;

y = d.Y + rand.NextDouble() * Height;

if (Check(new Point(x, y)))

count++;

}

return (Width * Height) * ((double)count / n);

}

bool Check(Point point)

{

if (point.X > e.X)

{

return !circle.CheckPoint(point);

}

else if (point.X < n.X)

return !triangle.CheckPoint(point);

return true;

}

}

}



Файл IAbstractFigure.cs

namespace КР_ООП_объектно_ориентированное_приложение

{

interface IAbstractFigure

{

bool CheckPoint(Point point);

double Square { get; }

}

}

Размещено на Allbest.ru