МИНИСТЕРСТВО НАУКИ И ВЫСШЕГО ОБРАЗОВАНИЯ РОССИЙСКОЙ ФЕДЕРАЦИИ
Федеральное государственное бюджетное образовательное учреждение
высшего образования
«Сибирский государственный университет науки и технологий
имени академика М.Ф. Решетнева»
Институт информатики и телекоммуникаций
Кафедра информатики и вычислительной техники
КУРСОВАЯ РАБОТА
Технологии обработки информации
Разработка программы « приложение, осуществляющего основные операции с
матрицами»
Руководитель
ктн, доцент
В.В. Вдовенко
подпись, дата
Обучающийся БИСЗ 18-02,
инициалы, фамилия
А.И Киреев
18733040
номер группы, зачетной книжки
подпись, дата
Красноярск 2020 г.
0
инициалы, фамилия
СОДЕРЖАНИЕ
ВВЕДЕНИЕ ........................................................................................................................................ 2
ГЛАВА 1 ............................................................................................................................................. 3
ТЕОРЕТИЧЕСКИЕ ОСНОВЫ ООП................................................................................................ 3
ГЛАВА 2 ............................................................................................................................................. 6
ТЕХНИЧЕСКОЕ ЗАДАНИЕ ............................................................................................................ 6
2.1.1 Матрицы ............................................................................................................................... 6
2.1.2 Определители. ................................................................................................................... 11
2.2 Выбор средств разработки ................................................................................................. 15
2.2.1. Функциональные требования ....................................................................................... 15
2.2.2. Требования к интерфейсу ........................................................................................... 16
2.2.4. Схема алгоритма ........................................................................................................ 17
2.2.5.Руководство пользователя ....................................................................................... 17
ЗАКЛЮЧЕНИЕ................................................................................................................................ 30
СПИСОК ИСПОЛЬЗОВАННЫХ ИСТОЧНИКОВ ...................................................................... 31
1
ВВЕДЕНИЕ
Для многих операций в офисах, лабораториях и прочих рабочих местах,
связанных с какими-либо расчетами, требуются какие-то вычисления с
нестандартными типами данных. Примером могут служить комплексные
числа, числа в какой-либо (отличающейся от десятичной) системе
исчисления, вектора, матрицы и так далее. Для быстрого выполнения всех
этих операции очень удобно использовать компьютер, если в нем есть
пригодная для конкретной задачи программа.
Целью данного курсового проекта является создание именно такой
программы, которая могла бы выполнять основные операции над матрицами.
Практически на любом современном компьютере сейчас установлена
программа Excel из популярного пакета Microsoft Office. В этой программе
можно выполнять все основные и дополнительные операции над матрицами.
Но для выполнения всех этих операции необходимо иметь довольно
обширную математическую базу и немалые навыки работы в Excel.
Значит предполагаемый проект должен обладать рядом качеств, которые бы
выделили его среди остальных программ с той же функцией.
Во-первых, функциональность, то есть программа должна включать
основной и дополнительный набор операций с матрицами.
Во-вторых, простота интерфейса, рассчитанного практически на любого
пользователя, имеющего хотя бы первоначальное понятие о матрицах.
В-третьих удобство в использовании программы.
Основное назначение данного курсового проекта – увеличение показателя
производительности работников, чья работа связана с вычислениями какихто величин размерностью матриц, из-за использования нового программного
продукта на производстве.
2
ГЛАВА 1
Теоретические основы ООП
История становления программирования богата какими-либо
нововведениями, которые коренным образом меняют всю предшествующую
систему. Одним из первых и наиболее ярких таких открытий можно считать
выход в свет книги «Программирование без GOTO». Следующим наиболее
важным шагом по праву считают переход к процедурно-функциональному
программированию, когда программы разбивались на ряд независимых
блоков, и в итоге просто грамотно соединялись в единое целое. Ну и третьим,
наверное, самым большим открытием можно считать появление объектноориентированного программирования. ООП объединило в себе
одновременно процедурные методы, для чего создавались самостоятельные
модули, структурное проектирование и стимулировало творческий подход к
созданию программ.
Сегодня ни одна программа не представляется без наличия в ней объектов.
Объектно-ориентированное программирование вышло на новую ступень
своего развития, когда внедрить объект в программу не составляет большого
труда, а порой, это за вас сделает визуальная среда. Таким образом, такой
мощный инструмент, как объект стал доступным даже для начинающего
программиста. Теперь любой программист может использовать всю мощь и
эффективность объектно-ориентированного программирования.
Неформально можно сказать, что объектно-ориентированное
программирование стоит на трёх китах, таких
как инкапсуляция, полиморфизм и наследование. Что же это такое?
Инкапсуляция – это процесс отделения друг от друга элементов объекта,
определяющих его устройство и поведение; инкапсуляция служит для того,
чтобы изолировать обязательства абстракции от их реализации.
Наследование означает такое отношение между классами (отношение
родитель - потомок), когда один класс заимствует структурную или
функциональную часть одного или нескольких других классов
(соответственно, одиночное и множественное наследование).
Полиморфизм: одно и то же имя может означать объекты разных типов, но,
имея общего предка, все они имеют и общее подмножество операций,
которые можно над ними выполнять.
Главным звеном программы в ООП является объект (например класс).
Главным в понятии объекта является объединение идей абстракции данных и
алгоритмов. Объекты обладают целостностью, которая не может быть
нарушена. Свойства, которые характеризуют объект и его поведение,
остаются неизменными.
3
Объектно-ориентированное проектирование – это методология
программирования, основанная на представлении программы в виде
совокупности объектов, каждый из которых является экземпляром
определенного класса, а классы образуют иерархию наследования.
Для ООП очень важное значение имеет понятие абстрагирования.
Абстракция выделяет существенные характеристики некоторого объекта,
отличающие его от всех других видов объектов и, таким образом, четко
определяет его концептуальные границы с точки зрения наблюдателя.
Абстрагирование концентрирует внимание на внешних особенностях объекта
и позволяет отделить самые существенные особенности поведения от
несущественных.
Класс делится на две части: интерфейс и реализацию.
Интерфейс отражает внешнее поведение объекта, описывая абстракцию
поведения всех объектов данного класса.
Внутренняя реализация описывает представление этой абстракции и
механизмы достижения желаемого поведения объекта.
Для удобного представления программы используются модульность и
иерархия. Модульность – это разделение программы на фрагменты, которые
компилируются по отдельности, но могут устанавливать связи с другими
модулями. Иерархия – это упорядочение абстракций, разложение их по
уровням.
Сохраняемость – способность объекта существовать во времени, переживая
породивший его процесс, и (или) в пространстве, перемещаясь из своего
первоначального адресного пространства. Говоря другими словами,
сохраняемость – это способность классов использоваться не только в одной
программе или части программы.
Программы в ООП должны быть написаны на соответствующем объектноориентированном языке программирования. По каким же критериям
определяется такой язык?
1) все объекты имеют свой специализированный тип - класс;
2) каждый класс должен иметь различные виды полей данных, в
зависимости от степени доступа: закрытые, открытые, наследованные;
4
3) классы могут наследовать часть полей данных и методов у других
классов;
4) методы представляются в виде именованных операций, что придает
программе читабельность.
С++ - это попытка решения разработчиками языка С задач объектноориентированного программирования. С++ был разработан сотрудником
исследовательской лаборатории компании AT&T Бьерном Страуструпом
(Bjarn Stroustrup) в 1980 году. В своих исторических замечаниях Страуструп
поясняет, почему в качестве базового языка был выбран С:
- многоцелевой, лаконичный и относительно низкого уровня;
- отвечает большинству задач системного программирования;
- "идет везде и на всем";
- пригоден в среде программирования UNIX.
Первоначальное название "С с классами" в 1983 году, по предложению Рика
Масситти(Rick Mascitti), было изменено на С++. В этом же году С++ был
впервые применен за пределами исследовательской группы. С 1980 года С++
претерпел два существенных изменения: в 1985 и 1990 годах. Первый
рабочий проект языка С++ стандарта ANSI (American National Standarts
Institute) был представлен в январе 1994 года.
5
ГЛАВА 2
Техническое задание
2.1.Описание предметной области.
Предлагается разработать калькулятор матриц, следовательно предметной
областью будет являться теория матриц. Теория матриц нашла огромное
применение в решении систем линейных уравнений и не только, поэтому
целесообразно было бы создать такой калькулятор.
2.1.1 Матрицы
Матрицей называется прямоугольная таблица, заполненная некоторыми
математическими объектами, например, числами, векторами, функциями,
производными, интегралами, операторами и т. д. Будем рассматривать
матрицы с элементами из поля действительных чисел, хотя все рассуждения
сохраняются и для матриц с другими элементами.
Чаще всего элементы матрицы обозначаются одной буквой с двумя
индексами, указывающими "адрес" элемента - первый индекс дает номер
строки, содержащий элемент, второй - номер столбца. Если матрица имеет m
строк и n столбцов, то говорят, что матрица имеет размеры
. Принято
обозначать матрицы заглавными латинскими буквами, часто - полужирными,
а ее элементы - такими же буквами, но строчными. Таким образом, матрица
(размеров
) записывается в виде
.
Для краткости допускается обозначение матрицы размеров
в
виде
, где индекс i пробегает все значения от 1 до m, а j - от 1 до n.
При обозначении матриц используются скобки - круглые и квадратные.
Матрицы, имеющие одно и то же число n строк и столбцов,
называют квадратными; это число n называют порядком квадратной
матрицы.
Важную роль играют так называемые диагональные матрицы. Под этим
подразумеваются квадратные матрицы, имеющие все элементы равные нулю,
кроме элементов главной диагонали, т. е. элементов в позициях (1,1), (2,2), ...,
(n, n). Диагональная матрица D с диагональными элементами d1, d2, ..., dn
обозначается diag(d1, d2, ..., dn). Диагональная матрица diag(1, 1, ..., 1)
называется единичной и обозначается E (или En) или же I (или In). Матрица,
состоящая из одних нулей, называется нулевой.
6
Матрица, состоящая из одной строки, часто называется вектором (строкой,
вектор-строкой, строчной матрицей), а из одного столбца - векторстолбцом (столбцом, столбцовой матрицей).
Две матрицы считаются равными, если они одного размера и у них
совпадают элементы, стоящие на одинаковых местах.
Матрицу A={ai j} можно транспонировать, т. е. заменить строки
столбцами, в результате чего получится транспонированная матрица
AT={aj i}.
Две матрицы A={ai j} и B={bi j} одного и того же размера
можно складывать, их суммой будет матрица того же размера C={ci
j},
, т. е. чтобы получить сумму двух матрицы достаточно сложить
соответствующие элементы этих матриц, находящихся на одних и тех же
позициях. Поскольку мы рассматриваем здесь матрицы с элементами из поля
P действительных чисел, то очевидна ассоциативность операции сложения
матриц, вытекающая из ассоциативности сложения элементов поля P.
Аналогично имеет место коммутативность сложения. Таким образом,
справедливы действия:
(A+B)+C=A+(B+C); [Ассоциативность] A+B=B+A; [Коммутативность]
Матрица 0, состоящая из нулей, играет роль нуля: A+0=A при любой A.
Определим произведение элемента c из поля P на матрицу A={ai j}: cA={cai
j}, т. е. чтобы умножить матрицу на число необходимо каждый элемент
матрицы умножить на это число.
Для любой матрицы A существует противоположная матрица - A такая, что
A+(-A)=0.
В качестве матрицы - A, очевидно, следует взять матрицу (-1)A, элементы
которой отличаются от элементов A знаком.
.
.
.
.
Все перечисленные свойства матриц непосредственно следуют из
определений и свойств действий в поле чисел.
Рассмотрим матрицу A={ai j} размером
и матрицу B={bi j}
размером
. Число столбцов первой матрицы (стоящей слева в
произведении) равно числу строк второй матрицы (стоящей справа в
произведении). Для матриц, обладающих таким свойством и только для
таких матриц, можно ввести действие умножения матрицы на матрицу, в
результате чего получается матрица C={ci j} размером
,
где
. Правило умножения легко запомнить в словесной форме:
"чтобы получить элемент произведения ci j двух матриц нужно элементы i-ой
строки первой матрицы умножить на соответствующие элементы j-го
столбца второй матрицы и все произведения сложить". Это правило
называют "правилом строка на столбец".
7
Пример:
Пусть A={ai j} размером
и B={bi j} размером
векторы
,
и
линейные подстановки с этими матрицами:
, а также введем
. Рассмотрим
и
.
Эти подстановки, используя определение умножения матриц, можно
записать в матричном виде: Y=AX, X=BT.
Покажем, что если эти две подстановки сделать одну за другой, т. е. выразить
переменные y1, ..., ym через t1, ..., tk, то матрица коэффициентов окажется
равной AB.
.
Тогда коэффициент ci j есть коэффициент при tj в yi. Выпишем все
необходимое для вычисления этого коэффициента:
8
.
При подстановке x1, x2, ..., xk в yi, получим
.
Таким образом,
, так что матрица коэффициентов в
выражениях y1, ..., ym через t1, ..., tk действительно равна AB.
Итак, последовательному произведению ("суперпозиции") двух линейных
подстановок соответствует произведение их матриц. В матричной форме
суперпозицию этих подстановок можно записать в виде Y=A(BT). Вместе с
тем матрица суперпозиции равна AB, и этот факт записывается так:
Y=(AB)T. Таким образом, верно следующее соотношение
ассоциативности:
A(BT)=(AB)T, где T - столбец.
Рассмотрим теперь свойства действия умножения матриц:
(cA)B=A(cB)=cAB; (A1+A2)B=A1B+A2B; A(B1+B2)=AB1+AB2.
Эти свойства непосредственно вытекают из того, что элементы произведения
выражаются как через элементы A, так и через элементы B в виде линейных
однородных многочленов. Это можно проверить, используя правило
умножения и сложения матриц, группируя необходимые слагаемые).
(AB)C=A(BC) [ассоциативность умножения].
Это свойство трактуется таким образом, что если одна из частей равенства
имеет смысл, то имеет смысл и другая, и они равны. Это равенство можно
доказать, воспользовавшись следующим простым замечанием. Пусть P и Q две матрицы такие, что PQ имеет смысл. Пусть Q1, Q2, ..., Qk - столбцы
матрицы Q. Тогда столбцами матрицы PQ являются PQ1, PQ2, ..., PQk, что
непосредственно следует из определения. Это обстоятельство можно
записать в виде P(Q1, Q2, ..., Qk) = (PQ1, PQ2, ..., PQk).
Обозначим через C1, C2, ..., Cl столбцы матрицы C. Тогда (AB)C = ((AB)C1,
(AB)C2, ..., (AB)Cl). Далее, BC = (BC1, BC2, ..., BCl) и A(BC) = (A(BC1),
9
A(BC2), ..., A(BCl)). Но как было установлено выше, (AB)C1 = A(BC1),
(AB)C2 = A(BC2), ..., ибо C1, C2, ... - столбцы. Таким образом, (AB)C =
A(BC).
Особую роль при умножении матриц играют единичные матрицы En (если
нужно буквой n указать порядок) или просто E. Из правила умножения
матриц непосредственно следует, что AE=A и EA=A, если эти произведения
определены.
(AB)T=BTAT.
Об этом свойстве произведения матриц говорят так: "при
транспонировании произведения матриц порядок сомножителей
меняется".
Докажем это.
Пусть
,
Положим
что
,
, так
,
.
Пусть, далее,
Тогда
Итак,
т. е.
.
,
,
.
.
при всех i = 1, 2, ..., m и j = 1, 2, ..., n, а это и означает, что G=FT,
, что и требовалось доказать.
Подведем итоги.
10
Матрицы можно складывать, умножать их на число, а также умножать
матрицы друг на друга. Эти действия обладают свойствами:
(A+B)+C=A+(B+C); A+B=B+A; Существует 0: A + 0 = 0 + A = A; Для A
существует - A: A + (-A)=0;
.
.
.
.
Если для некоторых объектов (в нашем случае, это матрицы) выполняются
эти восемь свойств, то говорят, что эти объекты образуют векторное
пространство, так что матрицы фиксированных размеров образуют
векторное пространство.
(AB)C=A(BC). (cA)B=A(cB)=cAB. (A1+A2)B=A1B+A2B.
A(B1+B2)=AB1+AB2. Существуют единичные матрицы (единицы), а именно,
если A размером
, то EmA = AEn = A. (AT)T = A. (A + B)T = AT + BT.
(cA)T = cAT. (AB)T = BTAT.
Для квадратных матриц фиксированного порядка n действия сложения и
умножения определены всегда, и их результатами являются квадратные
матрицы того же порядка. Об этом обстоятельстве говорят таким образом:
квадратные матрицы фиксированного порядка образуют кольцо. Кольцо,
наделенное структурой векторного пространства, т. е. система объектов,
обладающих свойствами 1-12, называется алгеброй над основным полем.
Таким образом, квадратные матрицы с элементами из поля K составляют
алгебру над этим полем.
2.1.2 Определители.
Перестановка - это упорядоченный (не обязательно по возрастанию, а
произвольно) набор (или, говоря для простоты понимания, запись) всех n
натуральных чисел из отрезка натурального ряда
(
- это множество
натуральных чисел 1, 2, ..., n) без повторений.
Утверждение 1. Число всех перестановок n элементов равно.
Доказательство. Действительно, общий вид перестановки из n символов
есть i1, i2, ..., in, где каждое is есть одно из чисел 1, 2, ..., n, причем ни одно
из этих чисел не встречается дважды. В качестве i1 можно взять любое из
чисел 1, 2, ..., n; это дает n различных возможностей. Если, однако, i1 уже
выбрано, то в качестве i2 можно взять лишь одно из оставшихся n-1 чисел,
т. е. число различных способов выбрать символы i1 и i2 равно произведению
n(n-1) и т. д.
Таким образом, число перестановок из n символов при n=2 равно 2!=2
(перестановки 12 и 21; в примерах, где n  9, мы не будем разделять
переставляемые символы запятыми); при n=3 это число равно 3!=6. С
ростом n число перестановок чрезвычайно быстро возрастает; так, при
n=10 оно равно 3628800.
11
Теперь разобьем все n! перестановок n элементов на два класса по признаку,
кажущемуся довольно искусственным, но именно это разбиение будет
нужно для разумного правила расстановки знаков в определителе.
Пусть ( 1,  2, ...,  n) - некоторая перестановка чисел 1, 2, ..., n. Говорят,
что пара элементов ( i,  j), i < j, образует инверсию, если  i >  j. Число
всех пар элементов перестановки, образующих инверсию,
называется числом инверсий в перестановке и обозначается inv( 1,  2,
...,  n). Так, inv()=7 (инверсии образуют пары 31, 32, 51, 54, 52, 42, 87).
Перестановки, содержащие четное число инверсий, называются четными,
содержащие нечетное число инверсий - нечетными.
Если в некоторой перестановке мы поменяем местами какие-либо два
символа (не обязательно стоящие рядом), а все остальные символы оставим
на месте, то получим, очевидно, новую перестановку. Это преобразование
перестановки называется транспозицией.
Утверждение 2. От любой перестановки из n символов можно перейти к
любой другой перестановки посредством нескольких транспозиций.
Доказательство. Применим индукцию. Это утверждение справедливо при n
= 2; если требуется начинать с перестановки 12, то вторая (а их всего две)
21 получается из первой в результате одной транспозиции. Предположим,
что наше утверждение уже доказано для n-1, и докажем его для n.
Пусть ( 1,  2, ...,  n) и ( 1,  2, ...,  n) - две данные перестановки.
Если  1=  1, то ( 2, ...,  n) и ( 2, ...,  n) отличаются только порядком и,
в силу предположения об индукции, посредством нескольких транспозиций
можно перейти от ( 2, ...,  n) к ( 2, ...,  n) и, следовательно, от ( 1,  2,
...,  n) к ( 1,  2, ...,  n). Пусть теперь  1  1. Тогда  1=  i при
некотором i  1. Сделав в ( 1,  2, ...,  n) транспозицию ( 1,  i), мы
придем к новой перестановке, у которой на первом месте находится  i =
1. В силу доказанного выше свойства, эта перестановка превращается в (
1,  2, ...,  n) посредством нескольких транспозиций. Следовательно, от (
1,  2, ...,  n) к ( 1,  2, ...,  n) можно перейти посредством нескольких
транспозиций, что и требовалось доказать.
Заметим, что переход от одной перестановки к другой посредством
транспозиций неоднозначен.
Утверждение 3. Всякая транспозиция меняет четность перестановки.
Доказательство. Рассмотрим сначала случай, когда транспонируемые
символы i и j стоят рядом, т. е. перестановка имеет вид..., i, j, ..., где
многоточия заменяют те символы, которые не затрагиваются
транспозицией. Транспозиция превращает нашу перестановку в
перестановку..., j, i, ..., причем, понятно, в обеих перестановках каждый из
символов i, j составляет одни и те же инверсии с символами, остающимися
на месте. Если символы i и j раньше не составляли инверсии, то в новой
12
перестановке появляется одна новая инверсия, т. е. число инверсий
увеличивается на единицу; если же они раньше составляли инверсию, то
теперь она пропадает, т. е. число инверсий на единицу уменьшается. В
обоих случаях четность перестановки меняется.
Пусть теперь между транспонируемыми символами i и j расположены s
символов, s > 0, т. е. перестановка имеет вид..., i, k1, k2, ..., ks, j,
Транспозицию символов i и j можно получить в результате
последовательного выполнения 2s+1 транспозиций соседних элементов. А
именно это будут транспозиции, переставляющие символы i и k1, затем i
(уже стоящие на месте символа k1) и k2 и т. д., пока i не займет место
символа ks. За этими s транспозициями следует транспозиция,
перемещающая символы i и j, а затем s транспозиций символа j со всеми k,
после чего j занимает место символа i, а символы k возвращаются на свои
старые места. Таким образом, мы нечетное число раз меняли четность
перестановки, а поэтому перестановки (1) и..., j, k1, k2, ..., ks, i, ... имеют
противоположные четности.
Утверждение 4. Число четных перестановок n элементов равно числу
нечетных перестановок.
Доказательство. Пусть число четных перестановок равно a, число
нечетных равно b. Рассмотрим множество всех четных перестановок.
Сделаем в них одну и ту же транспозицию, например, (1,2). Мы получим
нечетные перестановки, попарно различные, в количестве a штук. Так как
число всех нечетных перестановок равно b, то заключаем, что a  b. Теперь
рассмотрим множество всех нечетных перестановок и сделаем в них
транспозицию (1,2). Мы получим b четных перестановок и, следовательно, b
 a. Из установленных неравенств следует, что a = b, что и требовалось
