Форум программистов, компьютерный форум CyberForum.ru

Размер матрицы - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Перегрузка бинарных операций http://www.cyberforum.ru/cpp-beginners/thread161155.html
Привет! Начал изучать перегрузку операций. В отступление хочется сказать, что это очень увлекательно и интересно. Но в моей книге, есть один момент, который я не понял. Вернее понял, но не до конца. Итак, что диктует книга: Существует правило: объект, стоящий с левой стороны операции, вызывает функцию оператора. Объект, стоящий справа от знака операции, должен быть передан в функцию в...
C++ Имитация нажатия клавиш С/С++ Задача такая: Программа должна имитировать нажатие клавиш в фоновом режиме. То-есть она должна нажимать заранее заданные кнопки(кнопку), с определенной периодичностью. Что-то вроде бота. Каким способом это реализовать ? (на С или на С++ разницы нет, главное что бы работало) Добавлено через 33 минуты Вопрос решил, тему можно закрыть. http://www.cyberforum.ru/cpp-beginners/thread161154.html
Алгоритм Кнута-Морриса-Пратта C++
здравствуйте. можете объяснить по примеру алгоритм кнута-морриса-пратта
C++ Включение поддержки C99 в CodeBlocks
Здравствуйте! Нужно написать прогу на C (без плюсов, желательно чтоб стандарт С99). Пишу в C::B. Эта сволочь мне выдает: use option -std=c99 or -std=gnu99 to compile your code. (использую gcc) Я и сам знаю, что нужно использовать опцию, но как её включить в C::B? В меню Settings > Compiler and debugger только опции g++. Помогите пжалста, надоело компилить в консоли.
C++ считывание строки http://www.cyberforum.ru/cpp-beginners/thread161144.html
ввело в ступор... как считать строку без применения стринга..ну т.е.: char a; cin >> a; как мне теперь считать строку...какой функцией
C++ Перевод стандартных потоков ввода/вывода в файлы Интересует сея возможность.. Знаю про freopen с С файлами, но вот интересна такая возможность в С++. В книгах и сети написано типа такого: ofstream ofs; // открыли файл if(ofs) { cout=ofs; } Вполне неплохо. Но у меня так работать не хочет. Пробовал разными способами. подробнее

Показать сообщение отдельно
Nameless One
Эксперт С++
 Аватар для Nameless One
5754 / 3403 / 255
Регистрация: 08.02.2010
Сообщений: 7,393
24.08.2010, 17:40     Размер матрицы
Классы обеспечивают сложение и умножение матриц, умножение/деление матриц и векторов на число, умножение матриц на вектора, возведение матрицы в степень. Построение единичной и нулевой матриц заданных размеров.
Объявление и реализация классов:
vector.hpp
C++
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#ifndef VECTOR_HPP
#define VECTOR_HPP
 
#include <cstdlib>
 
namespace my
{
    class vector
    {
 
    public:
 
        vector(size_t size = 0);
        vector(double val, size_t size);
        vector(const vector& rhs);
        ~vector();
 
        void resize(size_t size); // Изменить размер вектора
        size_t size() const; // Размер вектора
 
        vector& operator = (const vector& rhs);
        double& operator [] (size_t index); // Доступ по индексу
 
        // Умножение на число (с обоих сторон)
        vector operator * (double val) const;
        friend vector operator * (double val, const vector& rhs);
 
        // Деление на число
        vector operator / (double val) const;
 
        double operator * (const vector& rhs) const; // Скалярное произведение
        vector operator + (const vector& rhs) const; // Сложение векторов
        vector operator - (const vector& rhs) const; // Вычитание векторов
 
        // Сравнение векторов
        bool operator == (const vector& rhs) const;
        bool operator != (const vector& rhs) const;
 
    private:
 
        size_t  m_nSize;
        double* m_pdVec;
    };
}
#endif // VECTOR_HPP

vector.cpp
C++
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#include "vector.hpp"
 
#include <stdexcept>
 
namespace my
{
    vector::vector(size_t size)
        : m_nSize(size)
    {
        if(size)
            m_pdVec = new double[m_nSize]();
        else
            m_pdVec = NULL;
    }
 
    vector::vector(double val, size_t size)
        : m_nSize(size)
    {
        if(m_nSize)
        {
            m_pdVec = new double[m_nSize];
            for(size_t i = 0; i < m_nSize; ++i)
                m_pdVec[i] = val;
        }
        else
            m_pdVec = NULL;
    }
 
    vector::vector(const vector& rhs)
        : m_nSize(rhs.m_nSize)
    {
        if(m_nSize)
        {
            m_pdVec = new double[m_nSize];
            for(size_t i = 0; i < m_nSize; ++i)
                m_pdVec[i] = rhs.m_pdVec[i];
        }
        else
            m_pdVec = NULL;
    }
 
