Назначение программы. Данная программа предназначена для исследования функции. Всостав исследования входит задавание параметров функций, построения графика функции, вывод таблицы значений функции, решение задачи поиска минимума. Исследуемая функция

Вид материала

Содержание

Подобный материал:

МОСКОВСКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ ПУТЕЙ СООБЩЕНИЯ (МИИТ)

Кафедра: «Управление и информатика в технических системах»

КУРСОВАЯ РАБОТА

по САУ

на тему:

«Реализация алгоритмов решения задач при проектировании Сау с использованием объектно-ориентированного языка программирования С++»

Выполнила: Селеутина В.Г.

Студент группы: АУИ-311

Проверила: Сидоренко В.Г.

Москва, 2009 г.

1.Назначение программы.

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

Исследуемая функция.

Характеристика «вход-выход» магнитного усилителя (МУ) – зависимость тока в рабочей обмотке

от тока в обмотке управления

,

где

– коэффициент.

Математическое описание способа решения задачи.

Метод одномерной оптимизации

Метод равномерного поиска

1. Задать допустимую погрешность вычислений точки экстремума

.

2. Определить число итераций

(циклов вычисления):

.

3. Вычислить значения независимой переменной в пробных точках:

.

4. Найти значения целевой функции в пробных точках

.

5. Определить минимальное значение целевой функции путем сравнения значений функции в пробных точках

3.Блок-схема алгоритма:

4. Текст программы.

// MainFrm.cpp : implementation of the CMainFrame class

//

#include "stdafx.h"

#include "FuncTest2.h"

#include "MainFrm.h"

#include "FuncParamDlg.h"

#include "ChartParamsDlg.h"

#include "SelectViewTypeDlg.h"

#ifdef _DEBUG

#define new DEBUG_NEW

#endif

// CMainFrame

IMPLEMENT_DYNAMIC(CMainFrame, CMDIFrameWnd)

BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)

ON_WM_CREATE()

ON_COMMAND(ID_FUNCTION_PARAMS, &CMainFrame::OnFunctionParams)

ON_COMMAND(ID_FUNCTION_VIEW, &CMainFrame::OnFunctionView)

ON_COMMAND(ID_FUNCTION_FINDMIN, &CMainFrame::OnFunctionFindmin)

ON_COMMAND(ID_FUNCTION_CHARTPARAMS, &CMainFrame::OnFunctionChartparams)

ON_COMMAND(ID_FUNCTION_PARAMETERSOFFUNCTION, &CMainFrame::OnFunctionParams)

ON_COMMAND(ID_FUNCTION_CHARTPARAMS32777, &CMainFrame::OnFunctionChartparams)

ON_COMMAND(ID_FUNCTION_VIEW32778, &CMainFrame::OnFunctionView)

ON_COMMAND(ID_FUNCTION_FINDMIN32779, &CMainFrame::OnFunctionFindmin)

END_MESSAGE_MAP()

static UINT indicators[] =

{

ID_SEPARATOR, // status line indicator

ID_INDICATOR_CAPS,

ID_INDICATOR_NUM,

ID_INDICATOR_SCRL,

};

// CMainFrame construction/destruction

CMainFrame::CMainFrame()

{

// TODO: add member initialization code here

}

CMainFrame::~CMainFrame()

{

}

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)

{

if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)

return -1;

if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP

| CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||

!m_wndToolBar.LoadToolBar(IDR_MAINFRAME))

{

TRACE0("Failed to create toolbar\n");

return -1; // fail to create

}

if (!m_wndStatusBar.Create(this) ||

!m_wndStatusBar.SetIndicators(indicators,

sizeof(indicators)/sizeof(UINT)))

{

TRACE0("Failed to create status bar\n");

return -1; // fail to create

}

// TODO: Delete these three lines if you don't want the toolbar to be dockable

m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);

EnableDocking(CBRS_ALIGN_ANY);

DockControlBar(&m_wndToolBar);

m_theApp=(CFuncTest2App*)AfxGetApp( );

return 0;

}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)

{

if( !CMDIFrameWnd::PreCreateWindow(cs) )

return FALSE;

// TODO: Modify the Window class or styles here by modifying

// the CREATESTRUCT cs

return TRUE;

}

// CMainFrame diagnostics

#ifdef _DEBUG

void CMainFrame::AssertValid() const

{

CMDIFrameWnd::AssertValid();

}

void CMainFrame::Dump(CDumpContext& dc) const

