43127

Розробка програми математичний калькулятор на мові Сі++

Курсовая

Информатика, кибернетика и программирование

Програмування являє собою комплекс по написанню системи програмних кодів, які здійснюватимуть керування тією чи іншою інформаційною системою, взаємодія з якою здійснюється через інформаційні технології.

Украинкский

2013-11-04

376 KB

17 чел.

PAGE  2

Зміст

Вступ

1.Формулювання задачі ………………………………………………….  5

2.Методи та засоби розв’язування задачі ………………………………. 6

3.Алгоритми розв’язування задачі ……………………………………… 8

4.Програма та її опис……………………………………………………...16

  4.1.Назва програми …………   ……………………………………….. .16

  4.2.Призначення програми ……………………………………………..16

  4.3.Мови програмування, на яких написана програма ……………….16

  4.4.Логічна структура програми ……………………………………….16

  4.5.Вхідні та вихідні дані …………………………………………….. ..17

  4.6.Програмні засоби.…………………………………………………... 17

  4.7.Технічні засоби …………………………………………………….. 17

5.Технологія програмування, виконання та відлагодження програми    18

  5.1.Технологія програмування програми ……………………………...18

  5.2.Технологія відлагодження програми ……………………………. ..18

  5.3.Технологія виконання програми …………………………………...18

6.Інструкція користувачеві …………………………………………….....19

7.Контрольний приклад та аналіз результатів комп’ютерної реалізації

  програми …………………………………………………………………22

  Висновки

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

  Додаток 1. Текст програми на мові Сі

  Додаток 2. Результати роботи програми


Вступ

Метою курсової роботи є закріплення теоретичних знань та практичних навичок програмування, набутих при вивченні дисциплін „Основи програмування” та „Проблемно орієнтовані мови програмування”. 

В ході виконання курсової роботи студенти повинні навчитися самостійно працювати з літературою, розробляти алгоритми, здійснювати їх програмну реалізацію та від лагодження на сучасних комп‘ютерних системах.

За останні роки відбувся різкий стрибок у розвитку комп’ютерної техніки й програмного забезпечення із одночасним розширення сфер застосування персональних комп’ютерів.

Програмування являє собою комплекс по написанню системи програмних кодів, які здійснюватимуть керування тією чи іншою інформаційною системою, взаємодія з якою здійснюється через інформаційні технології.

Тема моєї курсової роботи на сьогоднішній час є актуальною, так як теперішній час – це час цифрових технологій, де важливе місце посідає обчислення числових даних, для простих інженерних обчислень практичним засобом для цього є інженерний калькулятор, виконаний в віртуальному вигляді.

1.Формулювання задачі

У ході даної курсової роботи я повинен був зробити інтерфейс програми, який би забезпечував діалог: ком’ютер-користувач, для роботи з числовими обчисленнями   за допомогою інженерного калькулятора. Інтерфейс моєї програми – це калькулятор у віртуальному виконанні, тобто він має такі кнопки, як цифри: 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 та функції: sin, cos, ln, lg, +/-, arccos, arcsin, sqrt, x^2, x^y, n!, mod, div; дії: +, -, *, /  інші =, С, СЕ, BeakSpace, MC, MR, MS, M+.

В калькуляторі я передбачив основні математичні закони, правила, такі як: ділення на нуль, логарифм відємного числа, корінь відємного числа, також межі зміни синуса і косинуса для функцій арксинус та арккосинус.

Також я передбачив послідовне додавання чисел , віднімання, ділення, множення, послідовне стирання останньої цифри, відсутність двох ком.

Дана програма обчислює дані, що введені за допомогою натискання мишкою відповідних кнопок.

Дана програма може компілюватися у  середовищі С++, в тому числі Borland C++ Builder. Сама програма  реалізована на мові С++.

 Також її можна викликати в операційній системі  Windows і вона буде працювати у вигляді вікна.

 

2. Методи та засоби розв’язування задачі

Нижче  я наведу теоретичні відомості, які потрібні для розв’язання даної задачі та допоможуть краще усвідомити специфіку реалізації задачі.

2. Методи та засоби розв’язування задачі

Нижче  я наведу теоретичні відомості, які потрібні для розв’язання даної задачі та допоможуть краще усвідомити специфіку реалізації задачі.

       Оператори – це  основні елементи, з яких будуються програми на будь-якій мові програмування. Більшість операторів складаються з виразів. Вираз представляє собою об’єднання операцій і операндів.

       Найпростіший вираз складається з одного операнду.

                     Синтаксис оператора if:

if (<умова>)

<оператор1>;

[else <оператор2;>]

Оператор умови перевіряє чи вираз набуває правдивого значення, якщо так, то виконуються оператори, що розташовані безпосередньо після умови, якщо вираз набуває хибного значення, тобто =0, тоді виконуються наступні оператори. Оператор умови може використовуватись для перевірки більше ніж однієї послідовної умови.

Синтаксис оператора вибору:

switch(<вираз цілого типу>)

{

case <значення_1>:

<послідовність_операторів_1>;

break;

case <значення_2>:

<послідовність_операторів_2>;

break;

case <значення_n>:

<послідовність_операторів_n>;

break;

[default:

<послідовність_операторів_n+1>;]

}

       Оператор-перемикач switch призначений для вибору одного з декількох альтернативних шляхів виконання програми.

Оператор циклу for забезпечує циклічне повторення певного оператора певну кількість разів. Повторення циклу здійснюється з використанням змінної лічильника, що змінюється при кожному проходженні тіла програми.

Синтаксис оператора:

For(ініціалізація;перевірка умови;нове значення)

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

Масив може бути одновимірним (вектором), та багатовимірним (наприклад, двовимірною таблицею), тобто таким, де індексом є не одне число, а кортеж (сукупність) з декількох чисел, кількість яких співпадає з розмірністю масива

В переважній більшості мов програмування масив є стандартною вбудованою структурою даних.

В програмуванні та комп'ютерних науках структури даних — це способи організації даних в комп'ютерах. Часто разом зі структурою даних пов'язується і специфічний перелік операцій, які можуть бути виконаними над даними, організованими в таку структуру.

