Исполняемое Win32 приложение

РЕФЕРАТ
Пояснительная записка содержит:43 страницы, 8 рисунков, 5 формул.
Цель – закреплениезнаний, полученных при изучении технологии программирования гибкихкомпьютеризированных систем; приобретение практических навыков в созданиипрограммных проектов с использованием среды программирования MS Visual Studio; изучение принципов и методов создания приложений сиспользованием библиотеки Microsoft Foundational Classes (MFC), изучение основ теории нечетких множеств, вчастности функций принадлежности.
Результат – исполняемое приложение,реализующее построение функций принадлежности и определение степенипринадлежности выбранной точки.
Ключевыеслова: НЕЧЕТКОЕ МНОЖЕСТВО, ФУНКЦИЯ ПРИНАДЛЕЖНОСТИ, СТЕПЕНЬ ПРИНАДЛЕЖНОСТИ, ПРОГРАММА,C++, MFC, MICROSOFT VISUAL STUDIO.

СОДЕРЖАНИЕ
ВВЕДЕНИЕ
1. АНАЛИЗ ТЕХНИЧЕСКОГО ЗАДАНИЯ
2. АНАЛИЗ ТЕХНИЧЕСКИХ РЕШЕНИЙ
2.1 Библиотека MFC
2.2 Нечеткая логика – математическиеосновы
2.3 Применение нечеткой логики
3. ПРОЕКТИРОВАНИЕ ФУНКЦИОНАЛЬНОЙ СТРУКТУРЫ ПРОГРАММНОГООБЕСПЕЧЕНИЯ
4. ПРОГРАММНАЯ РЕАЛИЗАЦИЯ
ВЫВОДЫ
ПЕРЕЧЕНЬ ССЫЛОК
Приложение А. Исходный текст программы

ВВЕДЕНИЕ
Математическая теориянечетких множеств (fuzzy sets) инечеткая логика (fuzzy logic)являются обобщениями классической теории множеств и классической формальнойлогики. Данные понятия были впервые предложены американским ученым Лотфи Заде (Lotfi Zadeh) в статье «Fuzzy Sets» (Нечеткие Множества) в 1965году в журнале Information and Control. Основной причиной появления новой теории стало наличие нечетких иприближенных рассуждений при описании человеком процессов, систем, объектов.
Идея, лежащая в основетеории нечетких множеств, заключается в том, что человек в своей повседневнойжизни мыслит и принимает решения на основе нечетких понятий. Создание теориинечетких множеств ‑ это попытка формализовать человеческий способрассуждений. Развитие вычислительной техники позволяет в настоящее времясоздавать на базе теории нечетких множеств системы нечеткой логики, которыекопируют способ рассуждений человека.[2]
Прежде чем нечеткийподход к моделированию сложных систем получил признание во всем мире, прошло неодно десятилетие с момента зарождения теории нечетких множеств. И на этом путиразвития нечетких систем принято выделять три периода[5].
Первый период (конец 60-х– начало 70 гг.) характеризуется развитием теоретического аппарата нечеткихмножеств (Л. Заде, Э. Мамдани, Беллман). Во втором периоде (70–80-е годы)появляются первые практические результаты в области нечеткого управлениясложными техническими системами (парогенератор с нечетким управлением).Одновременно стало уделяться внимание вопросам построения экспертных систем,построенных на нечеткой логике, разработке нечетких контроллеров. Нечеткиеэкспертные системы для поддержки принятия решений находят широкое применение вмедицине и экономике. Наконец, в третьем периоде, который длится с конца 80-хгодов и продолжается в настоящее время, появляются пакеты программ дляпостроения нечетких экспертных систем, а области применения нечеткой логикизаметно расширяются. Она применяется в автомобильной, аэрокосмической и транспортнойпромышленности, в области изделий бытовой техники, в сфере финансов, анализа ипринятия управленческих решений и многих других.
Триумфальное шествиенечеткой логики по миру началось после доказательства в конце 80-х БартоломеемКоско знаменитой теоремы FAT (Fuzzy ApproximationTheorem). В бизнесе ифинансах нечеткая логика получила признание после того как в 1988 годуэкспертная система на основе нечетких правил для прогнозирования финансовыхиндикаторов единственная предсказала биржевой крах. И количество успешныхфаззи-применений в настоящее время исчисляется тысячами.
В гибкихкомпьютеризированных системах, как правило, обрабатываемые данные носят четкий,числовой характер. Однако иногда могут присутствовать неточности и неопределенности,часто приходится находить разумный компромисс между понятиями«точность» и «важность». В этом случае на помощь приходитконцепция нечеткой логики.

1. АНАЛИЗ ТЕХНИЧЕСКОГО ЗАДАНИЯ
Целью работы являетсяразработка исполняемого Win32приложения с визуальным интерфейсом, обеспечивающим построение функцийпринадлежности. Для реализации отмеченной функциональности необходимо:
а) спроектироватьвизуальный интерфейс приложения, включающий в себя кнопки доступа к функциямпостроения графика, выбора типа функции принадлежности, полей ввода исходныхданных;
б) определить областьотображения графика;
в) реализовать построениефункций принадлежности таких типов: треугольная, трапециидальная, гауссовская, расширеннаягауссовская, сигмоидальная с учетом масштаба;
г) реализоватьвозможность определения степени принадлежности точки для заданного типа функциипринадлежности;
д) произвеститестирование приложения на множестве исходных данных.
В целях сокращениявремени на разработку визуального интерфейса в операционной системе Microsoft Windows, целесообразно использовать функциональныевозможности динамически исполняемой библиотеки MFC в среде разработки Microsoft Visual Studio 6. Библиотека имеет собственную иерархическуюорганизацию программных компонент, позволяющих создавать различные визуальныеэлементы управления.
Таким образом, выполнениетехнического задания требует программной реализации приложения с визуальныминтерфейсом для построения функций принадлежности по исходным данным.