{

CMDIFrameWnd::Dump(dc);

}

#endif //_DEBUG

// CMainFrame message handlers

void CMainFrame::OnFunctionParams()

{

CFuncParamDlg Dlg;

Dlg.SetParams(m_theApp->m_FuncParams);

int res = Dlg.DoModal();

if(IDOK ==res)

{

m_theApp->m_FuncParams = Dlg.GetParams();

CMDIChildWnd* pChild = MDIGetActive();

if(pChild)

{

pChild->Invalidate();

}

}

}

void CMainFrame::OnFunctionView()

{

CSelectViewTypeDlg Dlg;

Dlg.SetViewType(m_theApp->m_Display);

int res = Dlg.DoModal();

if(IDOK ==res)

{

m_theApp->m_Display = Dlg.GetViewType();

GetTopWindow()->Invalidate();

CMDIChildWnd* pChild = MDIGetActive();

if(pChild)

{

pChild->Invalidate();

}

}

}

void CMainFrame::OnFunctionFindmin()

{

m_theApp->FindMin();

GetTopWindow()->Invalidate();

CMDIChildWnd* pChild = MDIGetActive();

if(pChild)

{

pChild->Invalidate();

}

}

void CMainFrame::OnFunctionChartparams()

{

CChartParamsDlg Dlg;

Dlg.SetSettings(m_theApp->m_ChartSettings);

int res = Dlg.DoModal();

if(IDOK == res)

{

m_theApp->m_ChartSettings = Dlg.GetSettings();

CMDIChildWnd* pChild = MDIGetActive();

if(pChild)

{

pChild->Invalidate();

}

}

}

________________________________________________________________________________

// FuncTest2View.cpp : implementation of the CFuncTest2View class

//

#include "stdafx.h"

#include "FuncTest2.h"

#include "FuncTest2Doc.h"

#include "FuncTest2View.h"

#ifdef _DEBUG

#define new DEBUG_NEW

#endif

// CFuncTest2View

IMPLEMENT_DYNCREATE(CFuncTest2View, CView)

BEGIN_MESSAGE_MAP(CFuncTest2View, CView)

// Standard printing commands

ON_COMMAND(ID_FILE_PRINT, &CView::OnFilePrint)

ON_COMMAND(ID_FILE_PRINT_DIRECT, &CView::OnFilePrint)

ON_COMMAND(ID_FILE_PRINT_PREVIEW, &CView::OnFilePrintPreview)

ON_WM_LBUTTONDOWN()

ON_WM_KEYUP()

END_MESSAGE_MAP()

// CFuncTest2View construction/destruction

CFuncTest2View::CFuncTest2View():m_pFuncTest2App(NULL),m_bPrevPointIsPresent(false)

{

// TODO: add construction code here

}

CFuncTest2View::~CFuncTest2View()

{

}

BOOL CFuncTest2View::PreCreateWindow(CREATESTRUCT& cs)

{

// TODO: Modify the Window class or styles here by modifying

// the CREATESTRUCT cs

m_pFuncTest2App = (CFuncTest2App*)AfxGetApp();

return CView::PreCreateWindow(cs);

}

// CFuncTest2View drawing

void CFuncTest2View::OnDraw(CDC* pDC)

{

CPen pen(PS_SOLID, 1, RGB(0, 0, 255));

CRect R;

int h = pDC->GetDeviceCaps(VERTSIZE);

// Инициализируем структуру LogFont

LOGFONT logFont;

logFont.lfHeight = 14;

logFont.lfWidth = 0;

logFont.lfEscapement = 0;

logFont.lfOrientation = 0;

logFont.lfWeight = FW_NORMAL;

logFont.lfItalic = 0;

logFont.lfUnderline = 0;

logFont.lfStrikeOut = 0;

logFont.lfCharSet = ANSI_CHARSET;

logFont.lfOutPrecision = OUT_DEFAULT_PRECIS;

logFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;

logFont.lfQuality = PROOF_QUALITY;

logFont.lfPitchAndFamily = VARIABLE_PITCH | FF_ROMAN;

lstrcpy(logFont.lfFaceName, TEXT("Arial"));

// Шрифт

CFont font;

font.CreateFontIndirect(&logFont);

CFont* oldFont = pDC->SelectObject(&font);

CFuncTest2Doc* pDoc = GetDocument();

ASSERT_VALID(pDoc);

if (pDoc)

{

switch(m_pFuncTest2App->m_Display)

{

case CFuncTest2App::eGraphic: ShowGraphic(pDC);

break;

case CFuncTest2App::eTable:ShowTable(pDC);

break;

}

}

pDC->SelectObject(oldFont);

}

