6.3. Зразок виконання роботи

Завдання 6.0. Задано такі дійсні числа: x = 1.3×(№ + 2.5), a = 1.7×(№ + 1.5) і b = 1.6×(№ + 1.5) (де № – номер варіанта) та цілі додатні числа m = n = int[2ln(№ + 10)]. Значення елементів векторів і матриць обчислюються за допомогою таких математичних виразів:

; ;

;

.

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

Внаслідок виконання наведена нижче програма (див. код прог. 6.1.) відображає на екрані такі результати:

Результат обчислення значень вхідних даних

Задача 6.1. Потрібно розробити код програми для присвоєння "=", додавання "+" і віднімання "–" векторів і матриць, а саме:

• присвоєння векторів: і ;

• присвоєння матриць: і ;

• додавання векторів: і ;

• віднімання векторів: і ;

• змішані дії над векторами: ;

• додавання матриць: і ;

• віднімання матриць: і ;

• змішані дії над матрицям: .

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

Внаслідок виконання наведена нижче програма (див. код прог. 6.1.) відображає на екрані такі результати:

Результат присвоєння "=", додавання "+" і віднімання "–" векторів і матриць

Присвоєння векторів Присвоєння матриць

Додавання векторів Віднімання векторів

Віднімання матриць Додавання матриць

Змішані дії над векторами Змішані дії над матрицями

Задача 6.2. Потрібно розробити код програми для множення "*" і ділення "/" векторів і матриць, а саме:

• множення числа на вектор і навпаки: , і ;

• ділення числа на вектор і навпаки: , і ;

• змішані дії над числами і векторами: і ;

• множення числа на матрицю та навпаки: , і ;

• ділення числа на матрицю та навпаки: , і ;

• змішані дії над числами і матрицями: і ;

• множення двох векторів: і ;

• множення вектора на матрицю та навпаки: , і , ;

• множення двох матриць: і .

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

Внаслідок виконання наведена нижче програма (див. код прог. 6.1.) відображає на екрані такі результати:

Результат множення "*" і ділення "/" векторів і матриць

Множення числа на вектор Ділення числа на вектор

Змішані дії над числами та векторами Змішані дії над числами і матрицями

Множення числа на матрицю Ділення числа на матрицю

Множення вектора на матрицю та навпаки

Множення двох векторів Множення двох матриць

Задача 6.3. Задано такі дійсні числа: x = 1.38ln(№ + 1.5) (де № – номер варіанта) та цілі додатні числа m = n = int[2ln(№ + 10)]. Значення елементів матриць обчислюються за допомогою таких математичних виразів:

, .

Потрібно розробити код програми для обчислення значення такого матричного виразу:

Внаслідок виконання наведена нижче програма (див. код прог. 6.1.) відображає на екрані такі результати:

Результат обчислення матричного виразу

Задача 6.4. Задано дійсне число x = 0.73ln(№ + 2.5) (де № – номер варіанта) та цілі додатні числа m = n = int[2ln(№ + 10)] (де № = 4 – номер варіанта). Потрібно розробити код основної програми для розв'язання таких матричних рівнянь:

• результат множення відомої матриці на невідому матрицю має дорівнювати відомій матриці: ;

• результат множення відомої матриці на невідний вектор-стовпець має дорівнювати відомому вектору-стовпцю: ;

• результат множення невідомої матриці на відому матрицю має дорівнювати відомій матриці: ;

• результат множення невідного вектора-рядка на відому матрицю має дорівнювати відомому вектору-рядку: ;

• результат множення відомої матриці на невідому матрицю і на відому матрицю має дорівнювати відомій матриці: .

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

Внаслідок виконання наведена нижче програма (див. код прог. 6.1.) відображає на екрані такі результати:

Результат розв'язання матричних рівнянь:

Код програми 6.1. Дії над векторами і матрицями

#include <vcl>

#include <conio> // Для консольного режиму роботи

#include <math> // Для математичних функцій

#include <iostream> // Для потокового введення-виведення

#include <iomanip> // Використання маніпуляторів введення-виведення

using namespace std; // Використання стандартного простору імен

const int sizeM = 5; // Максимальний розмір вектора

const int sizeN = 5; // Максимальний розмір матриці

double Fn_ai(double x, int i);

double Fn_bj(double x, int j);

double Fn_cij(double x, int i, int j);

double Fn_dij(double ai, double bj);

double Fn_aij(double x, int i, int j);

double Fn_bij(double x, int i, int j);

// Заповнення елементами одновимірного масиву

void Array(double ( *Fn)(double, int), double Vek[], double, int);