2. АНАЛИЗ ТЕХНИЧЕСКИХ РЕШЕНИЙ
2.1 Библиотека MFC
Система Microsoft Windows была разработана до того времени, когда идеяобъектно-ориентированного программирования нашла свое отражение в языке C++.Приложения на языке С реализовывались с применением функций программного интерфейса,называемых иногда функциями API (Application Programming Interface). Однако идеиобъектно-ориентированного программирования требуют и наличия средств,позволяющих, с одной стороны, программировать в терминах классов, а с другой –сохранить возможность использования в приложениях функций API. Именно такойобъектно-ориентированный интерфейс для Windows обеспечивает библиотека классов MFC (Microsoft FoundationClasses), входящая всостав пакета Visual C++.
Эта библиотека классовпозволяет:
а) значительно сократитьусилия по написанию программного кода приложений Windows;
б) уменьшить размерпрограммного кода;
в) обрабатывать сообщениянепосредственно методами класса без программирования цикла обработки сообщений;
г) выполнятьнепосредственный вызов любой функции Windows С;
д) легко преобразовыватьСи-приложения в приложения на языке C++;
е) использовать всефункции Windows API;
ж) легче адаптироватьприложения к различным платформам, использовать как статически, так идинамически подключаемые библиотеки MFC;
з) значительно упроститьприменение таких возможностей, как элементы управления OLE, работа с базамиданных, средства печати, управление наборами инструментария;
и) более эффективноиспользовать объектную ориентированность языка C++.
/>
Рисунок 2.1 – Иерархияклассов в библиотеке MFC
Следует отметить, что MFCинкапсулирует функции API в форме C++. Эта библиотека классов позволяетработать в терминах различных элементов Windows, таких, как окна, диалоги, элементы управления, атакже в терминах графического интерфейса: контекст устройства, кисть и перо. БиблиотекаMFC создана как иерархический набор классов, позволяющих реализовыватьWindows-приложения различных типов: диалоги, приложения с SDI или MDIинтерфейсом, приложения, поддерживающие работу с базами данных, OLE-приложения.Базовым классом большинства классов библиотеки является класс CObject. В этомклассе инкапсулированы общие методы работы с объектами: использование дампаобъектов класса при отладке приложения, доступ к информации о классе объектавремени выполнения, сохранение и восстановление объектов класса. Большую частьбиблиотеки составляют классы, наследуемые от CObject и реализующие архитектуруприложения (рисунок 2.1)[1]: CWinThread, CWinApp, CDoc-Template, CDocument, CFrameWnd, CView и др.
2.2 Нечеткая логика ‑ математические основы
Нечеткое множество ‑это пара (A, m), где A ‑ имя нечеткого множества, например: БОЛЬШОЙ,МОЛОДОЙ, ОТРИЦАТЕЛЬНО МАЛЫЙ, а m ‑ функция m:X-->L, называемаяфункцией принадлежности и обозначаемая обычно греческой буквой m. Часто полагается L = [0,1], а вкачестве X используется некоторое множество вещественных чисел. m(x)интерпретируется как степень принадлежности элемента x из X нечеткому множествуA.
Характеристикой нечеткогомножества выступает функция принадлежности (Membership Function)[4]. Обозначим через MFc(x)– степень принадлежности к нечеткому множеству C, представляющей собойобобщение понятия характеристической функции обычного множества. Тогда нечеткиммножеством С называется множество упорядоченных пар вида C={MFc(x)/x},MFc(x) [0,1]. Значение MFc(x)=0 означает отсутствиепринадлежности к множеству, 1 – полную принадлежность.
Проиллюстрируем это напростом примере. Формализуем неточное определение 'горячий чай'. В качестве x(область рассуждений) будет выступать шкала температуры в градусах Цельсия.Очевидно, что она будет изменяется от 0 до 100 градусов. Нечеткое множество дляпонятия 'горячий чай' может выглядеть следующим образом:
C={0/0; 0/10; 0/20;0,15/30; 0,30/40; 0,60/50; 0,80/60; 0,90/70; 1/80; 1/90; 1/100}.
Так, чай с температурой60 С принадлежит к множеству 'Горячий' со степенью принадлежности 0,80. Дляодного человека чай при температуре 60 С может оказаться горячим, для другого –не слишком горячим. Именно в этом и проявляется нечеткость заданиясоответствующего множества.
Для нечетких множеств,как и для обычных, определены основные логические операции[5]. Самымиосновными, необходимыми для расчетов, являются пересечение и объединение.
Пересечение двух нечеткихмножеств (нечеткое «И»): AÈB: MFAB(x)=min(MFA(x), MFB(x)).
Объединение двух нечеткихмножеств (нечеткое «ИЛИ»): AÇB: MFAB(x)=max(MFA(x), MFB(x)).
В теории нечеткихмножеств разработан общий подход к выполнению операторов пересечения,объединения и дополнения, реализованный в так называемых треугольных нормах иконормах. Приведенные выше реализации операций пересечения и объединения –наиболее распространенные случаи t-нормы и t-конормы.
Для описания нечеткихмножеств вводятся понятия нечеткой и лингвистической переменных.[4]
Нечеткая переменнаяописывается набором (N,X,A), где N – это название переменной, X – универсальноемножество (область рассуждений), A – нечеткое множество на X.
Значениямилингвистической переменной могут быть нечеткие переменные, т.е. лингвистическаяпеременная находится на более высоком уровне, чем нечеткая переменная. Каждаялингвистическая переменная состоит из:
— названия;
— множества своихзначений, которое также называется базовым терм-множеством T. Элементы базовоготерм-множества представляют собой названия нечетких переменных;
— универсальногомножества X;
— синтаксического правилаG, по которому генерируются новые термы с применением слов естественного илиформального языка;
— семантического правилаP, которое каждому значению лингвистической переменной ставит в соответствиенечеткое подмножество множества X.
Рассмотрим такое нечеткоепонятие как 'Цена акции'. Это и есть название лингвистической переменной.Сформируем для нее базовое терм-множество, которое будет состоять из трехнечетких переменных: 'Низкая', 'Умеренная', 'Высокая' и зададим областьрассуждений в виде X=[100;200](единиц). Последнее, что осталось сделать – построить функции принадлежностидля каждого лингвистического терма из базового терм-множества T.
Существует свыше десяткатиповых форм кривых для задания функций принадлежности.[2] Наибольшеераспространение получили: треугольная, трапецеидальная и гауссовская функциипринадлежности.
Треугольная функция(рисунок 2.2) принадлежности определяется тройкой чисел (a,b,c), и ее значениев точке x вычисляется согласно выражению:
/> (2.1)
При (b-a)=(c-b) имеемслучай симметричной треугольной функции принадлежности, которая может бытьоднозначно задана двумя параметрами из тройки (a,b,c).

/>
Рисунок 2.2 – Треугольнаяфункция принадлежности
Аналогично для заданиятрапецеидальной функции (рисунок 2.3) принадлежности необходима четверка чисел(a,b,c,d):
/>(2.2)
При (b-a)=(d-c)трапецеидальная функция принадлежности принимает симметричный вид.
/>
Рисунок 2.3 –Трапециидальная функция принадлежности
Функция принадлежностигауссова типа(рисунок 2.4) описывается формулой
/>(2.3)
и оперирует двумя параметрами.Параметр c обозначает центр нечеткого множества, а параметр s отвечает за крутизну функции.
/>
Рисунок 2.4 – Гауссовскаяфункция принадлежности
Расширенная функцияпринадлежности гауссова типа(рисунок 2.5) описывается формулой
/>(2.4)
/>
Рисунок 2.5 – Расширеннаягауссовская функция принадлежности
Сигмоидальная функцияпринадлежности (рисунок 2.6) описывается формулой
/>(2.5)