void CFuncTest2View::ShowGraphic(CDC* pDC)

{

CRect R;

GetClientRect(&R);

m_Chart.Init(pDC,R.Width(),R.Height(),14);

m_Chart.SetSettings(m_pFuncTest2App->m_ChartSettings);

m_Chart.DrawAxis();

m_Chart.Draw(m_pFuncTest2App->m_FuncData);

}

void CFuncTest2View::ShowTable(CDC* pDC)

{

m_Grid.Init(pDC);

m_Grid.Draw(m_pFuncTest2App->m_FuncData);

}

void CFuncTest2View::OnLButtonDown(UINT nFlags, CPoint point)

{

if(CFuncTest2App::eGraphic == m_pFuncTest2App->m_Display)

{

CView::OnLButtonDown(nFlags, point);

if(m_bPrevPointIsPresent)

{

int x1 = min(m_PrevPoint.x,point.x);

int x2 = max(m_PrevPoint.x,point.x);

double Value1 = m_Chart.CoordToXValue(x1);

double Value2 = m_Chart.CoordToXValue(x2);

m_pFuncTest2App->m_FuncParams.m_XMin = Value1;

m_pFuncTest2App->m_FuncParams.m_XMax = Value2;

}

m_PrevPoint = point;

m_bPrevPointIsPresent = true;

}

}

#include

void CFuncTest2View::OnKeyUp (UINT nChar,UINT nRepCnt, UINT nFlags)

{

static const double Step = 0.1;

if(VK_DOWN == nChar)

{

m_pFuncTest2App->m_FuncParams.m_Factor -= Step;

}

else if(VK_UP == nChar)

{

m_pFuncTest2App->m_FuncParams.m_Factor += Step;

}

CView::OnKeyUp (nChar, nRepCnt, nFlags);

}

// CFuncTest2View printing

BOOL CFuncTest2View::OnPreparePrinting(CPrintInfo* pInfo)

{

// default preparation

return DoPreparePrinting(pInfo);

}

void CFuncTest2View::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)

{

// TODO: add extra initialization before printing

}

void CFuncTest2View::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)

{

// TODO: add cleanup after printing

}

// CFuncTest2View diagnostics

#ifdef _DEBUG

void CFuncTest2View::AssertValid() const

{

CView::AssertValid();

}

void CFuncTest2View::Dump(CDumpContext& dc) const

{

CView::Dump(dc);

}

CFuncTest2Doc* CFuncTest2View::GetDocument() const // non-debug version is inline

{

ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CFuncTest2Doc)));

return (CFuncTest2Doc*)m_pDocument;

}

#endif //_DEBUG

// CFuncTest2View message handlers

// FuncTest2.h : main header file for the FuncTest2 application

//

#pragma once

#ifndef __AFXWIN_H__

#error "include 'stdafx.h' before including this file for PCH"

#endif

#include "resource.h" // main symbols

#include "SimpleChart.h"

// CFuncTest2App:

// See FuncTest2.cpp for the implementation of this class

//

class CFuncTest2App : public CWinApp

{

public:

CFuncTest2App();

// Overrides

public:

virtual BOOL InitInstance();

enum EViewTypes{eGraphic=0,eTable=1};

EViewTypes m_Display;

SimpleChart::SSettings m_ChartSettings;

SFuncParams m_FuncParams;

FuncData m_FuncData;

void FindMin();

// Implementation

afx_msg void OnAppAbout();

DECLARE_MESSAGE_MAP()

};

extern CFuncTest2App theApp;

_______________________________________________________________________________

#ifndef SIMPLE_CHART_H

#define SIMPLE_CHART_H

#include

#include "FuncProcessor.h"

class SimpleChart