// Заповнення елементами двовимірного масиву C

void Array(double ( *FnC)(double, int, int), double Mat[][sizeN], double, int, int);

// Заповнення елементами двовимірного масиву D

void Array(double ( *FnA)(double, int), double ( *FnB)(double, int),

double ( *FnD)(double, double), double Mat[][sizeN], double, int, int);

// Виконання дії додавання "+" двох матриць

void Addition(double Mat1[][sizeN], double Mat2[][sizeN], double Mat3[][sizeN], int, int);

// Виконання дії додавання "+" двох векторів

void Addition(double Vek1[], double Vek2[], double Vek3[], int);

// Виконання дії віднімання "-" двох матриць

void Deduction(double Mat1[][sizeN], double Mat2[][sizeN], double Mat3[][sizeN], int, int);

// Виконання дії віднімання "-" двох векторів

void Deduction(double Vek1[], double Vek2[], double Vek3[], int);

// Виконання дії множення "*" вектора-рядка на вектор-стовпець

double Increase(double Vek1[], double Vek2[], int);

// Виконання дії множення "*" вектора-стовпця на вектор-рядок

void Increase(double Vek1[], double Vek2[], double Mat1[][sizeM], int, int);

// Виконання дії множення "*" числа на вектор

void Increase(double variable, double Vek1[], double Vek2[], int);

// Виконання дії множення "*" вектора на число

void Increase(double Vek1[], double, double Vek2[], int);

// Виконання дії множення "*" вектора-рядка на матрицю

void Increase(double Mat1[][sizeN], double Mat2[][sizeN], double Mat3[][sizeN], int, int);

// Виконання дії множення "*" матриці на число

void Increase(double Mat1[][sizeN], double, double Mat2[][sizeN], int, int);

// Виконання дії множення "*" числа на матрицю

void Increase(double, double Mat1[][sizeN], double Mat2[][sizeN], int, int);

// Виконання дії множення "*" матриці на вектор-стовпець

void Increase(double Mat[][sizeN], double Vek1[], double Vek2[], int, int);

// Виконання дії множення "*" вектора-рядка на матрицю

void Increase(double Vek1[], double Mat[][sizeN], double Vek2[], int, int);

// Виконання дії ділення "/" числа на вектор

void Division(double, double Vek1[], double Vek2[], int);

// Виконання дії ділення "/" вектора на число

void Division(double Vek1[], double, double Vek2[], int);

// Виконання дії ділення "/" числа на матрицю

void Division(double variable, double Mat1[][sizeN], double Mat2[][sizeN], int, int);

// Виконання дії ділення "/" матриці на число

void Division(double Mat1[][sizeN], double, double Mat2[][sizeN], int, int);

// Присвоєння значень елементів однієї матриці іншій

void Appropriation(double Mat1[][sizeN], double Mat2[][sizeN], int, int);

// Присвоєння значень елементів одного вектора іншому

void Appropriation(double vek1[], double vek2[], int);

// Піднесення матриці до n-го степеня

void MStep(double Mat1[][sizeN], int, int);

// Обчислення транспонованої "^t" матриці

void Transp(double Mat[][sizeN], int, int);

// Обчислення оберненої " - 1" матриці

void MOBR(double Mat[][sizeN], int);

// Відображення елементів одновимірного масиву

void Fn_Show(char *, double Vek[], int, int z = 7);

// Відображення елементів двовимірного масиву

void Fn_Show(char *, double Mas[][sizeN], int, int, int z = 7);

int main()