    vector::~vector()
    {
        if(m_nSize)
            delete[] m_pdVec;
    }
 
    void vector::resize(size_t size)
    {
        if(m_nSize == size)
            return;
        if(m_nSize)
            delete[] m_pdVec;
        m_nSize = size;
        m_pdVec = new double[m_nSize]();
    }
 
    size_t vector::size() const
    {
        return m_nSize;
    }
 
    vector& vector::operator = (const vector& rhs)
    {
        this->resize(rhs.m_nSize);
        for(size_t i = 0; i < m_nSize; ++i)
            m_pdVec[i] = rhs.m_pdVec[i];
        return *this;
    }
 
    double& vector::operator [] (size_t index)
    {
        if(index >= m_nSize)
            throw(std::out_of_range("Vector: the index is out of range"));
        return m_pdVec[index];
    }
 
    vector vector::operator * (double val) const
    {
        vector temp(m_nSize);
        for(size_t i = 0; i < m_nSize; ++i)
            temp.m_pdVec[i] = m_pdVec[i] * val;
        return temp;
    }
 
    vector operator * (double val, const vector& rhs)
    {
        vector temp(rhs.m_nSize);
        for(size_t i = 0; i < rhs.m_nSize; ++i)
            temp.m_pdVec[i] = rhs.m_pdVec[i] * val;
        return temp;
    }
 
    vector vector::operator / (double val) const
    {
        if(!val)
            throw(std::domain_error("Vector: dividing by zero"));
        vector temp(m_nSize);
        for(size_t i = 0; i < m_nSize; ++i)
            temp.m_pdVec[i] = m_pdVec[i] / val;
        return temp;
    }
 
    double vector::operator * (const vector& rhs) const
    {
        if(m_nSize != rhs.m_nSize)
            throw(std::domain_error("Vector: incorrect dimensions"));
        double retval = 0;
        for(size_t i = 0; i < m_nSize; ++i)
            retval += m_pdVec[i] * rhs.m_pdVec[i];
        return retval;
    }
 
    vector vector::operator + (const vector& rhs) const
    {
        if(m_nSize != rhs.m_nSize)
            throw(std::domain_error("Vector: incorrect dimensions"));
        vector temp(m_nSize);
        for(size_t i = 0; i < m_nSize; ++i)
            temp.m_pdVec[i] = m_pdVec[i] + rhs.m_pdVec[i];
        return temp;
    }
 
    vector vector::operator - (const vector& rhs) const
    {
        if(m_nSize != rhs.m_nSize)
            throw(std::domain_error("Vector: incorrect dimensions"));
        vector temp(m_nSize);
        for(size_t i = 0; i < m_nSize; ++i)
            temp.m_pdVec[i] = m_pdVec[i] - rhs.m_pdVec[i];
        return temp;
    }
 
    bool vector::operator == (const vector& rhs) const
    {
        if(m_nSize != rhs.m_nSize)
            return false;
        for(size_t i = 0; i < m_nSize; ++i)
            if(m_pdVec[i] != rhs.m_pdVec[i])
                return false;
        return true;
    }
 
    bool vector::operator != (const vector& rhs) const
    {
        return !(*this == rhs);
    }
}

matrix.hpp
C++
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#ifndef MATRIX_HPP
#define MATRIX_HPP
 
#include "vector.hpp"
 
namespace my
{
    class matrix
    {
 
    public:
 
        matrix(size_t row, size_t col);
        matrix(double val, size_t row, size_t col);
        matrix(const matrix& rhs);
        ~matrix();
 
        void resize(size_t row, size_t col); // Изменить размер матрицы
        size_t rows() const; // Число строк
        size_t cols() const; // Число столбцов
 
        // Единичная и нулевая матрицы заданных размеров
        matrix E(size_t row, size_t col) const;
        matrix O(size_t row, size_t col) const;
 
        // Транспонирование матрицы
        matrix transpose() const;
 
        matrix& operator = (const matrix& rhs);
        vector& operator [] (size_t index); // Доступ по индексу
 
        // Умножение на число (с обоих сторон)
        matrix operator * (double val) const;
        friend matrix operator * (double val, const matrix& rhs);
 
        // Деление на число
        matrix operator / (double val) const;
 
        // Умножение на матрицы на вектор
        vector operator * (const vector& vec) const;
 
        // Умножение матриц
        matrix operator * (const matrix& rhs) const;
 
        // Возведение матрицы в степень (только для квадратных матриц!)
        matrix pow(size_t exp) const;
 
        // Сложение и вычитание матриц
        matrix operator + (const matrix& rhs) const;
        matrix operator - (const matrix& rhs) const;
 
        // Сравнение матриц
        bool operator == (const matrix& rhs) const;
        bool operator != (const matrix& rhs) const;
 
        //double determinant() const; // Определитель
        //matrix invertible() const; // Обратная матрица
 