/>
Рисунок 2.6 – Сигмоидальнаяфункция принадлежности
2.3 Применение нечеткой логики
Гибридизация методовинтеллектуальной обработки информации – девиз, под которым прошли 90-е годы узападных и американских исследователей. В результате объединения несколькихтехнологий искусственного интеллекта появился специальный термин – 'мягкиевычисления' (softcomputing), который ввелЛ. Заде в 1994 году. В настоящее время мягкие вычисления объединяют такиеобласти как[5]: нечеткая логика, искусственные нейронные сети, вероятностныерассуждения и эволюционные алгоритмы. Они дополняют друг друга и используются вразличных комбинациях для создания гибридных интеллектуальных систем.
Влияние нечеткой логикиоказалось, пожалуй, самым обширным. Подобно тому, как нечеткие множестварасширили рамки классической математическую теорию множеств, нечеткая логика'вторглась' практически в большинство методов Data Mining, наделив их новойфункциональностью. Ниже приводятся наиболее интересные примеры такихобъединений.
Нечеткие нейронные сети. Нечеткиенейронные сети (fuzzy-neural networks) осуществляют выводы на основе аппаратанечеткой логики, однако параметры функций принадлежности настраиваются сиспользованием алгоритмов обучения НС. Поэтому для подбора параметров такихсетей применим метод обратного распространения ошибки, изначально предложенныйдля обучения многослойного персептрона. Для этого модуль нечеткого управленияпредставляется в форме многослойной сети. Нечеткая нейронная сеть как правилосостоит из четырех слоев: слоя фазификации входных переменных, слояагрегирования значений активации условия, слоя агрегирования нечетких правил ивыходного слоя.
Наибольшеераспространение в настоящее время получили архитектуры нечеткой НС вида ANFIS иTSK. Доказано, что такие сети являются универсальными аппроксиматорами.
Быстрые алгоритмыобучения и интерпретируемость накопленных знаний – эти факторы сделали сегоднянечеткие нейронные сети одним из самых перспективных и эффективных инструментовмягких вычислений.
Адаптивные нечеткиесистемы. Классические нечеткие системы обладают тем недостатком, что дляформулирования правил и функций принадлежности необходимо привлекать экспертовтой или иной предметной области, что не всегда удается обеспечить. Адаптивныенечеткие системы (adaptive fuzzy systems) решают эту проблему. В таких системахподбор параметров нечеткой системы производится в процессе обучения наэкспериментальных данных. Алгоритмы обучения адаптивных нечетких системотносительно трудоемки и сложны по сравнению с алгоритмами обучения нейронныхсетей, и, как правило, состоят из двух стадий:
— генерациялингвистических правил;
— корректировка функцийпринадлежности. Первая задача относится к задаче переборного типа, вторая – коптимизации в непрерывных пространствах. При этом возникает определенноепротиворечие: для генерации нечетких правил необходимы функции принадлежности,а для проведения нечеткого вывода – правила. Кроме того, при автоматическойгенерации нечетких правил необходимо обеспечить их полноту и непротиворечивость.
Значительная частьметодов обучения нечетких систем использует генетические алгоритмы. Ванглоязычной литературе этому соответствует специальный термин – Genetic Fuzzy Systems.
Значительный вклад вразвитие теории и практики нечетких систем с эволюционной адаптацией внеслагруппа испанских исследователей во главе с Ф. Херрера (F. Herrera).
Нечеткие запросы. Нечеткиезапросы к базам данных (fuzzy queries) – перспективное направление в современных системах обработкиинформации. Данный инструмент дает возможность формулировать запросы наестественном языке, например: 'Вывести список недорогих предложений о съемежилья близко к центру города', что невозможно при использовании стандартногомеханизма запросов. Для этой цели разработана нечеткая реляционная алгебра испециальные расширения языков SQLдля нечетких запросов. Большая часть исследований в этой области принадлежитзападноевропейским ученым Д. Дюбуа и Г. Праде.
Нечеткие ассоциативныеправила. Нечеткие ассоциативные правила (fuzzy associative rules) – инструмент для извлечения из базданных закономерностей, которые формулируются в виде лингвистическихвысказываний. Здесь введены специальные понятия нечеткой транзакции, поддержкии достоверности нечеткого ассоциативного правила.
Нечеткие когнитивныекарты. Нечеткие когнитивные карты (fuzzy cognitive maps) были предложены Б. Коско в 1986 г. и используются для моделирования причинных взаимосвязей, выявленных между концептаминекоторой области. В отличие от простых когнитивных карт, нечеткие когнитивныекарты представляют собой нечеткий ориентированный граф, узлы которого являютсянечеткими множествами. Направленные ребра графа не только отражают причинно-следственныесвязи между концептами, но и определяют степень влияния (вес) связываемыхконцептов. Активное использование нечетких когнитивных карт в качестве средствамоделирования систем обусловлено возможностью наглядного представления анализируемойсистемы и легкостью интерпретации причинно-следственных связей междуконцептами. Основные проблемы связаны с процессом построения когнитивной карты,который не поддается формализации. Кроме того, необходимо доказать, чтопостроенная когнитивная карта адекватна реальной моделируемой системе. Длярешения данных проблем разработаны алгоритмы автоматического построениякогнитивных карт на основе выборки данных.
Нечеткая кластеризация. Нечеткиеметоды кластеризации, в отличие от четких методов (например, нейронные сетиКохонена), позволяют одному и тому же объекту принадлежать одновременнонескольким кластерам, но с различной степенью. Нечеткая кластеризация во многихситуациях более 'естественна', чем четкая, например, для объектов,расположенных на границе кластеров. Наиболее распространены: алгоритм нечеткойсамоорганизации c-means и его обобщение в виде алгоритма Густафсона-Кесселя.
Список можно продолжить идальше: нечеткие деревья решений, нечеткие сети Петри, нечеткая ассоциативнаяпамять, нечеткие самоорганизующиеся карты и другие гибридные методы.