Правильний підбір структур даних є надзвичайно важливим для ефективного функціонування відповідних алгоритмів їх обробки. Добре побудовані структури даних дозволяють оптимізувати використання машинного часу та пам'яті комп'ютера для виконання найбільш критичних операцій.

       Покажчик (вказівник) - це змінна або константа стандартного типу даних для збереження адреси змінної визначеного типу. Значення покажчика - це беззнакове ціле, воно повідомляє, де розміщена змінна,і нічого не говорить про саму змінну.

        Змінна типу покажчик оголошується подібно звичайним змінним                    із  застосуванням унарного символу “*”. Форма оголошення змінної типу покажчик наступна:

тип [модифікатор] * імені-покажчика ;

         Для визначення довжини рядка використовується функція strlen(). Її синтаксис :

size_t strlen(const char *s);

         Функція strlen() повертає довжину рядка s, при цьому завершуючий нульовий символ не враховується.

        Структури дозволяють об’єднувати в єдиному об’єкті сукупність значень, які можуть мати різні типи. Оголошення структури здійснюється за допомогою ключового слова struct.

        Синтаксис опису структури виглядає так :

struct [ім’я_структури]

{

тип1 елемент1;

тип2 елемент2;

типN елементN;

} [список описів];

       Операція розв’язання видимості :: (scope resolution operator) дозволяє здійснити доступ до глобальної змінної чи функції з блоку, в якому оголошена локальна змінна з тим самим ім’ям. Наприклад, вираз ::I означає глобальну змінну І, навіть якщо в даному блоці оголошена локальна змінна з таким самим ім’ям І.

       Для керування розподілом динамічної пам’яті в Сі++ широко використовуються оператори new та delete. Вони замінюють відомі нам з мови Сі malloc, calloc, free, проте це не означає, що всі вони не можуть використовуватися у Сі++. Уся справа саме у гнучкості нових операторів: new повертає покажчик на тип, для якого виділяється пам’ять, в той час як malloc повертає порожній покажчик, тому у першому випадку відпадає необхідність використовувати перетворення типу.

       Клaс (class) - це визначений користувачем тип даних, що застосовується для опису абстрактної множини об’єктів, які пов.язані узагальненням структури та поведінки. У синтаксичному смислі клас в Сі++ дуже нагадує визначення структури в Сі, за виключенням деяких моментів. По-перше, він може містити в собі одну або декілька специфікацій доступу, що задаються як public, private або protected, по-друге, клас, зазвичай, може включати в себе ще й функції-методи поряд з елементами-даними.

Синтаксис:

class <ім’я> {

[ private : ]

[ <опис прихованих елементів> ]

[ protected :

<опис захищених елементів> ]

[ public :

<опис доступних елементів> ]

};

До елементів класу(структури) можна звертатись двома способами – це перше, якщо оголошено через масив, тоді в такому вигляді: [ім’я класу].[назва елементу класа] або якщо клас оголошений через вказівник, тоді оголошення буде виглядати так: [ім’я класу]->[назва елемента].

В мові С++ є три види специфікаторів доступу це: public; protected; private.

Public – це елементи-функції та елементи-дані доступні для функцій-елементів та інших функцій, де має місце представник класу

Private - елементи-дані та елементи-функції доступні лише для функцій-елементів поточного классу

Protected - елементи-дані та елементи-функції доступні лише для функцій-елементів поточного класу та класів,похідних від нього.

Функції – це окрема підпрограма, яка розв язує певну підзадачу, вона має свій тип, свої формальні змінні. Функція полегшує розв язання основної задачі, ділить програму на логічні підструктури.

Функція оголошується так:

Тип результату  

назва функції(список формальних параметрів)

специфікації параметрів

{

Тіло функції

}

Назва функції обирається програмістом, вона не повинна співпадати з назвою змінних, службових слів та бібліотечних функцій.

Функція завжди повинна повертати результат у точку виклику з допомогою службового слова return.

В своїй  роботі я також використав наступні функції: функції переведення символьних даних в числові – це StrToFloat(змінна), функція переведення числових даних в символьні FloatToStr(змінна), Edit1->Text.Length()- для визначення довжини рядка редагування, Edit1->Text.operator [](1) – звертання до першого елемента рядка Edit, Edit1->Text.Delete() – стирання елемента рядка Edit, Edit1->Text.Insert() – вставляння в рядок Edit символа, pow(x,y) – піднесення числа x до степеня y. Щоб не допустити порушення таких законів математики як ділення на нуль та інших, я ввів змінну, якщо вона дорівнює символу ‘e’, то виводиться повідомлення про помилку. Перевірка цієї змінної відбувається при кожній дії. Також потрібно було ввести змінні, що відповідають за наявність доданків, змінну, що набуває значення true при натисканні кнопки =, також ввів змінні, що відповідають за наявність чогось у пам’яті та змінну, що відповідає за наявність коми. Для того, щоб зробити введення сумування, множення чисел безперервним, без натискання кнопки дорівнює, я ввів змінну, в котрій міститься останнє введене число.

Тепер я наведу методи, за допомогою яких функціонують деякі кнопки:

BeakSpace

В цій кнопці я передбачив такі ситуації: коли в полі введена одна цифра або коли введене одноцифрове відємне число, тоді при натисканні кнопки в полі знову містяться символи ’0,’ , також коли міститься в полі відємне число з однією цифрою після коми, поле очищується і знову містить ’0,’. При цілому додатному і з крапкою стирається остання цифра числа. Коли число не ціле, то при стиранні останньої цифри після коми змінна point набуває значення false.

Для цього я використав такі оператори: Edit1->Text.Length(), Edit1->Text.operator [], Edit1->Text.Delete.

Для кнопки зміни знаку потрібно було передбачити два випадки – це коли число відємне і коли додатнє. Коли число відємне, то стирається перший знак за допомогою оператора Edit1->Text.operator []. Коли число додатнє, то вставляється знак за допомогою оператора Edit1->Text.Insert().

При натисканні кнопки ‘ , ’ змінна  point набуває значення true. При натисканні кнопки =змінна end  набуває значення true.

Корінь квадратний

Перше потрібно перевірити умову чи число додатнє, якщо так то обчислюється результат так: pow(StrToFloat(Edit1->Text),0.5 ), якщо число від’ємне, то вивести відповідне повідомлення.

Квадрат

Для квадрата потрібно використати таку функцію: pow(StrToFloat(Edit1->Text),2).

Факторіал

Щоб обчислити факторіал потрібно ввести змінну-лічильник, яка при кожному циклі змінюється на 1 і так поки не буде рівним числу, факторіал якого обчислюєм.