    private:
 
        // "Быстрое" возведение в степень
        matrix fastpow(const matrix& base, size_t exp) const;
 
        size_t  m_nRow;
        size_t  m_nCol;
        vector* m_pvMatrix;
    };
}
 
#endif // MATRIX_HPP

matrix.cpp
C++
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
#include "matrix.hpp"
 
#include <stdexcept>
 
namespace my
{
    matrix::matrix(size_t row, size_t col)
        : m_nRow(row), m_nCol(col)
    {
        if(m_nRow)
        {
            m_pvMatrix = new vector[m_nRow];
            for(size_t i = 0; i < m_nRow; ++i)
                m_pvMatrix[i] = vector(m_nCol);
        }
        else
            m_pvMatrix = NULL;
    }
 
    matrix::matrix(double val, size_t row, size_t col)
        : m_nRow(row), m_nCol(col)
    {
        if(m_nRow)
        {
            m_pvMatrix = new vector[m_nRow];
            for(size_t i = 0; i < m_nRow; ++i)
                m_pvMatrix[i] = vector(val, m_nCol);
        }
        else
            m_pvMatrix = NULL;
    }
 
    matrix::matrix(const matrix &rhs)
        : m_nRow(rhs.m_nRow), m_nCol(rhs.m_nCol)
    {
        if(m_nRow)
        {
            m_pvMatrix = new vector[m_nRow];
            for(size_t i = 0; i < m_nRow; ++i)
                m_pvMatrix[i] = rhs.m_pvMatrix[i];
        }
        else
            m_pvMatrix = NULL;
    }
 
    matrix::~matrix()
    {
        if(m_nRow)
            delete[] m_pvMatrix;
    }
 
    void matrix::resize(size_t row, size_t col)
    {
        if(row != m_nRow)
        {
            if(m_nRow)
                delete[] m_pvMatrix;
            m_nRow = row;
            m_pvMatrix = new vector[m_nRow];
        }
        for(size_t i = 0; i < m_nRow; ++i)
            m_pvMatrix[i].resize(col);
    }
 
    size_t matrix::rows() const
    {
        return m_nRow;
    }
 
    size_t matrix::cols() const
    {
        return m_nCol;
    }
 
    matrix matrix::E(size_t row, size_t col) const
    {
        matrix temp(row, col);
        for(size_t i = 0; i < row; ++i)
            temp.m_pvMatrix[i][i] = 1;
        return temp;
    }
 
    matrix matrix::O(size_t row, size_t col) const
    {
        return matrix(row, col);
    }
 
    matrix matrix::transpose() const
    {
        matrix temp(m_nCol, m_nRow);
        for(size_t i = 0; i < m_nRow; ++i)
            for(size_t j = 0; j < m_nCol; ++j)
                temp.m_pvMatrix[j][i] = m_pvMatrix[i][j];
        return temp;
    }
 
    matrix& matrix::operator = (const matrix& rhs)
    {
        this->resize(rhs.m_nRow, rhs.m_nCol);
        for(size_t i = 0; i < m_nRow; ++i)
            m_pvMatrix[i] = rhs.m_pvMatrix[i];
        return *this;
    }
 
    vector& matrix::operator [] (size_t index)
    {
        if(index >= m_nRow)
            throw(std::out_of_range("Matrix: the index is out of range"));
        return m_pvMatrix[index];
    }
 
    matrix matrix::operator * (double val) const
    {
        matrix temp(m_nRow, m_nCol);
        for(size_t i = 0; i < m_nRow; ++i)
            temp.m_pvMatrix[i] = m_pvMatrix[i] * val;
        return temp;
    }
 
    matrix operator * (double val, const matrix& rhs)
    {
        matrix temp(rhs.m_nRow, rhs.m_nCol);
        for(size_t i = 0; i < temp.m_nRow; ++i)
            temp.m_pvMatrix[i] = rhs.m_pvMatrix[i] * val;
        return temp;
    }
 
    matrix matrix::operator / (double val) const
    {
        if(!val)
            throw(std::domain_error("Matrix: dividing by zero"));
        matrix temp(m_nRow, m_nCol);
        for(size_t i = 0; i < m_nRow; ++i)
            temp.m_pvMatrix[i] = m_pvMatrix[i] / val;
        return temp;
    }
 
    vector matrix::operator * (const vector& vec) const
    {
        if(m_nCol != vec.size())
            throw(std::domain_error("Matrix: incorrect dimensions"));
        vector temp(m_nRow);
        for(size_t i = 0; i < m_nRow; ++i)
            temp[i] = m_pvMatrix[i] * vec;
        return temp;
    }
 
