API tools faq
paste
Advertisement
Maco153

Kmap three variables

Maco153
Mar 21st, 2020
233
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.58 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  
  3. Project: Digital Design 1
  4. Kmap for three inputs
  5.  
  6. Group: Mohamed Basiouny
  7. Mahmoud Elshinawy
  8.  
  9.  
  10.  
  11. */
  12.  
  13. #include <iostream>
  14. #include <vector>
  15. using namespace std;
  16.  
  17. struct cell {
  18. int A, B, C, value=0,dec=0;
  19. };
  20.  
  21. void set_zero(cell kmap_arr[][4]) {
  22.  
  23. for (int i = 0; i < 2; i++) {
  24. for (int j = 0; j < 4; j++) {
  25. kmap_arr[i][j].value = 0;
  26. }
  27. }
  28. }
  29.  
  30. void set_dec(cell kmap_arr[][4]) {
  31.  
  32. for (int i = 0; i < 2; i++) {
  33.  
  34.  
  35. for (int j = 0; j < 4; j++) {
  36. if (i==0)
  37. kmap_arr[i][j].dec = j;
  38. else if(i==1)
  39. kmap_arr[i][j].dec = j+4;
  40.  
  41. }
  42. }
  43.  
  44. swap(kmap_arr[0][2], kmap_arr[0][3]);
  45. swap(kmap_arr[1][2], kmap_arr[1][3]);
  46. }
  47.  
  48. void set_literals(cell kmap_arr[][4]) {
  49. for (int i = 0; i < 2; i++) {
  50. for (int j = 0; j < 4; j++) {
  51. if (i == 0) {
  52. kmap_arr[i][j].A = 0;
  53. }
  54. if (i == 1) {
  55. kmap_arr[i][j].A = 1;
  56. }
  57. switch (j) {
  58. case 0:
  59. kmap_arr[i][j].B = 0;
  60. kmap_arr[i][j].C = 0;
  61. break;
  62. case 1:
  63. kmap_arr[i][j].B = 0;
  64. kmap_arr[i][j].C = 1;
  65. break;
  66. case 2:
  67. kmap_arr[i][j].B = 1;
  68. kmap_arr[i][j].C = 1;
  69. break;
  70. case 3:
  71. kmap_arr[i][j].B = 1;
  72. kmap_arr[i][j].C = 0;
  73. break;
  74. }
  75. }
  76. }
  77.  
  78.  
  79. }
  80.  
  81. void set_map(cell kmap_arr[][4]) {
  82. set_zero(kmap_arr);
  83. set_dec(kmap_arr);
  84. set_literals(kmap_arr);
  85. }
  86.  
  87. void input_user(cell kmap_arr[][4],int input [],int min_number) {
  88. cout << "enter the location of your minterms" << endl;
  89. for (int i = 0; i < min_number; i++) {
  90. cin >> input[i];
  91. while ((input[i] < 0) || (input[i] > 7)) {
  92. cout << "Please enter a number between 0 & 7" << endl;
  93. cin >> input[i];
  94. }
  95.  
  96. for (int k = 0; k < 2; k++) {
  97. for (int j = 0; j < 4; j++) {
  98. if (kmap_arr[k][j].dec == input[i]) {
  99. kmap_arr[k][j].value = 1;
  100. break;
  101. }
  102. }
  103. }
  104. }
  105.  
  106. }
  107.  
  108. void print_map(cell kmap_arr[][4]) {
  109. for (int i = 0; i < 2; i++) {
  110. for (int j = 0; j < 4; j++) {
  111. cout << kmap_arr[i][j].value << "\t";
  112. }
  113. cout << endl;
  114. }
  115. }
  116.  
  117. bool isAll_thesame(cell kmap_arr[][4],int a) {
  118. for (int i = 0; i < 2; i++) {
  119. for (int j = 0; j < 4;j++) {
  120. if (kmap_arr[i][j].value != a)
  121. return false;
  122.  
  123.  
  124. }
  125.  
  126.  
  127. }
  128. return true;
  129.  
  130. }
  131.  
  132. void print_func(vector<cell>& kmap) {
  133. bool flag = true; int i = 0;
  134. while (flag && i<int(kmap.size() - 1)) {
  135. if (kmap[i].A != kmap[i + 1].A)
  136. flag = false;
  137. else
  138. i++;
  139. }
  140. if (flag) {
  141. if (kmap[0].A == 0)
  142. cout << "~A";
  143. else if (kmap[0].A == 1)
  144. cout << "A";
  145. }
  146.  
  147. flag = true; i = 0;
  148. while (flag && i<int(kmap.size() - 1)) {
  149. if (kmap[i].B != kmap[i + 1].B)
  150. flag = false;
  151. else
  152. i++;
  153. }
  154. if (flag) {
  155. if (kmap[0].B == 0)
  156. cout << "~B";
  157. else if (kmap[0].B == 1)
  158. cout << "B";
  159. }
  160.  
  161. flag = true; i = 0;
  162. while (flag && i<int(kmap.size() - 1)) {
  163. if (kmap[i].C != kmap[i + 1].C)
  164. flag = false;
  165. else
  166. i++;
  167. }
  168. if (flag) {
  169. if (kmap[0].C == 0)
  170. cout << "~C";
  171. else if (kmap[0].C == 1)
  172. cout << "C";
  173. }
  174.  
  175. cout << " + ";
  176. }
  177.  
  178. void map_delete(vector<cell>& kmap, int num) {
  179. for (int i = 0; i < num; i++)
  180. kmap.pop_back();
  181. }
  182. void transfer_bool(bool& a,bool& b) {
  183. b = a;
  184. }
  185.  
  186. int main() {
  187. cell kmap_arr[2][4];
  188. set_map(kmap_arr);
  189. vector <cell> kmap;
  190. vector<cell> copy;
  191.  
  192. int min_number;
  193. cout << "How many minterms do you have\n";
  194. cin >> min_number;
  195. while (min_number > 8)
  196. {
  197. cout << "ERROR! PLEASE RE-ENTER A VALUE BETWEEN 0 & 8" << endl;
  198. cin >> min_number;
  199. }
  200.  
  201. int* input;
  202. input = new int[min_number];
  203. input_user(kmap_arr, input, min_number);
  204. print_map(kmap_arr);
  205.  
  206. /* ----------------------------------------------------------------------------------------------------------- */
  207. if (isAll_thesame(kmap_arr, 1))
  208. cout << "f= 1" << endl;
  209. if (isAll_thesame(kmap_arr, 0) || min_number == 0)
  210. cout << "f= 0" << endl;
  211.  
  212.  
  213. if (!isAll_thesame(kmap_arr,1)&&!isAll_thesame(kmap_arr,0)){
  214. bool flag = true; bool cons = true; bool pros = true; bool squareflag = true; bool four_below = true;
  215. cout << "f= ";
  216. if (kmap_arr[0][0].value == 1 && kmap_arr[0][3].value == 1 && kmap_arr[1][0].value == 1 && kmap_arr[1][3].value == 1) {
  217.  
  218. flag = false;
  219. copy.push_back(kmap_arr[0][0]);
  220. copy.push_back(kmap_arr[0][3]);
  221. copy.push_back(kmap_arr[1][0]);
  222. copy.push_back(kmap_arr[1][3]);
  223.  
  224. print_func(copy);
  225. map_delete(copy, copy.size());
  226. }
  227.  
  228.  
  229. int k(0), s(0);
  230. for (int i = 0; i < 2; i++) {
  231. for (int j = 0; j < 4; j++) {
  232. k = i; s = j;
  233. if (i == 0) {
  234. if (j == 0) {
  235. if (kmap_arr[k][s].value == 1) {
  236. kmap.push_back(kmap_arr[k][s]);
  237. s++;
  238. while (s < 4 && kmap_arr[k][s].value == 1) {
  239.  
  240. kmap.push_back(kmap_arr[k][s]);
  241. s++;
  242.  
  243. }
  244.  
  245. if (kmap.size() == 4) {
  246. print_func(kmap);
  247. map_delete(kmap, 4);
  248. cons = false;
  249. pros = false;
  250. }
  251. map_delete(kmap, kmap.size());
  252. k = i; s = j; int change(0);
  253.  
  254. //here comes some coding
  255. while (change < 4) {
  256. if (kmap_arr[k][s].value == 1) {
  257. kmap.push_back(kmap_arr[k][s]);
  258. }
  259. if (change == 0)
  260. s++;
  261.  
  262. else if (change == 1) {
  263. s = j;
  264. k++;
  265. }
  266. else if (change == 2)
  267. s++;
  268. change++;
  269. }
  270.  
  271. if (kmap.size() == 4) {
  272. print_func(kmap);
  273. map_delete(kmap, 4);
  274. squareflag = false;
  275. }
  276.  
  277. else if (kmap.size() == 3) {
  278. if (kmap_arr[i + 1][j + 1].value == 0) {
  279. copy.push_back(kmap[0]);
  280. copy.push_back(kmap[2]);
  281. map_delete(kmap, 1);
  282. if (cons)
  283. print_func(kmap);
  284. if (flag) {
  285. print_func(copy);
  286. }
  287. map_delete(kmap, kmap.size());
  288. map_delete(copy, copy.size());
  289. }
  290. else if (kmap_arr[1][0].value == 0) {
  291. map_delete(kmap, 1);
  292. if (cons) {
  293. print_func(kmap);
  294. map_delete(kmap, kmap.size());
  295. }
  296. }
  297. else if (kmap_arr[0][1].value == 0) {
  298. copy.push_back(kmap[0]);
  299. copy.push_back(kmap[1]);
  300. if (flag) {
  301. print_func(copy);
  302. }
  303. map_delete(copy, copy.size());
  304. }
  305. }
  306. else if (kmap.size() == 2) {
  307. if (kmap_arr[i + 1][j + 1].value == 0) {
  308. if (kmap_arr[0][1].value == 1)
  309. print_func(kmap);
  310. else
  311. if (flag)
  312. print_func(kmap);
  313. }
  314. else {
  315. map_delete(kmap, 1);
  316. if (kmap_arr[0][3].value == 1)
  317. if (flag) {
  318. kmap.push_back(kmap_arr[0][3]);
  319. print_func(kmap);
  320. map_delete(kmap, kmap.size());
  321. }
  322.  
  323. }
  324. }
  325. else if (kmap.size() == 1) {
  326. if (kmap_arr[0][3].value == 1)
  327. if (flag) {
  328. kmap.push_back(kmap_arr[0][3]);
  329. print_func(kmap);
  330. map_delete(kmap, kmap.size());
  331. }
  332. }
  333.  
  334. map_delete(kmap, kmap.size());
  335. map_delete(copy, copy.size());
  336.  
  337. }
  338. }
  339.  
  340. else {
  341. int k2(0), s2(0);
  342. if (kmap_arr[i][j].value == 1) {
  343. k2 = i; s2 = j; int change2(0);
  344.  
  345.  
  346. while (change2 < 4) {
  347. if (kmap_arr[k2][s2].value == 1) {
  348. kmap.push_back(kmap_arr[k2][s2]);
  349. }
  350. if (change2 == 0)
  351. s2++;
  352.  
  353. else if (change2 == 1) {
  354. s2 = j;
  355. k2++;
  356. }
  357. else if (change2 == 2)
  358. s2++;
  359. change2++;
  360. }
  361.  
  362. if (kmap.size() == 4) {
  363. print_func(kmap);
  364. map_delete(kmap, 4);
  365. squareflag = false;
  366. }
  367. else if (kmap.size() == 3) {
  368. if (kmap_arr[i + 1][j + 1].value == 0) {
  369. copy.push_back(kmap[0]);
  370. copy.push_back(kmap[2]);
  371. map_delete(kmap, 1);
  372.  
  373. if (cons) {
  374. print_func(kmap);
  375. }
  376. if (squareflag) {
  377. print_func(copy);
  378. }
  379. }
  380. else if (kmap_arr[i + 1][j].value == 0) {
  381. map_delete(kmap, 1);
  382. if (pros) {
  383. print_func(kmap);
  384. }
  385.  
  386.  
  387. }
  388. else if (kmap_arr[i][j + 1].value == 0) {
  389. map_delete(kmap, 1);
  390. if (squareflag) {
  391. print_func(kmap);
  392. }
  393.  
  394. }
  395. squareflag = false;
  396. }
  397. else if (kmap.size() == 2) {
  398. if (kmap_arr[i + 1][j + 1].value == 0) {
  399. if (kmap_arr[i][j + 1].value == 1)
  400. if (pros)
  401. print_func(kmap);
  402. else
  403. if (squareflag)
  404. print_func(kmap);
  405.  
  406. }
  407. else {
  408. map_delete(kmap, 1);
  409. if (kmap_arr[i][j - 1].value == 0)
  410. print_func(kmap);
  411.  
  412. map_delete(kmap, kmap.size());
  413.  
  414.  
  415. }
  416. squareflag = false;
  417. }
  418. else if (kmap.size() == 1) {
  419. if (j == 3) {
  420. if (kmap_arr[0][0].value == 0)
  421. print_func(kmap);
  422. }
  423. else {
  424. if (kmap_arr[i][j - 1].value == 0)
  425. print_func(kmap);
  426. }
  427. squareflag = false;
  428. }
  429. map_delete(kmap, kmap.size());
  430. map_delete(copy, copy.size());
  431. }
  432. }
  433. }
  434. else if (i == 1) {
  435. int k3 = i, s3 = j;
  436. if (kmap_arr[0][j].value == 0 || kmap_arr[0][j + 1].value == 0) {
  437. if (kmap_arr[k3][s3].value == 1) {
  438. kmap.push_back(kmap_arr[k3][s3]);
  439. s3++;
  440. while (s3 < 4 && kmap_arr[k3][s3].value == 1) {
  441. kmap.push_back(kmap_arr[k3][s3]);
  442. s3++;
  443. }
  444. if (kmap.size() == 4) {
  445. print_func(kmap);
  446. map_delete(kmap, 4);
  447. four_below = false;
  448. }
  449. else if (kmap.size() == 3) {
  450.  
  451. map_delete(kmap, 1);
  452. if (four_below)
  453. print_func(kmap);
  454.  
  455. map_delete(kmap, kmap.size());
  456.  
  457. }
  458.  
  459. else if (kmap.size() == 2) {
  460. if (four_below)
  461. print_func(kmap);
  462. map_delete(kmap, kmap.size());
  463.  
  464. }
  465. else if (kmap.size() == 1) {
  466. if (kmap_arr[0][j].value == 0 && kmap_arr[0][j + 1].value == 0) {
  467. if (j == 0) {
  468. if (kmap_arr[1][3].value == 1) {
  469. if (flag) {
  470. kmap.push_back(kmap_arr[1][3]);
  471. print_func(kmap);
  472. map_delete(kmap, kmap.size());
  473. }
  474. }
  475. else if (j == 3) {
  476. if (kmap_arr[1][0].value == 0 && kmap_arr[1][2].value == 0) {
  477. print_func(kmap);
  478. map_delete(kmap, kmap.size());
  479. }
  480. }
  481. else {
  482. if (kmap_arr[i][j - 1].value == 0)
  483. print_func(kmap);
  484. map_delete(kmap, kmap.size());
  485. }
  486. }
  487. }
  488. }
  489. }
  490. }
  491. }
  492. }
  493. map_delete(kmap, kmap.size());
  494. map_delete(copy, copy.size());
  495. }
  496. }
  497. cout << "\b\b" << " " << endl; // to overwrite the last + sign with space character
  498. delete[] input;
  499. return 0;
  500. }
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!