Для дій з одним числом такими як корінь квадратний, синус, косинус, арксинус, арккосинус, логарифм потрібно, щоб логічні змінні такі, що відповідають за наявність доданків, вмісту в рядку Edit змінили своє значення на протилежне.

Також потрібно змінити змінну, що відповідає за дію, наприклад на знак ‘\0’.

Таку дію потрібно виконати після кожної операції.

3.Алгоритми розв’язування задачі

long double Action(long double c)

 void Calculate(TEdit *Edit1, cCalc *Tc, char cd)

void Numbers(TEdit *Edit1, cCalc *Tc, char num)

BeakSpace

Кнопка +/-

Кнопка  =

Корінь квадратний

Квадрат

Ln(x)

                                               4.Програма та її опис

    4.1.Назва програми.

    Програма «Інженерний калькулятор»;

    4.2.Призначення програми.

Програма призначена для виконання нескладних арифметичних та алгебраїчних обчислень. Також обчислень таких тригонометричних функцій, як синус, косинус, арккосинус, арксинус. Програма виконує такі функції: додавання, віднімання, множення, ділення, піднесення до степеня, корінь квадратний, натуральний логарифм, десятковий логарифм, факторіал, зміна знаку. Програма може використовуватися як допоміжний засіб при обчисленні числових даних.

4.3.Мови програмування, на яких написана програма.

Програма написана на мові Сі++.

Мова Сі++ є мовою середнього рівня. Мова Сі++ має засоби системного програмування, включає у себе усі конструкції сучасних алгоритмічних мов, найкраще враховує можливості сучасних комп’ютерних систем, а також є мобільною мовою. Вона дещо відрізняється від Сі, а саме новими службовими словами, наявністю класів та деякими іншими функціями.

4.4.Логічна структура програми.

Програма складається з таких логічних частин, якщо зважати на особливості програмування в середовищі C++Builder, як My_kursova.bpr, My_kursova.exe, основний файл, де міститься код програми My_kursova.cpp.

Дана програма має наступну структуру:

                                     Функції файлу My_kursova.cpp

Action(long double c) – це функція, яка в залежності від дії, яку потрібно виконати та наявності доданків робить обчислення.

void Calculate(TEdit *Edit1, cCalc *Tc, char cd) – це функція, що в залежності від нажатої кнопки обчислює результат.

void Numbers(TEdit *Edit1, cCalc *Tc, char num) – це  функція, що вводить в рядок редагування цифри.

Формальним параметром функції Action є с, що дорівнює числу, яке вводиться і над яким потрібно виконати обчислення.

Формальними параметрами функції  Calculate є рядок редагування, тобто його вміст, клас  cCalc, що містить логічні змінні, та cd – дія, яку потрібно виконати.

Формальними параметрами функції Numbers є рядок редагування, тобто його вміст, клас  cCalc, що містить логічні змінні, та num – число, що вводиться.

Враховуючи особливості програмування в середовищі C++Builder, код програми містить код, кожної окремо запрограмованої кнопки, але існує на диску як єдине ціле.

My_kursova.bpr – це проект створений середовищем.

My_kursova.exe – це файл, що запускає файл на виконання.

Усі функції у даній програмі є взаємопов’язані. Обмін інформацією між ними відбувається як через локальні, так і через глобальні змінні, а також через список фактичних-формальних параметрів.

4.5.Вхідні та вихідні дані.

Вхідними даними у даній програмі є числові дані та дія чи операція, яку потрібно виконати над ними. Вихідними даними в даній програмі є результат виконання обчислень.

4.6.Програмні засоби.

Бажано мати середовище Borland_C++_Builder.А також встановлену операційну систему Windows. На інших ОС дана програма не тестувалася.

Програма повинна працювати у вигляді вікна-калькулятора  під керуванням Windows.

Та запускатися за допомогою файлу Project1.exe або з середовища.

     Для роботи програми необхідна ОС:  Windows 95/98/ME; Windows 2000; Windows XP; Windows Vista;

     Для компілювання проекту необхідний компілятор Borland_C++_Builder, бібліотечні функції : math.h,vcl.h .

4.7.Технічні засоби.

Програма не потребує особливої конфігурації комп’ютера, тому буде працювати практично на всіх конфігураціях.

5.Технологія програмування, виконання та відлагодження програми

5.1.Технологія програмування програми.

Використання моделі у розробці та вирішенні складних задач є одним з найважливіших методів. Модель – це заміщувач об’єкту дослідження, що знаходиться з ним у такій відповідності, яка дозволяє отримати нове значення про об’єкт.

Оскільки модель ґрунтується на аналогії, то вона губить сенс засобу пізнання як у випадку тотожності моделі та об’єкту дослідження, так і у випадку дуже великих відмінностей між ними. Таким чином моделювання пов’язане зі спрощенням, абстрагуванням прототипу від ряду його властивостей, ознак, сторін. Проте надмірно спрощена модель може призвести до невідповідності з досліджуваним об’єктом, що унеможливить дослідження його з допомогою такої моделі. З іншого боку, врахування в моделі якомога більшої кількості властивостей досліджуваного об’єкту призводить до ускладнення процесу дослідження.

Для вирішення своєї задачі я використав засоби обєктно-орієнтованої мови програмування Сі++. Кожний стиль програмування має свою концептуальну основу, вимагає різного підходу до розв’язування задачі. Для об’єктно-орієнтованого стилю концептуальна основа полягає в об’єктному підході. Цьому підходу відповідають чотири головних елементи: абстрагування, обмеження доступу, модульність та ієрархія.

1. Абстрагування – виділення таких вагомих характеристик

об’єктів, які відрізняють його від усіх інших об’єктів і які

чітко визначають особливості даного об’єкта з точки зору

подальшого аналізу.

2. Обмеження доступу – процес захисту окремих елементів,

який не впливає на вагомі характеристики об’єкта, як цілого.

3. Модульність – властивість системи, яка зв’язана з

можливістю декомпозиції на ряд тісно зв’язаних модулів

(частин).

4. Ієрархія - впорядкування за деякими правилами об’єктів

системи.

Ідея класів – це основа об’єктно-орієнтованого програмування (ООП). Мета ООП – намагання зв’язати дані й функції для їх обробки в єдине ціле – клас. В класах об’єднуються структури даних і функції їх обробки. Ідея класів відображає будову об’єктів реального світу – оскільки кожний предмет або процес має свої властивості, будову, поведінку.

