API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 18th, 2019
82
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.18 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <random>
  3. #include <cmath>
  4. #include <ctime>
  5. struct Vect {
  6. protected:
  7. double *massiv;
  8. int len;
  9. bool ornt;
  10.  
  11. public:
  12. Vect(bool b = true) {
  13. massiv = nullptr;
  14. len = 0;
  15. ornt = b;
  16. }
  17. Vect(int l, bool b = true) {
  18. massiv = new double[len = l];
  19. for(int i = 0; i < l; i++) massiv[i] = 0;
  20. }
  21. Vect(double *a, int l, bool b = true) {
  22. massiv = new double[l];
  23. len = l;
  24. for(int i = 0; i < l; i++) massiv[i] = a[i];
  25. }
  26. Vect(Vect *v) {
  27. len = v->len;
  28. massiv = new double[len];
  29. for(int i = 0; i < len; i++) massiv[i] = v->massiv[i];
  30. }
  31. Vect(const Vect &v) {
  32. len = v.len;
  33. massiv = new double[len];
  34. for(int i = 0; i < len; i++) massiv[i] = v.massiv[i];
  35. }
  36. double& operator [] (int index) {
  37. double zero = 0;
  38. return index < len ? massiv[index] : zero;
  39. }
  40. Vect& operator = (Vect v) {
  41. if(massiv) delete[] massiv;
  42. len = v.size();
  43. massiv = new double[len];
  44. for(int i = 0; i < len; i++) massiv[i] = v[i];
  45. return *this;
  46. }
  47. Vect operator + (Vect v) {
  48. Vect rslt(ornt);
  49. int l = v.size() > len ? v.size() : len;
  50. rslt.set_size(l);
  51. for(int i = 0; i < l; i++) rslt[i] = massiv[i] + v[i];
  52. return rslt;
  53. }
  54. Vect operator + (double n) {
  55. Vect rslt(ornt);
  56. rslt.set_size(len);
  57. for(int i = 0; i < len; i++) rslt[i] = massiv[i] + n;
  58. return rslt;
  59. }
  60. Vect operator * (Vect v) {
  61. Vect rslt(ornt);
  62. int l = v.size() > len ? v.size() : len;
  63. rslt.set_size(l);
  64. for(int i = 0; i < l; i++) rslt[i] = massiv[i] * v[i];
  65. return rslt;
  66. }
  67. Vect operator * (double n) {
  68. Vect rslt(ornt);
  69. rslt.set_size(len);
  70. for(int i = 0; i < len; i++) rslt[i] = massiv[i] * n;
  71. return rslt;
  72. }
  73. bool operator == (Vect v) {
  74. if(v.size() != len) return false;
  75. for(int i = 0; i < len; i++) if(massiv[i] != v[i]) return false;
  76. return true;
  77. }
  78. bool operator != (Vect v) {
  79. if(v.size() != len) return true;
  80. for(int i = 0; i < len; i++) if(massiv[i] != v[i]) return true;
  81. return true;
  82. }
  83. void set_size(int l) {
  84. int p = l < len ? l : len;
  85. double *buf = new double[len = l];
  86. for(int i = 0; i < p; i++) buf[i] = massiv[i];
  87. delete[] massiv;
  88. massiv = buf;
  89. }
  90. void push_back(double n) {
  91. set_size(len+1);
  92. massiv[len-1] = n;
  93. }
  94. void print() {
  95. std::cout << "(" << massiv[0];
  96. for(int i = 1; i < len; i++) std::cout << ", " << massiv[i];
  97. std::cout << ")" << std::endl;
  98. }
  99. int sum() {
  100. int rslt = 0;
  101. for(int i = 0; i < len; i++) rslt += massiv[i];
  102. return rslt;
  103. }
  104. int module() {
  105. int rslt = 0;
  106. for(int i = 0; i < len; i++) rslt += massiv[i]*massiv[i];
  107. return std::sqrt(rslt);
  108. }
  109. int size() {
  110. return len;
  111. }
  112. bool isRow() {
  113. return ornt;
  114. }
  115. bool isColumn() {
  116. return !ornt;
  117. }
  118. void transpose() {
  119. ornt = !ornt;
  120. }
  121. void random(int N, std::default_random_engine *generator, std::uniform_real_distribution<double> *distribution) {
  122. if(massiv) delete[] massiv;
  123. massiv = new double[N];
  124. len = N;
  125. std::uniform_real_distribution<double> d = *distribution;
  126. for(int i = 0; i < len; i++) massiv[i] = d(*generator);
  127. }
  128. void random(int N, double R, int seed = time(nullptr)) {
  129.  
  130. std::default_random_engine generator(seed);
  131. std::uniform_real_distribution<double> distribution(-R, R);
  132. random(N, &generator, &distribution);
  133. }
  134. ~Vect() {
  135. delete[] massiv;
  136. }
  137. };
  138. struct Matrix {
  139. protected:
  140. int NR;
  141. int NC;
  142. Vect* massiv;
  143.  
  144. public:
  145. Matrix() {
  146. massiv = nullptr;
  147. NR = 0;
  148. NC = 0;
  149. }
  150. Matrix(Vect v) {
  151. if(v.isRow()) {
  152. NR = 1, NC = v.size();
  153. massiv = new Vect[NR];
  154. massiv[0] = new Vect(v);
  155. }
  156. else {
  157. NR = v.size(), NC = 1;
  158. massiv = new Vect[NR];
  159. for(int i = 0; i < NR; i++) massiv[i] = new Vect(v[i], NC);
  160. }
  161. }
  162. Matrix(int a, int b) {
  163. massiv = new Vect[a];
  164. NR = a;
  165. NC = b;
  166. for(int i = 0; i < a; i++) {
  167. massiv[i] = new Vect(b);
  168. }
  169.  
  170. }
  171. Matrix(double n, int a, int b) {
  172. massiv = new Vect[a];
  173. NR = a;
  174. NC = b;
  175. for(int i = 0; i < a; i++) {
  176. massiv[i] = new Vect(b);
  177. if(i < b) massiv[i][i] = n;
  178. }
  179. }
  180. Matrix(double **m, int a, int b) {
  181. massiv = new Vect[a];
  182. NR = a;
  183. NC = b;
  184. for(int i = 0; i < a; i++) massiv[i] = new Vect(m[i], b);
  185. }
  186. Matrix(Vect *m, int a, int b) {
  187. massiv = new Vect[a];
  188. NR = a;
  189. NC = b;
  190. for(int i = 0; i < a; i++) massiv[i] = new Vect(m[i]);
  191. }
  192. Matrix(Matrix *m) {
  193. NR = m->NR;
  194. NC = m->NC;
  195. massiv = new Vect[NR];
  196. for(int i = 0; i < NR; i++) massiv[i] = new Vect(m->massiv[i]);
  197. }
  198. Matrix(const Matrix &m) {
  199. NR = m.NR;
  200. NC = m.NC;
  201. massiv = new Vect[NR];
  202. for(int i = 0; i < NR; i++) massiv[i] = new Vect(m.massiv[i]);
  203. }
  204. Vect& operator [] (int index) {
  205. return massiv[index];
  206. }
  207. Matrix& operator = (Matrix m) {
  208. if(massiv) delete[] massiv;
  209. NR = m.rows();
  210. NC = m.columns();
  211. massiv = new Vect[NR];
  212. for(int i = 0; i < NR; i++) massiv[i] = m[i];
  213. return *this;
  214. }
  215. Matrix operator + (Matrix m) {
  216. Matrix rslt;
  217. int a = m.rows() > NR ? m.rows() : NR;
  218. int b = m.columns() > NC ? m.columns() : NC;
  219. rslt.set_size(a, b);
  220. for(int i = 0; i < a; i++) rslt[i] = massiv[i] + m[i];
  221. return rslt;
  222. }
  223. Matrix operator + (double n) {
  224. Matrix rslt;
  225. rslt.set_size(NR, NC);
  226. for(int i = 0; i < NR; i++) rslt[i] = massiv[i] + n;
  227. return rslt;
  228. }
  229. Matrix operator * (Matrix m) {
  230. Matrix rslt(NR, m.columns());
  231. if (NC == m.rows()) {
  232. for (int i = 0; i < NR; i++) {
  233. for (int j = 0; j < m.columns(); j++) {
  234. for (int k = 0; k < NC; k++) {
  235. rslt[i][j] = rslt[i][j] + massiv[i][k] * m[k][j];
  236. }
  237. }
  238. }
  239. return rslt;
  240. }
  241. std::cout << "Error" << std::endl;
  242. return nullptr;
  243. }
  244. Matrix operator * (double n) {
  245. Matrix rslt;
  246. rslt.set_size(NR, NC);
  247. for(int i = 0; i < NR; i++) rslt[i] = massiv[i] * n;
  248. return rslt;
  249. }
  250. bool operator == (Matrix m) {
  251. if(m.rows() != NR || m.columns() != NC) return false;
  252. for(int i = 0; i < NR; i++) if(massiv[i] != m[i]) return false;
  253. return true;
  254. }
  255. bool operator != (Matrix m) {
  256. if(m.rows() != NR || m.columns() != NC) return true;
  257. for(int i = 0; i < NR; i++) if(massiv[i] != m[i]) return true;
  258. return false;
  259. }
  260. int rows() {
  261. return NR;
  262. }
  263. int columns() {
  264. return NC;
  265. }
  266. void random(int a, int b, int R, int seed) {
  267. std::default_random_engine generator(seed);
  268. std::uniform_real_distribution<double> distribution(-R, R);
  269. NR = a;
  270. NC = b;
  271. delete[] massiv;
  272. massiv = new Vect[NR];
  273. for(int i = 0; i < NR; i++) {
  274. massiv[i] = new Vect();
  275. massiv[i].random(NC, &generator, &distribution);
  276. }
  277. }
  278. void set_size(int a, int b) {
  279. NC = b;
  280. int p = a < NR ? a : NR;
  281. Vect *buf = new Vect[NR = a];
  282. for(int i = 0; i < p; i++) {
  283. massiv[i].set_size(NC);
  284. buf[i] = massiv[i];
  285. }
  286. for(int i = p; i < NR; i++) {
  287. buf[i] = new Vect(NC);
  288. }
  289. delete[] massiv;
  290. massiv = buf;
  291.  
  292. }
  293. int sum() {
  294. int rslt = 0;
  295. for(int i = 0; i < NR; i++) rslt += massiv[i].sum();
  296. return rslt;
  297. }
  298. int trace() {
  299. int rslt = 0, p = NR < NC ? NR : NC;
  300. for(int i = 0; i < p; i++) rslt += massiv[i][i];
  301. return rslt;
  302. }
  303. void print() {
  304. for(int i = 0; i < NR; i++) massiv[i].print();
  305. }
  306. void swapRows(int a, int b) {
  307. Vect buf = massiv[a];
  308. massiv[a] = massiv[b];
  309. massiv[b] = buf;
  310. }
  311. void swapColumns(int a, int b) {
  312. for(int i = 0; i < NR; i++) {
  313. double buf = massiv[i][a];
  314. massiv[i][a] = massiv[i][b];
  315. massiv[i][b] = buf;
  316. }
  317. }
  318. void transpose() {
  319. int c = NC;
  320. NC = NR;
  321. NR = c;
  322. Vect* buf = new Vect[NR];
  323. for(int i = 0; i < NR; i++) {
  324. buf[i] = new Vect(NC);
  325. for(int j = 0; j < NC; j++) {
  326. buf[i][j] = massiv[j][i];
  327. }
  328. }
  329. delete[] massiv;
  330. massiv = buf;
  331. }
  332. Matrix getBlock(int y, int x, int a, int b) {
  333. Matrix rslt(a, b);
  334. for(int i = 0; i < a; i++) {
  335. for(int j = 0; j < b; j++) {
  336. rslt[i][j] = massiv[i+y][j+x];
  337. }
  338. }
  339. return rslt;
  340. }
  341. void putBlock(int y, int x, double** m, int a, int b) {
  342. for(int i = 0; i < a; i++) {
  343. for(int j = 0; j < b; j++) {
  344. massiv[i+y][j+x] = m[i][j];
  345. }
  346. }
  347. }
  348. void putBlock(int y, int x, Matrix m) {
  349. for(int i = 0; i < m.rows(); i++) {
  350. for(int j = 0; j < m.columns(); j++) {
  351. massiv[i+y][j+x] = m[i][j];
  352. }
  353. }
  354. }
  355. Matrix sumRows(int a, int b, double n) {
  356. Matrix rslt(*this);
  357. for(int i = 0; i < NC; i++) rslt[a][i] = massiv[a][i] + massiv[b][i] * n;
  358. return rslt;
  359. }
  360. ~Matrix() {
  361. delete[] massiv;
  362. }
  363. };
  364.  
  365. double func(Matrix m) {
  366. double max = 0;
  367. int a = m.rows();
  368. int b = m.columns();
  369. int n = b - a;
  370. for(int i = 0; i < a; i++) max += m[i][i];
  371. for(int i = 1; i <= n; i++) {
  372. int sum = 0;
  373. for(int j = 0; j < n; j++) sum += m[j][j+i];
  374. if(sum > max) max = sum;
  375. }
  376. return max;
  377.  
  378. }
  379. void prog() {
  380. int m, n;
  381. std::cout << "Vvedi m: ";
  382. std::cin >> m;
  383. std::cout << "Vvedi n: ";
  384. std::cin >> n;
  385. Matrix M(m, n);
  386. for(int i = 0; i < m; i++) {
  387. for(int j = 0; j < n; j++) {
  388. M[i][j]= rand();
  389. std::cout << M[i][j] << " ";
  390. }
  391. std::cout << std::endl;
  392. }
  393. std::cout << "Max summa: " << func(M) << std::endl;
  394. }
  395. int main() {
  396. prog();
  397. system("pause");
  398. return 0;
  399. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!