{

public:

struct SSettings

{

double m_XMin;

double m_XMax;

double m_YMax;

double m_YMin;

std::string m_XAxisName;

std::string m_YAxisName;

int m_XLinesCount;

int m_YLinesCount;

//По умолчанию

SSettings():m_XMin(0),m_XMax(10),

m_YMax(10),m_YMin(0),

m_XAxisName("X"),m_YAxisName("Y"),

m_XLinesCount(3),m_YLinesCount(3)

{}

SSettings& operator = (const SSettings& Obj)

{

m_XMin = Obj.m_XMin;

m_XMax = Obj.m_XMax;

m_YMax = Obj.m_YMax;

m_YMin = Obj.m_YMin;

m_XAxisName = Obj.m_XAxisName;

m_YAxisName = Obj.m_YAxisName;

m_XLinesCount = Obj.m_XLinesCount;

m_YLinesCount = Obj.m_YLinesCount;

return *this;

}

};

SimpleChart():m_pDc(NULL){}

~SimpleChart();

void Init(CDC* pDc,int w,int h,int FontSize);

void Draw(const FuncData& DataCont);

void DrawAxis();

void SetSettings(const SSettings& obj);

const SSettings& GetSettings();

double CoordToXValue(int x);

private:

int x_to_coord(double x);

int y_to_coord(double y);

CDC* m_pDc;

RECT m_bound;

SSettings m_settings;

int m_w;

int m_h;

double m_Dx;

double m_Dy;

int m_XOffset;

int m_YOffset;

int m_FontSize;

};

#endif

_______________________________________________________________________________

#include "stdafx.h"

#include "SimpleChart.h"

void SimpleChart::Init(CDC* pDc,int w,int h,int FontSize)

{

m_pDc = pDc;

if(m_pDc)

{

m_FontSize = FontSize;

m_w = w;//m_pDc->GetDeviceCaps(HORZSIZE);

m_h = h;//m_pDc->GetDeviceCaps(VERTSIZE);

//TRACE("\nm_w = %d,m_h = %d \n",m_w,m_h);

m_bound.left =0;

m_bound.top =m_h;

m_bound.right = m_w;

m_bound.bottom = 0;

m_XOffset = m_FontSize*3;

m_YOffset = m_FontSize*7;

}

}

SimpleChart::~SimpleChart()

{

}

void SimpleChart::Draw(const FuncData& DataCont)

{

if(m_pDc)

{

CPen pen(PS_SOLID, 1, RGB(255, 0, 0));

CPen* oldPen = m_pDc->SelectObject(&pen);

bool bIsFirst =true;

for(

FuncData::const_iterator it =DataCont.begin(),it_end =DataCont.end();

it!=it_end;

++it

)

{

/*!преобразование координат в соответствии с масштабом */

int x = x_to_coord(it->m_X);

int y = y_to_coord(it->m_Y);

if(bIsFirst)

{

m_pDc->MoveTo(x,y);

bIsFirst = false;

}

else

{

/*!рисование*/

m_pDc->LineTo(x,y);

}

}

m_pDc->SelectObject(oldPen);

}

}

void SimpleChart::DrawAxis()