Клас – це визначений користувачем тип даних. В класі задаються властивості і поведінка якого-небудь, об’єкта у вигляді полів-даних і функцій для роботи з ними.

Парадигма програмування – це набір теорій, методів, стандартів, які використовуються при розробці та реалізації програм на комп’ютері. ООП часто називають новою парадигмою програмування, хоча її революційний поступ розпочався давно у минулому. ООП основане на трьох принципах, що надають класам нові властивості:

1. Інкапсуляція – об’єднання в єдине ціле даних і алгоритмів обробки цих даних. В ООП дані називаються полями, а алгоритми – методами або функціями-членами (methods,member functions).

2. Успадкування - властивість створення ієрархії класів, коли нащадки отримують від попередника поля і методи.

3. Поліморфізм (від гр. poly – багато і morphos форма, означає багато форм) – це властивість класів однієї ієрархії вирішувати схожі за змістом завдання за допомогою різних алгоритмів.

Абстрагування - один із головних засобів, що використовуються для розв’язання складних задач.

Абстракція - це досить суттєві характеристики деякого об’єкта, які відрізняють його від усіх інших видів об’єктів і, таким чином, чітко визначають особливості даного об’єкта з точки зору подальшого розгляду та аналізу.

Абстрагування концентрує увагу на зовнішніх особливостях об’єкта і дозвjляє відокремити найбільш суттєві особливості поведінки від деталей їх здійснення. Такий розподіл можна назвати бар’єром абстракції, який ґрунтується на принципі мінімізації зв’язків, коли інтерфейс об’єкта містить тільки суттєві аспекти поведінки. Корисним є ще один допоміжний принцип, який називається принципом найменшої виразності, за яким абстракція повинна охоплювати лише саму суть об’єкта, не більше, але й не менше. Вибір достатньої множини абстракцій для заданої предметної області є головною проблемою об’єктно-орієнтованого проектування. Існує цілий спектр абстракцій, який починається з об’єктів, що приблизно відповідають сутності предметної області, та закінчується об’єктами, які не мають реальних аналогів у житті. Підвищити ступінь абстракції можна :

1. описом власних типів даних;

2. використанням функцій;

3. об’єднання типів даних і функцій у модулі;

4. використанням класів.

Найбільш цікаві для нас абстракції сутності об’єктів, тому що вони відповідають словнику предметної області. Опис поведінки об’єкта містить опис операцій, які можуть виконуватись над ним, та операцій, які сам об’єкт виконує над іншими об’єктами. Такий підхід концентрує увагу на зовнішніх особливостях об’єкта. Створенню абстракції будь-якого об’єкта повинні передувати певні рішення про засіб її реалізації. Вибраний спосіб реалізації повинен бути схований та захищений для більшості об’єктів-користувачів (які звертаються до даної абстракції). Поняття обмеження доступу можна визначити таким чином:

Обмеження доступу - це процес захисту окремих елементів об’єкта, що не порушує суттєвих характеристик об’єкта як цілого.

Абстрагування та обмеження доступу являються взаємодоповнюючими факторами: абстрагування фокусує увагу на зовнішніх особливостях об’єкта, а обмеження доступу - або інакше захист інформації - не дозволяє об’єктам-користувачам розрізняти внутрішню будову об’єкта.

На практиці здійснюється захист як структури об’єкта, так і реалізації його методів. У мові Сі++ керування доступом та видимістю досягається з великою гнучкістю. Елементи об’єкта можуть бути віднесені до загальнодоступної, відокремленої або захищеної частини . Модульність - це властивість програмної системи, що пов’язана із можливістю декомпозиції її на ряд внутрішньо зв’язаних на слабко пов’язаних між собою модулів.

Розподіл програми на уривки (частини) дозволяє частково зменшити її складність, однак значно важливішим є той факт, що цей процес покращує опрацювання її частин. Ці частини дуже цінні для вичерпного розуміння програми в цілому. Модульність є елементом конструкції в Сі та дозволяє здійснювати на її основі проектні рішення.

В мові Сі++ класи та об’єкти складають логічну структуру системи; як абстракції організуються в модулі, які утворюють фізичну структуру системи. Така властивість стає особливо корисною, коли система складається із багатьох десятків, а то й сотень класів.     

5.2.Технологія виконання програми.

Виконання програми виконується частинами. Спочатку створюються підпрограми, які полегшують програмування необхідної задачі, і які будуть використовуватися в тексті основної програми. В нашому випадку такими підпрограмами є :

Функція для введення цифр в поле редагування – Numbers;

Функція, що робить обчислення в залежності  від дії, яку потрібно виконати та наявності доданків робить обчислення – Action;

Calculate – це функція, що в залежності від нажатої кнопки обчислює результат.

Також можна розглянути програмний код кожної кнопки як окрему підпрограму, тому отримаєм  підпрограми для обчислення таких функцій:

  •  Синус
  •  Косинус
  •  Натуральний логарифм
  •  Факторіал
  •  Корінь квадратний
  •  Квадрат
  •  Піднесення до довільного степеня числа
  •  Арксинус
  •  Арккосинус
  •  Цілочисельне ділення
  •  Остача від ділення
  •  Ділення
  •  Множення
  •  Додавання
  •  Віднімання

5.3.Технологія відлагодження програми.

Для того, щоб відлагодити програму, потрібно використати покрокове підключення підпрограм (так ми швидше зрозуміємо у якій частині програми є помилки і послідовно виправимо ці помилки). Тобто спочатку ми записуємо підпрограми в основний текст програми, потім, при наявності помилок, ми змінюємо підпрогами до такого виду, якого вимагає цей текст і синтаксис мови Сі. Потім підлаштовуємо їх під текст програми і перевіряємо їх робочу ефективність. Намагаються зробити найкращу ефективність шляхом зміни тексту підпрограм.

Після успішного під‘єднання головних підпрограм під‘єднуються інші підпрограми(таким чином, як і основні підпрограми). Намагаються створити найкращу взаємодію шляхом перестановки або зміни тексту підпрограм.

                                        6.Інструкція користувачеві

Інтерфейс програми реалізований у графічному режимі. Інтерфейс є зручним у користуванні і не потребує значних ресурсів комп’ютера для роботи у ньому.

Керування програмою здійснюється повністю за допомогою мишки.

Є два способи по запуску програми на виконання:

1) Запуск через середовище програмування