    matrix matrix::operator * (const matrix& rhs) const
    {
        if(m_nCol != rhs.m_nRow)
            throw(std::domain_error("Matrix: incorrect dimensions"));
        matrix ret(m_nRow, rhs.m_nCol);
        matrix temp = rhs.transpose();
        for(size_t i = 0; i < m_nRow; ++i)
            for(size_t j = 0; j < rhs.m_nCol; ++j)
                ret.m_pvMatrix[i][j] = m_pvMatrix[i] * temp.m_pvMatrix[j];
        return ret;
    }
 
    matrix matrix::pow(size_t exp) const
    {
        if(m_nRow != m_nCol)
            throw(std::domain_error("Matrix: not square matrix"));
        return fastpow((*this), exp);
    }
 
    matrix matrix::fastpow(const matrix& base, size_t exp) const
    {
        if(!exp)
            return matrix::E(m_nRow, m_nCol);
        if(exp & 1)
            return base * fastpow(base, --exp);
        return fastpow(base, (exp / 2)) * fastpow(base, (exp / 2));
    }
 
    matrix matrix::operator + (const matrix& rhs) const
    {
        if((m_nRow != rhs.m_nRow) || (m_nCol != rhs.m_nCol))
            throw(std::domain_error("Matrix: incorrect dimensions"));
        matrix temp(m_nRow, m_nCol);
        for(size_t i = 0; i < m_nRow; ++i)
            temp.m_pvMatrix[i] = m_pvMatrix[i] + rhs.m_pvMatrix[i];
        return temp;
    }
 
    matrix matrix::operator - (const matrix& rhs) const
    {
        if((m_nRow != rhs.m_nRow) || (m_nCol != rhs.m_nCol))
            throw(std::domain_error("Matrix: incorrect dimensions"));
        matrix temp(m_nRow, m_nCol);
        for(size_t i = 0; i < m_nRow; ++i)
            temp.m_pvMatrix[i] = m_pvMatrix[i] - rhs.m_pvMatrix[i];
        return temp;
    }
 
    bool matrix::operator == (const matrix& rhs) const
    {
        if((m_nRow != rhs.m_nRow) || (m_nCol != rhs.m_nCol))
            return false;
        for(size_t i = 0; i < m_nRow; ++i)
            if(m_pvMatrix[i] != rhs.m_pvMatrix[i])
                return false;
        return true;
    }
 
    bool matrix::operator != (const matrix& rhs) const
    {
        return !(*this == rhs);
    }
}


Тестирование класса matrix:
main.cpp
C++
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#include <iostream>
#include <cstdlib>
#include <iomanip>
 
#include "matrix.hpp"
#include "vector.hpp"
 
#define boolDebug(EXP) std::cout << std::boolalpha << #EXP " : " \
    << (EXP) << std::endl
 
void printM(my::matrix& m, const char* name)
{
    std::cout << "Matrix \'" << name << "\':" << std::endl;
    for(size_t i = 0; i < m.rows(); ++i, std::cout << std::endl)
        for(size_t j = 0; j < m.cols(); ++j)
            std::cout << std::left << std::setw(8) << m[i][j];
}
 
void initM(my::matrix& m)
{
    for(size_t i = 0; i < m.rows(); ++i)
        for(size_t j = 0; j < m.cols(); ++j)
            m[i][j] = i + j + i * j;
}
 
int main()
{
    try
    {
        my::matrix m32(3, 2);
        initM(m32);
        printM(m32, "m32");
        my::matrix m23(2, 3);
        initM(m23);
        printM(m23, "m23");
        boolDebug(m23 == m32);
        boolDebug(m23 == m32.transpose());
        my::matrix m33 = m32 * m23;
        printM(m33, "m33");
        my::matrix check(3, 3);
        for(size_t i = 0, di = 1, dj = 2;
            i < check.rows(); ++i, di += 2, dj += 5)
            for(size_t j = 0, val = di; j < check.cols(); ++j, val += dj)
                check[i][j] = val;
        printM(check, "check");
        boolDebug(m33 == check);
        my::matrix m22(2, 2);
        initM(m22);
        printM(m22, "m22");
        my::matrix m22_pow5 = m22.pow(5);
        my::matrix pow5_check = m22 * m22 * m22 * m22 * m22;
        printM(pow5_check, "(m22)^5_check");
        printM(m22_pow5, "(m22)^5");
        boolDebug(m22_pow5 == pow5_check);
        my::matrix m22_plus = m22 + m22_pow5;
        my::matrix m22_minus = m22 - m22_pow5;
        printM(m22_plus, "m22_plus");
        printM(m22_minus, "m22_minus");
        my::matrix E33 = m22.E(3, 3);
        my::matrix E33_check = m33 * E33;
        printM(E33_check, "E33_check");
        boolDebug(m33 == E33_check);
    }
    catch(std::exception& e)
    {
        std::cerr << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}


Вычисления определителя и обратной матрицы я делать не стал, но это добавить не трудно.
 
Текущее время: 21:25. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru