API tools faq
paste
Hexadroid

wappie

Hexadroid
Dec 24th, 2020
1,118
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 16.66 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <math.h>
  3. #include <random>
  4. #include <algorithm>
  5. #include <iterator>
  6. #include <iostream>
  7. #include <windows.h>
  8.  
  9. //disable or alter 'block x' if one changes the number of neurons.
  10. const int nr_neurons_A = 4;
  11. const int nr_neurons_B = 4;
  12. const int nr_neurons_C = 4;
  13. const int nr_neurons_D = 4;
  14. const int nr_neurons_E = 4;
  15. const int nr_neurons_F = 4;
  16. const int nr_neurons_G = 4;
  17. int tota = nr_neurons_A + nr_neurons_B + nr_neurons_C + nr_neurons_D + nr_neurons_E + nr_neurons_F + nr_neurons_G;
  18.  
  19. int Z;
  20. int A, B, C, D, E, F, G;
  21. int loops = 12660;
  22. int showtime = 0.50 * loops;
  23. int zrows = 99;
  24. int temp, i1, i2, rows, shuffled;
  25. int i, j;
  26. int showoutputs;
  27.  
  28. double xDD, gDD, fDD, eDD, dDD, cDD, bDD, zDD;
  29. double bDD_xupd, bDD_xbupd;
  30. double cDD_wupd, cDD_bupd;
  31. double dDD_wupd, dDD_bupd;
  32. double eDD_wupd, eDD_bupd;
  33. double fDD_wupd, fDD_bupd;
  34. double gDD_wupd, gDD_bupd;
  35. double zDD_wupd, zDD_bupd;
  36.  
  37. double membDD_xupd[nr_neurons_A][nr_neurons_B];
  38. double memBWC_xupd[nr_neurons_B][nr_neurons_C];
  39. double memCWD_xupd[nr_neurons_C][nr_neurons_D];
  40. double memDWD_xupd[nr_neurons_D][nr_neurons_E];
  41. double memEWD_xupd[nr_neurons_E][nr_neurons_F];
  42. double memFWD_xupd[nr_neurons_F][nr_neurons_G];
  43. double memGWD_xupd[nr_neurons_G];
  44.  
  45. double sqcalc, gemiddelde;
  46. double TOTAL, TOTALcCoD, TOTALao, TOTALbo, TOTALco, TOTALdo, TOTALeo, TOTALfo;
  47. double learn = 0.00000001;
  48. double xerr[nr_neurons_G], xerrtotal;
  49. double sqerrtot = 0;
  50.  
  51. bool training_mode = false;
  52.  
  53. double train_input[100][nr_neurons_A];
  54. double train_output[100][nr_neurons_G];
  55. double requested1[nr_neurons_A];
  56.  
  57. double gDD_times, fDD_times, eDD_times, dDD_times, cDD_times, bDD_times;
  58. double avgtot, aw, bw, cw, dw, ew, fw, gw;
  59. double tussen, row_0, row_1, row_2, row_3;
  60.  
  61. int tijdelijk;
  62.  
  63. struct MiddleNode {
  64.  
  65.   std::vector < double > w = std::vector < double > (256, 0.00);
  66.   std::vector < double > o = std::vector < double > (256, 0.00);
  67.   std::vector < double > bw = std::vector < double > (256, 0.00);
  68.   std::vector < double > b = std::vector < double > (256, 0.00);
  69.  
  70. };
  71.  
  72. struct InputNode {
  73.  
  74.   std::vector < double > w = std::vector < double > (256, 0.00);
  75.   std::vector < double > o = std::vector < double > (256, 0.00);
  76.   std::vector < double > bw = std::vector < double > (256, 0.00);
  77.   std::vector < double > b = std::vector < double > (256, 0.00);
  78.  
  79. };
  80.  
  81. struct OutputNode {
  82.  
  83.   std::vector < double > w = std::vector < double > (256, 0.00);
  84.   std::vector < double > o = std::vector < double > (256, 0.00);
  85.   std::vector < double > bw = std::vector < double > (256, 0.00);
  86.   std::vector < double > b = std::vector < double > (256, 0.00);
  87.  
  88. };
  89.  
  90. double choose(int x, int aa) {
  91.  
  92.   if (training_mode) return train_input[x][aa];
  93.   else return requested1[aa];
  94.  
  95. }
  96.  
  97. double initialize() {
  98.  
  99.   return ((rand() % 10000) / 10000.00);
  100.  
  101. }
  102.  
  103. double fd(double x) {
  104.  
  105.   return (x >= 0) ? (1) : (0);
  106.  
  107. }
  108.  
  109. double fx(double x) {
  110.  
  111.   return (x >= 0) ? (x) : (0);
  112.  
  113. }
  114.  
  115. int _tmain(int argc, _TCHAR * argv[]) {
  116.  
  117.   srand(time(NULL));
  118.  
  119.   std::random_device rd;
  120.   std::mt19937 gh(rd());
  121.  
  122.   learn = learn / tota;
  123.  
  124.   InputNode a[nr_neurons_A];
  125.   MiddleNode b[nr_neurons_B];
  126.   MiddleNode c[nr_neurons_C];
  127.   MiddleNode d[nr_neurons_D];
  128.   MiddleNode e[nr_neurons_E];
  129.   MiddleNode f[nr_neurons_F];
  130.   OutputNode g[nr_neurons_G];
  131.  
  132.   for (i = 0; i < zrows; i++) {
  133.  
  134.     for (j = 0; j < nr_neurons_A; j++) {
  135.                              //results will still fail at extreme low range or extreme high range of this set, afaik this is normal.
  136.  
  137.       train_input[i][j] = (i + 29.00) / (j + 1);
  138.       train_output[i][j] = 2.33 * pow(train_input[i][j], 2);//predict the outcome of this known calculation, as test. (verifiable)
  139.  
  140.     }
  141.  
  142.   }
  143.  
  144.   for (j = 0; j < nr_neurons_A; j++) {
  145.  
  146.     requested1[j] = 1.50 / (j + 1.00);
  147.  
  148.   }
  149.  
  150.   double input = 0;
  151.  
  152.   int i1, i2;
  153.  
  154.   for (i1 = 0; i1 < nr_neurons_A; i1++)
  155.     for (i2 = 0; i2 < nr_neurons_B; i2++) {
  156.       a[i1].w[i2] = initialize();
  157.       a[i1].bw[i2] = initialize();
  158.       a[i1].b[i2] = initialize();
  159.     }
  160.  
  161.   for (i1 = 0; i1 < nr_neurons_B; i1++)
  162.     for (i2 = 0; i2 < nr_neurons_C; i2++) {
  163.       b[i1].w[i2] = initialize();
  164.       b[i1].bw[i2] = initialize();
  165.       b[i1].b[i2] = initialize();
  166.     }
  167.  
  168.   for (i1 = 0; i1 < nr_neurons_C; i1++)
  169.     for (i2 = 0; i2 < nr_neurons_D; i2++) {
  170.       c[i1].w[i2] = initialize();
  171.       c[i1].bw[i2] = initialize();
  172.       c[i1].b[i2] = initialize();
  173.     }
  174.  
  175.   for (i1 = 0; i1 < nr_neurons_D; i1++)
  176.     for (i2 = 0; i2 < nr_neurons_E; i2++) {
  177.       d[i1].w[i2] = initialize();
  178.       d[i1].bw[i2] = initialize();
  179.       d[i1].b[i2] = initialize();
  180.     }
  181.  
  182.   for (i1 = 0; i1 < nr_neurons_E; i1++)
  183.     for (i2 = 0; i2 < nr_neurons_F; i2++) {
  184.       e[i1].w[i2] = initialize();
  185.       e[i1].bw[i2] = initialize();
  186.       e[i1].b[i2] = initialize();
  187.     }
  188.  
  189.   for (i1 = 0; i1 < nr_neurons_F; i1++)
  190.     for (i2 = 0; i2 < nr_neurons_G; i2++) {
  191.       f[i1].w[i2] = initialize();
  192.       f[i1].bw[i2] = initialize();
  193.       f[i1].b[i2] = initialize();
  194.     }
  195.  
  196.   for (i1 = 0; i1 < nr_neurons_G; i1++) {
  197.     g[i1].w[0] = initialize();
  198.     g[i1].bw[0] = initialize();
  199.     g[i1].b[0] = initialize();
  200.   }
  201.  
  202.   sqcalc = 99999999.99;
  203.   for (temp = 0; temp < loops; temp++) {
  204.  
  205.     for (rows = 0; rows < zrows+1; rows++) {
  206.     //rows = rand() % (zrows + 1); {
  207.  
  208.       shuffled = rows;
  209.  
  210.       if (shuffled == zrows) training_mode = false;
  211.       else training_mode = true;;
  212.  
  213.       TOTALbo = 0;
  214.       TOTALao = 0;
  215.       for (C = 0; C < nr_neurons_C; C++) {
  216.  
  217.         for (B = 0; B < nr_neurons_B; B++) {
  218.           TOTAL = 0;
  219.           for (A = 0; A < nr_neurons_A; A++) {
  220.  
  221.             if (C == 0) {
  222.               TOTALao += (a[A].o[B] = fx(choose(shuffled, A) * a[A].w[B] /*+ a[A].bw[B] * a[A].b[B]*/ ));
  223.  
  224.             }
  225.  
  226.             TOTAL += a[A].o[B] * b[B].w[C];
  227.           }
  228.  
  229.           TOTALbo += (b[B].o[C] = fx(TOTAL /*+ b[B].bw[C] * b[B].b[C]*/ ));
  230.  
  231.         }
  232.  
  233.       }
  234.  
  235.       TOTALdo = 0;
  236.       TOTALco = 0;
  237.  
  238.       for (E = 0; E < nr_neurons_E; E++) {
  239.         for (D = 0; D < nr_neurons_D; D++) {
  240.           TOTAL = 0;
  241.           TOTALcCoD = 0;
  242.           for (C = 0; C < nr_neurons_C; C++) {
  243.  
  244.             if (E == 0) {
  245.  
  246.               //double TOTALcCoD = 0;
  247.               for (B = 0; B < nr_neurons_B; B++) {
  248.                 TOTALcCoD += b[B].o[C] * c[C].w[D];
  249.               }
  250.  
  251.               TOTALco += (c[C].o[D] = fx(TOTALcCoD /*+ c[C].bw[D] * c[C].b[D]*/ ));
  252.  
  253.             }
  254.  
  255.             TOTAL += c[C].o[D] * d[D].w[E];
  256.  
  257.           }
  258.  
  259.           TOTALdo += (d[D].o[E] = fx(TOTAL /*+ d[D].bw[E] * d[D].b[E]*/ ));
  260.  
  261.         }
  262.  
  263.       }
  264.  
  265.       TOTALeo = 0;
  266.       for (F = 0; F < nr_neurons_F; F++) {
  267.         for (E = 0; E < nr_neurons_E; E++) {
  268.           TOTAL = 0;
  269.           for (D = 0; D < nr_neurons_D; D++) {
  270.             TOTAL += d[D].o[E] * e[E].w[F];
  271.           }
  272.           TOTALeo += (e[E].o[F] = fx(TOTAL /*+ e[E].bw[F] * e[E].b[F]*/ ));
  273.  
  274.         }
  275.  
  276.       }
  277.  
  278.       TOTALfo = 0;
  279.       for (G = 0; G < nr_neurons_G; G++) {
  280.         for (F = 0; F < nr_neurons_F; F++) {
  281.           TOTAL = 0;
  282.           for (E = 0; E < nr_neurons_E; E++) {
  283.             TOTAL += e[E].o[F] * f[F].w[G];
  284.           }
  285.  
  286.           TOTALfo += (f[F].o[G] = fx(TOTAL /*+ f[F].bw[G] * f[F].b[G]*/ ));
  287.  
  288.         }
  289.  
  290.       }
  291.  
  292.       for (G = 0; G < nr_neurons_G; G++) {
  293.         TOTAL = 0;
  294.         for (F = 0; F < nr_neurons_F; F++) {
  295.           TOTAL += f[F].o[G] * g[G].w[0];
  296.         }
  297.  
  298.         g[G].o[0] = fx(TOTAL /*+ g[G].bw[0] * g[G].b[0]*/ );
  299.  
  300.       }
  301.  
  302.       if (temp > showtime) {
  303.  
  304.         if (training_mode) {
  305.           printf("\n-");
  306.           for (showoutputs = 0; showoutputs < nr_neurons_G; showoutputs++) {
  307.  
  308.             printf("\n input: %.2lf The current output_%d for training set[%d] is %.28lf of (%lf)", train_input[shuffled][showoutputs], showoutputs, shuffled, g[showoutputs].o[0], train_output[shuffled][showoutputs]);
  309.  
  310.           }
  311.         } else {
  312.  
  313.           for (showoutputs = 0; showoutputs < nr_neurons_G; showoutputs++) {
  314.  
  315.             printf("\n(loop: % d) output_%d for requested data (%.28lf) is currently : %.8lf  (should be:%lf)", temp, showoutputs, requested1[showoutputs], g[showoutputs].o[0], 2.00 * pow(requested1[showoutputs], 2));
  316.  
  317.           }
  318.  
  319.         }
  320.  
  321.       }
  322.  
  323.       xerrtotal = 0;
  324.       if (training_mode) {
  325.         for (showoutputs = 0; showoutputs < nr_neurons_G; showoutputs++) {
  326.           xerr[showoutputs] = 2 * (g[showoutputs].o[0] - train_output[shuffled][showoutputs]);
  327.  
  328.           xerrtotal += (xerr[showoutputs]);
  329.         }
  330.  
  331.         sqerrtot = xerrtotal;
  332.  
  333.  
  334.  
  335.  
  336.  
  337.         tijdelijk = 0.00;
  338.  
  339.         xDD = learn;//*xerrtotal;
  340.         gDD_times = xDD;
  341.         avgtot = 0;
  342.         aw = 0;
  343.         bw = 0;
  344.         cw = 0;
  345.         dw = 0;
  346.         ew = 0;
  347.         fw = 0;
  348.         gw = 0;
  349.  
  350.         row_0=0; row_1=0; row_2=0; row_3=0;
  351.  
  352.  
  353.         for (G = 0; G < nr_neurons_G; G++) gDD_times *= g[G].w[0];
  354.         fDD_times = gDD_times;
  355.         for (G = 0; G < nr_neurons_G; G++) {
  356.           for (F = 0; F < nr_neurons_F; F++) fDD_times *= f[F].w[G];
  357.         }
  358.         eDD_times = fDD_times;
  359.         for (F = 0; F < nr_neurons_F; F++) {
  360.           for (E = 0; E < nr_neurons_E; E++) eDD_times *= e[E].w[F];
  361.         }
  362.         dDD_times = eDD_times;
  363.         for (E = 0; E < nr_neurons_E; E++) {
  364.           for (D = 0; D < nr_neurons_D; D++) dDD_times *= d[D].w[E];
  365.         }
  366.         cDD_times = dDD_times;
  367.         for (D = 0; D < nr_neurons_D; D++) {
  368.           for (C = 0; C < nr_neurons_C; C++) cDD_times *= c[C].w[D];
  369.         }
  370.         bDD_times = cDD_times;
  371.         for (C = 0; C < nr_neurons_C; C++) {
  372.           for (B = 0; B < nr_neurons_B; B++) bDD_times *= b[B].w[C];
  373.         }
  374.  
  375.  
  376.         //slower but more precise
  377.         for (G = 0; G < nr_neurons_G; G++) {
  378.  
  379.           zDD_wupd = TOTALfo * learn * xerr[G];
  380.           gDD = learn * xerr[G] * g[G].w[0];
  381.           gDD_wupd = TOTALeo * gDD;
  382.  
  383.           tussen = fd(g[G].o[0]) * zDD_wupd;
  384.           g[G].w[0] -= tussen;
  385.           //g[G].w[0] -= new_avgtot;
  386.           //g[G].w[0] -= new_gw;
  387.           gw += tussen;
  388.           avgtot += tussen;
  389.           if (G == 0) row_0 += tussen;
  390.           if (G == 1) row_1 += tussen;
  391.           if (G == 2) row_2 += tussen;
  392.           if (G == 3) row_3 += tussen;
  393.  
  394.           for (F = 0; F < nr_neurons_F; F++) {
  395.  
  396.             fDD_wupd = TOTALdo * fDD_times;
  397.  
  398.             tussen = fd(f[F].o[G]) * gDD_wupd;
  399.             f[F].w[G] -= tussen;
  400.             //f[F].w[G] -= new_avgtot;
  401.             //f[F].w[G] -= new_fw;
  402.             fw += tussen;     tijdelijk++;
  403.             avgtot += tussen;
  404.             if (F == 0) row_0 += tussen;
  405.             if (F == 1) row_1 += tussen;
  406.             if (F == 2) row_2 += tussen;
  407.             if (F == 3) row_3 += tussen;
  408.  
  409.             for (E = 0; E < nr_neurons_E; E++) {
  410.               eDD_wupd = TOTALco * eDD_times;
  411.  
  412.               tussen = fd(e[E].o[F]) * fDD_wupd;
  413.               e[E].w[F] -= tussen;
  414.               //e[E].w[F] -= new_avgtot;
  415.               //e[E].w[F] -= new_ew;
  416.               ew += tussen;
  417.               avgtot += tussen;
  418.               if (E == 0) row_0 += tussen;
  419.               if (E == 1) row_1 += tussen;
  420.               if (E == 2) row_2 += tussen;
  421.               if (E == 3) row_3 += tussen;
  422.  
  423.               for (D = 0; D < nr_neurons_D; D++) {
  424.                 dDD_wupd = TOTALbo * dDD_times;
  425.  
  426.                 tussen = fd(d[D].o[E]) * eDD_wupd;
  427.                 d[D].w[E] -= tussen;
  428.                 //d[D].w[E] -= new_avgtot;
  429.                 //d[D].w[E] -= new_dw;
  430.                 dw += tussen;
  431.                 avgtot += tussen;
  432.                 if (D == 0) row_0 += tussen;
  433.                 if (D == 1) row_1 += tussen;
  434.                 if (D == 2) row_2 += tussen;
  435.                 if (D == 3) row_3 += tussen;
  436.  
  437.                 for (C = 0; C < nr_neurons_C; C++) {
  438.  
  439.                   cDD_wupd = TOTALao * cDD_times;
  440.  
  441.                   tussen = fd(c[C].o[D]) * dDD_wupd;
  442.                   c[C].w[D] -= tussen;
  443.                   //c[C].w[D] -= new_avgtot;
  444.                   //c[C].w[D] -= new_cw;
  445.                   cw += tussen;
  446.                   avgtot += tussen;
  447.                   if (C == 0) row_0 += tussen;
  448.                   if (C == 1) row_1 += tussen;
  449.                   if (C == 2) row_2 += tussen;
  450.                   if (C == 3) row_3 += tussen;
  451.  
  452.                   for (B = 0; B < nr_neurons_B; B++) {
  453.  
  454.                     tussen = fd(b[B].o[C]) * cDD_wupd;
  455.                     b[B].w[C] -= tussen;
  456.                     //b[B].w[C] -= new_avgtot;
  457.                     //b[B].w[C] -= new_bw;
  458.                     bw += tussen;
  459.                     avgtot += tussen;
  460.                     if (B == 0) row_0 += tussen;
  461.                     if (B == 1) row_1 += tussen;
  462.                     if (B == 2) row_2 += tussen;
  463.                     if (B == 3) row_3 += tussen;
  464.  
  465.                     for (A = 0; A < nr_neurons_A; A++) {
  466.  
  467.                       tussen = train_input[shuffled][A] * fd(a[A].o[B]) * bDD_times;
  468.                       a[A].w[B] -= tussen;
  469.                       //a[A].w[B] -= new_avgtot;
  470.                       //a[A].w[B] -= new_aw;
  471.                       aw += tussen;
  472.                       avgtot += tussen;
  473.                       if (A == 0) row_0 += tussen;
  474.                       if (A == 1) row_1 += tussen;
  475.                       if (A == 2) row_2 += tussen;
  476.                       if (A == 3) row_3 += tussen;
  477.  
  478.                     }
  479.  
  480.                   }
  481.  
  482.                 }
  483.  
  484.               }
  485.  
  486.             }
  487.  
  488.           }
  489.  
  490.         }
  491.  
  492.  
  493.         //printf("\ntijdelijk %d",tijdelijk);
  494.  
  495.  
  496.  
  497.         //BLOCK X BEGIN
  498.  
  499.         //new_avgtot = avgtot / 21844;
  500.         avgtot = avgtot / 21844;
  501.  
  502.         aw = aw / 16384;
  503.         bw = bw / 4096;
  504.         cw = cw / 1024;
  505.         dw = dw / 256;
  506.         ew = ew / 64;
  507.         fw = fw / 16;
  508.         gw = gw / 4;
  509.  
  510.         row_0 = row_0 / 21844;
  511.         row_1 = row_1 / 21844;
  512.         row_2 = row_2 / 21844;
  513.         row_3 = row_3 / 21844;
  514.  
  515.         for (G = 0; G < nr_neurons_G; G++) {
  516.  
  517.           g[G].w[0] -= avgtot; //average change for all nodes
  518.           g[G].w[0] -= gw; //average change for this 'block'
  519.           if (G == 0) g[G].w[0] -= row_0;
  520.           if (G == 1) g[G].w[0] -= row_1;
  521.           if (G == 2) g[G].w[0] -= row_2;
  522.           if (G == 3) g[G].w[0] -= row_3;
  523.  
  524.           for (F = 0; F < nr_neurons_F; F++) {
  525.  
  526.             f[F].w[G] -= avgtot;
  527.             f[F].w[G] -= fw;
  528.             if (F == 0) f[F].w[G] -= row_0;
  529.             if (F == 1) f[F].w[G] -= row_1;
  530.             if (F == 2) f[F].w[G] -= row_2;
  531.             if (F == 3) f[F].w[G] -= row_3;
  532.  
  533.           }
  534.         }
  535.  
  536.         for (F = 0; F < nr_neurons_F; F++) {
  537.  
  538.           for (E = 0; E < nr_neurons_E; E++) {
  539.  
  540.             e[E].w[F] -= avgtot;
  541.             e[E].w[F] -= ew;
  542.  
  543.             if (E == 0) e[E].w[F] -= row_0;
  544.             if (E == 1) e[E].w[F] -= row_1;
  545.             if (E == 2) e[E].w[F] -= row_2;
  546.             if (E == 3) e[E].w[F] -= row_3;
  547.  
  548.           }
  549.         }
  550.  
  551.         for (E = 0; E < nr_neurons_E; E++) {
  552.  
  553.           for (D = 0; D < nr_neurons_D; D++) {
  554.  
  555.             d[D].w[E] -= avgtot;
  556.             d[D].w[E] -= dw;
  557.  
  558.             if (D == 0) d[D].w[E] -= row_0;
  559.             if (D == 1) d[D].w[E] -= row_1;
  560.             if (D == 2) d[D].w[E] -= row_2;
  561.             if (D == 3) d[D].w[E] -= row_3;
  562.  
  563.           }
  564.         }
  565.  
  566.         for (D = 0; D < nr_neurons_D; D++) {
  567.  
  568.           for (C = 0; C < nr_neurons_C; C++) {
  569.  
  570.             c[C].w[D] -= avgtot;
  571.             c[C].w[D] -= cw;
  572.  
  573.             if (C == 0) c[C].w[D] -= row_0;
  574.             if (C == 1) c[C].w[D] -= row_1;
  575.             if (C == 2) c[C].w[D] -= row_2;
  576.             if (C == 3) c[C].w[D] -= row_3;
  577.  
  578.           }
  579.         }
  580.  
  581.         for (C = 0; C < nr_neurons_C; C++) {
  582.  
  583.           for (B = 0; B < nr_neurons_B; B++) {
  584.  
  585.             b[B].w[C] -= avgtot;
  586.             b[B].w[C] -= bw;
  587.  
  588.             if (B == 0) b[B].w[C] -= row_0;
  589.             if (B == 1) b[B].w[C] -= row_1;
  590.             if (B == 2) b[B].w[C] -= row_2;
  591.             if (B == 3) b[B].w[C] -= row_3;
  592.  
  593.           }
  594.         }
  595.  
  596.         for (B = 0; B < nr_neurons_B; B++) {
  597.  
  598.           for (A = 0; A < nr_neurons_A; A++) {
  599.  
  600.             a[A].w[B] -= avgtot;
  601.             a[A].w[B] -= aw;
  602.  
  603.             if (A == 0) a[A].w[B] -= row_0;
  604.             if (A == 1) a[A].w[B] -= row_1;
  605.             if (A == 2) a[A].w[B] -= row_2;
  606.             if (A == 3) a[A].w[B] -= row_3;
  607.  
  608.           }
  609.         }
  610.  
  611.         //BLOCK X END
  612.  
  613.       }
  614.  
  615.     }
  616.  
  617.     if (!(temp % (showtime / 100))) printf("\n %d %%", ++Z);
  618.  
  619.     sqcalc += sqerrtot;
  620.  
  621.     if (temp % 1000 == 0) {
  622.       gemiddelde = sqcalc / 1000;
  623.       sqcalc = 0;
  624.     }
  625.  
  626.     sqerrtot = 0;
  627.  
  628.   }
  629.  
  630.   printf("\nEnd.");
  631.   scanf("%d", & Z);
  632.  
  633.   return 0;
  634.  
  635. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!