3. ПРОЕКТИРОВАНИЕ ФУНКЦИОНАЛЬНОЙ СТРУКТУРЫ ПРОГРАММНОГООБЕСПЕЧЕНИЯ
Проектирование приложенийс использованием библиотеки MFCосновывается на предопределенной структуре иерархии взаимодействия стандартныхклассов (рисунок 2.1). Для реализации необходимой функциональности приложениядостаточным является использование обычного диалогового окна. При этом основнаяструктура приложения будет определяться двумя классами:
— класс CFuzzyApp, обеспечивающий функциональностьдинамического исполнения приложения в целом, порожденный от базового MFC-класса CWinApp;
— класс CFuzzyDlg,обеспечивающий работу с визуальными компонентами операционной среды Microsoft Windows, порожденный от базового MFC-класса CDialog;
Класс CFuzzyApp наследуется от класса приложения CWinApp. Основной перегружаемым виртуальнымметодом данного класса является метод CFuzzyApp::InitInstance().Перегрузка метода необходима для инициализации вспомогательных компонентприложения, а также для реализации связи визуального окна компонентов MS Windows с исполняемым приложением. В целом, метод CFuzzyApp::InitInstance() готовит приложение к работе.
Как известно [3], программы, работающие в среде MS Windows, имеют графический интерфейс пользователя (GUI – Graphical User Interface). Исходные данные поступают впрограмму через диалоговое окно. Например, пользователь может сообщитьприложению о выборе функции, включив один из переключателей (класс CButton(BS_RADIOBUTTON, …)) или выполнивнекоторое действие с другими элементами управления. Для каждого диалоговогоокна в приложении есть две вещи, которые необходимо разработать, – ресурсы окнаи класс окна.
Ресурсы окна используютсяпрограммой для того, чтобы вывести на экран его изображение и изображенияэлементов управления, которые входят в него. В класс окна включены егопараметры и методы, ответственные за вывод окна на экран. Они работаютсовместно для достижения общей цели – обеспечить максимально эффективноевзаимодействие пользователя и программы.
Ресурсы диалогового окнасоздаются посредством редактора ресурсов, с помощью которого возможно включатьв состав окна необходимые элементы управления и размещать их в пространствеокна желаемым образом. Помощь в создании класс окна может оказать ClassWizard, встроенный в стандартом наборе MS Visual Studio. Как правило, класс конкретного диалогового окна в проектеявляется производным от базового класса CDialog, имеющегося в составе MFC. Обычно каждый элемент управления, включенный всостав ресурсов окна, имеет в классе окна соответствующий член класса. Для тогочтобы вывести диалоговое окно на экран, необходимо вызвать метод его класса.Для того, чтобы установить значения по умолчанию для элементов управления передвыводом окна на экран или считать состояние элементов управления после завершенияработы пользователя, необходимо обращаться к членам класса.
Таким образом, первымшагом проектирования MFC-приложенияявляется формирование ресурса окна, который служит своего рода шаблоном для MS Windows. Когда MS Windows обнаруживает ресурс окна впрограмме, она использует команды из этого ресурса для конструированияработающего окна.
Далее в редакторересурсов в диалоговое окно должны быть добавлены необходимые элементыуправления – кнопки, радиокнопки, поля ввода, текстовые метки, декоративныеэлементы (Group Box) и элемент Picture.
Проектируемый интерфейсизображен на рисунке 3.1.

/>
Рисунок 3.1 –Проектируемый интерфейс
Когда сформированыресурсы окна и подготовлен класс CFuzzyDlg для окна приложения, можно создавать объект этого класса в самойпрограмме и выводить на экран связанное с ним диалоговое окно. Врассматриваемом случае, достаточно в методе CFuzzyApp::InitInstance() вывести диалоговое окно на экрансразу после запуска приложения, используя базовый метод CDialog::DoModal() класса диалогового окна CDialog.
Отображение результатовпостроения функции производится в элемент Picture. Для вывода графики в Windows и в Visual C++ используется понятие контекста устройства (device context). Контекст устройства ‑ этообъект класса CDC, содержащий все методы дляпостроения изображения в окне.
Таким образомспроектированная структура программного обеспечения является адекватной решениюпоставленной в техническом задании задачи.

