/assn2/src/tests/test.c

https://github.com/gnidan/cs650 · C · 274 lines · 63 code · 73 blank · 138 comment · 12 complexity · 3e17cb56906ceaf498a3dec6f5b78e82 MD5 · raw file 

    

  1. #include <complex.h>
    2. 

  2. #include <stdio.h>
    3. 

  3. #include <stdlib.h>
    4. 

  4. #include <math.h>
    5. 

  5. 

  6. #include "out.c"
    7. 

  7. 

  8. 

  9. #define M_PI 3.14159265358979323846
    10. 

  10. 

  11. 

  12. /**
    13. 

  13.  * @brief Compare the observed column of the DFT matrix with the actual column.
    14. 

  14.  *
    15. 

  15.  * @param col     The observed column.
    16. 

  16.  * @param col_num Which column in the matrix we're looking at.
    17. 

  17.  * @param size    The size of the DFT matrix.
    18. 

  18.  *
    19. 

  19.  * @return 1 if the columns match, 0 otherwise
    20. 

  20.  */
    21. 

  21. unsigned int compare_col (complex double *col, size_t col_num, size_t size)
    22. 

  22. {
    23. 

  23.   static const double TOL = 0.001;
    24. 

  24.   double omega_r, omega_i, o_r, o_i, a, b;
    25. 

  25.   unsigned int i;
    26. 

  26. 

  27.   /* 0th column should be all 1.0 + 0.0 * I */
    28. 

  28.   if ( col_num == 0 )
    29. 

  29.     for ( i = 0; i < size; ++i )
    30. 

  30.       if ( (fabs (creal(col[i]) - 1.0) > TOL) || 
    31. 

  31. 	   (fabs (cimag(col[i]) - 0.0) > TOL) )
    32. 

  32. 	return 0;
    33. 

  33.   
    34. 

  34.  
    35. 

  35.   /* 0th row should always be 1.0 + 0.0 * I */
    36. 

  36.   if ( (fabs (creal(col[0]) - 1.0) > TOL ) ||
    37. 

  37.        (fabs (cimag(col[0]) - 0.0) > TOL ) )
    38. 

  38.     return 0;
    39. 

  39. 

  40.   
    41. 

  41.   /* calculate the primitive nth root of unity */
    42. 

  42.   omega_r = cos (2 * M_PI / (float) size);
    43. 

  43.   omega_i = sin (2 * M_PI / (float) size);
    44. 

  44.   
    45. 

  45.   /* set o_r and o_i to represents omeaga^col_num */
    46. 

  46.   o_r = 1.0;
    47. 

  47.   o_i = 0.0;
    48. 

  48.   for ( i = 0; i < col_num; ++i )
    49. 

  49.     {
    50. 

  50.       a = o_r;
    51. 

  51.       b = o_i;
    52. 

  52.       o_r = a * omega_r - b * omega_i;
    53. 

  53.       o_i = a * omega_i + b * omega_r;
    54. 

  54.     }
    55. 

  55. 

  56.   /* now, o_r + o_i * i is omega^col_num */
    57. 

  57.   omega_r = o_r;
    58. 

  58.   omega_i = o_i;
    59. 

  59.   for ( i = 1; i < size; ++i )
    60. 

  60.     {
    61. 

  61.       if ( (fabs (creal(col[i]) - o_r) > TOL) ||
    62. 

  62. 	   (fabs (cimag(col[i]) - o_i) > TOL) )
    63. 

  63. 	return 0;
    64. 

  64.       a = o_r;
    65. 

  65.       b = o_i;
    66. 

  66.       o_r = a * omega_r - b * omega_i;
    67. 

  67.       o_i = a * omega_i + b * omega_r;
    68. 

  68.     }
    69. 

  69.   return 1;
    70. 

  70. }
    71. 

  71. 

  72. 

  73. /**
    74. 

  74.  * @brief Verify that the DFT of the given size is correct.
    75. 

  75.  *
    76. 

  76.  * @param s    The size of the DFT being computed.
    77. 

  77.  * @param fptr A pointer to the function which computes the DFT of the given
    78. 

  78.  *             size.
    79. 

  79.  *
    80. 

  80.  * @return 1 if the function is correct, 0 otherwise
    81. 

  81.  */
    82. 

  82. unsigned int test_func(size_t s, 
    83. 

  83. 		       void (*fptr)(complex double *, complex double *)) {
    84. 

  84.   complex double *x = malloc(sizeof(complex double) * s);
    85. 

  85.   complex double *y = malloc(sizeof(complex double) * s);
    86. 

  86. 

  87.   for (size_t col = 0; col < s; col++) {
    88. 

  88.     for (size_t i = 0; i < s; i++) {
    89. 

  89.       x[i] = col==i;
    90. 

  90.       y[i] = 0;
    91. 

  91.     }
    92. 

  92. 

  93.     fptr(y, x);
    94. 

  94.     if ( !compare_col (y, col, s) )
    95. 

  95.       return 0;
    96. 

  96. /*  printf("col = %zu\n", col); */
    97. 

  97. /*     for (size_t i = 0; i < s; i++) { */
    98. 

  98. /*       printf("%f + %f i\n", creal(y[i]), cimag(y[i])); */
    99. 

  99. /*     } */
    100. 

  100. /*     printf("\n"); */
    101. 

  101.   }
    102. 

  102.  /*  printf("\n\n"); */
    103. 

  103.   return 1;
    104. 

  104. }
    105. 

  105. 

  106. int main(int argc, char *argv[]) {
    107. 

  107. 

  108.   /* printf("F(2)\n"); */
    109. 

  109.   /* test_func(2, func_2); */
    110. 

  110. 

  111.   /* printf("F(3)\n"); */
    112. 

  112.   /* test_func(3, func_3); */
    113. 

  113. 

  114.   /* printf("F(4)\n"); */
    115. 

  115.   /* test_func(4, func_4); */
    116. 

  116. 

  117.   /* printf("F(5)\n"); */
    118. 

  118.   /* test_func(5, func_5); */
    119. 

  119. 

  120.   /* printf("F(6)\n"); */
    121. 

  121.   /* test_func(6, func_6); */
    122. 

  122. 

  123.   /* printf("F(7)\n"); */
    124. 

  124.   /* test_func(7, func_7); */
    125. 

  125. 

  126.   /* printf("F(8)\n"); */
    127. 

  127.   /* test_func(8, func_8); */
    128. 

  128. 

  129.   /* printf("F(8)\n"); */
    130. 

  130.   /* test_func(8, func_8); */
    131. 

  131. 

  132. /*   printf("F(64) -- "); */
    133. 

  133. /*   if ( !test_func(64, func) ) */
    134. 

  134. /*     printf ("PASSSED\n"); */
    135. 

  135. 

  136.   printf ("F(64) -- %s\n", test_func (64, func) ? "PASSED" : "FAILED");
    137. 

  137. 

  138.   /* printf("F(9)\n"); */
    139. 

  139.   /* test_func(9, func_9); */
    140. 

  140. 

  141.   /* printf("F(10)\n"); */
    142. 

  142.   /* test_func(10, func_10); */
    143. 

  143. 

  144.   /* printf("F(11)\n"); */
    145. 

  145.   /* test_func(11, func_11); */
    146. 

  146. 

  147.   /* printf("F(12)\n"); */
    148. 

  148.   /* test_func(12, func_12); */
    149. 

  149. 

  150.   /* printf("F(13)\n"); */
    151. 

  151.   /* test_func(13, func_13); */
    152. 

  152. 

  153.   /* printf("F(14)\n"); */
    154. 

  154.   /* test_func(14, func_14); */
    155. 

  155. 

  156.   /* printf("F(15)\n"); */
    157. 

  157.   /* test_func(15, func_15); */
    158. 

  158. 

  159.   /* printf("F(16)\n"); */
    160. 

  160.   /* test_func(16, func_16); */
    161. 

  161. 

  162.   /* printf("F(17)\n"); */
    163. 

  163.   /* test_func(17, func_17); */
    164. 

  164. 

  165.   /* printf("F(18)\n"); */
    166. 

  166.   /* test_func(18, func_18); */
    167. 

  167. 

  168.   /* printf("F(18)\n"); */
    169. 

  169.   /* test_func(18, func_18); */
    170. 

  170. 

  171.   /* printf("F(19)\n"); */
    172. 

  172.   /* test_func(19, func_19); */
    173. 

  173. 

  174.   /* printf("F(20)\n"); */
    175. 

  175.   /* test_func(20, func_20); */
    176. 

  176. 

  177.   /* printf("F(21)\n"); */
    178. 

  178.   /* test_func(21, func_21); */
    179. 

  179. 

  180.   /* printf("F(22)\n"); */
    181. 

  181.   /* test_func(22, func_22); */
    182. 

  182. 

  183.   /* printf("F(23)\n"); */
    184. 

  184.   /* test_func(23, func_23); */
    185. 

  185. 

  186.   /* printf("F(24)\n"); */
    187. 

  187.   /* test_func(24, func_24); */
    188. 

  188. 

  189.   /* printf("F(25)\n"); */
    190. 

  190.   /* test_func(25, func_25); */
    191. 

  191. 

  192.   /* printf("F(26)\n"); */
    193. 

  193.   /* test_func(26, func_26); */
    194. 

  194. 

  195.   /* printf("F(27)\n"); */
    196. 

  196.   /* test_func(27, func_27); */
    197. 

  197. 

  198.   /* printf("F(28)\n"); */
    199. 

  199.   /* test_func(28, func_28); */
    200. 

  200. 

  201.   /* printf("F(28)\n"); */
    202. 

  202.   /* test_func(28, func_28); */
    203. 

  203. 

  204.   /* printf("F(29)\n"); */
    205. 

  205.   /* test_func(29, func_29); */
    206. 

  206. 

  207.   /* printf("F(30)\n"); */
    208. 

  208.   /* test_func(30, func_30); */
    209. 

  209. 

  210.   /* printf("F(31)\n"); */
    211. 

  211.   /* test_func(31, func_31); */
    212. 

  212. 

  213.   /* printf("F(32)\n"); */
    214. 

  214.   /* test_func(32, func_32); */
    215. 

  215. 

  216.   /* printf("F(33)\n"); */
    217. 

  217.   /* test_func(33, func_33); */
    218. 

  218. 

  219.   /* printf("F(34)\n"); */
    220. 

  220.   /* test_func(34, func_34); */
    221. 

  221. 

  222.   /* printf("F(35)\n"); */
    223. 

  223.   /* test_func(35, func_35); */
    224. 

  224. 

  225.   /* printf("F(36)\n"); */
    226. 

  226.   /* test_func(36, func_36); */
    227. 

  227. 

  228.   /* printf("F(37)\n"); */
    229. 

  229.   /* test_func(37, func_37); */
    230. 

  230. 

  231.   /* printf("F(38)\n"); */
    232. 

  232.   /* test_func(38, func_38); */
    233. 

  233. 

  234.   /* printf("F(38)\n"); */
    235. 

  235.   /* test_func(38, func_38); */
    236. 

  236. 

  237.   /* printf("F(39)\n"); */
    238. 

  238.   /* test_func(39, func_39); */
    239. 

  239. 

  240.   /* printf("F(30)\n"); */
    241. 

  241.   /* test_func(30, func_30); */
    242. 

  242. 

  243.   /* printf("F(31)\n"); */
    244. 

  244.   /* test_func(31, func_31); */
    245. 

  245. 

  246.   /* printf("F(32)\n"); */
    247. 

  247.   /* test_func(32, func_32); */
    248. 

  248. 

  249.   /* printf("F(33)\n"); */
    250. 

  250.   /* test_func(33, func_33); */
    251. 

  251. 

  252.   /* printf("F(34)\n"); */
    253. 

  253.   /* test_func(34, func_34); */
    254. 

  254. 

  255.   /* printf("F(35)\n"); */
    256. 

  256.   /* test_func(35, func_35); */
    257. 

  257. 

  258.   /* printf("F(36)\n"); */
    259. 

  259.   /* test_func(36, func_36); */
    260. 

  260. 

  261.   /* printf("F(37)\n"); */
    262. 

  262.   /* test_func(37, func_37); */
    263. 

  263. 

  264.   /* printf("F(38)\n"); */
    265. 

  265.   /* test_func(38, func_38); */
    266. 

  266. 

  267.   /* printf("F(38)\n"); */
    268. 

  268.   /* test_func(38, func_38); */
    269. 

  269. 

  270.   /* printf("F(39)\n"); */
    271. 

  271.   /* test_func(39, func_39); */
    272. 

  272. 

  273.   return 0;
    274. 

  274. }
    275.