Цей спосіб зручний тим, що при наявності бажань користувача щось змінити у програмі можна одразу ж вийти з програми у середовище програмування і змінити певний код, при цьому відразу ж відкомпілювати новостворений код.

Певною незручністю є те, що не всі можуть мати саме середовище програмування чи компілятор. Для запуску програми потрібно мати щонайменше середовище Borland C++ Builder 6. На попередніх версіях програма не тестувалася.

Щоб запустити програму на виконання із середовища програмування потрібно натиснути клавіші  F9. Або здійснити таку послідовність дій у меню самого середовища:  Run -> Run . 

2) Запуск програми через операційну систему

На мій погляд, цей спосіб є набагато зручнішим від попереднього. Щоб запустити програму через операційну систему потрібно знайти файл My_kursova.exe і два рази клікнути по ньому мишкою. В результаті програма буде запущена у вікні під керуванням операційної системи.

 Недоліком цього способу є те, що зміни у програмний код програми вносити не можна.

Коли програма запустилась з’являється вікно, що має такий вигляд: 

Зверху знаходиться рядок, де відображаються введені дані та результати обчислення. У верхньому правому куті є кнопки для переключення між градусами та радіанами, відповідно, якщо потрібно обчислити синус чи косинус від величини вказаної в градусах, потрібно, щоб відміченою була кнопка «градуси», в протилежному випадку відміченою має бути кнопка «радіани».

Нижче знаходяться такі кнопки: BeakSpace, C, CE. BeakSpace для стирання останньої цифри числа. C для очищення поля вводу/виведення. CE для видалення числа, що відображається в полі обчислення.

Далі розташовані такі кнопки: цифри від 0 до 9, зміна знаку +/-, кома « , » , дорівнює, дії: Додавання +, Віднімання  -, Множення  *, Ділення /, кнопки роботи з пам’ятю MR для виклику числа з пам’яті, MS для занесення числа в пам’ять, MC для очищення пам’яті, M+ для додавання довільного числа до числа в пам’яті, mod - остача від ділення, div - цілочисельне ділення, sin – синус, cos – косинус, ln - натуральний логарифм, lg – десятковий логарифм, n! – факторіал, sqrt -  корінь квадратний, x^2 – квадрат, x^y -  піднесення до довільного степеня числа, arcsin – арксинус, arccos -  арккосинус.

7.Контрольний приклад та аналіз результатів комп’ютерної реалізації програми

Для програми «інженерний калькулятор» вхідними даними є числові дані, тому в якості прикладу та аналізу результатів, я використав набір різних чисел до яких застосував різні функції.

Послідовність виконання:

  1.  23+24+12-33= 26
  2.  44*55*77= 186340
  3.  33 ‘+/-‘ – 22= -55
  4.  44443 ‘beakspace’= 4444
  5.  25 mod 2= 1
  6.  25 div 2= 12
  7.  64 ‘sqrt’= 8
  8.  4 ‘x^y’ 2= 16
  9.  5 ‘n!’ = 120
  10.   30 ‘sin(x)’ = 0,5

Всі обчислення виконанні на калькуляторі, результати мають вигляд:

1.

2.

3.

4.

5.

6.

7.

8.

9.

10.

При зміні вхідних даних результат правильний. Ніяких збоїв програми не відмічено.

                                                      Висновки

Після виконання своєї курсової роботи я набув практичних навичок роботи в середовищі обєктно-орієнтованого програмування. Навчився програмувати в середовищі Builder C++  та працювати з об’єктами, створювати форму, програмувати кнопки, працювати з рядком редагування Edit, здійснювати доступ до елементів рядка Edit, виконувати операції над ними, також навчився оголошувати класи, працювати з елементами класу, закріпив навички роботи з циклами та створення функцій.

Отримана програма є якісною, швидкою при виконанні і не потребує  значних ресурсів комп’ютера для її запуску.

   Дана програма може згодитися для дуже багатьох користувачів, підприємств, навчальних установ. Вона є універсальною, оскільки калькулятор є невід’ємним атрибутом будь-якої комп’ютерної системи. Тому актуальність даної програми є надзвичайно великою.

Додаток 1. Текст програми на мові Сі++

//---------------------------------------------------------------------------

#include <math.h>

#include <vcl.h>

#pragma hdrstop

#include "Unit1.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

class cCalc

{

 public:

      long double a,b,last,memory;

     bool a1,b1,end,flag,point, mem;

   char d;

   cCalc()

   {

     a1=b1=point=end=flag=memory=false;

   }

  

   long double Action(long double c)

   {

     if (a1==false && b1==false)

       {

         a1=true;

         a=c;

         return a;

       }

     else if (a1 && b1==false)

             {

               switch (d)

               {

                 case '+': {

                             b=c;

                             a=a+b;

                             last=b;

                             b=0;

                             return a;

                           }

                 case '-': {

                               b=c;

                               a=a-b;

                               last=b;

                               b=0;

                               return a;

                           }

                 case '*': {

                               b=c;

                               a=a*b;

                               last=b;

                               b=0;

                               return a;

                           }

                 case '/': {

                             b=c;

                             if (b!=0)

                             {

                                 a=a/b;

                                 last=b;

                                 b=0;

                                 return a;

                             }

                             else d='e';

                           }

                 case '%': {

                             b=c;

                             if (b!=0)

                             {

                                 b=c;

                                 a=(int)a % (int)b;

                                 last=b;

                                 b=0;

                                 return a;

                             }

                             else d='e';

                           }

                 case 'd': {

                             b=c;

                             if (b!=0)

                             {

                                 b=c;

                                 a=(int)a / (int)b;

                                 last=b;

                                 b=0;

                                 return a;

                             }

                             else d='e';

                           }

                 case '^': {

                               b=c;

                               a=pow(a,b);

                               last=a;

                               b=0;

                               return a;

                           }

               }

             }

     else if (a1 && b1)

             {

               switch (d)

               {

                 case '+': return a=a+last;

                 case '-': return a=a-last;

                 case '*': return a=a*last;

                 case '/': {

                             if (last!=0)

                             {

                               a=a / last;

                               return a;

                             }

                             else d='e';

                           }

                 case '%': {

                             if (last!=0)

                             {

                               a=(int)a % (int)last;

                               return a;

                             }

                             else d='e';

                           }

                 case 'd': {

                             if (last!=0)

                             {

                               a=(int)a / (int)last;

                               return a;

                             }

                             else d='e';

                           }

                 case '^': return a*=last;

               };

             }

   }

};