{

cout.precision(2); // Формат #.###

cout.setf(ios_base::fixed); // Формат #.###

SetConsoleOutputCP(1251); // Виведення кирилиці

cout << "Лабораторна робота № 6" << endl;

int Nv; cout << "Введіть значення N = "; cin >> Nv;

int n = 2 * log(Nv + 10); cout << "Значення n = " << n << "; ";

int m = 2 * log(Nv + 10); cout << setw(17) << "Значення m = " << m << "." << endl;

double x = 1.3 * log(Nv + 2.5); cout << "Значення x = " << setw(4) << x << "; ";

double a = 1.7 * log(Nv + 1.5); cout << setw(17) << "Значення a = " << setw(4) << a << "; ";

double b = 1.6 * log(Nv + 1.5); cout << setw(17) << "Значення b = " << setw(4) << b << "." << endl;

double Av[sizeM], Bv[sizeM], C[sizeM][sizeN], D[sizeM][sizeM];

double Cv[sizeM], Gv[sizeM], RezV[sizeM];

double Zm[sizeM][sizeN], Qm[sizeM][sizeN], RezM[sizeM][sizeN];

double Am[sizeM][sizeN], Bm[sizeM][sizeN], temp[sizeM][sizeN];

char r;

cout << "Завдання 6.0." << endl << "Обчислення значень елементів векторів і матриць" << endl;

Array(Fn_ai, Av, x, n);

Fn_Show("Одновимірний масив < Av > ", Av, n);

Array(Fn_bj, Bv, x, n);

Fn_Show("Одновимірний масив < Bv > ", Bv, n);

Array(Fn_cij, C, x, m, n);

Fn_Show("Двовимірний масив < C > ", C, m, n);

Array(Fn_ai, Fn_bj, Fn_dij, D, x, m, n);

Fn_Show("Двовимірний масив < D > ", D, m, n);

cout << "Завдання 6.1." << endl << "Додавання та віднімання векторів і матриць" << endl;

cout << "6.1.1. Присвоєння векторів" << endl;

Appropriation(Cv, Av , m);

Fn_Show("Cv = Av", Cv, m);

Appropriation(Gv, Bv , m); Appropriation(Cv, Gv , m);

Fn_Show("Gv = Bv", Gv, m);

Fn_Show("Cv = Gv = Bv", Cv, m);

cout << "6.1.2. Присвоєння матриць" << endl;

Appropriation(Zm, C, m, n);

Fn_Show("Zm = C", Zm, m, n);

Appropriation(Zm, D, m, n); Appropriation(Qm, Zm, m, n);

Fn_Show("Zm = D", Zm, m, n);

Fn_Show("Qm = Zm = D", Qm, m, n);

cout << "6.1.3. Додавання векторів" << endl;

Addition(Av, Bv, Cv , m);

Fn_Show("Cv = Av + Bv", Cv , m);

Addition(Av, Bv, RezV , m);

Addition(RezV, Cv, Gv , m);

Fn_Show("Gv = Av + Bv + Cv", Gv , m);

cout << "6.1.4. Віднімання векторів" << endl;

Deduction(Av, Bv, Cv , m);

Fn_Show("Cv = Av - Bv", Cv , m);

Deduction(Cv, Av, RezV , m);

Deduction(RezV, Bv, Gv , m);

Fn_Show("Gv = Av - Bv - Cv", Gv , m);

cout << "6.1.5. Змішані дії над векторами" << endl;

Addition(Av, Bv, RezV , m);

Deduction(RezV, Cv, Gv , m);

Fn_Show("Gv = Av + Bv - Cv", Gv , m);

cout << "6.1.6. Додавання матриць" << endl;

Addition(C, D, Zm, m, n);

Fn_Show("Zm = C + D", Zm, m, n);

Addition(Zm, C, RezM, m, n);

Addition(RezM, D, Qm, m, n);

Fn_Show("Qm = Zm + C + D", Qm, m, n);

cout << "6.1.7. Віднімання матриць" << endl;

Deduction(C, D, Zm, m, n);

Fn_Show("Zm = C - D", Zm, m, n, 8);

Deduction(Zm, C, RezM, m, n);

Deduction(RezM, D, Qm, m, n);

Fn_Show("Qm = Zm - C - D", Qm, m, n, 8);

cout << "6.1.8. Змішані дії над матрицями" << endl;

Deduction(Qm, C, RezM, m, n);

Addition(RezM, D, Zm, m, n);

Fn_Show("Zm = Qm - C + D", Zm, m, n);

cout << "Завдання 6.2. Множення векторів і матриць" << endl;

cout << "6.2.1. Множення числа на вектор і навпаки" << endl;

Increase(a, Av, Cv, m);

Fn_Show("Cv = a * Av", Cv, m);

Increase(Bv, b, Gv, m);

Fn_Show("Gv = Bv * b", Gv, m);

Increase(a, Bv, RezV, m);

Increase(RezV, b, Cv, m);

Fn_Show("Cv = a * Bv * b", Cv, m);

cout << "6.2.2. Ділення числа на вектор і навпаки" << endl;

Division(a, Av, Cv, m);

Fn_Show("Cv = a/Av", Cv, m);

Division(Bv, b, Gv, m);

Fn_Show("Gv = Bv/b", Gv, m);

Division(a, Bv, RezV, m);

Division(RezV, b, Cv, m);

Fn_Show("Cv = a/Bv/b", Cv, m);

cout << "6.2.3. Змішані дії над числами та векторами" << endl;

Increase(a, Av, RezV, m);

Division(RezV, b, Cv, m);

Fn_Show("Cv = a * Av/b", Cv, m);

Division(a, Bv, RezV, m);

Increase(RezV, b, Gv, m);

Fn_Show("Gv = a/Bv * b", Gv, m);

cout << "6.2.4. Множення числа на матрицю та навпаки" << endl;

Increase(a, C, Zm, m, n);

Fn_Show("Zm = a * C", Zm, m, n);

Increase(D, b, Qm, m, n);

Fn_Show("Qm = D * b", Qm, m, n);

Increase(a, D, RezM, m, n);

Increase(RezM, b, Zm, m, n);

Fn_Show("Zm = a * D * b", Zm, m, n);

cout << "6.2.5. Ділення числа на матрицю та навпаки" << endl;

Division(a, C, Zm, m, n);

Fn_Show("Zm = a/C", Zm, m, n);

Division(D, b, Qm, m, n);

Fn_Show("Qm = D/b", Qm, m, n);

Division(a, D, RezM, m, n);

Division(RezM, b, Zm, m, n);

Fn_Show("Zm = a/D/b", Zm, m, n);

cout << "6.2.6. Змішані дії над числами і матрицею" << endl;

Increase(a, C, RezM, m, n);

Division(RezM, b, Zm, m, n);

Fn_Show("Zm = a * C/b", Zm, m, n);

Division(a, D, RezM, m, n);

Increase(RezM, b, Qm, m, n);

Fn_Show("Qm = a/D * b", Qm, m, n);

cout << "6.2.7. Множення вектора-ряка на вектор-стовпець і навпаки" << endl;

cout << "Значення z = " << Increase(Bv, Av, m) << endl;

Increase(Av, Bv, Zm, m, n);

Fn_Show("Zm = Av * Bv", Zm, m, n, 9);

cout << "6.2.8. Множення вектора-рядка на матрицю та навпаки" << endl;

Increase(Bv, C, Cv, m, n);

Fn_Show("Cv = Bv * Cm", Cv, m, n);

Increase(D, Av, Gv, m, n);

Fn_Show("Gv = Dm * Av", Gv, m, n);

Increase(Av, C, RezV, m, n);

cout << "c = " << Increase(RezV, Bv, m) << endl;

Increase(Av, C, RezV, m, n);

Increase(RezV, D, Cv, m, n);

Fn_Show("Cv = Av * Cm * Dm", Cv, m);

cout << "6.2.9. Множення матриць" << endl;

Increase(C, D, Zm, m, n);

Fn_Show("Zm = C * D", Zm, m, n, 9);

Increase(C, D, RezM, m, n);

Increase(RezM, C, Qm, m, n);

Fn_Show("Qm = C * D * C", Qm, m, n, 9);

cout << "Завдання 6.3. Обчислення матричного виразу" << endl;

Array(Fn_aij, Am, x, m, n);

Array(Fn_bij, Bm, x, m, n);

Fn_Show("Am", Am, m, n);

Fn_Show("Bm", Bm, m, n);

Appropriation(Qm, Am, m, n); Transp(Qm, m, n); // Qm = Am^t

Appropriation(RezM, Bm, m, n); MOBR(RezM, m); //Bm^-1

Increase(Qm, RezM, Zm, m, n); // Zm = Am^t * Bm^-1

Appropriation(Qm, Bm, m, n); MStep(Qm, 2, m); //Qm = Bm^2

Increase(Qm, Am, Qm, m, n); // Qm = Bm^2 * Am

Addition(Zm, Qm, Qm, m, n); // Qm = Am^t * Bm^-1 + Bm^2 * Am

Appropriation(Zm, Bm, m, n); Transp(Zm, m, n); //Zm = Bm^t

Increase(Zm, RezM, temp, m, n); // temp = Bm^t * Bm^-1

Appropriation(Zm, Am, m, n); MStep(Zm, m, 2); //Zm = A^2

Addition(Zm, temp, Zm, m, n); // Zm = Am^2 + Bm^t * Bm^-1

Increase(Zm, Am, RezM, m, n); // RezM = (Am^2 + Bm^t * Bm^-1) * Am

Deduction(RezM, Qm, Zm, m, n); // Zm = (Am^2 + Bm^t * Bm^-1) * Am - (Am^t * Bm^-1 + Bm^2 * Am)

Fn_Show("Zm = (Am^2 + Bm^t * Bm^-1) * Am - (Am^t * Bm^-1 + Bm^2 * Am)", Zm, m, n, 9);

cout << "Завдання 6.4. Розв'язання матричного рівняння" << endl;

cout << "6.4.1. Am * Xm = Bm" << endl;

Fn_Show("Am", C, m, n);

Fn_Show("Bm", D, m, n);

Appropriation(RezM, C, m, n); MOBR(RezM, n);

Increase(RezM, D, Zm, m, n);

Fn_Show("Xm = Am^ - 1 * Bm", Zm, m, n);

Increase(C, Zm, Qm, m, n);

Fn_Show("Am * Xm = Bm", Qm, m, n);

cout << "6.4.2. Am * Xv = Bv" << endl;

Fn_Show("Am", C, m, n);

Fn_Show("Bv", Av, n);

Appropriation(RezM, C, m, n); MOBR(RezM, n);

Increase(RezM, Av, Cv, m, n);

Fn_Show("Xv = Am^ - 1 * Bv", Cv, n);

Increase(C, Cv, Gv, m, n);

Fn_Show("Am * Xv = Bv", Gv, n);

cout << "6.4.3. Xm * Am = Bm" << endl;

Fn_Show("Am", C, m, n);

Fn_Show("Bm", D, m, n);

Appropriation(RezM, C, m, n); MOBR(RezM, n);

Increase(D, RezM, Zm, m, n);

Fn_Show("Xm = Bm * Am^ - 1", Zm, m, n);

Increase(Zm, C, Qm, m, n);

Fn_Show("Xm * Am = Bm", Qm, m, n);

cout << "6.4.4. Xv * Am = Bv" << endl;

Fn_Show("Am", C, m, n);

Fn_Show("Bv", Bv, n);

Appropriation(RezM, C, m, n); MOBR(RezM, n);

Increase(Bv, RezM, Cv, m, n);

Fn_Show("Xv = Bv * Am^ - 1", Cv, n);

Increase(Cv, C, Gv, m, n);

Fn_Show("Xv * Am = Bv", Gv, n);

cout << "6.4.5. Am * Xm * Bm = Cm" << endl;

Fn_Show("Am", C, m, n);

Fn_Show("Bm", Bm, m, n);

Fn_Show("Cm", D, m, n);

Appropriation(RezM, C, m, n); MOBR(RezM, n);

Increase(RezM, D, Qm, m, n);

Appropriation(RezM, Bm, m, n); MOBR(RezM, n);

Increase(Qm, RezM, Zm, m, n);

Fn_Show("X = Am^ - 1 * Cm * Bm^ - 1", Zm, m, n, 8);

Increase(C, Zm, RezM, m, n);

Increase(RezM, Bm, Qm, m, n);

Fn_Show("Am * Xm * Bm = Cm", Qm, m, n);

getch(); return 0;

}

