2.3. Схема связей модулей проекта

Глава 3. Показательная часть

3.1. Характеристика программы

Программа выполняется в операционной среде Windows, в 32-битном режиме. По заверениям Диспетчера задач Windows, программа занимает 1 140 Кбайт оперативной памяти, что совсем не влияет на работоспособность системы. Исполняемый файл занимает на диске 1,08 МБ.

3.2. Решение контрольных примеров

Пример 1. f(x) = e^x – ln(x)

Ответ: Ошибка, на интервале чётное число корней или их там нет.

Всё верно, ибо эта функция не имеет корней, она нигде не пересекает ось абсцисс.

Графический интерфейс:

Пример 2. f(x) = 8sin²(x) – cos(√x)

Ответ: 0.3299019933

Графический интерфейс:

Пример 3. f(x) = 12x⁴ – 6x³ + 7x² + 5x – 24

Ответ: 1.107093811

Графический интерфейс:

Пример 4. f(x) = abs(x) – 5

Ответ: -5.001953125

Графический интерфейс:

Пример 5. f(x) = 2 – sqrt(abs(x))

Ответ: -4.000038147

Графический интерфейс:

3.3. Инструкция пользователя

Для того чтобы воспользоваться программой, запустите исполняемый файл «slv.exe». Вы увидите перед собой рабочее окно программы. Первое поле в этом окне предназначено для ввода левой части уравнения, представляемого в виде f(x) = 0. Формула f(x) может состоять из аргумента x, чисел, знаков арифметических операций, знака степени ^, скобок и имён математических функций. Программа поддерживает следующие математические функции:

sin, cos, tan, ctg, sh, ch, th, cth, asin, acos, atan, actg, exp, ln, sqrt, abs

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

Внизу рабочего окна расположена кнопка «Решить!», по нажатию на которую запускается алгоритм решения уравнения. Вывод результата работы алгоритма осуществляется в поле рядом с кнопкой. Это поле предназначено только для вывода, ввести какой-либо текст в него нельзя, о чём свидетельствует затемнение данного поля. Однако из него можно скопировать выведенный текст стандартными средствами Windows.

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

ВЫВОДЫ ПО РАБОТЕ

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

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

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

И это хорошо.

ПРИЛОЖЕНИЯ

Приложение 1.

Файл main.h

#include <windows.h>

LRESULT CALLBACK WinPro(HWND, UINT, WPARAM, LPARAM);

extern void AddStringFloat(HWND);

extern void ClearStringFloatList();

extern int WorkSolve(const char*, const char*, const char*, const char*, char*);

extern void wOut(int);

HINSTANCE hInst;

HWND equ, segmin, segmax, epsi, res;

HWND hwnd;

Файл main.cpp

#include "main.h"

int WINAPI WinMain(HINSTANCE hThisInstance, HINSTANCE hPrevInstance,

LPSTR lpszArgument, int nFunsterStil)

{

MSG messages;

WNDCLASSEX wincl;

wincl.hInstance = hThisInstance;

wincl.lpszClassName = "WinApp";

wincl.lpfnWndProc = WinPro;

wincl.style = CS_DBLCLKS;

wincl.cbSize = sizeof (WNDCLASSEX);

wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);

wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);

wincl.hCursor = LoadCursor (NULL, IDC_ARROW);

wincl.lpszMenuName = NULL;

wincl.cbClsExtra = 0;

wincl.cbWndExtra = 0;

wincl.hbrBackground = (HBRUSH) COLOR_3DSHADOW;

if (!RegisterClassEx (&wincl)) return -80; // error - win class not registered

hInst = hThisInstance;

hwnd = CreateWindow("WinApp", "Sample Solve 3D", WS_MINIMIZEBOX | WS_SYSMENU,

CW_USEDEFAULT, CW_USEDEFAULT, 480, 220,

HWND_DESKTOP, NULL, hThisInstance, NULL);

ShowWindow(hwnd, nFunsterStil);

while (GetMessage (&messages, NULL, 0, 0))

{

TranslateMessage(&messages);

DispatchMessage(&messages);

};

return messages.wParam;

}