void Calculate(TEdit *Edit1, cCalc *Tc, char cd)

{

 if (Tc->d=='e') Edit1->Text="Error!";

 else

 {

   if (!Tc->end)

   {

         if (Tc->d==cd || Tc->d=='\0')

         {

            Tc->d=cd;

            if (Tc->a1 && !Tc->b1 && !Tc->flag)

            {

              Edit1->Text=FloatToStr(Tc->Action(StrToFloat(Edit1->Text)));

              Tc->flag=true;

            }

            else if (!Tc->a1 && !Tc->b1)

            {

              Edit1->Text=FloatToStr(Tc->Action(StrToFloat(Edit1->Text)));

              Tc->flag=true;

            }

         }

         else

         {

            if (!Tc->flag)

            {

               Edit1->Text=FloatToStr(Tc->Action(StrToFloat(Edit1->Text)));

               Tc->a1=Tc->flag=true;

               Tc->b1=false;

               Tc->a=StrToFloat(Edit1->Text);

            }

            Tc->d=cd;

         }

   }

   else if (!Tc->flag)

   {

     Tc->d=cd;

     Tc->b1=Tc->end=false;

     Tc->a1=Tc->flag=true;

     Tc->a=StrToFloat(Edit1->Text);

   }

 }

}

void Numbers(TEdit *Edit1, cCalc *Tc, char num)

{

 if (Tc->d=='e') Edit1->Text="Error!";

 else

 {

 if (Tc->flag || (Tc->point==false && Edit1->Text=="0,"))

 {

   Edit1->Clear();

   Tc->flag=false;

   Tc->point=false;

 }

 Edit1->Text=Edit1->Text+num;

 }

}

TForm1 *Form1;

cCalc *Tc= new cCalc;

__fastcall TForm1::TForm1(TComponent* Owner)

 : TForm(Owner)

{

}

//============================================================

//======================' + '====================================

void __fastcall TForm1::Button13Click(TObject *Sender)

{

 Calculate(Edit1, Tc,'+');

}

//======================' - '====================================

void __fastcall TForm1::Button14Click(TObject *Sender)

{

   Calculate(Edit1, Tc,'-');

}

//======================' * '====================================

void __fastcall TForm1::Button15Click(TObject *Sender)

{

     Calculate(Edit1, Tc,'*');

}

//======================' / '====================================

void __fastcall TForm1::Button16Click(TObject *Sender)

{

     Calculate(Edit1, Tc,'/');

}

//======================' Mod '==================================

void __fastcall TForm1::Button25Click(TObject *Sender)

{

         Calculate(Edit1, Tc,'%');

}

//======================' Div '==================================

void __fastcall TForm1::Button26Click(TObject *Sender)

{

     Calculate(Edit1, Tc,'d');

}

//======================' x^y '==================================

void __fastcall TForm1::Button29Click(TObject *Sender)

{

     Calculate(Edit1, Tc,'^');

}

//===============================================================

//==========================================================

//========================' 1 '==================================

void __fastcall TForm1::Button2Click(TObject *Sender)

{

   Numbers(Edit1, Tc, '1');

}

//========================' 2 '==================================

void __fastcall TForm1::Button3Click(TObject *Sender)

{

   Numbers(Edit1, Tc, '2');

}

//========================' 3 '==================================

void __fastcall TForm1::Button4Click(TObject *Sender)

{

   Numbers(Edit1, Tc, '3');

}

//========================' 4 '==================================

void __fastcall TForm1::Button5Click(TObject *Sender)

{

   Numbers(Edit1, Tc, '4');

}

//========================' 5 '==================================

void __fastcall TForm1::Button6Click(TObject *Sender)

{

   Numbers(Edit1, Tc, '5');

}

//========================' 6 '==================================

void __fastcall TForm1::Button7Click(TObject *Sender)

{

   Numbers(Edit1, Tc, '6');

}

//========================' 7 '==================================

void __fastcall TForm1::Button8Click(TObject *Sender)

{

   Numbers(Edit1, Tc, '7');

}

//========================' 8 '==================================

void __fastcall TForm1::Button9Click(TObject *Sender)

{

   Numbers(Edit1, Tc, '8');

}

//========================' 9 '==================================

void __fastcall TForm1::Button10Click(TObject *Sender)

{

   Numbers(Edit1, Tc, '9');

}

//========================' 0 '==================================

void __fastcall TForm1::Button1Click(TObject *Sender)

{

   if (Tc->point) Numbers(Edit1, Tc, '0');

   else if (StrToFloat(Edit1->Text)>0) Numbers(Edit1, Tc, '0');

}

//===============================================================

//========================BeakSpace==============================

void __fastcall TForm1::Button18Click(TObject *Sender)

{

 if (Tc->d=='e') Edit1->Text="Error!";

 else

 {

 if (Edit1->Text.Length()==1 ||

 (Edit1->Text.Length()==2 && Edit1->Text.operator [](1)=='-'))

 {

    Edit1->Text="0,";

    Tc->point=false;

 }

 else

 if (Edit1->Text.Length()==4 && Edit1->Text.operator [](1)=='-' &&

     Edit1->Text.operator [](2)=='0' && Edit1->Text.operator [](3)==',')

 {

    Edit1->Text="0,";

    Tc->point=false;

 }

 else

 if (Edit1->Text.operator [](Edit1->Text.Length())==',' &&

     Edit1->Text!="0,")

 {

    Tc->point=false;

    Edit1->Text=Edit1->Text.Delete(Edit1->Text.Length(),1);

 }

 else

 if (Edit1->Text!="0,") Edit1->Text=Edit1->Text.Delete(Edit1->Text.Length(),1);

 }

}

//===============================================================

//========================' +/- '================================

void __fastcall TForm1::Button11Click(TObject *Sender)

{

 if (Tc->d=='e') Edit1->Text="Error!";

 else

 {

   if (Edit1->Text.operator [](1)=='-')

   Edit1->Text=Edit1->Text.Delete(1,1);

   else if (Edit1->Text!="0,") Edit1->Text=Edit1->Text.Insert("-",1);

 }

}

//===============================================================

//========================' , '==================================

void __fastcall TForm1::Button12Click(TObject *Sender)

{

 if (Tc->d=='e') Edit1->Text="Error!";

 else

 {

   if (Edit1->Text!="0," && Tc->point==false)

   Edit1->Text=Edit1->Text+',';

   Tc->point=true;

 }

}