double Fn_ai(double x, int i)

{

double a1 = i * i + 5.36 * x;

double a2 = pow(x, 0.7) + cos(i * i);

return a1/a2;

}

double Fn_bj(double x, int j)

{

double b1 = x * x + 1.36 * j;

double b2 = sin(pow(j, 0.7) + pow(x, 0.4));

return b1/b2;

}

double Fn_cij(double x, int i, int j)

{

double c1 = pow(x, 3) + cos(j + i * i);

double c2 = 1 + pow(sin(i + pow(j, 3)), 2);

return c1/c2 - i * i;

}

double Fn_dij(double ai, double bj)

{

double d1 = pow(fabs(ai), 1.2);

double d2 = bj - 3.2 * ai;

double d3 = pow(fabs(bj * bj - 1.2), 1.23);

return d1 + d2/d3;

}

double Fn_aij(double x, int i, int j)

{

double a1 = pow(i, 3) + sin(pow(x + j, 0.7));

double a2 = x + pow(i + j, j/2.);

return a1/a2;

}

double Fn_bij(double x, int i, int j)

{

double b1 = x * pow(i + j, i/4.);

double b2 = j + cos(pow(i - x, 2));

return b1/b2;

}

// Заповнення елементами одновимірного масиву

void Array(double ( *Fn)(double, int), double Vek[], double x, int n)