LRESULT CALLBACK WinPro(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

{

switch (message)

{

case WM_CREATE:

{

CreateWindow("static", "Уравнение F(x) =", WS_CHILD | WS_VISIBLE,

20, 10, 120, 20, hwnd, (HMENU) 1, hInst, NULL);

equ = CreateWindow("edit", "", WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOVSCROLL,

150, 10, 300, 20, hwnd, (HMENU) 2, hInst, NULL);

CreateWindow("static", "Интервал:", WS_CHILD | WS_VISIBLE,

30, 60, 100, 20, hwnd, (HMENU) 3, hInst, NULL);

segmin = CreateWindow("edit", "", WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOVSCROLL,

150, 60, 60, 20, hwnd, (HMENU) 4, hInst, NULL);

CreateWindow("static", ";", WS_CHILD | WS_VISIBLE,

215, 60, 20, 20, hwnd, (HMENU) 5, hInst, NULL);

segmax = CreateWindow("edit", "", WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOVSCROLL,

230, 60, 60, 20, hwnd, (HMENU) 6, hInst, NULL);

CreateWindow("static", "Погрешность:", WS_CHILD | WS_VISIBLE,

30, 90, 100, 20, hwnd, (HMENU) 7, hInst, NULL);

epsi = CreateWindow("edit", "", WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOVSCROLL,

150, 90, 60, 20, hwnd, (HMENU) 8, hInst, NULL);

CreateWindow("button", "Решить!", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,

30, 150, 100, 20, hwnd, (HMENU) 9, hInst, NULL);

res = CreateWindow("edit", "", WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOVSCROLL | ES_READONLY,

150, 150, 200, 20, hwnd, (HMENU) 10, hInst, NULL);

AddStringFloat(segmin);

AddStringFloat(segmax);

AddStringFloat(epsi);

break;

};

case WM_COMMAND:

if(LOWORD(wParam) == 9)

{

char str_equ[256];

char str_segmin[64];

char str_segmax[64];

char str_epsi[64];

char str_res[64];

SendMessage(equ, WM_GETTEXT, 256, (LPARAM)str_equ);

SendMessage(segmin, WM_GETTEXT, 64, (LPARAM)str_segmin);

SendMessage(segmax, WM_GETTEXT, 64, (LPARAM)str_segmax);

SendMessage(epsi, WM_GETTEXT, 64, (LPARAM)str_epsi);

int err = WorkSolve(str_equ, str_segmin, str_segmax, str_epsi, str_res);

if(err) wOut(err);

else SendMessage(res, WM_SETTEXT, 64, (LPARAM)str_res);

};

break;

case WM_DESTROY:

{

ClearStringFloatList();

PostQuitMessage(0);

break;

};

default:

return DefWindowProc (hwnd, message, wParam, lParam);

}

return 0;

}

Приложение 2.

Файл FloatInput.cpp

#include <windows.h>

#include <ctype.h>

struct StringFloatNumeric {

HWND handle;

WNDPROC EditWndProc;

StringFloatNumeric *next;

};

static StringFloatNumeric *first = NULL;

LRESULT CALLBACK FloatNumStringPro(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);

void AddStringFloat(HWND str)

{

StringFloatNumeric *cur;

if(first == NULL)

{

first = new StringFloatNumeric;

cur = first;

}

else

{

for(cur = first; cur->next != NULL; cur = cur->next);

cur->next = new StringFloatNumeric;

cur = cur->next;

};

cur->next = NULL;

cur->handle = str;

cur->EditWndProc = (WNDPROC)SetWindowLong(str, GWL_WNDPROC, (LONG)FloatNumStringPro);

}

void ClearStringFloatList()

{

StringFloatNumeric *cur = first;

StringFloatNumeric *p;

while(cur != NULL)

{

p = cur;

SetWindowLong(cur->handle, GWL_WNDPROC, (LONG)cur->EditWndProc);

cur = cur->next;

delete p;

};

}

LRESULT CALLBACK FloatNumStringPro(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

{

StringFloatNumeric *cur;

for(cur = first; cur != NULL; cur = cur->next)

if(hwnd == cur->handle) break;

if(message == WM_CHAR) // при вводе символа решаем, какие символы пропускать на обработку

{

if(wParam == VK_BACK || isdigit((int) wParam)); // пропускаем все цифры и BackSpaсe

else if(wParam == '.') // а вот с точкой сложнее

{

char* tbuff = new char [128]; char* Text = tbuff;

CallWindowProc(cur->EditWndProc, cur->handle, WM_GETTEXT, 128, (LPARAM)Text); // тоже самое, что SendMessage

while(*Text++) if(*Text == '.') // если уже имеется точка

{

message = 0; MessageBeep(MB_SERVICE_NOTIFICATION); // тогда это сообщение мы не пропускаем

break;

};

delete tbuff;

}

else if(wParam == '-')

{

LRESULT i = CallWindowProc(cur->EditWndProc, cur->handle, EM_GETSEL, 0, 0);

if(LOWORD(i) == 0) // проверяем, стоит ли курсор вначале строки

{

char Text [128];

CallWindowProc(cur->EditWndProc, cur->handle, WM_GETTEXT, 128, (LPARAM) &Text);

if(Text[0] == '-') // и, если вдруг, вначале уже стоит минус, то блокируем сообщение

{ message = 0; MessageBeep(MB_SERVICE_NOTIFICATION); };

}

else

{ message = 0; MessageBeep(MB_SERVICE_NOTIFICATION); };

}

else

{ // все остальные символы не пропускаются

message = 0; MessageBeep(MB_SERVICE_NOTIFICATION);

};

};

return CallWindowProc(cur->EditWndProc, hwnd, message, wParam, lParam);

}

Приложение 3.

Файл WorkSolve.cpp

#include "formuls.h"

extern FORMULA* SyntaxAnalysing(const char*);

extern int get_error();

extern void reset_error();

int WorkError(int);

static FORMULA* Equation = NULL;

int WorkSolve(const char* EquationString,

const char* SegmentMinimum,

const char* SegmentMaximum,

const char* Epsilon,

char* OutputString)

{

reset_error();

float left = atof(SegmentMinimum);

float right = atof(SegmentMaximum);

float middle;

if(left >= right) return WorkError(-5); // -5 // ошибка "некорректный интервал"

float eps = atof(Epsilon);

if(eps <= 0) return WorkError(-6); // -6 // ошибка "отрицательная погрешность"

Equation = SyntaxAnalysing(EquationString);

if(get_error()) return WorkError(-8); // -8 // ошибка "некорректная формула"

float F_left = Calculate(Equation, left);

float F_right = Calculate(Equation, right);

float F_middle;

if(get_error()) return WorkError(-36); // ошибка при вычислениях

if(F_left * F_right > 0) return WorkError(-12); // -12 // ошибка "на интервале чётное число корней

// (или их там нет)"

while(right - left > eps)

{

middle = (left + right) / 2;

F_middle = Calculate(Equation, middle);

if(get_error()) return WorkError(-36);

if(F_left * F_middle > 0)

{

left = middle; F_left = F_middle;

}

else

{

right = middle; F_right = F_middle;

};

};

gcvt(middle, 10, OutputString);

FreeFormula(Equation);

return 0;

}

int WorkError(int i)

{

if(Equation) FreeFormula(Equation);

return i;

}

Приложение 4.

Файл formuls.h

#include <windef.h>

#include <stdlib.h>

class FORMULA {

public:

virtual float Calc() = 0;

virtual void destroy() = 0;

};

class ARGUMENT : public FORMULA {

public:

float Calc();

void destroy();

};

class CONSTANT : public FORMULA {

public:

float num;

float Calc();

void destroy();

};

class ARITHMETIC : public FORMULA {

public:

FORMULA* left;

FORMULA* right;

virtual float Calc() = 0;

void destroy();

};

class ADDITION : public ARITHMETIC { public: float Calc(); };

class SUBTRACTION : public ARITHMETIC { public: float Calc(); };

class MULTIPLICATION : public ARITHMETIC { public: float Calc(); };

class DIVISION : public ARITHMETIC { public: float Calc(); };

class POWER : public ARITHMETIC { public: float Calc(); };

class MATH_LIB : public FORMULA {

public:

FORMULA* sub;

virtual float Calc() = 0;

void destroy();

};

class NEGATIVE : public MATH_LIB { public: float Calc(); };

class SIN_ : public MATH_LIB { public: float Calc(); };

class COS_ : public MATH_LIB { public: float Calc(); };

class TAN_ : public MATH_LIB { public: float Calc(); };

class CTG_ : public MATH_LIB { public: float Calc(); };

class SH_ : public MATH_LIB { public: float Calc(); };

class CH_ : public MATH_LIB { public: float Calc(); };

class TH_ : public MATH_LIB { public: float Calc(); };

class CTH_ : public MATH_LIB { public: float Calc(); };

class ASIN_ : public MATH_LIB { public: float Calc(); };

class ACOS_ : public MATH_LIB { public: float Calc(); };

class ATAN_ : public MATH_LIB { public: float Calc(); };

class ACTG_ : public MATH_LIB { public: float Calc(); };

class EXP_ : public MATH_LIB { public: float Calc(); };

class LN_ : public MATH_LIB { public: float Calc(); };

class SQRT_ : public MATH_LIB { public: float Calc(); };

class ABS_ : public MATH_LIB { public: float Calc(); };

extern float Calculate(FORMULA*, float);

extern void FreeFormula(FORMULA*);

extern FORMULA* error(int);

Приложение 5.

Файл formuls.cpp

#include "formuls.h"

#include <math.h>

static float Arg;

float Calculate(FORMULA* E, float x)

{

Arg = x;

return E->Calc();

}

float ARGUMENT::Calc() { return Arg; }

float CONSTANT::Calc() { return num; }

float ADDITION::Calc()

{ return left->Calc() + right->Calc(); }

float SUBTRACTION::Calc()

{ return left->Calc() - right->Calc(); }

float MULTIPLICATION::Calc()

{ return left->Calc() * right->Calc(); }

float DIVISION::Calc()

{

float d = right->Calc();

if( d == 0 ) { error(64); return 1; }; // ошибка - деление на ноль

return left->Calc() / d;

}

float POWER::Calc()

{ return pow( left->Calc(), right->Calc() ); }

float NEGATIVE::Calc()

{ return -(sub->Calc()); }

float SIN_::Calc()

{ return sin(sub->Calc()); }

float COS_::Calc()

{ return cos(sub->Calc()); }

float TAN_::Calc()

{

float d = sub->Calc();

float g = cos(d);

if(g == 0 ) { error(68); return 1; }; // ошибка - неверный аргумент тангенса

return sin(d)/g;

}

float CTG_::Calc()

{

float d = sub->Calc();

float g = sin(d);

if(g == 0 ) { error(66); return 1; }; // ошибка - неверный аргумент котангенса

return cos(d)/g;

}

float SH_::Calc()

{ return sinh(sub->Calc()); }

float CH_::Calc()

{ return cosh(sub->Calc()); }

float TH_::Calc()

{ return tanh(sub->Calc()); }

float CTH_::Calc()

{

float d = sub->Calc();

float g = sinh(d);

if(g == 0 ) { error(130); return 1; }; // ошибка - неверный аргумент гиперкотангенса

return cos(d) / g;

}

float ASIN_::Calc()

{

float d = sub->Calc();

if(-1 <= d && d <= 1) { error(256); return 0; } // ошибка - неверный аргумент арксинуса

return asin(d);

}

float ACOS_::Calc()

{

float d = sub->Calc();

if(-1 <= d && d <= 1) { error(257); return 0; } // ошибка - неверный аргумент арккосинуса

return acos(sub->Calc());

}

float ATAN_::Calc()

{ return atan(sub->Calc()); }

float ACTG_::Calc()

{ return atan(1/sub->Calc()); }

float EXP_::Calc()

{ return exp(sub->Calc()); }

float LN_::Calc()

{ return log(sub->Calc()); }

float SQRT_::Calc()

{

float d = sub->Calc();

if(d < 0) { error(80); return 0; } // ошибка - корень из отрицательного числа

return sqrt(d);

}

float ABS_::Calc()

{ return fabs(sub->Calc()); }

Приложение 6.

Файл formuls2.cpp

#include "formuls.h"

void FreeFormula(FORMULA* E)

{

E->destroy(); delete E;

return;

}

void ARGUMENT::destroy() { return; }

void CONSTANT::destroy() { return; }

void ARITHMETIC::destroy()

{

if(left)

{ left->destroy(); delete left; }

if(right)

{ right->destroy(); delete right; }

return;

}

void MATH_LIB::destroy()

{

if(sub)

{ sub->destroy(); delete sub; }

return;

}

Приложение 7.

Файл Analisator.h

#include "formuls.h"

#include <ctype.h>

enum token_type {

NUMBER, FUNC, END, UNKNOW,

X='x',

PLUS='+', MINUS='-', MUL='*', DIV='/', PWR='^',

LeftP='(', RightP=')'

};

enum func_type {

F_SIN, F_COS, F_TAN, F_CTG,

F_SH, F_CH, F_TH, F_CTH,

F_ASIN, F_ACOS, F_ATAN, F_ACTG,

F_EXP, F_LN, F_SQRT, F_ABS

};

class AnalisingContainer

{

public:

const char* src_str;

token_type curr_tok;

float curr_value;

func_type curr_func;

void get_token();

};

extern AnalisingContainer AC;

extern MATH_LIB* new_func();

Приложение 8.

Файл Analisator.cpp

#include "Analisator.h"

FORMULA* expr();

FORMULA* term();

FORMULA* pw();

FORMULA* prim();

FORMULA* SyntaxAnalysing(const char* str)

{

AC.src_str = str;

AC.get_token();

FORMULA* e = expr();

if( AC.curr_tok != END ) return error(2); // неверный символ

return e;

}

FORMULA* expr()

{

FORMULA* left = term();

for(;;)

switch( AC.curr_tok )

{

case PLUS: {

ADDITION* res = new ADDITION;

AC.get_token();

res->left = left; res->right = term();

left = (FORMULA*) res;

break;

};

case MINUS: {

SUBTRACTION* res = new SUBTRACTION;

AC.get_token();

res->left = left; res->right = term();

left = (FORMULA*) res;

break;

};

default:

return left;

};

}

FORMULA* term()

{

FORMULA* left = pw();

for(;;)

switch( AC.curr_tok )

{

case MUL: {

MULTIPLICATION* res = new MULTIPLICATION;

AC.get_token();

res->left = left; res->right = pw();

left = (FORMULA*) res;

break;

};

case DIV: {

DIVISION* res = new DIVISION;

AC.get_token();

res->left = left; res->right = pw();

left = (FORMULA*) res;

break;

};

default:

return left;

};

}

FORMULA* pw()

{

FORMULA* left = prim();

if( AC.curr_tok == PWR )

{

POWER* res = new POWER;

AC.get_token();

res->left = left; res->right = prim();

return (FORMULA*) res;

};

return left;

}

FORMULA* prim()

{

switch( AC.curr_tok )

{

case NUMBER: {

CONSTANT* res = new CONSTANT;

res->num = AC.curr_value;

AC.get_token();

return (FORMULA*) res;

};

case X: {

AC.get_token();

return (FORMULA*) new ARGUMENT;

};

case MINUS: {

NEGATIVE* res = new NEGATIVE;

AC.get_token();

res->sub = prim();

return (FORMULA*) res;

};

case FUNC: {

MATH_LIB* res = new_func();

AC.get_token();

res->sub = prim();

return (FORMULA*) res;

};

case LeftP: {

AC.get_token();

FORMULA* e = expr();

if( AC.curr_tok != RightP ) return error(4); // требуется закрывающая скобка

AC.get_token();

return e;

};

case END:

return NULL;

default:

return error(16); // нарушен порядок символов

};

}

Приложение 9.

Файл AnalisatorService.cpp

#include "Analisator.h"

#include <windows.h>

AnalisingContainer AC;

const char* F_names [16] = {

"sin", "cos", "tan", "ctg",

"sh", "ch", "th", "cth",

"asin", "acos", "atan", "actg",

"exp", "ln", "sqrt", "abs"

};

MATH_LIB* new_func()

{

switch( AC.curr_func )

{

case F_SIN: return (MATH_LIB*) new SIN_;

case F_COS: return (MATH_LIB*) new COS_;

case F_TAN: return (MATH_LIB*) new TAN_;

case F_CTG: return (MATH_LIB*) new CTG_;

case F_SH: return (MATH_LIB*) new SH_;

case F_CH: return (MATH_LIB*) new CH_;

case F_TH: return (MATH_LIB*) new TH_;

case F_CTH: return (MATH_LIB*) new CTH_;

case F_ASIN: return (MATH_LIB*) new ASIN_;

case F_ACOS: return (MATH_LIB*) new ACOS_;

case F_ATAN: return (MATH_LIB*) new ATAN_;

case F_ACTG: return (MATH_LIB*) new ACTG_;

case F_EXP: return (MATH_LIB*) new EXP_;

case F_LN: return (MATH_LIB*) new LN_;

case F_SQRT: return (MATH_LIB*) new SQRT_;

case F_ABS: return (MATH_LIB*) new ABS_;

};

}

void AnalisingContainer::get_token()

{

while(isspace((int) *src_str)) src_str++;

char ch = *src_str;

if(ch == '\0')

{ curr_tok = END; return; };

switch(ch) {

case '+': case '-': case '*': case '/':

case '(': case ')': case '^': case 'x':

curr_tok = token_type(ch);

src_str++;

return;

case '0': case '1': case '2': case '3': case '4':

case '5': case '6': case '7': case '8': case '9':

case '.':

{

curr_tok = NUMBER;

char* buff = new char [128];

char* buff2 = buff;

while(isdigit((int) *src_str) || *src_str == '.') *buff++ = *src_str++;

*buff = '\0';

curr_value = atof(buff2);

delete buff2;

return;

};

default:

{

register int i;

register int k;

for(i = 0; i < 16; i++)

{

k = 0;

while(src_str[k] != '\0' && F_names[i][k] == src_str[k]) k++;

if(F_names[i][k] == '\0')

{

curr_tok = FUNC;

curr_func = func_type(i);

src_str += k;

return;

};

};

curr_tok = UNKNOW; error(8); // неизвестная функция

return;

};

};

}

static int error_code = 0;

FORMULA* error(int code)

{

if(error_code == 0) error_code = code;

return NULL;

}

int get_error()

{ return error_code; }

void reset_error()

{ error_code = 0; return; }

Приложение 10.

Файл WarningsOut.cpp

#include <windows.h>

extern HWND hwnd;

extern int get_error();

void wOut(int err)

{

char err_str [256] = "error: ";

char* p = err_str + 7;

itoa(err, p, 10);

while( *p++ ); p--;

char* mp;

switch(err) {

case -5 : mp = " - некорректный интервал"; break;

case -6 : mp = " - отрицательная погрешность"; break;

case -8 : mp = " - некорректная формула"; break;

case -36 : mp = " - ошибка при вычислениях"; break;

case -12 : mp = " - на интервале чётное число корней (или их там нет)";

};

while(*p++ = *mp++);

p--;

if(err == -8)

{

mp = "\nsyntax error: ";

while(*p++ = *mp++);

p--;

itoa(get_error(), p, 10);

while( *p++ ); p--;

switch(get_error()) {

case 2 : mp = " - ожидался конец строки"; break;

case 4 : mp = " - требуется закрывающая скобка"; break;

case 8 : mp = " - неизвестная функция"; break;

case 16 : mp = " - неверный порядок символов"; break;

};

while(*p++ = *mp++);

}

else if(err == -36)

{

mp = "\ncalculate error: ";

while(*p++ = *mp++);

p--;

itoa(get_error(), p, 10);

while( *p++ ); p--;

switch(get_error()) {

case 64 : mp = " - деление на ноль"; break;

case 68 : mp = " - неверный аргумент тангенса"; break;

case 66 : mp = " - неверный аргумент котангенса"; break;

case 130 : mp = " - неверный аргумент гиперкотангенса"; break;

case 256 : mp = " - неверный аргумент арксинуса"; break;

case 257 : mp = " - неверный аргумент арккосинуса"; break;

case 80 : mp = " - корень из отрицательного числа"; break;

};

while(*p++ = *mp++);

};

MessageBox(hwnd, err_str, "Work Error", MB_ICONERROR | MB_OK);

}

СПИСОК ИСПОЛЬЗОВАННЫХ ИСТОЧНИКОВ

1. Бахвалов Н.С., Лапин А.В., Чижонков Е.В.

Численные методы в задачах и упражнениях: Учеб. пособие. / Под ред. В.А. Садовничего. – М.: Высш. шк., 2000.

2. Страуструп Б.

Язык программирования C++. – М.:Бином,1999.