//===============================================================

//========================' = '==================================

void __fastcall TForm1::Button17Click(TObject *Sender)

{

 if (Tc->d=='e') Edit1->Text="Error!";

 else

 {

   if (Tc->a1)

   {

     Edit1->Text=FloatToStr(Tc->Action(StrToFloat(Edit1->Text)));

     if (Tc->d=='e') Edit1->Text="Error!";

     if (!Tc->b1) Tc->b1=true;

     Tc->end=true;

   }

 }

}

//===============================================================

//========================================

void __fastcall TForm1::FormCreate(TObject *Sender)

{

 Tc->point=false;

}

//===============================================================

//================'корінь квадратний '==========================

void __fastcall TForm1::Button27Click(TObject *Sender)

{

   if (Tc->d=='e') Edit1->Text="Error!";

   else

   {

     if (StrToFloat(Edit1->Text)>=0)

     {

       Edit1->Text=FloatToStr(pow(StrToFloat(Edit1->Text),0.5));

       Tc->flag=true;

       Tc->a1=false;

       Tc->b1=false;

       Tc->d='\0';

     }

     else

     {

       Edit1->Text="Error!";

       Tc->d='e';

     }

   }

}

//===============================================================

//====================='квадрат'===============================

void __fastcall TForm1::Button28Click(TObject *Sender)

{

   if (Tc->d=='e') Edit1->Text="Error!";

   else

   {

      Edit1->Text=FloatToStr(pow(StrToFloat(Edit1->Text),2));

      Tc->flag=true;

      Tc->a1=false;

      Tc->b1=false;

      Tc->d='\0';

   }

}

//===============================================================

//===================='факторіал'==============================

void __fastcall TForm1::Button30Click(TObject *Sender)

{

   if (Tc->d=='e') Edit1->Text="Error!";

   else

   {

     if (StrToFloat(Edit1->Text)>=0)

     {

       long double fact;

       fact=1.0;

       for (int i=1; i<(int)StrToFloat(Edit1->Text)+1; i++)

        fact*=i;

       Edit1->Text=FloatToStr(fact);

       Tc->flag=true;

       Tc->a1=false;

       Tc->b1=false;

       Tc->d='\0';

     }

     else

     {

       Edit1->Text="Error!";

       Tc->d='e';

     }

   }

}

//===============================================================

//======================' Ln(x) '================================

void __fastcall TForm1::Button31Click(TObject *Sender)

{

   if (Tc->d=='e') Edit1->Text="Error!";

   else

   {

     if (StrToFloat(Edit1->Text)>0)

     {

       Edit1->Text=log(StrToFloat(Edit1->Text));

       Tc->flag=true;

       Tc->a1=false;

       Tc->b1=false;

       Tc->d='\0';

     }

     else

     {

       Edit1->Text="Error!";

       Tc->d='e';

     }

   }

}

//===============================================================

//======================' Lg(x) '================================

void __fastcall TForm1::Button32Click(TObject *Sender)

{

   if (Tc->d=='e') Edit1->Text="Error!";

   else

   {

     if (StrToFloat(Edit1->Text)>0)

     {

       Edit1->Text=FloatToStr(log10(StrToFloat(Edit1->Text)));

       Tc->flag=true;

       Tc->a1=false;

       Tc->b1=false;

       Tc->d='\0';

     }

     else

     {

       Edit1->Text="Error!";

       Tc->d='e';

     }

   }

}

//===============================================================

//======================' Sin(x) '===============================

void __fastcall TForm1::Button33Click(TObject *Sender)

{

   if (Tc->d=='e') Edit1->Text="Error!";

   else

   {

     float p;

     if (RadioButton1->Checked) p=StrToFloat(Edit1->Text)*M_PI/180;

     else p=StrToFloat(Edit1->Text);

     Edit1->Text=FloatToStr(sin(p));

   }

}

//======================' Cos(x) '===============================

void __fastcall TForm1::Button34Click(TObject *Sender)

{

   if (Tc->d=='e') Edit1->Text="Error!";

   else

   {

     float p;

     if (RadioButton1->Checked) p=StrToFloat(Edit1->Text)*M_PI/180;

     else p=StrToFloat(Edit1->Text);

     Edit1->Text=FloatToStr(cos(p));

   }

}

//===============================================================

//===================' ArcSin(x) '===============================

void __fastcall TForm1::Button35Click(TObject *Sender)

{

   if (Tc->d=='e') Edit1->Text="Error!";

   else

   {

     if (abs(StrToFloat(Edit1->Text))>1) Tc->d='e';

     else

       if (RadioButton1->Checked)

         Edit1->Text=asin(StrToFloat(Edit1->Text))/M_PI*180;

       else

         Edit1->Text=asin(StrToFloat(Edit1->Text));

   }

}

//===============================================================

//===================' ArcCos(x) '===============================

void __fastcall TForm1::Button36Click(TObject *Sender)

{

   if (Tc->d=='e') Edit1->Text="Error!";

   else

   {

     if (abs(StrToFloat(Edit1->Text))>1) Tc->d='e';

     else

       if (RadioButton1->Checked)

         Edit1->Text=acos(StrToFloat(Edit1->Text))/M_PI*180;

       else

         Edit1->Text=acos(StrToFloat(Edit1->Text));

   }

}

//===============================================================

//========================' MS '=================================

void __fastcall TForm1::Button21Click(TObject *Sender)

{

 Tc->memory=StrToFloat(Edit1->Text);

 Tc->mem=true;

}

//===============================================================

//========================' MR '=================================

void __fastcall TForm1::Button22Click(TObject *Sender)

{

 if (Tc->mem) Edit1->Text=FloatToStr(Tc->memory);

}

//===============================================================

//========================' MC '=================================

void __fastcall TForm1::Button23Click(TObject *Sender)

{

 Tc->mem=false;

}

//===============================================================

//========================' M+ '=================================

void __fastcall TForm1::Button24Click(TObject *Sender)

{

 Tc->memory+=StrToFloat(Edit1->Text);

}

//===============================================================

//==========================' CE '===============================

void __fastcall TForm1::Button19Click(TObject *Sender)

{

 Tc->a1=Tc->b1=Tc->point=Tc->end=Tc->flag=Tc->memory=false;

 Tc->d='\0';

 Edit1->Text="0,";

}

//===============================================================

//=========================' C '==================================