{

for(int j = 0; j < n; j++) Vek[j] = ( *Fn)(x, j + 1);

}

// Заповнення елементами двовимірного масиву C

void Array(double ( *FnC)(double, int, int), double Mat[][sizeN], double x, int m, int n)

{

for(int i = 0; i < m; i++)

for(int j = 0; j < n; j++)

Mat[i][j] = ( *FnC)(x, i + 1, j + 1);

}

// Заповнення елементами двовимірного масиву D

void Array(double ( *FnA)(double, int), double ( *FnB)(double, int), double ( *FnD)(double, double),

double Mat[][sizeN], double x, int m, int n)

{

double ai, bj;

for(int i = 0; i < m; i++)

{

ai = ( *FnA)(x, i + 1);

for(int j = 0; j < n; j++)

{

bj = ( *FnB)(x, j + 1);

Mat[i][j] = ( *FnD)(ai, bj);

}

}

}

// Виконання дії додавання "+" двох матриць

void Addition(double Mat1[][sizeN], double Mat2[][sizeN], double Mat3[][sizeN], int m, int n)

{

for(int i = 0; i < m; i++)

for(int j = 0; j < n; j++)

Mat3[i][j] = Mat1[i][j] + Mat2[i][j];

}

// Виконання дії додавання "+" двох векторів