{

if(m_pDc)

{

CBrush br(RGB(200, 200, 200));

RECT r = {0,0,m_w,m_h};

/*!

закраска фона

*/

m_pDc->FillRect(&r,&br);

int NullX = x_to_coord(0);

int NullY = y_to_coord(0);

m_pDc->MoveTo(NullX,0);

m_pDc->LineTo(NullX,m_h);

m_pDc->MoveTo(0,NullY);

m_pDc->LineTo(m_w,NullY);

CString XAxisName(m_settings.m_XAxisName.c_str());

CString YAxisName(m_settings.m_YAxisName.c_str());

m_pDc->TextOut(NullX+1,m_FontSize,YAxisName);

int YPrintXLine = m_h-m_YOffset + (2* m_FontSize);

m_pDc->TextOut(m_w-(m_FontSize*m_settings.m_XAxisName.size()),NullY -m_FontSize ,XAxisName);

{

double XValueStep = m_Dx/(m_settings.m_XLinesCount-1);

int XCoordStep = (m_w)/(m_settings.m_XLinesCount-1);

double CurrXValue =m_settings.m_XMin;

int CurrXCoord =0;

CString Buff;

for(int i=0;i
{

Buff.Format(_T("%0.2f"),CurrXValue);

m_pDc->TextOut(CurrXCoord,NullY+m_FontSize,Buff);

CurrXValue += XValueStep;

CurrXCoord += XCoordStep;

}

}

{

double YValueStep = m_Dy/(m_settings.m_YLinesCount-1);

int YCoordStep = (m_h)/(m_settings.m_XLinesCount-1);

double CurrYValue =m_settings.m_YMin;

int CurrYCoord =0;

CString Buff;

for(int i=0;i
{

CurrYCoord = (m_h) - (YCoordStep*i);

Buff.Format(_T("%0.2f"),CurrYValue);

m_pDc->TextOut(NullX +2 ,CurrYCoord,Buff);

CurrYValue += YValueStep;

}

}

}

}

void SimpleChart::SetSettings(const SSettings& obj)

{

m_settings = obj;

double X = max(abs(m_settings.m_XMax),abs(m_settings.m_XMin));

m_settings.m_XMax = X;

m_settings.m_XMin = -X;

double Y = max(abs(m_settings.m_YMax),abs(m_settings.m_YMin));

m_settings.m_YMax = Y;

m_settings.m_YMin = -Y;

m_Dx = m_settings.m_XMax - m_settings.m_XMin;

m_Dy = m_settings.m_YMax - m_settings.m_YMin;

}

const SimpleChart::SSettings& SimpleChart::GetSettings()

{

return m_settings;

}

double SimpleChart::CoordToXValue(int x)

{

double ret = ((double)(x)*(double)(m_Dx/m_w))+m_settings.m_XMin ;

return ret;

}

int SimpleChart::x_to_coord(double x)

{

int ret =static_cast ((x-m_settings.m_XMin)*(double)(m_w)/m_Dx);

return ret;

}

int SimpleChart::y_to_coord(double y)

{

int ret =static_cast ((y-m_settings.m_YMin)*(double)(m_h)/m_Dy);

//переворачиваем

ret = m_h -ret ;

return ret;

}

__________________________________________________________________________________

#ifndef FUNC_PROCESSOR_H

#define FUNC_PROCESSOR_H

#include

struct SFuncParams

{

SFuncParams():m_XMax(10),m_XMin(0),m_PointCount(10),m_Factor(2){}

double m_XMax;

double m_XMin;

size_t m_PointCount;

double m_Factor;

};

struct FuncPoint

{

double m_X;

double m_Y;

FuncPoint():m_X(0),m_Y(0){}

FuncPoint(double X,double Y):m_X(X),m_Y(Y){}

FuncPoint(const FuncPoint& Obj)

{

operator = (Obj);

}

FuncPoint& operator =(const FuncPoint& Obj)

{

m_X = Obj.m_X;

m_Y = Obj.m_Y;

return *this;

}

bool operator <(const FuncPoint& Obj)

{

return m_Y < Obj.m_Y;

}

};

class CXCLess

{

public:

bool operator ()(const FuncPoint& Obj1,const FuncPoint& Obj2)const

{

return Obj1.m_X < Obj2.m_X;

}

};

typedef std::vector FuncData;

void CalculateFunc(FuncData& FuncDataObj,const SFuncParams&Params);

#endif

______________________________________________________________________________

#include "stdafx.h"

#include "FuncProcessor.h"

void CalculateFunc(FuncData& FuncDataObj,const SFuncParams&Params)

{

// погрешность

double e = (Params.m_XMax - Params.m_XMin)/Params.m_PointCount;

for(size_t i=0;i

{

//пробная точка

double Xi = Params.m_XMin+(e*i);

//множитель 10000 для борьбы с переполнением

int YiTop = (int)(Params.m_Factor-1)*10000;

//Xi, это Iy

double Yi = YiTop/(abs(Xi)+1);

Yi = (Yi/10000)+1;

FuncDataObj.push_back(FuncPoint(Xi,Yi));

}

}

5. Тестовый пример работы программы

,

где

– коэффициент.

Параметры отображения графика

Таблица

График функции

Нахождение минимума

СПИСОК ЛИТЕРАТУРЫ

Баранов Л.А., Максимов В.М. Методические указания к дипломному проектированию. – М.: МИИТ, 2005. – 36 с.
Волков Е. А. Численные методы. Учебное пособие. – М.: Наука, 1982.Грегори К. Использование Visual C++ 6. – М.; СПб.; К.: Издательский дом «Вильямс», 2000. – 864 с.
Дейтел Х., Дейтел П. Как программировать на С++. – М.: ЗАО «Издательство БИНОМ», 1999. – 1024с.
Павловская Т.А. C/C++. Программирование на языке высокого уровня. Учебник для ВУЗов. – Питер, 2006.
Павловская Т.А. C++. Объектно-ориентированное программирование. Практикум. – Питер, 2005.
Страуструп Б. Язык программирования C++. Специальное издание. – Бином, 2001. 1099с.
Шлее М. Qt. Профессиональное программирование на С++. – BHV-СПб, 2005. 544с.

Blog

Содержание