void __fastcall TForm1::Button20Click(TObject *Sender)

{

 if (Tc->d!='e') Edit1->Text="0,";

}

//===============================================================

ЛІТЕРАТУРА

1)  Кравець П. О.    Методичні вказівки до виконання лабораторних робіт з   дисципліни Проблемно-орієнтовані мови програмування, 2005.

2)  Кравець П. О.    Методичні вказівки до виконання курсової роботи з дисципліни Проблемно-орієнтовані мови програмування, 2005

3)  Культин Н.   С, С++ в задачах и примерах, Санкт-Петербург 2005.

4)  Ричард Хезфилд, Лоуренс Кирби    Исскуство программирования на С,  Москва, Санкт-Петербург 2001

5)  Павловская Т. А., Щупак Ю. А.   С,С++ - программирование на языке високого уровня (Структурное программирование),  Санкт-Петербург 2003

6)  Романов Е. Л.  Практикум по программированию на С++,  Санкт-Петербург 2004  

7) В.В. Войтенко С/С++ теорія та практика, навчально-методичний посібник.

8) Программирование в С++Builder 6 и 2006 (Архангельский А.Я., Тагин М.А., 2007)

9) Стівен Прата,   Язык  программирование С, 2002.


      begin

a1==false && b1==false

           a1=true;

            a=c;

           return a;

a1 && b1==false

case '+':  b=c;                              a=a+b; last=b;                              b=0; return a;

case '-': b=c;                                a=a-b;  last=b;                                b=0; return a;

case '*': b=c;                              a=a*b; last=b;                               b=0; return a;

case '/': a=a/b;                                 last=b; b=0;                                  return a;

case '%': b=c;                a=(int)a % (int)b;                                  last=b;  b=0;                                 return a;

case 'd': b=c;                                 a=(int)a / (int)b;                              last=b; b=0;                                  return a;

case '^': b=c;                              a=pow(a,b);                               last=a;   b=0;                                return a;

1 && b1

case '+': return a=a+last;

case '-': return a=a-last;

case '*': return a=a*last;

case '/': a=a / last;

                               return a

case '%': a=(int)a % (int)last;

                               return a;

case 'd': a=(int)a / (int)last;

                               return a;

case '^': return a*=last;

    End.

    begin

Tc->d=='e'

Edit1->Text="Error!"

!Tc->end

Tc->d==cd || Tc->d=='\0'

Tc->d=cd;

Tc->a1 && !Tc->b1 && !Tc->flag

Edit1->Text=FloatToStr(Tc->Action(StrToFloat(Edit1->Text))); Tc->flag=true;

!Tc->a1 && !Tc->b1

  Edit1->Text=FloatToStr(Tc->Action(StrToFloat(Edit1->Text))); Tc->flag=true;

!Tc->flag

Edit1->Text=FloatToStr(Tc->Action(StrToFloat(Edit1->Text)));     Tc->a1=Tc->flag=true;

Tc->b1=false;

Tc->a=StrToFloat(Edit1->Text);

    End.

  begin

Tc->d=='e'

Edit1->Text="Error!"

Tc->flag ||                            (Tc->point==false && Edit1->Text=="0,"

Edit1->Clear();

   Tc->flag=false;

   Tc->point=false;

Edit1->Text=Edit1->Text+num;

    End.

    begin

Tc->d=='e'

Edit1->Text="Error!"

Edit1->Text.Length()==1 ||

 (Edit1->Text.Length()==2 && Edit1->Text.operator  [](1)=='-')

Edit1->Text.Length()==4 && Edit1->Text.operator [](1)=='-' &&

     Edit1->Text.operator [](2)=='0' && Edit1->Text.operator [](3)==','

Edit1->Text="0,";

    Tc->point=false;

Edit1->Text.operator [](Edit1->Text.Length())==',' &&

     Edit1->Text!="0,"

Tc->point=false;

    Edit1->Text=Edit1->Text.Delete(Edit1->Text.Length(),1);

Edit1->Text!="0,"

Edit1->Text=Edit1->Text.Delete(Edit1->Text.Length(),1

  End.

begin

Tc->d=='e'

Edit1->Text="Error!"

Edit1->Text!="0," && Tc->point==false

Edit1->Text=Edit1->Text+',';

   Tc->point=true;

End.

Tc->d=='e'

Edit1->Text="Error!"

Tc->a1

Edit1->Text=FloatToStr(Tc->Action(StrToFloat(Edit1->Text)

begin

Tc->d=='e'

Edit1->Text="Error!"

!Tc->b1

Tc->b1=true

End.

Tc->d=='e'

Edit1->Text="Error!"

StrToFloat(Edit1->Text)>=0

Edit1->Text=FloatToStr(pow(StrToFloat(Edit1->Text),0.5));

       Tc->flag=true;

       Tc->a1=false;

       Tc->b1=false;

       Tc->d='\0';

Edit1->Text="Error!";

       Tc->d='e';

begin

End.

begin

Tc->d=='e'

Edit1->Text="Error!"

Edit1->Text=FloatToStr(pow(StrToFloat(Edit1->Text),2));

      Tc->flag=true;

      Tc->a1=false;

      Tc->b1=false;

      Tc->d='\0';

  End.

begin

Tc->d=='e'

StrToFloat(Edit1->Text)>0

Edit1->Text="Error!"

Edit1->Text=log(StrToFloat(Edit1->Text));

       Tc->flag=true;

       Tc->a1=false;

       Tc->b1=false;

       Tc->d='\0';

Edit1->Text="Error!";

       Tc->d='e';

End.

a

b

c

a

b

c

a

a


 

А также другие работы, которые могут Вас заинтересовать

49505. Розкриття парубоцьких взаємовідношень, характерів, у життєвих ситуаціях засобами українського народного танцю 263.5 KB
  Переважна більшість творів саме цього жанру – сюжетні композиції, де за незначний відрізок часу балетмейстер відтворює певні події, явища, які підказані самим життям. Тематична своєрідність і оригінальність, різноманітність вирішення цих тем засобами танцювального мистецтва
49507. Сравнении значения нормативного показателя эффективности капитальных вложений (0,16) с эффективностью данного проекта 645.5 KB
  В зарубежной практике используются такие методы для оценки риска реализации проекта как метод пороговых значений анализ чувствительности методика моделирования.В зарубежной практике для данных целей используется расчетно-конструктивный метод определения точки безубыточности объема производства. руб. руб.