void Addition(double Vek1[], double Vek2[], double Vek3[], int m)

{

for(int i = 0; i < m; i++)

Vek3[i] = Vek1[i] + Vek2[i];

}

// Виконання дії віднімання "-" двох матриць

void Deduction(double Mat1[][sizeN], double Mat2[][sizeN], double Mat3[][sizeN], int m, int n)

{

for(int i = 0; i < m; i++)

for(int j = 0; j < n; j++)

Mat3[i][j] = Mat1[i][j] - Mat2[i][j];

}

// Виконання дії віднімання "-" двох векторів

void Deduction(double Vek1[], double Vek2[], double Vek3[], int m)

{

for(int i = 0; i < m; i++)

Vek3[i] = Vek1[i] - Vek2[i];

}

// Виконання дії множення "*" вектора-рядка на вектор-стовпець

double Increase(double Vek1[], double Vek2[], int m)

{

double zm = 0;

for(int i = 0; i < m; i++)

zm += Vek1[i] * Vek2[i];

return zm;

}

// Виконання дії множення "*" вектора-стовпця на вектор-рядок

void Increase(double Vek1[], double Vek2[], double Mat1[][sizeM], int m, int n)

{

for(int i = 0; i < m; i++)

for(int j = 0; j < n; j++)

Mat1[i][j] = Vek1[i] * Vek2[j];

}

// Виконання дії множення "*" числа на вектор

void Increase(double variable, double Vek1[], double Vek2[], int m)

{

for(int i = 0; i < m; i++)

Vek2[i] = variable * Vek1[i];

}

// Виконання дії множення "*" вектора на число

void Increase(double Vek1[], double variable, double Vek2[], int m)

{

for(int i = 0; i < m; i++)

Vek2[i] = Vek1[i] * variable;

}

// Виконання дії множення "*" вектора-рядка на матрицю

void Increase(double Mat1[][sizeN], double Mat2[][sizeN], double Mat3[][sizeN], int m, int n)

{

double s = 0;

double temp[sizeM][sizeN];

for(int i = 0; i < m; i++)

for(int j = 0; j < n; j++)

{

s = 0;

for(int k = 0; k < m; k++)

s += Mat1[i][k] * Mat2[k][j];

temp[i][j] = s;

}

Appropriation(Mat3, temp, m, n);

}

// Виконання дії множення "*" матриці на число

void Increase(double Mat1[][sizeN], double variable, double Mat2[][sizeN], int m, int n)

{

for(int i = 0; i < m; i++)

for(int j = 0; j < n; j++)

Mat2[i][j] = Mat1[i][j] * variable;

}

// Виконання дії множення "*" числа на матрицю

void Increase(double variable, double Mat1[][sizeN], double Mat2[][sizeN], int m, int n)

{

for(int i = 0; i < m; i++)

for(int j = 0; j < n; j++)

Mat2[i][j] = variable * Mat1[i][j];

}

// Виконання дії множення "*" матриці на вектор-стовпець

void Increase(double Mat[][sizeN], double Vek1[], double Vek2[], int m, int n)

{

double s = 0;

for(int i = 0; i < m; i++)

{

s = 0;

for(int k = 0; k < n; k++)

s += Mat[i][k] * Vek1[k];

Vek2[i] = s;

}

}

// Виконання дії множення "*" вектора-рядка на матрицю

void Increase(double Vek1[], double Mat[][sizeN], double Vek2[], int m, int n)

{

double s = 0;

for(int i = 0; i < m; i++)

{

s = 0;

for(int k = 0; k < n; k++)

s += Vek1[k] * Mat[k][i];

Vek2[i] = s;

}

}

// Виконання дії ділення "/" числа на вектор

void Division(double variable, double Vek1[], double Vek2[], int m)

{

for(int i = 0; i < m; i++)

Vek2[i] = variable/Vek1[i];

}

// Виконання дії ділення "/" вектора на число