4. ПРОГРАММНАЯ РЕАЛИЗАЦИЯ ПОСТАВЛЕННОЙ ЗАДАЧИ
Программная реализацияразработанной выше структуры приложения состоит в разработке исполняемого Win32-приложения в среде визуального программированияMS Visual Studio. Проект программного обеспечения состоит из трехклассов – CFuzzyApp, CFuzzyDlg, CFuzzy_.
В классе CFuzzy_ выполняются непосредственныерасчеты значений функций неопределенности. Расчеты выполняютсяфункциями-членами[6] этого класса:
— CFuzzy_::fisTriangleMf(double x, double *params) – вычисление значений треугольной функциипринадлежности;
— CFuzzy_::fisTrapezoidMf(double x, double *params) – вычисление значений трапециидальнойфункции принадлежности;
— CFuzzy_::fisGaussianMf(double x, double *params) – вычисление значений гауссовскойфункции принадлежности;
— CFuzzy_::fisGaussian2Mf(double x, double *params)– вычисление значений расширенной гауссовской функции принадлежности;
— CFuzzy_::fisSigmoidMf(double x, double *params) – вычисление значений сигмоидальнойфункции принадлежности.
Например, функция CFuzzy_::fisTrapezoidMf(double x,double *params):
/*Trapezpoidal membership function */
double CFuzzy_::fisTrapezoidMf(doublex, double *params)
{
double a =params[0], b = params[1], c = params[2], d = params[3];
double y1 = 0,y2 = 0;
if (a>b) {
fisError(«Illegalparameters in fisTrapezoidMf() --> a > b»);
}
if (b>c)
{
fisError(«Illegalparameters in fisTrapezoidMf() --> b > c»);
}
if (c>d) {
fisError(«Illegalparameters in fisTrapezoidMf() --> c > d»);
}
if (b
y1 = 1;
else if (x
y1 = 0;
else if (a !=b)
y1 =(x-a)/(b-a);
if (x
y2 = 1;
else if (d
y2 = 0;
else if (c !=d)
y2 = (d-x)/(d-c);
return(MIN(y1, y2));
}
Так же в классе CFuzzy_находится функция-член fisError(char *msg), которая реализует выдачу сообщенияоб ошибке, если пользователь ввел неправильные данные. Само сообщениепередается в функцию fisError(char *msg) в качестве параметра из функций,вычисляющих значение функций принадлежности.
В классе CFuzzyApp реализована базовая функциональностьстандартного MFC-приложения. В частности,переопределен виртуальный метод базового класса CWinApp::InitInstance():
BOOLCFuzzyApp::InitInstance()
{
AfxEnableControlContainer();
#ifdef _AFXDLL
Enable3dControls();
#else
Enable3dControlsStatic();
#endif
CFuzzyDlg dlg;
m_pMainWnd =&dlg;
dlg.DoModal();
return FALSE;
}
В результате исполняемыйкод приложения был связан со спроектированным ранее визуальным интерфейсом(рисунок 3.1). В качестве члена в классе CFuzzyApp была введена переменная[6] dlg типа CFuzzyDlg. Она обеспечивает непосредственную связь приложения с интерфейсом,предоставляемого пользователю.
В классе CFuzzyDlg выполняется инициализация диалога иэлементов управления.
BOOLCFuzzyDlg::OnInitDialog()
{
CDialog::OnInitDialog();
SetIcon(m_hIcon,TRUE);
SetIcon(m_hIcon,FALSE);
par_a.SetWindowText(«1»);
par_b.SetWindowText(«3»);
par_c.SetWindowText(«5»);
par_d.SetWindowText(«9»);
R_Tri=(CButton*)GetDlgItem(IDC_RADIO1);
R_Tra=(CButton*)GetDlgItem(IDC_RADIO2);
R_Ga=(CButton*)GetDlgItem(IDC_RADIO3);
R_Ga2=(CButton*)GetDlgItem(IDC_RADIO4);
R_Sig=(CButton*)GetDlgItem(IDC_RADIO5);
param = newdouble[3];
WIDTH = 600;
HEIGHT = 400;
return TRUE;
}
С помощью элементовуправления, являющимися объектами класса CEdit – par_a, par_b, par_c, par_d реализуется ввод параметров дляфункций принадлежности.
В классе CFuzzyDlg имеются функции для построениякоординатных осей (функция CFuzzyDlg::Axis()) и отображения графика функциипринадлежности (одна из функций CFuzzyDlg::PlotTriangle(),CFuzzyDlg::PlotTrapezoid(),CFuzzyDlg::PlotGaussian(),CFuzzyDlg::PlotGaussian2(), CFuzzyDlg::PlotSigmoid()в зависимости от типа функции, выбранной пользователем). Вывод графикаосуществляется с помощью класса CDC, который
При нажатии пользователемкнопки «Построить!!» происходит выполнение функции CFuzzyDlg::OnButton1(), изкоторой вызываются функции построения осей и функции принадлежности, выбраннойпользователем или, если не был выбран тип функции, выдается сообщение «Выберитетип функции!!».
Функции для построениякоординатных осей (функция CFuzzyDlg::Axis()) и отображения графика функциипринадлежности (одна из функций CFuzzyDlg::PlotTriangle(),CFuzzyDlg::PlotTrapezoid(),CFuzzyDlg::PlotGaussian(),CFuzzyDlg::PlotGaussian2(), CFuzzyDlg::PlotSigmoid()в зависимости от типа функции, выбранной пользователем) вызываются так же приперерисовке окна (обработка сообщения WM_PAINT с помощью функцииCFuzzyDlg::OnPaint()).
void CFuzzyDlg::OnPaint()
{
CDialog::OnPaint();
Axis();
if(function==GAUSSIAN)
PlotGaussian();
else
if(function==TRIANGLE)
PlotTriangle();
else
if(function==TRAPEZOID)
PlotTrapezoid();
else
if(function==GAUSSIAN2)
PlotGaussian2();
else
if(function==SIGMOID)
PlotSigmoid();
}
Для того чтобы определитьзначение данной функции распределения в конкретной точке, в класс CFuzzyDlg была добавлена функцияобработки сообщения перемещения манипулятора «Мышь» WM_MOUSEMOVE ‑CFuzzyDlg::OnMouseMove(UINT nFlags, CPoint point). При перемещении мышивыводится значение точки x (сучетом масштаба) и степень принадлежности (значение данной функциипринадлежности) этой точки x.
voidCFuzzyDlg::OnMouseMove(UINT nFlags, CPoint point)
{
if(point.x>10 && point.x10 &&point.y
{
CDC *dc =m_grapho.GetDC();
CPen SolidPen;
SolidPen.CreatePen(PS_SOLID,1,RGB(255,255,255));
CBrush brush;
brush.CreateSolidBrush(RGB(255,255,255));
dc->SelectObject(brush);
dc->SelectObject(SolidPen);
dc->Rectangle(350,10,580,30);
double _tmp;
char crds[15];
CStringcoords;
_tmp=(point.x-36)*1000/kX+_par;
itoa((int)(_tmp),crds,10);
coords=crds;
itoa(ABS((int)(_tmp*100)%100),crds,10);
(ABS((int)(_tmp*100)%100)
coords+=crds;
if(function==GAUSSIAN)
gcvt(fuzzy.fisGaussianMf(_tmp,param),2,crds);
else
if(function==TRIANGLE)
gcvt(fuzzy.fisTriangleMf(_tmp,param),2,crds);
else
if(function==TRAPEZOID)
gcvt(fuzzy.fisTrapezoidMf(_tmp,param),2,crds);
else
if(function==GAUSSIAN2)
gcvt(fuzzy.fisGaussian2Mf(_tmp,param),2,crds);
else
if(function==SIGMOID)
gcvt(fuzzy.fisSigmoidMf(_tmp,param),2,crds);
else
crds[0]='\0';
CFont *font =new CFont();
font->CreateFont(14,10, 0, 0, FW_NORMAL, 0, 0, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,DEFAULT_PITCH | FF_SWISS, «Courier»);
dc->SelectObject(font);
dc->TextOut(50,10,«Точка x:»+coords+" Степень принадлежности:"+crds);
}
CDialog::OnMouseMove(nFlags,point);
}
Результат выполненияпрограммы изображен на рисунке 4.1. В данном случае построена сигмоидальнаяфункция принадлежности.
/>
Рисунок 4.1 – Результатвыполнения программы – сигмоидальная функция принадлежности

ВЫВОДЫ
Результатом работыявляется исполняемое Win32-приложение,позволяющее строить следующие функции принадлежности:
— треугольную;
— трапециидальную;
— гауссовскую;
— расширеннуюгауссовскую;
— сигмоидальную.
Так же программапозволяет определять значение степени принадлежности заданной точки x.
В ходе разработкиприложения были изучены структура и возможности набора классов MFC, принципы проектирования визуальногоинтерфейса пользователя в операционной среде MS Windows с использованием среды разработки MS Visual Studio. Было замечено, что классы MFC существенно ускоряютпроцесс создания приложений для операционной системы Microsoft Windows.
Так же были изученыосновы теории нечетких множеств, в частности функции принадлежности.

ПЕРЕЧЕНЬ ССЫЛОК
1. Microsoft DeveloperNetwork Library ‑April 2003
2. Васильев В.И., Ильясов Б.Г.Интеллектуальные системы управления с использованием нечеткой логики: Учеб.пособие / Уфимск. гос. авиац. техн. ун-т. -Уфа, 1995. -80 c
3. Грегори К. Использование Visual C++ 6. Специальное издание.: Пер. с англ. – М.: СПб.; К.:Издательский дом «Вильямс», 2003. – 849 с.
4. Заде Л. Понятие лингвистическойпеременной и его применение к принятию приближенных решений. – М.: Мир, 1976.
5. Нечеткая логика ‑математические основы ‑ BaseGroup Labs
www.basegroup.ru/fuzzylogic/math_print.htm
6. Страуструп Бьярн Языкпрограммирования C++ Второе издание.– К.: ДиаСофт, 1993. – 480 с.

ПРИЛОЖЕНИЕ
Приложение А
Листинг программы
// Fuzzy_.h:interface for the CFuzzy_ class.
class CFuzzy_
{
public:
voidfisError(char *msg);
CFuzzy_();
virtual~CFuzzy_();
doubleCFuzzy_::fisTriangleMf(double x, double *params);
doublefisTrapezoidMf(double x, double *params);
doublefisGaussianMf(double x, double *params);
doublefisGaussian2Mf(double x, double *params);
doublefisSigmoidMf(double x, double *params);
};
// Fuzzy_.cpp:implementation of the CFuzzy_ class.
#include«stdafx.h»
#include«fuzzy.h»
#include«Fuzzy_.h»
#include
#ifndef ABS
# defineABS(x) ( (x) > (0)? (x): (-(x)) )
#endif
#ifndef MAX
# defineMAX(x,y) ( (x) > (y)? (x): (y) )
#endif
#ifndef MIN
# defineMIN(x,y) ( (x)
#endif
CFuzzy_::CFuzzy_()
{
}
CFuzzy_::~CFuzzy_()
{
}
/* Triangularmembership function */
doubleCFuzzy_::fisTriangleMf(double x, double *params)
{
double a =params[0], b = params[1], c = params[2];
if (a>b)
{fisError(«Illegalparameters in fisTriangleMf() --> a > b»);return -1;}
if (b>c)
{fisError(«Illegalparameters in fisTriangleMf() --> b > c»);return -1;}
if (a == b&& b == c)
return(x ==a);
if (a == b)
return((c-x)/(c-b)*(b
if (b == c)
return((x-a)/(b-a)*(a
return(MAX(MIN((x-a)/(b-a),(c-x)/(c-b)), 0));
}
/*Trapezpoidal membership function */
doubleCFuzzy_::fisTrapezoidMf(double x, double *params)
{
double a =params[0], b = params[1], c = params[2], d = params[3];
double y1 = 0,y2 = 0;
if (a>b) {
fisError(«Illegalparameters in fisTrapezoidMf() --> a > b»);
}
if (b>c)
{
fisError(«Illegalparameters in fisTrapezoidMf() --> b > c»);
}
if (c>d) {
fisError(«Illegalparameters in fisTrapezoidMf() --> c > d»);
}
if (b
y1 = 1;
else if (x
y1 = 0;
else if (a !=b)
y1 =(x-a)/(b-a);
if (x
y2 = 1;
else if (d
y2 = 0;
else if (c !=d)
y2 =(d-x)/(d-c);
return(MIN(y1,y2));
}
/* Gaussianmembership function */
doubleCFuzzy_::fisGaussianMf(double x, double *params)
{
double sigma =params[0], c = params[1];
double tmp;
if (sigma==0)
fisError(«Illegalparameters in fisGaussianMF() --> sigma = 0»);
tmp =(x-c)/sigma;
return(exp(-tmp*tmp/2));
}
/* ExtendedGaussian membership function */
doubleCFuzzy_::fisGaussian2Mf(double x, double *params)
{
double sigma1= params[0], c1 = params[1];
double sigma2= params[2], c2 = params[3];
double tmp1,tmp2;
if ((sigma1 ==0) || (sigma2 == 0))
fisError(«Illegalparameters in fisGaussian2MF() --> sigma1 or sigma2 is zero»);
tmp1 = x >=c1? 1:exp(-pow((x-c1)/sigma1, 2.0)/2);
tmp2 = x
return(tmp1*tmp2);
}
/* Sigmoidalmembership function */
doubleCFuzzy_::fisSigmoidMf(double x, double *params)
{
double a =params[0], c = params[1];
return(1/(1+exp(-a*(x-c))));
}
voidCFuzzy_::fisError(char *msg)
{
MessageBox(NULL,msg,«Error»,MB_OK|MB_ICONSTOP);
}
// fuzzy.h:main header file for the FUZZY application CFuzzyApp
#include«resource.h»
classCFuzzyApp: public CWinApp
{
public:
CFuzzyApp();
// Overrides
// ClassWizardgenerated virtual function overrides
//{{AFX_VIRTUAL(CFuzzyApp)
public:
virtual BOOLInitInstance();
//}}AFX_VIRTUAL
//Implementation
//{{AFX_MSG(CFuzzyApp)
// NOTE — theClassWizard will add and remove member functions here.
// DO NOT EDITwhat you see in these blocks of generated code !
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
// fuzzy.cpp:Defines the class behaviors for the application. CFuzzyApp
#include«stdafx.h»
#include«fuzzy.h»
#include«fuzzyDlg.h»
BEGIN_MESSAGE_MAP(CFuzzyApp,CWinApp)
//{{AFX_MSG_MAP(CFuzzyApp)
// NOTE — theClassWizard will add and remove mapping macros here.
// DO NOT EDITwhat you see in these blocks of generated code!
//}}AFX_MSG
ON_COMMAND(ID_HELP,CWinApp::OnHelp)
END_MESSAGE_MAP()
CFuzzyApp::CFuzzyApp()
{
}
CFuzzyApptheApp;
// CFuzzyAppinitialization
BOOLCFuzzyApp::InitInstance()
{
AfxEnableControlContainer();
#ifdef _AFXDLL
Enable3dControls();
#else
Enable3dControlsStatic();
#endif
CFuzzyDlg dlg;
m_pMainWnd =&dlg;
dlg.DoModal();
// Since thedialog has been closed, return FALSE so that we exit the
// application,rather than start the application's message pump.
return FALSE;
}
// fuzzyDlg.h: header file
// CFuzzyDlgdialog
classCFuzzyDlg: public CDialog
{
//Construction
public:
voidPlotTrapezoid();
voidPlotTriangle();
voidPlotGaussian();
voidPlotSigmoid();
voidPlotGaussian2();
void Axis();
CButton*R_Tri, *R_Tra, *R_Ga, *R_Ga2, *R_Sig;
CFuzzyDlg(CWnd*pParent = NULL);// standard constructor
// Dialog Data
//{{AFX_DATA(CFuzzyDlg)
enum { IDD =IDD_FUZZY_DIALOG };
CEditpar_d;
CEditpar_c;
CEditpar_b;
CEditpar_a;
CStaticm_grapho;
//}}AFX_DATA
// ClassWizardgenerated virtual function overrides
//{{AFX_VIRTUAL(CFuzzyDlg)
protected:
virtual voidDoDataExchange(CDataExchange* pDX);// DDX/DDV support
//}}AFX_VIRTUAL
//Implementation
protected:
HICON m_hIcon;
// Generatedmessage map functions
//{{AFX_MSG(CFuzzyDlg)
virtual BOOLOnInitDialog();
afx_msg voidOnPaint();
afx_msgHCURSOR OnQueryDragIcon();
afx_msg voidOnButton1();
afx_msg voidOnMouseMove(UINT nFlags, CPoint point);
afx_msg voidOnRadio1();
afx_msg voidOnRadio2();
afx_msg voidOnRadio3();
afx_msg voidOnRadio4();
afx_msg voidOnRadio5();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//fuzzyDlg.cpp: implementation file
//
#include«stdafx.h»
#include«fuzzy.h»
#include«fuzzyDlg.h»
#include«fuzzy_.h»
#ifndef ABS
# defineABS(x) ( (x) > (0)? (x): (-(x)) )
#endif
#ifndef MAX
# defineMAX(x,y) ( (x) > (y)? (x): (y) )
#endif
#ifndef MIN
# defineMIN(x,y) ( (x)
#endif
CFuzzy_ fuzzy;
double *param,x, y=0, kX=1000, _par=0;
int WIDTH,HEIGHT;
bytefunction=0;
const byteTRIANGLE = 1;
const byteTRAPEZOID = 2;
const byteGAUSSIAN = 3;
const byteGAUSSIAN2 = 4;
const byteSIGMOID = 5;
/////////////////////////////////////////////////////////////////////////////
// CFuzzyDlgdialog
CFuzzyDlg::CFuzzyDlg(CWnd*pParent /*=NULL*/)
:CDialog(CFuzzyDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CFuzzyDlg)
//}}AFX_DATA_INIT
// Note thatLoadIcon does not require a subsequent DestroyIcon in Win32
m_hIcon =AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}
voidCFuzzyDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CFuzzyDlg)
DDX_Control(pDX,IDC_EDITD, par_d);
DDX_Control(pDX,IDC_EDITC, par_c);
DDX_Control(pDX,IDC_EDITB, par_b);
DDX_Control(pDX,IDC_EDITA, par_a);
DDX_Control(pDX,IDC_GRAPHO, m_grapho);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CFuzzyDlg,CDialog)
//{{AFX_MSG_MAP(CFuzzyDlg)
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
ON_BN_CLICKED(IDC_BUTTON1,OnButton1)
ON_WM_MOUSEMOVE()
ON_BN_CLICKED(IDC_RADIO1,OnRadio1)
ON_BN_CLICKED(IDC_RADIO2,OnRadio2)
ON_BN_CLICKED(IDC_RADIO3,OnRadio3)
ON_BN_CLICKED(IDC_RADIO4,OnRadio4)
ON_BN_CLICKED(IDC_RADIO5,OnRadio5)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CFuzzyDlgmessage handlers
BOOLCFuzzyDlg::OnInitDialog()
{
CDialog::OnInitDialog();
SetIcon(m_hIcon,TRUE);// Set big icon
SetIcon(m_hIcon,FALSE);
par_a.SetWindowText(«1»);
par_b.SetWindowText(«3»);
par_c.SetWindowText(«5»);
par_d.SetWindowText(«9»);
R_Tri=(CButton*)GetDlgItem(IDC_RADIO1);
R_Tra=(CButton*)GetDlgItem(IDC_RADIO2);
R_Ga=(CButton*)GetDlgItem(IDC_RADIO3);
R_Ga2=(CButton*)GetDlgItem(IDC_RADIO4);
R_Sig=(CButton*)GetDlgItem(IDC_RADIO5);
param = newdouble[3];
WIDTH = 600;
HEIGHT = 400;
// Set smallicon
return TRUE; //return TRUE unless you set the focus to a control
}
// If you adda minimize button to your dialog, you will need the code below
// to draw theicon. For MFC applications using the document/view model,
// this isautomatically done for you by the framework.
voidCFuzzyDlg::OnPaint()
{
CDialog::OnPaint();
Axis();
if(function==GAUSSIAN)
PlotGaussian();
else
if(function==TRIANGLE)
PlotTriangle();
else
if(function==TRAPEZOID)
PlotTrapezoid();
else
if(function==GAUSSIAN2)
PlotGaussian2();
else
if(function==SIGMOID)
PlotSigmoid();
}
// The systemcalls this to obtain the cursor to display while the user drags
// theminimized window.
HCURSORCFuzzyDlg::OnQueryDragIcon()
{
return(HCURSOR) m_hIcon;
}
voidCFuzzyDlg::OnButton1()
{
Axis();
if(R_Tri->GetState()==1)
{
PlotTriangle();
} else
if(R_Tra->GetState()==1)
{
PlotTrapezoid();
} else
if(R_Ga->GetState()==1)
{
PlotGaussian();
}
else
if(R_Ga2->GetState()==1)
{
PlotGaussian2();
} else
if(R_Sig->GetState()==1)
{
PlotSigmoid();
}
elseAfxMessageBox(«Выберите тип функции!!», MB_ICONWARNING|MB_OK, 0);
}
voidCFuzzyDlg::OnMouseMove(UINT nFlags, CPoint point)
{
if(point.x>10 && point.x10 &&point.y
{
CDC *dc =m_grapho.GetDC();
CPen SolidPen;
SolidPen.CreatePen(PS_SOLID,1,RGB(255,255,255));
CBrush brush;
brush.CreateSolidBrush(RGB(255,255,255));
dc->SelectObject(brush);
dc->SelectObject(SolidPen);
dc->Rectangle(350,10,580,30);
double _tmp;
char crds[15];
CStringcoords;
_tmp=(point.x-36)*1000/kX+_par;
itoa((int)(_tmp),crds,10);
coords=crds;
itoa(ABS((int)(_tmp*100)%100),crds,10);
(ABS((int)(_tmp*100)%100)
coords+=crds;
if(function==GAUSSIAN)
gcvt(fuzzy.fisGaussianMf(_tmp,param),2,crds);
else
if(function==TRIANGLE)
gcvt(fuzzy.fisTriangleMf(_tmp,param),2,crds);
else
if(function==TRAPEZOID)
gcvt(fuzzy.fisTrapezoidMf(_tmp,param),2,crds);
else
if(function==GAUSSIAN2)
gcvt(fuzzy.fisGaussian2Mf(_tmp,param),2,crds);
else
if(function==SIGMOID)
gcvt(fuzzy.fisSigmoidMf(_tmp,param),2,crds);
else
crds[0]='\0';
CFont *font =new CFont();
font->CreateFont(14,10, 0, 0, FW_NORMAL, 0, 0, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,DEFAULT_PITCH | FF_SWISS, «Courier»);
dc->SelectObject(font);
dc->TextOut(50,10,«Точкаx:»+coords+" Степень принадлежности:"+crds);
}
CDialog::OnMouseMove(nFlags,point);
}
voidCFuzzyDlg::OnRadio1()
{
par_d.EnableWindow(false);
}
voidCFuzzyDlg::OnRadio2()
{
par_c.EnableWindow(true);
par_d.EnableWindow(true);
}
voidCFuzzyDlg::OnRadio3()
{
par_c.EnableWindow(false);
par_d.EnableWindow(false);
}
voidCFuzzyDlg::OnRadio4()
{
par_c.EnableWindow(true);
par_d.EnableWindow(true);
}
voidCFuzzyDlg::OnRadio5()
{
par_c.EnableWindow(false);
par_d.EnableWindow(false);
}
voidCFuzzyDlg::Axis()
{
CDC *_dc =m_grapho.GetDC();
CPen DotPen;
DotPen.CreatePen(PS_DOT,1,RGB(0,0,0));
CPen SolidPen;
SolidPen.CreatePen(PS_SOLID,1,RGB(0,0,0));
CBrush brush;
brush.CreateSolidBrush(RGB(255,255,255));
_dc->SelectObject(brush);
_dc->Rectangle(0,0,WIDTH,HEIGHT);
_dc->SelectObject(SolidPen);
_dc->MoveTo(25,10);
_dc->LineTo(25,HEIGHT-40);
_dc->MoveTo(20,HEIGHT-40);
_dc->LineTo(WIDTH-20,HEIGHT-40);
_dc->SelectObject(DotPen);;
CFont *font =new CFont();
font->CreateFont(12,7, 0, 0, FW_NORMAL, 0, 0, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,DEFAULT_PITCH | FF_SWISS, «Courier»);
_dc->SelectObject(font);
_dc->TextOut(1,360-5,CString("0"));
for (intq=1;q
{
_dc->MoveTo(20,360-q*32);
_dc->LineTo(580,360-q*32);
char iY[5];
gcvt(q*0.1,2,iY);
(q!=10)?_dc->TextOut(1,360-q*32-5,iY,3):_dc->TextOut(1,360-q*32-5,CString("1"));
}
_dc->TextOut(580,360,«x»);
}
voidCFuzzyDlg::PlotTriangle()
{
function=TRIANGLE;
CDC *dc =m_grapho.GetDC();
double tmp;
CStringpar_tmp;
par_a.GetWindowText(par_tmp);
param[0]=atof(par_tmp);
par_b.GetWindowText(par_tmp);
param[1]=atof(par_tmp);
par_c.GetWindowText(par_tmp);
param[2]=atof(par_tmp);
kX =520000/ABS(param[2]-param[0]);
_par=param[0];
for(x=param[0];x
{
tmp = fuzzy.fisTriangleMf(x,param);
tmp*=320;
dc->SetPixel((int)(((x)-param[0])*kX/1000+25),HEIGHT-40-(int)tmp,RGB(255,100,120));
}
dc->Rectangle((int)((param[0]-param[0])*kX/1000+25-4),HEIGHT-40-0*320-4,
(int)((param[0]-param[0])*kX/1000+25+4),HEIGHT-40-0*320+4);
dc->Rectangle((int)((param[1]-param[0])*kX/1000+25-4),HEIGHT-40-1*320-4,
(int)((param[1]-param[0])*kX/1000+25+4),HEIGHT-40-1*320+4);
dc->Rectangle((int)((param[2]-param[0])*kX/1000+25-4),HEIGHT-40-0*320-4,
(int)((param[2]-param[0])*kX/1000+25+4),HEIGHT-40-0*320+4);
}
voidCFuzzyDlg::PlotTrapezoid()
{
function=TRAPEZOID;
CDC *dc =m_grapho.GetDC();
double tmp;
CStringpar_tmp;
par_a.GetWindowText(par_tmp);
param[0]=atof(par_tmp);
par_b.GetWindowText(par_tmp);
param[1]=atof(par_tmp);
par_c.GetWindowText(par_tmp);
param[2]=atof(par_tmp);
par_d.GetWindowText(par_tmp);
param[3]=atof(par_tmp);
kX =520000/ABS(param[3]-param[0]);
_par=param[0];
for(x=param[0];x
{
tmp =fuzzy.fisTrapezoidMf(x,param);
tmp*=320;
dc->SetPixel((int)(((x-param[0]))*kX/1000+25),HEIGHT-40-(int)tmp,RGB(255,100,100));
}
dc->Rectangle((int)((param[0]-param[0])*kX/1000+25-4),HEIGHT-40-0*320-4,
(int)((param[0]-param[0])*kX/1000+25+4),HEIGHT-40-0*320+4);
dc->Rectangle((int)((param[1]-param[0])*kX/1000+25-4),HEIGHT-40-1*320-4,
(int)((param[1]-param[0])*kX/1000+25+4),HEIGHT-40-1*320+4);
dc->Rectangle((int)((param[2]-param[0])*kX/1000+25-4),HEIGHT-40-1*320-4,
(int)((param[2]-param[0])*kX/1000+25+4),HEIGHT-40-1*320+4);
dc->Rectangle((int)((param[3]-param[0])*kX/1000+25-4),HEIGHT-40-0*320-4,
(int)((param[3]-param[0])*kX/1000+25+4),HEIGHT-40-0*320+4);
}
voidCFuzzyDlg::PlotGaussian()
{
function=GAUSSIAN;
CDC *dc =m_grapho.GetDC();
double tmp;
CStringpar_tmp;
par_a.GetWindowText(par_tmp);
param[0]=atof(par_tmp);
par_b.GetWindowText(par_tmp);
param[1]=atof(par_tmp);
par_c.GetWindowText(par_tmp);
param[2]=atof(par_tmp);
par_d.GetWindowText(par_tmp);
param[3]=atof(par_tmp);
double_0=param[1];
do
{
tmp =fuzzy.fisGaussianMf(_0,param);
_0-=ABS(param[1])/1000;
}
while(tmp>=0.001);
kX =520000/(2*ABS(param[1]-_0));
_par = _0;
for(x=_0;x
{
tmp =fuzzy.fisGaussianMf(x,param);
tmp*=320;
dc->SetPixel((int)(((x)-_0)*kX/1000+25),HEIGHT-40-(int)tmp,RGB(255,100,100));
}
dc->Rectangle((int)((param[1]-_0)*kX/1000+25-4),HEIGHT-40-1*320-4,
(int)((param[1]-_0)*kX/1000+25+4),HEIGHT-40-1*320+4);
}
voidCFuzzyDlg::PlotGaussian2()
{
function=GAUSSIAN2;
CDC *dc =m_grapho.GetDC();
double tmp;
CStringpar_tmp;
par_a.GetWindowText(par_tmp);
param[0]=atof(par_tmp);
par_b.GetWindowText(par_tmp);
param[1]=atof(par_tmp);
par_c.GetWindowText(par_tmp);
param[2]=atof(par_tmp);
par_d.GetWindowText(par_tmp);
param[3]=atof(par_tmp);
double_0=MIN(param[1], param[3]);
do
{
tmp =fuzzy.fisGaussian2Mf(_0,param);
_0-=ABS(MIN(param[1],param[3]))/10000;
}
while(tmp>=0.001);
kX =520000/(ABS(MAX(param[1], param[3])-_0));
_par = _0;
for(x=_0;x
{
tmp =fuzzy.fisGaussian2Mf(x,param);
tmp*=320;
dc->SetPixel((int)(((x)-_0)*kX/1000+25),HEIGHT-40-(int)tmp,RGB(255,100,100));
}
dc->Rectangle((int)((MAX(param[1],param[3])-_0)*kX/1000+25-4),HEIGHT-40-1*320-4,
(int)((MAX(param[1],param[3])-_0)*kX/1000+25+4),HEIGHT-40-1*320+4);
}
voidCFuzzyDlg::PlotSigmoid()
{
function=SIGMOID;
CDC *dc =m_grapho.GetDC();
double tmp;
CStringpar_tmp;
par_a.GetWindowText(par_tmp);
param[0]=atof(par_tmp);
par_b.GetWindowText(par_tmp);
param[1]=atof(par_tmp);
par_c.GetWindowText(par_tmp);
param[2]=atof(par_tmp);
par_d.GetWindowText(par_tmp);
param[3]=atof(par_tmp);
double_0=param[1],_1=param[1];
do
{
tmp =fuzzy.fisSigmoidMf(_0,param);
_0-=param[1]*0.0001;
}
while(tmp>=0.0001);
do
{
tmp =fuzzy.fisSigmoidMf(_1,param);
_1+=param[1]*0.0001;
}
while(tmp
kX =520000/(ABS(_1-_0));
_par = _0;
for(x=_0;x
{
tmp =fuzzy.fisSigmoidMf(x,param);
tmp*=320;
dc->SetPixel((int)(((x)-_0)*kX/1000+25),HEIGHT-40-(int)tmp,RGB(255,100,100));
}
dc->Rectangle((int)((param[1]-_0)*kX/1000+25-4),(int)(HEIGHT-40-0.5*320-4),(int)((param[1]-_0)*kX/1000+25+4),(int)(HEIGHT-40-0.5*320+4));
}