доказать.
Попутно мы получили, что если во всех четных перестановках сделать одну
и ту же транспозицию, что мы получим все нечетные перестановки.
Определим теперь еще одно понятие, а именно понятие подстановки.
Подстановкой n-й степени на множестве {1, 2, ..., n} называется взаимно
однозначное отображение множества на себя. Удобно задавать
подстановку прямым указанием замен для каждого элемента, посредством
записи образа под прообразом. Так, запись
задает
подстановку, которая заменяет элементы 1, 2, 3, 4, 5, соответственно, на
5, 1, 3, 2, 4; порядок расположения ее столбцов безразличен. В такой записи
в "числителе" и в "знаменателе" оказываются перестановки. Удобно в
"числителе" записывать элементы в натуральном расположении. От одной
записи подстановки к другой можно перейти при помощи нескольких
13
транспозиций столбиков. В частности, всякая подстановка на множестве
{1, 2, ..., n} может быть записана в виде
(2)
При такой записи различные подстановки отличаются друг от друга
перестановками, стоящими в нижней строке, и поэтому число
подстановок n-й степени равно числу перестановок из n символов, т. е.
равно n!
Перестановки, составляющие верхнюю и нижнюю строки ее записи, могут
иметь или одинаковые или противоположные четности. Переход к любой
другой записи можно осуществить путем последовательного выполнения
нескольких транспозиций в верхней строке и соответствующих
транспозиций в нижней строке. Однако, совершая одну транспозицию в
верхней строке записи
и одну транспозицию соответствующих элементов в нижней строке, мы
одновременно меняем четности обеих перестановок и поэтому сохраняем
совпадение или противоположность этих четностей. Отсюда следует
Утвержденние 5. Либо при всех записях подстановки четности верхней и
нижней строк совпадают, либо же при всех записях они противоположны.
В первом случае подстановка будет называться четной, во втором нечетной.
Если подстановка записана в виде (2), т. е. в верхней строке стоит четная
перестановка 1, 2, ..., n, то четность подстановки будет определяться
четностью перестановки  1,  2, ...,  n, стоящей в нижней строке.
Отсюда следует
Утверждение 6. Число
четных
нечетных, т. е. равно
.
подстановок n-й степени
14
равно
числу
2.2 Выбор средств разработки
Microsoft Visual Studio — линейка продуктов компании Microsoft,
включающих интегрированную среду разработки программного обеспечения
и ряд других инструментальных средств. Данные продукты позволяют
разрабатывать как консольные приложения, так и приложения с графическим
интерфейсом, в том числе с поддержкой технологии Windows Forms, а
также веб-сайты, веб-приложения, веб-службы как в родном, так и
в управляемом кодах для всех платформ,
поддерживаемых Windows, Windows Mobile, Windows CE, .NET
Framework, Xbox, Windows Phone .NET Compact Framework и Silverlight.
Visual Studio – инструментальная среда разработки, включающая в себя
интегрированную среду разработки, редактор исходного кода, встроенный
отладчик. Многие другие инструменты возможно получить благодаря
подключению плагинов – сторонних расширений. Был выбран по причине
наличия интеграции с Unity 3d, поддержки языка программирования С#,
наличие возможности написание собственных Unit-тестов. Также это
наиболее изученная разработчиком платформа, что позволяет быстрее
разрабатывать приложения не тратя время на изучения нового материала.
В даннаом проекте была выбрана среда разработки пограммы Visual
Studio 2019 C++ по сравнению с аналогичными программными продуктами.
– быстрота разработки приложения;
– высокая производительность разработанного приложения;
– низкие требования разработанного приложения к ресурсам компьютера;
– возможность разработки новых компонентов и инструментов
– удачная проработка иерархии объектов.
2.2.1. Функциональные требования
В программе должны быть реализованы:
- Представление матрицы в формате, описанном выше. Для этого должен
использоваться отдельный класс – класс матриц.
15
- Операции инициализации матриц (инициализация единичной, нулевой,
случайной, одночисельнной матрицы).
- Операции сложения, и умножения матриц.
- Операции умножения матрицы на скаляр и возведение в скалярную
степень.
- Удобная память калькулятора (буфер).
2.2.2. Требования к интерфейсу
Интерфейс должен обеспечивать пользователю возможность.(рис1):
1) удобного ввода данных с клавиатуры;
2) Производить все операции, перечисленные в «Функциональных
требованиях» интуитивно понятным и удобным способом;
5) Не допускать обработки исходных данных, противоречащих логике
работы программы путем вывода сообщений об ошибке;
рис.1 Внешний вид программы
16
2.2.4. Схема алгоритма
Любая функция нажатия функциональной кнопки главного окна использует
одну из функций чтения формы и/или одну из функций вывода в форму
описанных в файле MatrixCalculator.vbl
Сначала происходит чтение одной или двух таблиц строк StringGrid с
занесением значений из них в соответствующие матрицы.
Затем с помощью методов класса TMatrix данные обрабатываются и
выводятся по необходимости в результирующую или одну из рабочих
StringGrid.
Рассмотрим на примере функции нажатия кнопки сложения.
1) Чтение обеих StringGrid с помощью метода ReadForm() с занесением
результата в _Mat1 и _Mat2.
2) Присвоение матрице _Res значения суммы матриц _Mat1 и _Mat2 с
помощью метода класса TMatrix MSumm(TMatrix, TMatrix).
3) Вывод матрицы _Res в форму с помощью функции WriteForm().
2.2.5.Руководство пользователя
Интерфейс любой программы должен отличаться легкой восприимчивостью
пользователем.
Если пользователь сможет разобраться в программе без руководства, то
работа программиста будет считаться выполненной великолепно. В этой
работе тоже были приложены усилия для создания простого, понятного и
удобного интерфейс (рис2.)
17
(рис.2) Интерфейс калькулятора
В левой части окна матрица «A» нужно туда ввести чилса
Потом в матрицу B ввести числа. Нажать на «A+B, A-B, A*B » , умножит
Матрицу «A» или «B», Транспонировать, в зависимости от действия
пользователя.
Можно менять цвет окна на свой вкус в кнопке вид.
Через функционал можно быстро очистить матрицу A или B.
Исходный тест программы: using System;
using System.Drawing;
using System.Windows.Forms;
using System.Runtime.InteropServices;
namespace MatrixCalculator
{
public partial class Form1 : Form
{
[DllImport("dwmapi.dll")]
static extern int DwmExtendFrameIntoClientArea(IntPtr hwnd, ref
MARGINS margins);
[StructLayout(LayoutKind.Sequential)]
18
public struct MARGINS
{
public int leftWidth;
public int rightWidth;
public int topHeight;
public int bottomHeight;
}
public Form1()
{
InitializeComponent();
AeroGlass(true);
}
static Color ColorsBackColor(int i)
{
Color[] colors = { Color.Silver, Color.Red, Color.Green, Color.Blue,
Color.White };
return colors[i];
}
void AeroGlass(bool _enabled)
{
MARGINS _margins = new MARGINS();
_margins.bottomHeight = 23;
if (_enabled)
{
DwmExtendFrameIntoClientArea(this.Handle, ref _margins);
}
}
private void MatricesM_Click(object sender, System.EventArgs e)
{
try
19
{
label3.Text = $"Ответ ({MatricesM.Text}):";
matrixAB1.Text = ((int.Parse(matrixA1.Text) *
int.Parse(matrixB1.Text)) + (int.Parse(matrixA4.Text) * int.Parse(matrixB2.Text))
+ (int.Parse(matrixA7.Text) * int.Parse(matrixB3.Text))).ToString();
matrixAB4.Text = ((int.Parse(matrixA1.Text) *
int.Parse(matrixB4.Text)) + (int.Parse(matrixA4.Text) * int.Parse(matrixB5.Text))
+ (int.Parse(matrixA7.Text) * int.Parse(matrixB6.Text))).ToString();
matrixAB7.Text = ((int.Parse(matrixA1.Text) *
int.Parse(matrixB7.Text)) + (int.Parse(matrixA4.Text) * int.Parse(matrixB8.Text))
+ (int.Parse(matrixA7.Text) * int.Parse(matrixB9.Text))).ToString();
matrixAB2.Text = ((int.Parse(matrixA2.Text) *
int.Parse(matrixB1.Text)) + (int.Parse(matrixA5.Text) * int.Parse(matrixB2.Text))
+ (int.Parse(matrixA8.Text) * int.Parse(matrixB3.Text))).ToString();
matrixAB5.Text = ((int.Parse(matrixA2.Text) *
int.Parse(matrixB4.Text)) + (int.Parse(matrixA5.Text) * int.Parse(matrixB5.Text))
+ (int.Parse(matrixA8.Text) * int.Parse(matrixB6.Text))).ToString();
matrixAB8.Text = ((int.Parse(matrixA2.Text) *
int.Parse(matrixB7.Text)) + (int.Parse(matrixA5.Text) * int.Parse(matrixB8.Text))
+ (int.Parse(matrixA8.Text) * int.Parse(matrixB9.Text))).ToString();
matrixAB3.Text = ((int.Parse(matrixA3.Text) *
int.Parse(matrixB1.Text)) + (int.Parse(matrixA6.Text) * int.Parse(matrixB2.Text))
+ (int.Parse(matrixA9.Text) * int.Parse(matrixB3.Text))).ToString();
matrixAB6.Text = ((int.Parse(matrixA3.Text) *
int.Parse(matrixB4.Text)) + (int.Parse(matrixA6.Text) * int.Parse(matrixB5.Text))
+ (int.Parse(matrixA9.Text) * int.Parse(matrixB6.Text))).ToString();
matrixAB9.Text = ((int.Parse(matrixA3.Text) *
int.Parse(matrixB7.Text)) + (int.Parse(matrixA6.Text) * int.Parse(matrixB8.Text))
+ (int.Parse(matrixA9.Text) * int.Parse(matrixB9.Text))).ToString();
}
catch (FormatException exc)
20
{
label4.Text = "Статус:" + exc.Message;
}
}
private void MatricesS_Click(object sender, System.EventArgs e)
{
try
{
label3.Text = $"Ответ ({MatricesS.Text}):";
matrixAB1.Text = (int.Parse(matrixA1.Text) +
int.Parse(matrixB1.Text)).ToString();
matrixAB2.Text = (int.Parse(matrixA2.Text) +
int.Parse(matrixB2.Text)).ToString();
matrixAB3.Text = (int.Parse(matrixA3.Text) +
int.Parse(matrixB3.Text)).ToString();
matrixAB4.Text = (int.Parse(matrixA4.Text) +
int.Parse(matrixB4.Text)).ToString();
matrixAB5.Text = (int.Parse(matrixA5.Text) +
int.Parse(matrixB5.Text)).ToString();
matrixAB6.Text = (int.Parse(matrixA6.Text) +
int.Parse(matrixB6.Text)).ToString();
matrixAB7.Text = (int.Parse(matrixA7.Text) +
int.Parse(matrixB7.Text)).ToString();
matrixAB8.Text = (int.Parse(matrixA8.Text) +
int.Parse(matrixB8.Text)).ToString();
matrixAB9.Text = (int.Parse(matrixA9.Text) +
int.Parse(matrixB9.Text)).ToString();
}
catch (FormatException exc)
{
label4.Text = "Статус:" + exc.Message;
21
}
}
private void MatricesD_Click(object sender, System.EventArgs e)
{
try
{
label3.Text = $"Ответ ({MatricesD.Text}):";
matrixAB1.Text = (int.Parse(matrixA1.Text) int.Parse(matrixB1.Text)).ToString();
matrixAB2.Text = (int.Parse(matrixA2.Text) int.Parse(matrixB2.Text)).ToString();
matrixAB3.Text = (int.Parse(matrixA3.Text) int.Parse(matrixB3.Text)).ToString();
matrixAB4.Text = (int.Parse(matrixA4.Text) int.Parse(matrixB4.Text)).ToString();
matrixAB5.Text = (int.Parse(matrixA5.Text) int.Parse(matrixB5.Text)).ToString();
matrixAB6.Text = (int.Parse(matrixA6.Text) int.Parse(matrixB6.Text)).ToString();
matrixAB7.Text = (int.Parse(matrixA7.Text) int.Parse(matrixB7.Text)).ToString();
matrixAB8.Text = (int.Parse(matrixA8.Text) int.Parse(matrixB8.Text)).ToString();
matrixAB9.Text = (int.Parse(matrixA9.Text) int.Parse(matrixB9.Text)).ToString();
}
catch (FormatException exc)
{
label4.Text = "Статус:" + exc.Message;
}
22
}
private void очиститьМатрицуAToolStripMenuItem_Click(object sender,
System.EventArgs e)
{
TextBox[] MatricesATextBox = { matrixA1, matrixA2, matrixA3,
matrixA4, matrixA5, matrixA6, matrixA7, matrixA8, matrixA9 };
foreach (var MatricesA in MatricesATextBox)
MatricesA.Clear();
}
private void очиститьМатрицуBToolStripMenuItem_Click(object sender,
System.EventArgs e)
{
TextBox[] MatricesBTextBox = { matrixB1, matrixB2, matrixB3,
matrixB4, matrixB5, matrixB6, matrixB7, matrixB8, matrixB9 };
foreach (var MatricesB in MatricesBTextBox)
MatricesB.Clear();
}
private void очиститьМатрицуAИBToolStripMenuItem_Click_1(object
sender, System.EventArgs e)
{
TextBox[] MatricesABTextBox = { matrixA1, matrixA2, matrixA3,
matrixA4, matrixA5, matrixA6, matrixA7, matrixA8, matrixA9, matrixB1,
matrixB2, matrixB3, matrixB4, matrixB5, matrixB6, matrixB7, matrixB8,
matrixB9 };
foreach (var MatricesAB in MatricesABTextBox)
MatricesAB.Clear();
}
private void очиститьВсёToolStripMenuItem_Click(object sender,
System.EventArgs e)
{
23
TextBox[] AllMatricesTextBox = { matrixA1, matrixA2, matrixA3,
matrixA4, matrixA5, matrixA6, matrixA7, matrixA8, matrixA9, matrixB1,
matrixB2, matrixB3, matrixB4, matrixB5, matrixB6, matrixB7, matrixB8,
matrixB9, matrixAB1, matrixAB2, matrixAB3, matrixAB4, matrixAB5,
matrixAB6, matrixAB7, matrixAB8, matrixAB9 };
foreach (var AllMatrices in AllMatricesTextBox)
AllMatrices.Clear();
}
private void MatricesChange_Click(object sender, System.EventArgs e)
{
try
{
string stack = String.Empty;
stack = matrixA1.Text;
matrixA1.Text = matrixB1.Text;
matrixB1.Text = stack;
stack = matrixA4.Text;
matrixA4.Text = matrixB4.Text;
matrixB4.Text = stack;
stack = matrixA7.Text;
matrixA7.Text = matrixB7.Text;
matrixB7.Text = stack;
stack = matrixA2.Text;
matrixA2.Text = matrixB2.Text;
matrixB2.Text = stack;
stack = matrixA5.Text;
matrixA5.Text = matrixB5.Text;
matrixB5.Text = stack;
stack = matrixA8.Text;
matrixA8.Text = matrixB8.Text;
matrixB8.Text = stack;
24
stack = matrixA3.Text;
matrixA3.Text = matrixB3.Text;
matrixB3.Text = stack;
stack = matrixA6.Text;
matrixA6.Text = matrixB6.Text;
matrixB6.Text = stack;
stack = matrixA9.Text;
matrixA9.Text = matrixB9.Text;
matrixB9.Text = stack;
}
catch (FormatException exc)
{
label4.Text = "Статус:" + exc.Message;
}
}
private void MultiplyMatricesA_Click(object sender, EventArgs e)
{
try
{
matrixA1.Text = (int.Parse(matrixA1.Text) *
numericMatricesA.Value).ToString();
matrixA4.Text = (int.Parse(matrixA4.Text) *
numericMatricesA.Value).ToString();
matrixA7.Text = (int.Parse(matrixA7.Text) *
numericMatricesA.Value).ToString();
matrixA2.Text = (int.Parse(matrixA2.Text) *
numericMatricesA.Value).ToString();
matrixA5.Text = (int.Parse(matrixA5.Text) *
numericMatricesA.Value).ToString();
matrixA8.Text = (int.Parse(matrixA8.Text) *
numericMatricesA.Value).ToString();
25
matrixA3.Text = (int.Parse(matrixA3.Text) *
numericMatricesA.Value).ToString();
matrixA6.Text = (int.Parse(matrixA6.Text) *
numericMatricesA.Value).ToString();
matrixA9.Text = (int.Parse(matrixA9.Text) *
numericMatricesA.Value).ToString();
}
catch (FormatException exc)
{
label4.Text = "Статус:" + exc.Message;
}
}
private void MultiplyMatricesB_Click(object sender, EventArgs e)
{
try
{
matrixB1.Text = (int.Parse(matrixB1.Text) *
numericMatricesB.Value).ToString();
matrixB4.Text = (int.Parse(matrixB4.Text) *
numericMatricesB.Value).ToString();
matrixB7.Text = (int.Parse(matrixB7.Text) *
numericMatricesB.Value).ToString();
matrixB2.Text = (int.Parse(matrixB2.Text) *
numericMatricesB.Value).ToString();
matrixB5.Text = (int.Parse(matrixB5.Text) *
numericMatricesB.Value).ToString();
matrixB8.Text = (int.Parse(matrixB8.Text) *
numericMatricesB.Value).ToString();
matrixB3.Text = (int.Parse(matrixB3.Text) *
numericMatricesB.Value).ToString();
26
matrixB6.Text = (int.Parse(matrixB6.Text) *
numericMatricesB.Value).ToString();
matrixB9.Text = (int.Parse(matrixB9.Text) *
numericMatricesB.Value).ToString();
}
catch (FormatException exc)
{
label4.Text = "Статус:" + exc.Message;
}
}
private void TransposeMatricesA_Click(object sender, EventArgs e)
{
try
{
string stackTransposeA = String.Empty;
stackTransposeA = matrixA1.Text;
matrixA1.Text = matrixA1.Text;
matrixA1.Text = stackTransposeA;
stackTransposeA = matrixA2.Text;
matrixA2.Text = matrixA4.Text;
matrixA4.Text = stackTransposeA;
stackTransposeA = matrixA3.Text;
matrixA3.Text = matrixA7.Text;
matrixA7.Text = stackTransposeA;
stackTransposeA = matrixA5.Text;
matrixA5.Text = matrixA5.Text;
matrixA5.Text = stackTransposeA;
stackTransposeA = matrixA6.Text;
matrixA6.Text = matrixA8.Text;
matrixA8.Text = stackTransposeA;
stackTransposeA = matrixA9.Text;
27
matrixA9.Text = matrixA9.Text;
matrixA9.Text = stackTransposeA;
}
catch (FormatException exc)
{
label4.Text = "Статус:" + exc.Message;
}
}
private void TransposeMatricesB_Click(object sender, EventArgs e)
{
try
{
string stackTransposeB = String.Empty;
stackTransposeB = matrixB1.Text;
matrixB1.Text = matrixB1.Text;
matrixB1.Text = stackTransposeB;
stackTransposeB = matrixB2.Text;
matrixB2.Text = matrixB4.Text;
matrixB4.Text = stackTransposeB;
stackTransposeB = matrixB3.Text;
matrixB3.Text = matrixB7.Text;
matrixB7.Text = stackTransposeB;
stackTransposeB = matrixB5.Text;
matrixB5.Text = matrixB5.Text;
matrixB5.Text = stackTransposeB;
stackTransposeB = matrixB6.Text;
matrixB6.Text = matrixB8.Text;
matrixB8.Text = stackTransposeB;
stackTransposeB = matrixB9.Text;
matrixB9.Text = matrixB9.Text;
matrixB9.Text = stackTransposeB;
28
}
catch (FormatException exc)
{
label4.Text = "Статус:" + exc.Message;
}
}
private void silverToolStripMenuItem_Click(object sender, EventArgs e)
{
this.BackColor = ColorsBackColor(0);
}
private void redToolStripMenuItem_Click(object sender, EventArgs e)
{
this.BackColor = ColorsBackColor(1);
}
private void greenToolStripMenuItem_Click(object sender, EventArgs e)
{
this.BackColor = ColorsBackColor(2);
}
private void blueToolStripMenuItem_Click(object sender, EventArgs e)
{
this.BackColor = ColorsBackColor(3);
}
private void whiteToolStripMenuItem_Click(object sender, EventArgs e)
{
this.BackColor = ColorsBackColor(4);
}
}
}
29
ЗАКЛЮЧЕНИЕ
Система Visual Studio 2019 позволяет решать множество задач, в частности:
Создавать законченные приложения для Windows самой различной
направленности: от чисто вычислительных и логических, до графических и
мультимедиа. Быстро создавать (даже начинающим программистам)
профессионально выглядящий оконный интерфейс для любых приложений .
В процессе выполнения курсового проекта я усвоил некоторые
возможности Visual Studio 2019. Но даже этот небольшой объем материала
позволил мне убедиться в колоссальности данной среды.
Целью курсовой работы было изучение языка программирования Visual
Studio 2019 и разработка практических заданий.
При выполнении курсовой работы: была изучена теория и технология
работы с средой программирования Visual Studio 2019. Была изучена и
проанализирована соответствующая литература;
30
Список использованных источников
1.А. Н. Вальвачев, К. А. Сурков, Д. А. Сурков, Ю. М. Четырько.
1. Бьерном Страуструпом Программирование. Принципы и практика с
использованием C++ - Вильямс 2016г
2. Беллман Р. Введение в теорию матриц. — М.: Мир, 1969.
3. ГолубДж. (Gene H. Golub), ВанЛоунЧ. (Charles F. Van Loan)
Матричные вычисления. — М.: Мир, 1999, 548с., ил. (ISBN 5-03-002406-9)
4.Хорн Р. (Roger A.Horn), Джонсон Ч. (Charles C. Johnson) Матричный анализ. —
М.: Мир, 1989, 655с., ил. (ISBN 5-03-001042-4)
31