void Division(double Vek1[], double variable, double Vek2[], int m)

{

for(int i = 0; i < m; i++)

Vek2[i] = Vek1[i]/variable;

}

// Виконання дії ділення "/" числа на матрицю

void Division(double variable, double Mat1[][sizeN], double Mat2[][sizeN], int m, int n)

{

for(int i = 0; i < m; i++)

for(int j = 0; j < n; j++)

Mat2[i][j] = variable/Mat1[i][j];

}

// Виконання дії ділення "/" матриці на число

void Division(double Mat1[][sizeN], double variable, double Mat2[][sizeN], int m, int n)

{

for(int i = 0; i < m; i++)

for(int j = 0; j < n; j++)

Mat2[i][j] = Mat1[i][j]/variable;

}

// Присвоєння значень елементів однієї матриці іншій

void Appropriation(double Mat1[][sizeN], double Mat2[][sizeN], int m, int n)

{

for(int i = 0; i < m; i++)

for(int j = 0; j < n; j++)

Mat1[i][j] = Mat2[i][j];

}

// Присвоєння значень елементів одного вектора іншому

void Appropriation(double vek1[], double vek2[], int m)

{

for(int i = 0; i < m; i++) vek1[i] = vek2[i];

}

// Піднесення матриці до n-го степеня

void MStep(double Mat1[][sizeN], int variable, int m)

{

int step;

double Mat2[sizeM][sizeN];

Appropriation(Mat2, Mat1, m, m);

if(variable >= 2)

{

step = 1;

while(step < variable)

{

Increase(Mat2, Mat1, Mat2, m, m); step++;

}

Appropriation(Mat1, Mat2, m, m);

}

}

// Обчислення транспонованої "^t" матриці

void Transp(double Mat[][sizeN], int m, int n)

{

double temp[sizeM][sizeN];

Appropriation(temp, Mat, m, n);

for(int i = 0; i < m; i++)

for(int j = 0; j < n; j++)

Mat[j][i] = temp[i][j];

}

// Обчислення оберненої " - 1" матриці

void MOBR(double Mat[][sizeN], int n)

{

int i, j, K, z[sizeM];

double b[sizeM], c[sizeM];

double Y, D = 1.0, w, E = 0.000000000001;

for(j = 0; j < n; j++) z[j] = j;

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

{

K = i; Y = Mat[i][i];

for(j = i + 1; j < n; j++)

{

w = Mat[i][j];

if(fabs(w) > fabs(Y))

{

K = j; Y = w;

}

}

D *= Y;

if(fabs(Y) < E) exit(1);

for(j = 0; j < n; j++)

{

b[j] = Mat[j][K]; Mat[j][K] = Mat[j][i];

Mat[j][i] = -b[j]/Y; Mat[i][j] = Mat[i][j]/Y;

c[j] = Mat[i][j];

}

Mat[i][i] = 1/Y; j = z[i]; z[i] = z[K]; z[K] = j;

for(K = 0; K < n; K++)

if(K != i)

for(j = 0; j < n; j++)

if(j != i)

Mat[K][j] = Mat[K][j] - c[j] * b[K];

}

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

{

K = z[i];

if(K != i)

{

for(j = 0; j < n; j++)

{

w = Mat[i][j]; Mat[i][j] = Mat[K][j]; Mat[K][j] = w;

}

j = z[i]; z[i] = z[K]; z[K] = j; D = -D;

}

}

}

// Відображення елементів одновимірного масиву

void Fn_Show(char *name, double Vek[], int n, int z)

{

cout << name << endl;

for(int i = 0; i < n; i++)

cout << setw(3) << i << " -- > " << setw(z) << Vek[i] << endl;

cout << " --- " << endl << endl;

}

// Відображення елементів двовимірного масиву

void Fn_Show(char *name, double Mas[sizeM][sizeN], int m, int n, int z)

{

cout << name << endl;

for(int i = 0; i < m; i++)

{

for(int j = 0; j < n; j++)

cout << setw(z) << Mas[i][j];

cout << endl;

}

cout << " --- " << endl << endl;

}

6.4. Індивідуальні завдання

Задача 6.0. Задано такі дійсні числа: x = 1.8ln(№ + 0.5), a = 1.3ln(№ + 0.5) і b = 1.6ln(№ + 0.5) (де № – номер варіанта) та цілі додатні числа m = n = int[2ln(№ + 10)]. Значення елементів вектора-стовпця обчислюються за допомогою таких математичних виразів:

1. ; 2. ; 3. ;

4. ; 5. ; 6. ;

7. ; 8. ; 9. ;

10. ; 11. ; 12. ;

13. ; 14. ; 15. ;

16. ; 17. ; 18. ;

19. ; 20. ; 21. ;

22. ; 23. ; 24. ;

25. ; 26. ; 27. ;

28. ; 29. ; 30. .

Значення елементів вектора-рядка обчислюються за допомогою таких математичних виразів:

1. ; 2. ; 3. ;

4. ; 5. ; 6. ;

7. ; 8. ; 9. ;

10. ; 11. ; 12. ;

13. ; 14. ; 15. ;

16. ; 17. ; 18. ;

19. ; 20. ; 21. ;

22. ; 23. ; 24. ;

25. ; 26. ; 27. ;

28. ; 29. ; 30. .

Значення елементів матриці обчислюються за допомогою таких математичних виразів:

1. ; 2. ;

3. ; 4. ;

5. ; 6. ;

7. ; 8. ;

9. ; 10. ;

11. ; 12. ;

13. ; 14. ;

15. ; 16. ;

17. ; 18. ;

19. ; 20. ;

21. ; 22. ;

23. ; 24. ;

25. ; 26. ;

27. ; 28. ;

29. ; 30. .

Значення елементів матриці обчислюються за допомогою таких математичних виразів:

; 2. ; 3. ;

4. ; 5. ; 6. ;

7. ; 8. ; 9. ;

10. ; 11. ; 12. ;

13. ; 14. ; 15. ;

16. ; 17. ; 18. ;

19. ; 20. ; 21. ;

22. ; 23. ; 24. ;

25. ; 26. ; 27. ;

28. ; 29. ; 30. .

Потрібно розробити коди функцій, які реалізують такі дій над векторами і матрицями: додавання "+", віднімання "–", множення "*", ділення "/" (ділення вектора чи матриці тільки на число). Потрібно розробити код основної програми, яка демонструватиме різні механізми роботи з цими функціями.

Задача 6.1. Потрібно розробити код програми для присвоєння "=", додавання "+" і віднімання "–" векторів і матриць, а саме:

• присвоєння векторів: і ;

• присвоєння матриць: і ;

• додавання векторів: і ;

• віднімання векторів: і ;

• змішані дії над векторами: ;

• додавання матриць: і ;

• віднімання матриць: і ;

• змішані дії над матрицям: .

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

Задача 6.2. Потрібно розробити код програми для множення "*" і ділення "/" векторів і матриць, а саме:

• множення числа на вектор і навпаки: , і ;

• ділення числа на вектор і навпаки: , і ;

• змішані дії над числами і векторами: і ;

• множення числа на матрицю та навпаки: , і ;

• ділення числа на матрицю та навпаки: , і ;

• змішані дії над числами і матрицями: і ;

• множення двох векторів: і ;

• множення вектора на матрицю та навпаки: , і , ;

• множення двох матриць: і .

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

Задача 6.3. Задано дійсне число x = 1.38ln(№ + 1.5) (де № – номер варіанта) та цілі додатні числа m = n = int[2ln(№ + 10)]. Значення елементів матриць обчислюються за допомогою таких математичних виразів:

, .

Потрібно розробити код програми для обчислення значення одного з таких матричних виразів:

1. ; 2. ; 3. ;

4. ; 5. ; 6. ;

7. ; 8. ; 9. ;

10. ; 11. ; 12. ;

13. ; 14. ; 15. ;

16. ; 17. ; 18. ;

19. ; 20. ; 21. ;

22. ; 23. ; 24. ;

25. ; 26. ; 27. ;

28. ; 29. ; 30. .

Задача 6.4. Задано дійсне число x = 1.73ln(№ + 1.5) (де № – номер варіанта) та цілі додатні числа m = n = int[2ln(№ + 10)]. Значення елементів матриць обчислюються за допомогою таких математичних виразів:

;

;

;

;

.

Потрібно розробити код основної програми для розв'язання таких матричних рівнянь:

• результат множення відомої матриці на невідому матрицю має дорівнювати відомій матриці: ;

• результат множення відомої матриці на невідний вектор-стовпець має дорівнювати відомому вектору-стовпцю: ;

• результат множення невідомої матриці на відому матрицю має дорівнювати відомій матриці: ;

• результат множення невідного вектора-рядка на відому матрицю має дорівнювати відомому вектору-рядку: ;

• результат множення відомої матриці на невідому матрицю і на відому матрицю має дорівнювати відомій матриці: .

Зробити перевірку правильності розв'язання кожного з матричних рівнянь.

Лабораторна робота № 7. Характерні механізми оброблення елементів матриць